static int _init(netdev2_t *netdev) { at86rf2xx_t *dev = (at86rf2xx_t *)netdev; /* initialise GPIOs */ spi_init_cs(dev->params.spi, 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; }
static int _init(netdev_t *encdev) { encx24j600_t *dev = (encx24j600_t *) encdev; DEBUG("encx24j600: starting initialization...\n"); /* setup IO */ if (spi_init_cs(dev->spi, dev->cs) != SPI_OK) { return -1; } gpio_init_int(dev->int_pin, GPIO_IN_PU, GPIO_FALLING, encx24j600_isr, (void*)dev); 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(&encdev->stats, 0, sizeof(netstats_t)); #endif return 0; }
static int _init(netdev_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 */ spi_init_cs(dev->params.spi, 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); }
int adt7310_init(adt7310_t *dev, spi_t spi, spi_clk_t clk, gpio_t cs) { int status; uint8_t reg = 0; /* write device descriptor */ dev->spi = spi; dev->clk = clk; dev->cs = cs; dev->initialized = false; dev->high_res = false; /* CS */ spi_init_cs(dev->spi, dev->cs); #if ENABLE_DEBUG for (int i = 0; i < 8; ++i) { uint16_t dbg_reg = 0; status = adt7310_read_reg(dev, i, sizeof(dbg_reg), (uint8_t *)&dbg_reg); if (status != 0) { printf("Error reading address 0x%02x", i); } dbg_reg = htons(dbg_reg); printf("%02x: %04" PRIx16 "\n", i, dbg_reg); } #endif /* Read ID register from device */ status = adt7310_read_reg(dev, ADT7310_REG_ID, ADT7310_REG_SIZE_ID, ®); if (status != 0) { /* SPI bus error */ return -1; } if ((reg & ADT7310_REG_ID_MASK_MANUFACTURER_ID) != ADT7310_EXPECTED_MANUF_ID) { /* Wrong part ID */ return -2; } /* Set a configuration, go to shut down mode to save power until the sensor is needed. */ if (adt7310_set_config(dev, ADT7310_MODE_SHUTDOWN) != 0) { /* communication error */ return -3; } dev->initialized = true; return 0; }
int ds3234_pps_init(const ds3234_params_t *dev) { /* initialize CS pin */ int res = spi_init_cs(dev->spi, dev->cs); if (res < 0) { return DS3234_NO_SPI; } DEBUG("ds3234: init on SPI_DEV(%u)\n", dev->spi); if (ENABLE_DEBUG) { for (int k = 0; k <= 0x19; ++k) { uint8_t dbg_reg = 0; ds3234_read_reg(dev, k, 1, &dbg_reg); DEBUG("%2x: %2x\n", k, dbg_reg); } } uint8_t reg = 0; ds3234_read_reg(dev, DS323X_REG_CONTROL, 1, ®); /* set reg to a non-zero known value to check if device is present */ reg |= DS323X_REG_CONTROL_RS1_MASK; ds3234_write_reg(dev, DS323X_REG_CONTROL, 1, ®); uint8_t readback = 0; ds3234_read_reg(dev, DS323X_REG_CONTROL, 1, &readback); if (reg != readback) { DEBUG("ds3234: readback mismatch: expected %u, actual %u\n", (unsigned)reg, (unsigned)readback); return DS3234_NO_DEV; } /* The control register is configured to: * - Enable the oscillator * - Enable an square wave output on the SQW pin * - Sets the square wave frequency to 1 Hz */ reg &= ~(DS323X_REG_CONTROL_EOSC_MASK | DS323X_REG_CONTROL_INTCN_MASK | DS323X_REG_CONTROL_RS1_MASK | DS323X_REG_CONTROL_RS2_MASK); ds3234_write_reg(dev, DS323X_REG_CONTROL, 1, ®); return DS3234_OK; }
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(reset, GPIO_OUT); gpio_init(mode, GPIO_OUT); DEBUG("done with gpios\n"); /* clear CS line */ DEBUG("done clearing CS line\n"); /* initialize SPI */ spi_init_cs(spi, (spi_cs_t)cs); DEBUG("done initializing SPI master\n"); /* reset display */ gpio_clear(reset); xtimer_usleep(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 */ lock(dev); _write(dev, MODE_CMD, CMD_ENABLE_H); _write(dev, MODE_CMD, CMD_MODE_NORMAL); done(dev); return 0; }
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); }