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);
}
