void at86rf231_gpio_spi_interrupts_init(void) { /* set up GPIO pins */ /* SCLK and MOSI*/ GPIOA->CRL &= ~(0xf << (5 * 4)); GPIOA->CRL |= (0xb << (5 * 4)); GPIOA->CRL &= ~(0xf << (7 * 4)); GPIOA->CRL |= (0xb << (7 * 4)); /* MISO */ gpio_init_in(SPI_0_MISO_GPIO, GPIO_NOPULL); /* SPI init */ spi_init_master(SPI_0, SPI_CONF_FIRST_RISING, SPI_SPEED_5MHZ); spi_poweron(SPI_0); /* IRQ0 */ gpio_init_in(SPI_0_IRQ0_GPIO, GPIO_NOPULL); gpio_init_int(SPI_0_IRQ0_GPIO, GPIO_NOPULL, GPIO_RISING, (gpio_cb_t)at86rf231_rx_irq, NULL); /* Connect EXTI4 Line to PC4 pin */ at86rf231_enable_interrupts(); /* CS */ gpio_init_out(SPI_0_CS_GPIO, GPIO_NOPULL); /* SLEEP */ gpio_init_out(SPI_0_SLEEP_GPIO, GPIO_NOPULL); /* RESET */ gpio_init_out(SPI_0_RESET_GPIO, GPIO_NOPULL); }
/*---------------------------------------------------------------------------*/ void leds_arch_init(void) { gpio_init_out(&ledgreen,LED1); gpio_init_out(&ledyellow,LED2); gpio_init_out(&ledred,LED3); gpio_init_out(&ledblue,LED4); }
//****************************************************************************** void serial_break_clear(serial_t *obj) { // Configure the GPIO to output 1 gpio_t tx_gpio; switch (((UARTName)(obj->uart))) { case UART_0: gpio_init_out(&tx_gpio, UART0_TX); break; case UART_1: gpio_init_out(&tx_gpio, UART1_TX); break; default: gpio_init_out(&tx_gpio, (PinName)NC); break; } gpio_write(&tx_gpio, 1); // Renable UART switch (((UARTName)(obj->uart))) { case UART_0: serial_pinout_tx(UART0_TX); break; case UART_1: serial_pinout_tx(UART1_TX); break; default: serial_pinout_tx((PinName)NC); break; } }
int main(void) { puts("PIR motion sensor test application\n"); printf("Initializing red LED at GPIO_%i... ", GPIO_LED_RED); led_red = GPIO_LED_RED; if (gpio_init_out(led_red, GPIO_NOPULL) == 0) { puts("[OK]\n"); } else { puts("[Failed]"); return 1; } gpio_clear(led_red); printf("Initializing green LED at GPIO_%i... ", GPIO_LED_GREEN); led_green = GPIO_LED_GREEN; if (gpio_init_out(led_green, GPIO_NOPULL) == 0) { puts("[OK]\n"); } else { puts("[Failed]"); return 1; } gpio_clear(led_green); printf("Initializing PIR sensor at GPIO_%i... ", PIR_GPIO); if (pir_init(&pir, PIR_GPIO) == 0) { puts("[OK]\n"); } else { puts("[Failed]"); return 1; } kernel_pid_t pir_handler_pid = thread_create( pir_handler_stack, sizeof(pir_handler_stack), PRIORITY_MAIN - 1, CREATE_WOUT_YIELD | CREATE_STACKTEST, pir_handler, NULL, "pir_handler"); #if TEST_PIR_POLLING puts("Checking sensor state every half second."); pir_event_t status_old; while (1) { pir_event_t status = pir_get_status(&pir); if (status != status_old) { msg_t m = { .type = status, .content.ptr = (void*)&pir, }; msg_send(&m, pir_handler_pid, 0); } status_old = status; vtimer_usleep(1000 * 500); } #endif return 0; }
//****************************************************************************** void serial_break_set(serial_t *obj) { // Make sure that nothing is being sent while ( ((obj->uart->tx_fifo_ctrl & MXC_F_UART_TX_FIFO_CTRL_FIFO_ENTRY) >> MXC_F_UART_TX_FIFO_CTRL_FIFO_ENTRY_POS) > 0); while (!(obj->uart->intfl & MXC_F_UART_INTFL_TX_DONE)); // Configure the GPIO to output 0 gpio_t tx_gpio; switch (((UARTName)(obj->uart))) { case UART_0: gpio_init_out(&tx_gpio, UART0_TX); break; case UART_1: gpio_init_out(&tx_gpio, UART1_TX); break; case UART_2: gpio_init_out(&tx_gpio, UART2_TX); break; case UART_3: gpio_init_out(&tx_gpio, UART3_TX); break; default: gpio_init_out(&tx_gpio, (PinName)NC); break; } gpio_write(&tx_gpio, 0); // GPIO is setup now, but we need to map GPIO to the pin switch (((UARTName)(obj->uart))) { case UART_0: MXC_IOMAN->uart0_req &= ~MXC_F_IOMAN_UART_REQ_IO_REQ; MBED_ASSERT((MXC_IOMAN->uart0_ack & (MXC_F_IOMAN_UART_ACK_IO_MAP | MXC_F_IOMAN_UART_ACK_IO_ACK)) == 0); break; case UART_1: MXC_IOMAN->uart1_req &= ~MXC_F_IOMAN_UART_REQ_IO_REQ; MBED_ASSERT((MXC_IOMAN->uart1_ack & (MXC_F_IOMAN_UART_ACK_IO_MAP | MXC_F_IOMAN_UART_ACK_IO_ACK)) == 0); break; case UART_2: MXC_IOMAN->uart2_req &= ~MXC_F_IOMAN_UART_REQ_IO_REQ; MBED_ASSERT((MXC_IOMAN->uart2_ack & (MXC_F_IOMAN_UART_ACK_IO_MAP | MXC_F_IOMAN_UART_ACK_IO_ACK)) == 0); break; case UART_3: MXC_IOMAN->uart3_req &= ~MXC_F_IOMAN_UART_REQ_IO_REQ; MBED_ASSERT((MXC_IOMAN->uart3_ack & (MXC_F_IOMAN_UART_ACK_IO_MAP | MXC_F_IOMAN_UART_ACK_IO_ACK)) == 0); break; default: break; } }
int kw2xrf_spi_init(spi_t spi, spi_speed_t spi_speed, gpio_t cs_pin) { int res; kw2xrf_cs_pin = cs_pin; /**< for later reference */ kw2xrf_spi = spi; #if KW2XRF_SHARED_SPI spi_acquire(kw2xrf_spi); #endif res = spi_init_master(kw2xrf_spi, SPI_CONF_FIRST_RISING, spi_speed); #if KW2XRF_SHARED_SPI spi_release(kw2xrf_spi); gpio_init_out(kw2xrf_cs_pin, GPIO_NOPULL); gpio_set(kw2xrf_cs_pin); #endif if (res < 0) { DEBUG("kw2xrf_spi_init: error initializing SPI_%i device (code %i)\n", kw2xrf_spi, res); return -1; } return 0; }
int main() { gpio_init_out(&led, LED1); while(1) { gpio_write(&led, !gpio_read(&led)); HAL_Delay(150); } }
void pinMode( uint32_t dwPin, uint32_t dwMode ) { gpio_t gpio; if (dwMode == INPUT) gpio_init_in(&gpio, digiPins[dwPin]); else gpio_init_out(&gpio, digiPins[dwPin]); }
void mbed_sdk_init(void) { if (STDIO_UART_RTS != NC) { gpio_t rts; gpio_init_out(&rts, STDIO_UART_RTS); /* Set STDIO_UART_RTS as gpio driven low */ gpio_write(&rts, 0); } }
int main() { serial_init(&pc,SERIAL_TX,SERIAL_RX); gpio_init_out(&led, LED1); while(1) { gpio_write(&led, !gpio_read(&led)); serial_putc(&pc, 'A'); HAL_Delay(150); } }
/** * main * * The main function for the project. This function initializes the os, calls * init_tasks to initialize tasks (and possibly other objects), then starts the * OS. We should not return from os start. * * @return int NOTE: this function should never return! */ int main(void) { int i; int rc; uint32_t seed; /* Initialize OS */ os_init(); /* Set cputime to count at 1 usec increments */ rc = cputime_init(1000000); assert(rc == 0); rc = os_mempool_init(&g_mbuf_mempool, MBUF_NUM_MBUFS, MBUF_MEMBLOCK_SIZE, &g_mbuf_buffer[0], "mbuf_pool"); rc = os_mbuf_pool_init(&g_mbuf_pool, &g_mbuf_mempool, MBUF_MEMBLOCK_SIZE, MBUF_NUM_MBUFS); assert(rc == 0); /* Dummy device address */ memcpy(g_dev_addr, prphtest_slv_addr, 6); /* * Seed random number generator with least significant bytes of device * address. */ seed = 0; for (i = 0; i < 4; ++i) { seed |= g_dev_addr[i]; seed <<= 8; } srand(seed); /* Set the led pin as an output */ g_led_pin = LED_BLINK_PIN; gpio_init_out(g_led_pin, 1); /* Init the console */ rc = console_init(NULL); assert(rc == 0); /* Init tasks */ init_tasks(); /* Start the OS */ os_start(); /* os start should never return. If it does, this should be an error */ assert(0); return rc; }
WEAK void mbed_die(void) { #ifndef NRF51_H __disable_irq(); // dont allow interrupts to disturb the flash pattern #endif #if (DEVICE_ERROR_RED == 1) gpio_t led_red; gpio_init_out(&led_red, LED_RED); #elif (DEVICE_ERROR_PATTERN == 1) gpio_t led_1; gpio_init_out(&led_1, LED1); gpio_t led_2; gpio_init_out(&led_2, LED2); gpio_t led_3; gpio_init_out(&led_3, LED3); gpio_t led_4; gpio_init_out(&led_4, LED4); #endif while (1) { #if (DEVICE_ERROR_RED == 1) gpio_write(&led_red, 1); #elif (DEVICE_ERROR_PATTERN == 1) gpio_write(&led_1, 1); gpio_write(&led_2, 0); gpio_write(&led_3, 0); gpio_write(&led_4, 1); #endif wait_ms(150); #if (DEVICE_ERROR_RED == 1) gpio_write(&led_red, 0); #elif (DEVICE_ERROR_PATTERN == 1) gpio_write(&led_1, 0); gpio_write(&led_2, 1); gpio_write(&led_3, 1); gpio_write(&led_4, 0); #endif wait_ms(150); } }
WEAK void mbed_die_advanced(uint32_t err_code) { #ifndef NRF51_H __disable_irq(); // dont allow interrupts to disturb the flash pattern #endif #if (DEVICE_ERROR_RED == 1) mbed_die(); #elif (DEVICE_ERROR_PATTERN == 1) gpio_t led_1; gpio_init_out(&led_1, LED1); gpio_t led_2; gpio_init_out(&led_2, LED2); gpio_t led_3; gpio_init_out(&led_3, LED3); gpio_t led_4; gpio_init_out(&led_4, LED4); uint32_t i = 0; // Show this is advanced die for(i=0 ;i<4; i++) { gpio_write(&led_1, 1); gpio_write(&led_2, 0); gpio_write(&led_3, 1); gpio_write(&led_4, 0); wait_ms(150); gpio_write(&led_1, 0); gpio_write(&led_2, 1); gpio_write(&led_3, 0); gpio_write(&led_4, 1); wait_ms(150); } i = 0; while (1) { gpio_write(&led_1, i&0x01); gpio_write(&led_2, (i>>1)&0x01); gpio_write(&led_3, (i>>2)&0x01); gpio_write(&led_4, (i>>3)&0x01); i++; if(i>err_code) i = 0; wait_ms(150); } #endif }
WEAK void mbed_die(void) { #if !defined (NRF51_H) && !defined(TARGET_EFM32) core_util_critical_section_enter(); #endif #if (DEVICE_ERROR_RED == 1) gpio_t led_red; gpio_init_out(&led_red, LED_RED); #elif (DEVICE_ERROR_PATTERN == 1) gpio_t led_1; gpio_init_out(&led_1, LED1); gpio_t led_2; gpio_init_out(&led_2, LED2); gpio_t led_3; gpio_init_out(&led_3, LED3); gpio_t led_4; gpio_init_out(&led_4, LED4); #endif while (1) { #if (DEVICE_ERROR_RED == 1) gpio_write(&led_red, 1); #elif (DEVICE_ERROR_PATTERN == 1) gpio_write(&led_1, 1); gpio_write(&led_2, 0); gpio_write(&led_3, 0); gpio_write(&led_4, 1); #endif wait_ms(150); #if (DEVICE_ERROR_RED == 1) gpio_write(&led_red, 0); #elif (DEVICE_ERROR_PATTERN == 1) gpio_write(&led_1, 0); gpio_write(&led_2, 1); gpio_write(&led_3, 1); gpio_write(&led_4, 0); #endif wait_ms(150); } }
int pcd8544_init(pcd8544_t *dev, spi_t spi, gpio_t cs, gpio_t reset, gpio_t mode) { /* save pin mapping */ dev->spi = spi; dev->cs = cs; dev->reset = reset; dev->mode = mode; dev->inverted = 0; DEBUG("done setting dev members\n"); /* initialze pins */ gpio_init_out(cs, GPIO_NOPULL); gpio_init_out(reset, GPIO_NOPULL); gpio_init_out(mode, GPIO_NOPULL); DEBUG("done with gpios\n"); /* clear CS line */ gpio_set(cs); DEBUG("done clearing CS line\n"); /* initialize SPI */ spi_init_master(spi, SPI_CONF_FIRST_RISING, SPI_SPEED_1MHZ); DEBUG("done initializing SPI master\n"); /* reset display */ gpio_clear(reset); hwtimer_wait(RESET_DELAY); gpio_set(reset); /* clear display memory */ pcd8544_clear(dev); /* write initialization sequence to display */ pcd8544_set_contrast(dev, PCD8544_DEFAULT_CONTRAST); pcd8544_set_bias(dev, PCD8544_DEFAULT_BIAS); pcd8544_set_tempcoef(dev, PCD8544_DEFAULT_TEMPCOEF); /* enable display */ _write(dev, MODE_CMD, CMD_ENABLE_H); _write(dev, MODE_CMD, CMD_MODE_NORMAL); return 0; }
void DispatcherPrivate::set_channel_action(SYNCHRONIZATION_CHANNEL* channel, PinName pin, SendChannelMode mode, int pulse_length_us) { for (int i = 0; i < MAX_SEND_DATA; ++i) { SendData* sd = &channel->data->state->send[i]; if (sd->pin != NC && sd->pin != pin) continue; gpio_init_out(&sd->gpio, pin); sd->mode = mode; sd->pulse_length_us = pulse_length_us; sd->pin = pin; } }
//****************************************************************************** void serial_break_set(serial_t *obj) { // Make sure that nothing is being sent while (!(obj->uart->status & MXC_F_UART_STATUS_TX_FIFO_EMPTY)); while (obj->uart->status & MXC_F_UART_STATUS_TX_BUSY); // Configure the GPIO to outpu 0 gpio_t tx_gpio; switch (((UARTName)(obj->uart))) { case UART_0: gpio_init_out(&tx_gpio, UART0_TX); break; case UART_1: gpio_init_out(&tx_gpio, UART1_TX); break; default: gpio_init_out(&tx_gpio, (PinName)NC); break; } gpio_write(&tx_gpio, 0); // GPIO is setup now, but we need to maps gpio to the pin switch (((UARTName)(obj->uart))) { case UART_0: MXC_IOMAN->uart0_req &= ~MXC_F_IOMAN_UART_CORE_IO; MBED_ASSERT((MXC_IOMAN->uart0_ack & (MXC_F_IOMAN_UART_CORE_IO | MXC_F_IOMAN_UART_CORE_IO)) == 0); break; case UART_1: MXC_IOMAN->uart1_req &= ~MXC_F_IOMAN_UART_CORE_IO; MBED_ASSERT((MXC_IOMAN->uart1_ack & (MXC_F_IOMAN_UART_CORE_IO | MXC_F_IOMAN_UART_CORE_IO)) == 0); break; default: break; } }
int nvram_spi_init(nvram_t *dev, nvram_spi_params_t *spi_params, size_t size) { dev->size = size; if (size > 0x100 && spi_params->address_count == 1) { dev->write = nvram_spi_write_9bit_addr; dev->read = nvram_spi_read_9bit_addr; } else { dev->write = nvram_spi_write; dev->read = nvram_spi_read; } dev->extra = spi_params; gpio_init_out(spi_params->cs, GPIO_NOPULL); gpio_set(spi_params->cs); return 0; }
void cmd_init_master(int argc, char **argv) { int res; spi_master = -1; if (parse_spi_dev(argc, argv) < 0) { return; } res = spi_init_master(spi_dev, spi_mode, spi_speed); if (res < 0) { printf("spi_init_master: error initializing SPI_%i device (code %i)\n", spi_dev, res); } res = gpio_init_out(spi_cs, GPIO_PULLUP); if (res < 0){ printf("gpio_init_out: error initializing GPIO_%i as CS line (code %i)\n", spi_cs, res); } gpio_set(spi_cs); spi_master = 1; printf("SPI_%i successfully initialized as master, cs: GPIO_%i, mode: %i, speed: %i\n", spi_dev, spi_cs, spi_mode, spi_speed); return; }
WEAK void mbed_die(void) { #if !defined (NRF51_H) && !defined(TARGET_EFM32) core_util_critical_section_enter(); #endif gpio_t led_err; gpio_init_out(&led_err, LED1); while (1) { for (int i = 0; i < 4; ++i) { gpio_write(&led_err, 1); wait_ms(150); gpio_write(&led_err, 0); wait_ms(150); } for (int i = 0; i < 4; ++i) { gpio_write(&led_err, 1); wait_ms(400); gpio_write(&led_err, 0); wait_ms(400); } } }
/** * main * * The main function for the project. This function initializes the os, calls * init_tasks to initialize tasks (and possibly other objects), then starts the * OS. We should not return from os start. * * @return int NOTE: this function should never return! */ int main(void) { int i; int rc; int cnt; uint32_t seed; struct nffs_area_desc descs[NFFS_AREA_MAX]; /* Initialize OS */ os_init(); /* Set cputime to count at 1 usec increments */ rc = cputime_init(1000000); assert(rc == 0); rc = os_mempool_init(&g_mbuf_mempool, MBUF_NUM_MBUFS, MBUF_MEMBLOCK_SIZE, &g_mbuf_buffer[0], "mbuf_pool"); assert(rc == 0); rc = os_mbuf_pool_init(&g_mbuf_pool, &g_mbuf_mempool, MBUF_MEMBLOCK_SIZE, MBUF_NUM_MBUFS); assert(rc == 0); rc = os_msys_register(&g_mbuf_pool); assert(rc == 0); /* Dummy device address */ #if BLETEST_CFG_ROLE == BLETEST_ROLE_ADVERTISER g_dev_addr[0] = 0x00; g_dev_addr[1] = 0x00; g_dev_addr[2] = 0x00; g_dev_addr[3] = 0x88; g_dev_addr[4] = 0x88; g_dev_addr[5] = 0x08; g_bletest_cur_peer_addr[0] = 0x00; g_bletest_cur_peer_addr[1] = 0x00; g_bletest_cur_peer_addr[2] = 0x00; g_bletest_cur_peer_addr[3] = 0x99; g_bletest_cur_peer_addr[4] = 0x99; g_bletest_cur_peer_addr[5] = 0x09; #else g_dev_addr[0] = 0x00; g_dev_addr[1] = 0x00; g_dev_addr[2] = 0x00; g_dev_addr[3] = 0x99; g_dev_addr[4] = 0x99; g_dev_addr[5] = 0x09; g_bletest_cur_peer_addr[0] = 0x00; g_bletest_cur_peer_addr[1] = 0x00; g_bletest_cur_peer_addr[2] = 0x00; g_bletest_cur_peer_addr[3] = 0x88; g_bletest_cur_peer_addr[4] = 0x88; g_bletest_cur_peer_addr[5] = 0x08; #endif /* * Seed random number generator with least significant bytes of device * address. */ seed = 0; for (i = 0; i < 4; ++i) { seed |= g_dev_addr[i]; seed <<= 8; } srand(seed); /* Set the led pin as an output */ g_led_pin = LED_BLINK_PIN; gpio_init_out(g_led_pin, 1); /* Init the console */ rc = console_init(shell_console_rx_cb); assert(rc == 0); rc = hal_flash_init(); assert(rc == 0); nffs_config.nc_num_inodes = 32; nffs_config.nc_num_blocks = 64; nffs_config.nc_num_files = 2; nffs_config.nc_num_dirs = 2; rc = nffs_init(); assert(rc == 0); cnt = NFFS_AREA_MAX; rc = flash_area_to_nffs_desc(FLASH_AREA_NFFS, &cnt, descs); assert(rc == 0); if (nffs_detect(descs) == FS_ECORRUPT) { rc = nffs_format(descs); assert(rc == 0); } shell_task_init(SHELL_TASK_PRIO, shell_stack, SHELL_TASK_STACK_SIZE, SHELL_MAX_INPUT_LEN); nmgr_task_init(NEWTMGR_TASK_PRIO, newtmgr_stack, NEWTMGR_TASK_STACK_SIZE); imgmgr_module_init(); /* Init statistics module */ stats_module_init(); /* Init tasks */ init_tasks(); /* Start the OS */ os_start(); /* os start should never return. If it does, this should be an error */ assert(0); return rc; }
int main(void) { GPIO_0_CLKEN(); gpio_init_out(GPIO_0, GPIO_NOPULL); GPIO_1_CLKEN(); gpio_init_out(GPIO_1, GPIO_NOPULL); GPIO_2_CLKEN(); gpio_init_out(GPIO_2, GPIO_NOPULL); GPIO_3_CLKEN(); gpio_init_out(GPIO_3, GPIO_NOPULL); GPIO_9_CLKEN(); gpio_init_in(GPIO_9, GPIO_PULLDOWN); GPIO_10_CLKEN(); gpio_init_in(GPIO_10, GPIO_PULLDOWN); GPIO_11_CLKEN(); gpio_init_in(GPIO_11, GPIO_PULLDOWN); gpio_set(GPIO_3); gpio_clear(GPIO_1); hwtimer_wait(HWTIMER_TICKS(500 * 1000)); gpio_set(GPIO_0); gpio_set(GPIO_1); gpio_set(GPIO_2); while(1) { #if LEEEEDS gpio_clear(GPIO_1); hwtimer_wait(HWTIMER_TICKS(500 * 1000)); gpio_clear(GPIO_0); hwtimer_wait(HWTIMER_TICKS(500 * 1000)); gpio_clear(GPIO_2); hwtimer_wait(HWTIMER_TICKS(500 * 1000)); gpio_set(GPIO_0); gpio_set(GPIO_1); gpio_set(GPIO_2); #endif if (gpio_read(GPIO_9)) { gpio_clear(GPIO_0); } else { gpio_set(GPIO_0); } if (gpio_read(GPIO_10)) { gpio_clear(GPIO_1); } else { gpio_set(GPIO_1); } if (gpio_read(GPIO_11)) { gpio_clear(GPIO_2); } else { gpio_set(GPIO_2); } } return 0; }
//****************************************************************************** static void usurp_pin(PinName pin, int state) { gpio_t gpio; gpio_init_out(&gpio, pin); gpio_write(&gpio, state); }
int nrf24l01p_init(nrf24l01p_t *dev, spi_t spi, gpio_t ce, gpio_t cs, gpio_t irq) { int status; char INITIAL_TX_ADDRESS[] = {0xe7, 0xe7, 0xe7, 0xe7, 0xe7,}; char INITIAL_RX_ADDRESS[] = {0xe7, 0xe7, 0xe7, 0xe7, 0xe7,}; dev->spi = spi; dev->ce = ce; dev->cs = cs; dev->irq = irq; dev->listener = KERNEL_PID_UNDEF; /* Init CE pin */ gpio_init_out(dev->ce, GPIO_NOPULL); /* Init CS pin */ gpio_init_out(dev->cs, GPIO_NOPULL); gpio_set(dev->cs); /* Init IRQ pin */ gpio_init_int(dev->irq, GPIO_PULLUP, GPIO_FALLING, nrf24l01p_rx_cb, dev); /* Init SPI */ spi_poweron(dev->spi); spi_acquire(dev->spi); status = spi_init_master(dev->spi, SPI_CONF_FIRST_RISING, SPI_SPEED_400KHZ); spi_release(dev->spi); if (status < 0) { return status; } hwtimer_spin(DELAY_AFTER_FUNC_TICKS); /* Flush TX FIFIO */ status = nrf24l01p_flush_tx_fifo(dev); if (status < 0) { return status; } /* Flush RX FIFIO */ status = nrf24l01p_flush_tx_fifo(dev); if (status < 0) { return status; } /* Setup adress width */ status = nrf24l01p_set_address_width(dev, NRF24L01P_AW_5BYTE); if (status < 0) { return status; } /* Setup payload width */ status = nrf24l01p_set_payload_width(dev, NRF24L01P_PIPE0, NRF24L01P_MAX_DATA_LENGTH); if (status < 0) { return status; } /* Set RF channel */ status = nrf24l01p_set_channel(dev, INITIAL_RF_CHANNEL); if (status < 0) { return status; } /* Set RF power */ status = nrf24l01p_set_power(dev, 0); if (status < 0) { return status; } /* Set RF datarate */ status = nrf24l01p_set_datarate(dev, NRF24L01P_DR_250KBS); if (status < 0) { return status; } /* Set TX Address */ status = nrf24l01p_set_tx_address(dev, INITIAL_TX_ADDRESS, INITIAL_ADDRESS_WIDTH); if (status < 0) { return status; } /* Set RX Adress */ status = nrf24l01p_set_rx_address(dev, NRF24L01P_PIPE0, INITIAL_RX_ADDRESS, INITIAL_ADDRESS_WIDTH); if (status < 0) { return status; } /* Reset auto ack for all pipes */ status = nrf24l01p_disable_all_auto_ack(dev); if (status < 0) { return status; } /* Setup Auto ACK and retransmission */ status = nrf24l01p_setup_auto_ack(dev, NRF24L01P_PIPE0, NRF24L01P_RETR_750US, 15); if (status < 0) { return status; } /* Setup CRC */ status = nrf24l01p_enable_crc(dev, NRF24L01P_CRC_2BYTE); if (status < 0) { return status; } /* Reset all interrupt flags */ status = nrf24l01p_reset_all_interrupts(dev); if (status < 0) { return status; } return nrf24l01p_on(dev); }