static int _init(netdev2_t *encdev)
{
encx24j600_t *dev = (encx24j600_t *) encdev;
DEBUG("encx24j600: starting initialization...\n");
/* setup IO */
gpio_init(dev->cs, GPIO_OUT);
gpio_set(dev->cs);
gpio_init_int(dev->int_pin, GPIO_IN_PU, GPIO_FALLING, encx24j600_isr, (void*)dev);
if (spi_init_master(dev->spi, SPI_CONF_FIRST_RISING, ENCX24J600_SPI_SPEED) < 0) {
return -1;
}
lock(dev);
/* initialization procedure as described in data sheet (39935c.pdf) */
do {
do {
xtimer_usleep(ENCX24J600_INIT_DELAY);
reg_set(dev, ENC_EUDAST, 0x1234);
xtimer_usleep(ENCX24J600_INIT_DELAY);
} while (reg_get(dev, ENC_EUDAST) != 0x1234);
while (!(reg_get(dev, ENC_ESTAT) & ENC_CLKRDY));
/* issue System Reset */
cmd(dev, ENC_SETETHRST);
/* make sure initialization finalizes */
xtimer_usleep(1000);
} while (!(reg_get(dev, ENC_EUDAST) == 0x0000));
/* configure flow control */
phy_reg_set(dev, ENC_PHANA, 0x05E1);
reg_set_bits(dev, ENC_ECON2, ENC_AUTOFC);
/* setup receive buffer */
reg_set(dev, ENC_ERXST, RX_BUFFER_START);
reg_set(dev, ENC_ERXTAIL, RX_BUFFER_END);
dev->rx_next_ptr = RX_BUFFER_START;
/* configure receive filter to receive multicast frames */
reg_set_bits(dev, ENC_ERXFCON, ENC_MCEN);
/* setup interrupts */
reg_set_bits(dev, ENC_EIE, ENC_PKTIE | ENC_LINKIE);
cmd(dev, ENC_ENABLERX);
cmd(dev, ENC_SETEIE);
DEBUG("encx24j600: initialization complete.\n");
unlock(dev);
#ifdef MODULE_NETSTATS_L2
memset(&netdev->stats, 0, sizeof(netstats_t));
#endif
return 0;
}
int ng_at86rf2xx_init(ng_at86rf2xx_t *dev, spi_t spi, spi_speed_t spi_speed,
gpio_t cs_pin, gpio_t int_pin,
gpio_t sleep_pin, gpio_t reset_pin)
{
dev->driver = &ng_at86rf2xx_driver;
/* initialize device descriptor */
dev->spi = spi;
dev->cs_pin = cs_pin;
dev->int_pin = int_pin;
dev->sleep_pin = sleep_pin;
dev->reset_pin = reset_pin;
/* initialise SPI */
spi_init_master(dev->spi, SPI_CONF_FIRST_RISING, spi_speed);
/* initialise GPIOs */
gpio_init(dev->cs_pin, GPIO_DIR_OUT, GPIO_NOPULL);
gpio_set(dev->cs_pin);
gpio_init(dev->sleep_pin, GPIO_DIR_OUT, GPIO_NOPULL);
gpio_clear(dev->sleep_pin);
gpio_init(dev->reset_pin, GPIO_DIR_OUT, GPIO_NOPULL);
gpio_set(dev->reset_pin);
gpio_init_int(dev->int_pin, GPIO_NOPULL, GPIO_RISING, _irq_handler, dev);
/* test if the SPI is set up correctly and the device is responding */
if (ng_at86rf2xx_reg_read(dev, NG_AT86RF2XX_REG__PART_NUM) !=
NG_AT86RF2XX_PARTNUM) {
DEBUG("[ng_at86rf2xx] error: unable to read correct part number\n");
return -1;
}
/* reset device to default values and put it into RX state */
ng_at86rf2xx_reset(dev);
return 0;
}
int cmd_init_slave(int argc, char **argv)
{
int res;
spi_master = -1;
if (parse_spi_dev(argc, argv) < 0) {
return 1;
}
spi_acquire(spi_dev);
res = spi_init_slave(spi_dev, spi_mode, slave_on_data);
spi_release(spi_dev);
if (res < 0) {
printf("spi_init_slave: error initializing SPI_%i device (code: %i)\n",
spi_dev, res);
return 1;
}
res = gpio_init_int(spi_cs, GPIO_IN, GPIO_FALLING, slave_on_cs, 0);
if (res < 0){
printf("gpio_init_int: error initializing GPIO_%ld as CS line (code %i)\n",
(long)spi_cs, res);
return 1;
}
spi_master = 0;
printf("SPI_%i successfully initialized as slave, cs: GPIO_%ld, mode: %i\n",
spi_dev, (long)spi_cs, spi_mode);
return 0;
}
int main(void)
{
sock_udp_ep_t corerd_server;
/* Schalte On-Board-LED aus */
LED0_OFF;
/* Verknüpfe den On-Board-Button-Pin mit dem entsprechenden Handler */
gpio_init_int(BTN0_PIN, BTN0_MODE, GPIO_FALLING, _toggle_dino, NULL);
/* Initialisiere den Dino-Motor-Pin als ausgehenden Pin */
gpio_init(DINO_MOVE_PIN, GPIO_OUT);
/* Registriere die CoAP-Server Definition */
gcoap_register_listener(&_listener);
/* warte ein wenig, bis sich das Netzwerk konfiguriert hat */
xtimer_sleep(2);
/* Erstelle einen sock-Endpunkt für die vorkonfigurierte Addresse
* des Ressourcen-Verzeichnisses */
if (make_sock_ep(&corerd_server, corerd_server_addr) < 0) {
puts("Can not parse CORERD_SERVER_ADDR");
}
/* Registriere den CoAP-Server im Ressourcen-Verzeichnis */
cord_ep_register(&corerd_server, NULL);
/* wir müchten nicht terminieren */
while (1) { /* Endlos-Schleife */ }
return 0;
}
static int _init(netdev2_t *netdev)
{
at86rf2xx_t *dev = (at86rf2xx_t *)netdev;
/* initialise GPIOs */
gpio_init(dev->params.cs_pin, GPIO_OUT);
gpio_set(dev->params.cs_pin);
gpio_init(dev->params.sleep_pin, GPIO_OUT);
gpio_clear(dev->params.sleep_pin);
gpio_init(dev->params.reset_pin, GPIO_OUT);
gpio_set(dev->params.reset_pin);
gpio_init_int(dev->params.int_pin, GPIO_IN, GPIO_RISING, _irq_handler, dev);
/* make sure device is not sleeping, so we can query part number */
at86rf2xx_assert_awake(dev);
/* test if the SPI is set up correctly and the device is responding */
if (at86rf2xx_reg_read(dev, AT86RF2XX_REG__PART_NUM) !=
AT86RF2XX_PARTNUM) {
DEBUG("[at86rf2xx] error: unable to read correct part number\n");
return -1;
}
#ifdef MODULE_NETSTATS_L2
memset(&netdev->stats, 0, sizeof(netstats_t));
#endif
/* reset device to default values and put it into RX state */
at86rf2xx_reset(dev);
return 0;
}
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);
}
int main(void)
{
int cnt = 0;
/* get the number of available buttons and init interrupt handler */
#ifdef BTN0_PIN
if (gpio_init_int(BTN0_PIN, BTN0_MODE, TEST_FLANK, cb, (void *)cnt) < 0) {
puts("[FAILED] init BTN0!");
return 1;
}
++cnt;
#endif
#ifdef BTN1_PIN
if (gpio_init_int(BTN1_PIN, BTN1_MODE, TEST_FLANK, cb, (void *)cnt) < 0) {
puts("[FAILED] init BTN1!");
return 1;
}
++cnt;
#endif
#ifdef BTN2_PIN
if (gpio_init_int(BTN2_PIN, BTN2_MODE, TEST_FLANK, cb, (void *)cnt) < 0) {
puts("[FAILED] init BTN2!");
return 1;
}
++cnt;
#endif
#ifdef BTN3_PIN
if (gpio_init_int(BTN3_PIN, BTN3_MODE, TEST_FLANK, cb, (void *)cnt) < 0) {
puts("[FAILED] init BTN3!");
return 1;
}
++cnt;
#endif
puts("On-board button test\n");
/* cppcheck-suppress knownConditionTrueFalse
* (reason: board-dependent ifdefs) */
if (cnt == 0) {
puts("[FAILED] no buttons available!");
return 2;
}
printf(" -- Available buttons: %i\n\n", cnt);
puts(" -- Try pressing buttons to test.\n");
puts("[SUCCESS]");
return 0;
}
static int init_int(int argc, char **argv)
{
int port, pin, flank, pull;
if (argc < 4) {
printf("usage: %s <port> <pin> <flank> [pull_config]\n", argv[0]);
puts(" flank: 0: falling\n"
" 1: rising\n"
" 2: both\n"
" pull_config: 0: no pull resistor (default)\n"
" 1: pull up\n"
" 2: pull down");
return 1;
}
port = atoi(argv[1]);
pin = atoi(argv[2]);
flank = atoi(argv[3]);
switch (flank) {
case 0:
flank = GPIO_FALLING;
break;
case 1:
flank = GPIO_RISING;
break;
case 2:
flank = GPIO_BOTH;
break;
default:
printf("wrong flank setting.\n");
return 0;
}
if (argc >= 5) {
pull = parse_pull(argv[4]);
if (pull < 0) {
return 1;
}
}
else {
pull = GPIO_NOPULL;
}
if (gpio_init_int(GPIO(port, pin), pull, flank, cb, (void *)pin) < 0) {
printf("Error while initializing PORT_%i.%02i as external interrupt\n",
port, pin);
return 1;
}
printf("PORT_%i.%02i initialized successful as external interrupt\n",
port, pin);
return 0;
}
static int _init(netdev2_t *netdev)
{
cc2420_t *dev = (cc2420_t *)netdev;
uint16_t reg;
/* initialize power and reset pins -> put the device into reset state */
gpio_init(dev->params.pin_reset, GPIO_OUT);
gpio_set(dev->params.pin_reset);
gpio_init(dev->params.pin_vrefen, GPIO_OUT);
gpio_clear(dev->params.pin_vrefen);
/* initialize the input lines */
gpio_init(dev->params.pin_cca, GPIO_IN);
gpio_init(dev->params.pin_sfd, GPIO_IN);
gpio_init(dev->params.pin_fifo, GPIO_IN);
gpio_init_int(dev->params.pin_fifop, GPIO_IN, GPIO_RISING, _irq_handler, dev);
/* initialize the chip select line and the SPI bus */
gpio_init(dev->params.pin_cs, GPIO_OUT);
gpio_set(dev->params.pin_cs);
/* power on and toggle reset */
gpio_set(dev->params.pin_vrefen);
gpio_clear(dev->params.pin_reset);
xtimer_usleep(CC2420_RESET_DELAY);
gpio_set(dev->params.pin_reset);
/* test the connection to the device by reading MANFIDL register */
reg = cc2420_reg_read(dev, CC2420_REG_MANFIDL);
if (reg != CC2420_MANFIDL_VAL) {
DEBUG("cc2420: init: unable to communicate with device\n");
return -1;
}
/* turn on the oscillator and wait for it to be stable */
cc2420_en_xosc(dev);
if (!(cc2420_status(dev) & CC2420_STATUS_XOSC_STABLE)) {
DEBUG("cc2420: init: oscillator did not stabilize\n");
return -1;
}
#ifdef MODULE_NETSTATS_L2
memset(&netdev->stats, 0, sizeof(netstats_t));
#endif
return cc2420_init((cc2420_t *)dev);
}
static int _init(netdev2_t *dev)
{
DEBUG("%s:%u\n", __func__, __LINE__);
cc110x_t *cc110x = &((netdev2_cc110x_t*) dev)->cc110x;
gpio_init_int(cc110x->params.gdo2, GPIO_NOPULL, GPIO_BOTH,
&_netdev2_cc110x_isr, (void*)dev);
gpio_set(cc110x->params.gdo2);
gpio_irq_disable(cc110x->params.gdo2);
/* Switch to RX mode */
cc110x_rd_set_mode(cc110x, RADIO_MODE_ON);
return 0;
}
int kw2xrf_init(kw2xrf_t *dev, gpio_cb_t cb)
{
if (dev == NULL) {
return -ENODEV;
}
kw2xrf_set_out_clk(dev);
kw2xrf_disable_interrupts(dev);
/* set up GPIO-pin used for IRQ */
gpio_init_int(dev->params.int_pin, GPIO_IN, GPIO_FALLING, cb, dev);
kw2xrf_abort_sequence(dev);
kw2xrf_update_overwrites(dev);
kw2xrf_timer_init(dev, KW2XRF_TIMEBASE_62500HZ);
DEBUG("[kw2xrf] init finished\n");
return 0;
}
void cmd_init_slave(int argc, char **argv)
{
int res;
spi_master = -1;
if (parse_spi_dev(argc, argv) < 0) {
return;
}
res = spi_init_slave(spi_dev, spi_mode, slave_on_data);
if (res < 0) {
printf("spi_init_slave: error initializing SPI_%i device (code: %i)\n", spi_dev, res);
}
res = gpio_init_int(spi_cs, GPIO_NOPULL, GPIO_FALLING, slave_on_cs, 0);
if (res < 0){
printf("gpio_init_int: error initializing GPIO_%i as CS line (code %i)\n", spi_cs, res);
}
spi_master = 0;
printf("SPI_%i successfully initialized as slave, cs: GPIO_%i, mode: %i\n",
spi_dev, spi_cs, spi_mode);
return;
}
int at86rf2xx_init(at86rf2xx_t *dev, spi_t spi, spi_speed_t spi_speed,
gpio_t cs_pin, gpio_t int_pin,
gpio_t sleep_pin, gpio_t reset_pin)
{
dev->driver = &at86rf2xx_driver;
/* initialize device descriptor */
dev->spi = spi;
dev->cs_pin = cs_pin;
dev->int_pin = int_pin;
dev->sleep_pin = sleep_pin;
dev->reset_pin = reset_pin;
dev->idle_state = AT86RF2XX_STATE_TRX_OFF;
dev->state = AT86RF2XX_STATE_SLEEP;
/* initialise SPI */
spi_init_master(dev->spi, SPI_CONF_FIRST_RISING, spi_speed);
/* initialise GPIOs */
gpio_init(dev->cs_pin, GPIO_DIR_OUT, GPIO_NOPULL);
gpio_set(dev->cs_pin);
gpio_init(dev->sleep_pin, GPIO_DIR_OUT, GPIO_NOPULL);
gpio_clear(dev->sleep_pin);
gpio_init(dev->reset_pin, GPIO_DIR_OUT, GPIO_NOPULL);
gpio_set(dev->reset_pin);
gpio_init_int(dev->int_pin, GPIO_NOPULL, GPIO_RISING, _irq_handler, dev);
/* make sure device is not sleeping, so we can query part number */
at86rf2xx_assert_awake(dev);
/* test if the SPI is set up correctly and the device is responding */
if (at86rf2xx_reg_read(dev, AT86RF2XX_REG__PART_NUM) !=
AT86RF2XX_PARTNUM) {
DEBUG("[at86rf2xx] error: unable to read correct part number\n");
return -1;
}
/* reset device to default values and put it into RX state */
at86rf2xx_reset(dev);
return 0;
}
int
sol_interrupt_scheduler_gpio_init_int(gpio_t dev, gpio_mode_t mode, gpio_flank_t flank, gpio_cb_t cb, const void *arg, void **handler)
{
struct gpio_interrupt_data *int_data;
int ret;
int_data = calloc(1, sizeof(*int_data));
SOL_NULL_CHECK(int_data, -ENOMEM);
int_data->cb = cb;
int_data->data = arg;
ret = gpio_init_int(dev, mode, flank, gpio_cb, int_data);
SOL_INT_CHECK_GOTO(ret, < 0, error);
*handler = int_data;
return 0;
error:
free(int_data);
return ret;
}
int
sol_interrupt_scheduler_gpio_init_int(gpio_t dev, gpio_pp_t pullup, gpio_flank_t flank, gpio_cb_t cb, void *arg, void **handler)
{
int retval = -1;
struct interrupt_data *int_data = malloc(sizeof(struct interrupt_data));
if (!int_data)
return retval;
int_data->cb = cb;
int_data->data = arg;
int_data->base.deleted = false;
int_data->base.refcount = 1;
retval = gpio_init_int(dev, pullup, flank, gpio_cb, int_data);
if (retval != 0) {
free(int_data);
int_data = NULL;
}
if (handler != NULL && int_data != NULL)
*handler = int_data;
return retval;
}
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(dev->ce, GPIO_DIR_OUT, GPIO_NOPULL);
/* Init CS pin */
gpio_init(dev->cs, GPIO_DIR_OUT, 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;
}
xtimer_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_rx_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, INITIAL_RX_POWER_0dB);
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);
}
int main(void)
{
lis3dh_t dev;
lis3dh_data_t acc_data;
puts("LIS3DH accelerometer driver test application\n");
printf("Initializing SPI_%i... ", TEST_LIS3DH_SPI);
if (spi_init_master(TEST_LIS3DH_SPI, SPI_CONF, SPI_SPEED) == 0) {
puts("[OK]");
}
else {
puts("[Failed]\n");
return 1;
}
puts("Initializing LIS3DH sensor... ");
if (lis3dh_init(&dev, TEST_LIS3DH_SPI, TEST_LIS3DH_CS, SCALE) == 0) {
puts("[OK]");
}
else {
puts("[Failed]\n");
return 1;
}
puts("Set ODR... ");
if (lis3dh_set_odr(&dev, ODR) == 0) {
puts("[OK]");
}
else {
puts("[Failed]\n");
return 1;
}
puts("Set scale... ");
if (lis3dh_set_scale(&dev, SCALE) == 0) {
puts("[OK]");
}
else {
puts("[Failed]\n");
return 1;
}
puts("Set axes XYZ... ");
if (lis3dh_set_axes(&dev, LIS3DH_AXES_XYZ) == 0) {
puts("[OK]");
}
else {
puts("[Failed]\n");
return 1;
}
puts("Enable streaming FIFO mode... ");
if (lis3dh_set_fifo(&dev, LIS3DH_FIFO_MODE_STREAM, WATERMARK_LEVEL) == 0) {
puts("[OK]");
}
else {
puts("[Failed]\n");
return 1;
}
puts("Enable temperature reading... ");
if (lis3dh_set_aux_adc(&dev, 1, 1) == 0) {
puts("[OK]");
}
else {
puts("[Failed]\n");
return 1;
}
puts("Set INT1 watermark function... ");
if (lis3dh_set_int1(&dev, LIS3DH_CTRL_REG3_I1_WTM_MASK) == 0) {
puts("[OK]");
}
else {
puts("[Failed]\n");
return 1;
}
puts("Set INT1 callback");
if (gpio_init_int(TEST_LIS3DH_INT1, GPIO_IN, GPIO_RISING, test_int1, (void*)&int1_count) == 0) {
puts("[OK]");
}
else {
puts("[Failed]\n");
return 1;
}
puts("LIS3DH init done.\n");
while (1) {
int fifo_level;
fifo_level = lis3dh_get_fifo_level(&dev);
printf("int1_count = %d\n", int1_count);
printf("Reading %d measurements\n", fifo_level);
while (fifo_level > 0) {
int16_t temperature;
int int1;
if (lis3dh_read_xyz(&dev, &acc_data) != 0) {
puts("Reading acceleration data... ");
puts("[Failed]\n");
}
if (lis3dh_read_aux_adc3(&dev, &temperature) != 0) {
puts("Reading temperature data... ");
puts("[Failed]\n");
return 1;
}
int1 = gpio_read(TEST_LIS3DH_INT1);
printf("X: %6d Y: %6d Z: %6d Temp: %6d, INT1: %08x\n",
acc_data.acc_x, acc_data.acc_y, acc_data.acc_z, temperature, int1);
--fifo_level;
}
xtimer_usleep(SLEEP);
}
return 0;
}
static int pir_activate_int(pir_t *dev)
{
return gpio_init_int(dev->gpio_dev, GPIO_NOPULL, GPIO_BOTH, pir_callback, dev);
}
int nrf24l01p_init(nrf24l01p_t *dev, spi_t spi, gpio_t ce, gpio_t cs, gpio_t irq)
{
int status;
static const char INITIAL_TX_ADDRESS[] = {0xe7, 0xe7, 0xe7, 0xe7, 0xe7,};
static const 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(dev->ce, GPIO_OUT);
/* Init CS pin */
spi_init_cs(dev->spi, dev->cs);
/* Init IRQ pin */
gpio_init_int(dev->irq, GPIO_IN_PU, GPIO_FALLING, nrf24l01p_rx_cb, dev);
/* Test the SPI connection */
if (spi_acquire(dev->spi, dev->cs, SPI_MODE, SPI_CLK) != SPI_OK) {
DEBUG("error: unable to acquire SPI bus with given params\n");
return -1;
}
spi_release(dev->spi);
xtimer_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_rx_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, INITIAL_RX_POWER_0dB);
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);
}
int main(void)
{
(RCC->AHBENR |= RCC_AHBENR_GPIOAEN);
(RCC->AHBENR |= RCC_AHBENR_GPIOBEN);
// initialize ringbuffer for received packets
packet_queue_init();
switch_init();
led_init();
board_uart0_init(); //uart_init wird von syscalls schon vorher aufgerufen - hoffentlich zumindest
//<just for debug>
// GPIO_9 SW1
// GPIO_10 SW2
// GPIO_11 SW4
// GPIO_12 nRF-IRQ
gpio_init_int(GPIO_9, GPIO_PULLDOWN, GPIO_FALLING, (void *)test, 0); //wird extern auf high gezogen
gpio_irq_enable(GPIO_9);
led1_on();
// </just for debug>
// initialize radio driver
radio_nrf_init();
radio_nrf_register_rx_callback(packet_received);
//eeprom_init();
// TODO get node address from eeprom
// if not available, go through algorithm to determine new address:
// 1. generate randomly address of length 11 bit
// 2. send PING with generated address
// 3. wait X seconds for answer (ping_answer)
// 4. if no answer received, accept address and save it
// 5. if an answer is received, start over with 1.
// (or determine another address on another way)
//
while (1) {
// we can go to sleep here
// THIS DOES NOT WAKE UP!
// (if needed, thread has to be woken up externally)
thread_sleep();
}
return 0;
}
static int nd_init(netdev2_t *netdev)
{
enc28j60_t *dev = (enc28j60_t *)netdev;
int res;
uint8_t tmp;
/* get exclusive access of the device */
mutex_lock(&dev->devlock);
/* setup the low-level interfaces */
gpio_init(dev->reset_pin, GPIO_OUT);
gpio_clear(dev->reset_pin); /* this puts the device into reset state */
gpio_init(dev->cs_pin, GPIO_OUT);
gpio_set(dev->cs_pin);
gpio_init_int(dev->int_pin, GPIO_IN, GPIO_FALLING, on_int, (void *)dev);
res = spi_init_master(dev->spi, SPI_CONF_FIRST_RISING, SPI_SPEED);
if (res < 0) {
DEBUG("[enc28j60] init: error initializing SPI bus [%i]\n", res);
return -1;
}
/* wait at least 1ms and then release device from reset state */
xtimer_usleep(DELAY_RESET);
gpio_set(dev->reset_pin);
/* wait for oscillator to be stable before proceeding */
res = 0;
do {
tmp = cmd_rcr(dev, REG_ESTAT, -1);
if (res++ >= STARTUP_TIMEOUT) {
DEBUG("[enc28j60] init: error waiting for stable clock, SPI ok?\n");
return -1;
}
} while (!(tmp & ESTAT_CLKRDY));
/* disable clock output to save a little power */
cmd_wcr(dev, REG_B3_ECOCON, 3, 0x00);
/* BUFFER configuration */
/* configure the RX buffer */
cmd_w_addr(dev, ADDR_RX_START, BUF_RX_START);
cmd_w_addr(dev, ADDR_RX_END, BUF_RX_END);
cmd_w_addr(dev, ADDR_RX_READ, BUF_RX_START);
/* configure the TX buffer */
cmd_w_addr(dev, ADDR_TX_START, BUF_TX_START);
cmd_w_addr(dev, ADDR_TX_END, BUF_TX_END);
/* FILTER configuration */
/* setup receive filters - we accept everything per default */
cmd_wcr(dev, REG_B1_ERXFCON, 1, 0);
/* MAC configuration */
/* enable RX through filter and enable sending of RX and TX pause frames */
tmp = (MACON1_TXPAUS | MACON1_RXPAUS | MACON1_MARXEN);
cmd_wcr(dev, REG_B2_MACON1, 2, tmp);
/* enable full duplex mode, padding to min 60 byte + CRC for all frames and
* CRC creation for all packets before transmission */
tmp = (MACON3_FULDPX | MACON3_PADCFG0 | MACON3_TXCRCEN | MACON3_FRMLNEN);
cmd_wcr(dev, REG_B2_MACON3, 2, tmp);
/* defer TX infinitely if medium is busy for IEEE 802.3 compliance */
tmp = (MACON4_DEFER);
cmd_wcr(dev, REG_B2_MACON4, 2, tmp);
/* set back-to-back inter-packet gap -> 0x15 for full duplex */
cmd_wcr(dev, REG_B2_MABBIPG, 2, MABBIPG_FD);
/* set non-back-to-back inter packet gap -> 0x12 is default */
cmd_wcr(dev, REG_B2_MAIPGL, 2, MAIPGL_FD);
/* set default MAC address */
#if CPUID_LEN
uint8_t macbuf[CPUID_LEN];
cpuid_get(&macbuf); /* we get the full ID but use only parts of it */
macbuf[0] |= 0x02; /* locally administered address */
macbuf[0] &= ~0x01; /* unicast address */
#else
uint8_t macbuf[] = ENC28J60_FALLBACK_MAC;
#endif
mac_set(dev, macbuf);
/* PHY configuration */
cmd_w_phy(dev, REG_PHY_PHCON1, PHCON1_PDPXMD);
cmd_w_phy(dev, REG_PHY_PHIE, PHIE_PLNKIE | PHIE_PGEIE);
/* Finishing touches */
/* enable hardware flow control */
cmd_wcr(dev, REG_B3_EFLOCON, 3, EFLOCON_FULDPXS | EFLOCON_FCEN1);
/* enable auto-inc of read and write pointers for the RBM/WBM commands */
cmd_bfs(dev, REG_ECON2, -1, ECON2_AUTOINC);
/* enable receive, link and tx interrupts */
cmd_bfc(dev, REG_EIR, -1, (EIR_LINKIF | EIR_PKTIF | EIR_RXERIF | EIR_TXIF |
EIR_TXERIF));
cmd_bfs(dev, REG_EIE, -1, (EIE_INTIE | EIE_LINKIE | EIE_PKTIE | EIE_RXERIE |
EIE_TXIE | EIE_TXERIE));
/* allow receiving bytes from now on */
cmd_bfs(dev, REG_ECON1, -1, ECON1_RXEN);
#ifdef MODULE_NETSTATS_L2
memset(&netdev->stats, 0, sizeof(netstats_t));
#endif
mutex_unlock(&dev->devlock);
return 0;
}
