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; }
static int _reg_write(const ccs811_t *dev, uint8_t reg, uint8_t *data, uint32_t len) { DEBUG_DEV("write %"PRIu32" bytes to sensor registers starting at addr %02x", dev, len, reg); int res = CCS811_OK; if (ENABLE_DEBUG && data && len) { printf("[css811] %s dev=%d addr=%02x: write following bytes: ", __func__, dev->params.i2c_dev, dev->params.i2c_addr); for (unsigned i = 0; i < len; i++) { printf("%02x ", data[i]); } printf("\n"); } if (i2c_acquire(dev->params.i2c_dev)) { DEBUG_DEV("could not aquire I2C bus", dev); return -CCS811_ERROR_I2C; } #if MODULE_CCS811_FULL if (dev->params.wake_pin != GPIO_UNDEF) { /* wake the sensor with low active WAKE signal */ gpio_clear(dev->params.wake_pin); /* t_WAKE is 50 us */ xtimer_usleep(50); } #endif if (!data || !len) { res = i2c_write_byte(dev->params.i2c_dev, dev->params.i2c_addr, reg, 0); } else { res = i2c_write_regs(dev->params.i2c_dev, dev->params.i2c_addr, reg, data, len, 0); } i2c_release(dev->params.i2c_dev); #if MODULE_CCS811_FULL if (dev->params.wake_pin != GPIO_UNDEF) { /* let the sensor enter to sleep mode */ gpio_set(dev->params.wake_pin); /* minimum t_DWAKE is 20 us */ xtimer_usleep(20); } #endif if (res != CCS811_OK) { DEBUG_DEV("could not write %"PRIu32" bytes to sensor registers " "starting at addr %02x, reason %i", dev, len, reg, res); return -CCS811_ERROR_I2C; } return CCS811_OK; }
void at86rf2xx_hardware_reset(at86rf2xx_t *dev) { /* wake up from sleep in case radio is sleeping */ at86rf2xx_assert_awake(dev); /* trigger hardware reset */ gpio_clear(dev->reset_pin); xtimer_usleep(AT86RF2XX_RESET_PULSE_WIDTH); gpio_set(dev->reset_pin); xtimer_usleep(AT86RF2XX_RESET_DELAY); }
int main(void) { isl29125_t dev; isl29125_rgb_t data; color_rgb_t data8bit; memset(&data, 0x00, sizeof(data)); puts("ISL29125 light sensor test application\n"); printf("Initializing ISL29125 sensor at I2C_%i... ", TEST_ISL29125_I2C); if (isl29125_init(&dev, TEST_ISL29125_I2C, TEST_ISL29125_IRQ_PIN, ISL29125_MODE_RGB, ISL29125_RANGE_10K, ISL29125_RESOLUTION_16) == 0) { puts("[OK]\n"); } else { puts("[Failed]"); return 1; } /* try out some modes */ static const isl29125_mode_t modes[] = { ISL29125_MODE_DOWN, ISL29125_MODE_STANDBY, ISL29125_MODE_RGB, ISL29125_MODE_R, ISL29125_MODE_G, ISL29125_MODE_B, ISL29125_MODE_RG, ISL29125_MODE_GB}; static const char* mode_names[] = { "ISL29125_MODE_DOWN", "ISL29125_MODE_STANDBY", "ISL29125_MODE_RGB", "ISL29125_MODE_R", "ISL29125_MODE_G", "ISL29125_MODE_B", "ISL29125_MODE_RG", "ISL29125_MODE_GB"}; for (int i = 0; i < sizeof(modes); i++) { printf("Setting mode %s\n", mode_names[i]); isl29125_set_mode(&dev, modes[i]); xtimer_usleep(SLEEP); isl29125_read_rgb_color(&dev, &data8bit); printf("RGB value: (%3i / %3i / %3i) 8 bit\n", data8bit.r, data8bit.g, data8bit.b); } puts("Resetting mode to RGB and reading continuously"); isl29125_set_mode(&dev, ISL29125_MODE_RGB); xtimer_usleep(SLEEP); while (1) { isl29125_read_rgb_lux(&dev, &data); printf("RGB value: (%5i / %5i / %5i) lux\n", (int)data.red, (int)data.green, (int)data.blue); xtimer_usleep(SLEEP); } return 0; }
int ping_cmd(int argc, char **argv) { ipv6_addr_t dst; int payload_len, _num; if ((argc < 2) || (ipv6_addr_from_str(&dst, argv[1]) == NULL)) { usage(argv[0]); return 1; } if ((argc < 3) || ((_num = atoi(argv[2])) == 0)) { _num = 3; } if ((argc < 4) || ((payload_len = atoi(argv[3])) == 0)) { payload_len = 16; } atomic_store(&num, _num); atomic_store(&received, 0); seq = 0; if (recv_ntfy.callback == NULL) { uip_icmp6_echo_reply_callback_add(&recv_ntfy, handle_reply); } for (uint16_t i = 0; i < _num; i++) { _waiting = true; ping_send((uip_ipaddr_t *)&dst, payload_len); xtimer_usleep(1000000); if (_waiting) { puts("Timeout"); } } return 0; }
int main(void) { dht_t dev; puts("DHT temperature and humidity sensor test application\n"); printf("Initializing DHT sensor at GPIO_%ld... ", (long)DHT_GPIO); if (dht_init(&dev, DHT_TYPE, DHT_GPIO) == 0) { puts("[OK]\n"); } else { puts("[Failed]"); return 1; } dht_data_t data; float temp, hum; while (1) { if (dht_read_raw(&dev, &data) == -1) { puts("error reading data"); } dht_parse(&dev, &data, &hum, &temp); printf("raw relative humidity: %i\nraw temperature: %i C\n", data.humidity, data.temperature); printf("relative humidity: %i\ntemperature: %i C\n", (int) hum, (int) temp); xtimer_usleep(2000 * MS_IN_USEC); } return 0; }
void cc110x_cs(cc110x_t *dev) { volatile int retry_count = 0; /* Switch MISO/GDO1 to GPIO input mode */ #ifndef GPIO_READS_SPI_PINS gpio_init(dev->params.gdo1, GPIO_DIR_IN, GPIO_NOPULL); #endif /* CS to low */ gpio_clear(dev->params.cs); /* Wait for SO to go low (voltage regulator * has stabilized and the crystal is running) */ while (gpio_read(dev->params.gdo1)) { /* Wait ~500us and try again */ xtimer_usleep(CS_SO_WAIT_TIME); if (gpio_read(dev->params.gdo1)) { retry_count++; if (retry_count > CC110X_GDO1_LOW_RETRY) { puts("[CC110X spi] fatal error\n"); break; } gpio_set(dev->params.cs); gpio_clear(dev->params.cs); } } /* Switch MISO/GDO1 to spi mode */ #ifndef GPIO_READS_SPI_PINS spi_conf_pins(dev->params.spi); #endif }
/** * @brief Measure the illuminance with a TCS37727. * * @ return illuminance in lux */ long get_illuminance(void) { tcs37727_data_t data; // enable TCS37727 and start the measurment if (tcs37727_set_rgbc_active(&tcsDev) != 0) { puts("[sensors] ERROR: TCS37727 activation failed"); return -1; } // wait for the measurment to finish xtimer_usleep(2400 + tcsDev.atime_us); if (tcs37727_read(&tcsDev, &data) != 0) { puts("[sensors] ERROR: TCS37727 reading data failed"); return -1; } printf("[sensors] INFO: TCS37727 Data R: %5"PRIu32" G: %5"PRIu32 " B: %5"PRIu32" C: %5"PRIu32"\n", data.red, data.green, data.blue, data.clear); printf("[sensors] INFO: TCS37727 Data CT : %5"PRIu32" Lux: %6"PRIu32 " AGAIN: %2d ATIME %d\n", data.ct, data.lux, tcsDev.again, tcsDev.atime_us); // disable the TCS37727 if (tcs37727_set_rgbc_standby(&tcsDev) != 0) { puts("[sensors] ERROR: TCS37727 deactivation failed"); } return data.lux; }
static int udp_send(char *addr_str, char *port_str, char *data, unsigned int num, unsigned int delay) { sock_udp_ep_t dst = SOCK_IPV6_EP_ANY; uint8_t byte_data[SHELL_DEFAULT_BUFSIZE / 2]; size_t data_len; /* parse destination address */ if (ipv6_addr_from_str((ipv6_addr_t *)&dst.addr.ipv6, addr_str) == NULL) { puts("Error: unable to parse destination address"); return 1; } /* parse port */ dst.port = atoi(port_str); data_len = hex2ints(byte_data, data); for (unsigned int i = 0; i < num; i++) { sock_udp_t *sock = NULL; if (server_running) { sock = &server_sock; } if (sock_udp_send(sock, byte_data, data_len, &dst) < 0) { puts("could not send"); } else { printf("Success: send %u byte over UDP to [%s]:%" PRIu16 "\n", (unsigned)data_len, addr_str, dst.port); } xtimer_usleep(delay); } return 0; }
int main(void) { puts("PIR motion sensor test application\n"); printf("Initializing PIR sensor at GPIO_%ld... ", (long)PIR_GPIO); if (pir_init(&dev, PIR_GPIO) == 0) { puts("[OK]\n"); } else { puts("[Failed]"); return 1; } #if TEST_PIR_POLLING puts("Printing sensor state every second."); while (1) { printf("Status: %s\n", pir_get_status(&dev) == PIR_STATUS_LO ? "lo" : "hi"); xtimer_usleep(1000 * 1000); } #else thread_create( pir_handler_stack, sizeof(pir_handler_stack), THREAD_PRIORITY_MAIN - 1, THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST, pir_handler, NULL, "pir_handler"); #endif return 0; }
int main(void) { lis3mdl_t dev; lis3mdl_3d_data_t mag_value; int16_t temp_value = 0; puts("\nLIS3MDL test application"); printf("Initializing LIS3MDL sensor at I2C_%i ... \n", TEST_LIS3MDL_I2C); if (lis3mdl_init(&dev, TEST_LIS3MDL_I2C, TEST_LIS3MDL_MAG_ADDR, LIS3MDL_XY_MODE_MEDIUM, LIS3MDL_Z_MODE_MEDIUM, LIS3MDL_ODR_10Hz, LIS3MDL_SCALE_4G, LIS3MDL_OP_CONT_CONV) == 0) { puts("[ OK ]\n"); } else { puts("[ FAIL ]\n"); return 1; } while(1){ lis3mdl_read_mag(&dev, &mag_value); printf("Magnetometer [G]:\tX: %2d\tY: %2d\tZ: %2d\n", mag_value.x_axis, mag_value.y_axis, mag_value.z_axis); lis3mdl_read_temp(&dev, &temp_value); printf("Temperature:\t\t%i°C\n", temp_value); xtimer_usleep(SLEEP); } return 0; }
uint16_t bh1750fvi_sample(const bh1750fvi_t *dev) { uint32_t tmp; uint8_t raw[2]; /* power on the device and send single H-mode measurement command */ DEBUG("[bh1750fvi] sample: triggering a conversion\n"); i2c_acquire(dev->i2c); i2c_write_byte(dev->i2c, dev->addr, OP_POWER_ON, 0); i2c_write_byte(dev->i2c, dev->addr, OP_SINGLE_HRES1, 0); i2c_release(dev->i2c); /* wait for measurement to complete */ xtimer_usleep(DELAY_HMODE); /* read the results */ DEBUG("[bh1750fvi] sample: reading the results\n"); i2c_acquire(dev->i2c); i2c_read_bytes(dev->i2c, dev->addr, raw, 2, 0); i2c_release(dev->i2c); /* and finally we calculate the actual LUX value */ tmp = ((uint32_t)raw[0] << 24) | ((uint32_t)raw[1] << 16); tmp /= RES_DIV; return (uint16_t)(tmp); }
int main(void) { int16_t data; puts("ADCXX1C analog to digital driver test application\n"); printf("Initializing ADCXX1C analog to digital at I2C_DEV(%i)... ", adcxx1c_params->i2c); if (adcxx1c_init(&dev, adcxx1c_params) == ADCXX1C_OK) { puts("[OK]\n"); } else { puts("[Failed]"); return -1; } puts("Enabling alert interrupt: "); if (adcxx1c_enable_alert(&dev, alert_cb, NULL) == ADCXX1C_OK) { puts("[OK]\n"); } else { puts("[Failed]"); return -1; } while (1) { adcxx1c_read_raw(&dev, &data); printf("Raw analog value: %d\n", data); xtimer_usleep(SLEEP); } return 0; }
int main(void) { hdc1000_t dev; int16_t temp, hum; size_t len; char tstr[8]; char hstr[8]; puts("HDC1000 Temperature and Humidity Sensor driver test application\n"); printf("Initializing HDC1000 sensor at I2C_DEV(%i)... ", (int)hdc1000_params[0].i2c); if (hdc1000_init(&dev, &hdc1000_params[0]) == HDC1000_OK) { puts("[OK]\n"); } else { puts("[Failed]"); return 1; } while (1) { hdc1000_read(&dev, &temp, &hum); len = fmt_s16_dfp(tstr, temp, 2); tstr[len] = '\0'; len = fmt_s16_dfp(hstr, hum, 2); hstr[len] = '\0'; printf("Reading: T: %s °C RH: %s %%\n", tstr, hstr); xtimer_usleep(SLEEP); } return 0; }
static void _init_interface(void) { gnrc_netif_t *netif; netdev_test_setup(&_ieee802154_dev, NULL); netdev_test_set_get_cb(&_ieee802154_dev, NETOPT_DEVICE_TYPE, _get_netdev_device_type); netdev_test_set_get_cb(&_ieee802154_dev, NETOPT_PROTO, _get_netdev_proto); netdev_test_set_get_cb(&_ieee802154_dev, NETOPT_MAX_PDU_SIZE, _get_netdev_max_packet_size); netdev_test_set_get_cb(&_ieee802154_dev, NETOPT_SRC_LEN, _get_netdev_src_len); netdev_test_set_get_cb(&_ieee802154_dev, NETOPT_ADDRESS_LONG, _get_netdev_addr_long); netif = gnrc_netif_ieee802154_create( _netif_stack, THREAD_STACKSIZE_DEFAULT, GNRC_NETIF_PRIO, "dummy_netif", (netdev_t *)&_ieee802154_dev); ipv6_addr_t addr = IPV6_ADDR_UNSPECIFIED; /* fd01::01 */ addr.u8[0] = 0xfd; addr.u8[1] = 0x01; addr.u8[15] = 0x01; xtimer_usleep(500); /* wait for thread to start */ if (gnrc_netapi_set(netif->pid, NETOPT_IPV6_ADDR, 64U << 8U, &addr, sizeof(addr)) < 0) { printf("error: unable to add IPv6 address fd01::1/64 to interface %u\n", netif->pid); } }
int main(void) { tcs37727_t dev; tcs37727_data_t data; puts("TCS37727 RGBC Data; Sensor driver test application\n"); printf("Initializing TCS37727 sensor at I2C_%i... ", TEST_TCS37727_I2C); if (tcs37727_init(&dev, TEST_TCS37727_I2C, TEST_TCS37727_ADDR, TCS37727_ATIME_DEFAULT) == 0) { puts("[OK]\n"); } else { puts("[Failed]"); return -1; } if (tcs37727_set_rgbc_active(&dev)) { puts("Measurement start failed."); return -1; } while (1) { tcs37727_read(&dev, &data); printf("R: %5"PRIu32" G: %5"PRIu32" B: %5"PRIu32" C: %5"PRIu32"\n", data.red, data.green, data.blue, data.clear); printf("CT : %5"PRIu32" Lux: %6"PRIu32" AGAIN: %2d ATIME %d\n", data.ct, data.lux, dev.again, dev.atime_us); xtimer_usleep(SLEEP); } return 0; }
void *_stats_print(void *arg) { (void) arg; while (1) { if (print_stats) { printf("RPL;%u" ",%"PRIu32",%"PRIu32",%"PRIu32",%"PRIu32 ",%"PRIu32",%"PRIu32",%"PRIu32",%"PRIu32 ",%"PRIu32",%"PRIu32",%"PRIu32",%"PRIu32 ",%"PRIu32",%"PRIu32",%"PRIu32",%"PRIu32 ",%"PRIu32",%"PRIu32",%"PRIu32",%"PRIu32 ",%"PRIu32",%"PRIu32",%"PRIu32",%"PRIu32 ",%"PRIu32",%"PRIu32",%"PRIu32",%"PRIu32 ",%"PRIu32",%"PRIu32",%"PRIu32",%"PRIu32 "\n", gnrc_rpl_instances[0].dodag.my_rank, rps->dio_rx_ucast_count, rps->dio_rx_ucast_bytes, rps->dio_rx_mcast_count, rps->dio_rx_mcast_bytes, rps->dio_tx_ucast_count, rps->dio_tx_ucast_bytes, rps->dio_tx_mcast_count, rps->dio_tx_mcast_bytes, rps->dis_rx_ucast_count, rps->dis_rx_ucast_bytes, rps->dis_rx_mcast_count, rps->dis_rx_mcast_bytes, rps->dis_tx_ucast_count, rps->dis_tx_ucast_bytes, rps->dis_tx_mcast_count, rps->dis_tx_mcast_bytes, rps->dao_rx_ucast_count, rps->dao_rx_ucast_bytes, rps->dao_rx_mcast_count, rps->dao_rx_mcast_bytes, rps->dao_tx_ucast_count, rps->dao_tx_ucast_bytes, rps->dao_tx_mcast_count, rps->dao_tx_mcast_bytes, rps->dao_ack_rx_ucast_count, rps->dao_ack_rx_ucast_bytes, rps->dao_ack_rx_mcast_count, rps->dao_ack_rx_mcast_bytes, rps->dao_ack_tx_ucast_count, rps->dao_ack_tx_ucast_bytes, rps->dao_ack_tx_mcast_count, rps->dao_ack_tx_mcast_bytes ); } xtimer_usleep(STATS_INTERVAL); } return NULL; }
int main(void) { lps331ap_t dev; int temp, pres; int temp_abs, pres_abs; puts("LPS331AP pressure sensor test application\n"); printf("Initializing LPS331AP sensor at I2C_%i... ", TEST_LPS331AP_I2C); if (lps331ap_init(&dev, TEST_LPS331AP_I2C, TEST_LPS331AP_ADDR, RATE) == 0) { puts("[OK]\n"); } else { puts("[Failed]"); return 1; } while (1) { pres = lps331ap_read_pres(&dev); temp = lps331ap_read_temp(&dev); pres_abs = pres / 1000; pres -= pres_abs * 1000; temp_abs = temp / 1000; temp -= temp_abs * 1000; printf("Pressure value: %2i.%03i bar - Temperature: %2i.%03i °C\n", pres_abs, pres, temp_abs, temp); xtimer_usleep(SLEEP); } return 0; }
int main(void) { puts("MPL3115A2 pressure sensor driver test application\n"); printf("Initializing MPL3115A2 sensor at I2C_%i... ", mpl3115a2_params[0].i2c); if (mpl3115a2_init(&dev, &mpl3115a2_params[0]) != MPL3115A2_OK) { puts("[FAILED] init device!"); return 1; } if (mpl3115a2_set_active(&dev) != MPL3115A2_OK) { puts("[FAILED] activate measurement!"); return 2; } puts("[SUCCESS]"); while (1) { uint32_t pressure; int16_t temp; uint8_t status; xtimer_usleep(SLEEP); if ((mpl3115a2_read_pressure(&dev, &pressure, &status) | mpl3115a2_read_temp(&dev, &temp)) != MPL3115A2_OK) { puts("[FAILED] read values!"); } else { printf("Pressure: %u Pa, Temperature: %3d.%d C, State: %#02x\n", (unsigned int)pressure, temp/10, abs(temp%10), status); } } return 0; }
int main(void) { lis3mdl_t dev; puts("LIS3MDL test application"); puts("Initializing LIS3MDL sensor"); if (lis3mdl_init(&dev, &lis3mdl_params[0]) == 0) { puts("[ OK ]\n"); } else { puts("[ FAIL ]\n"); return 1; } while(1) { lis3mdl_3d_data_t mag_value; lis3mdl_read_mag(&dev, &mag_value); printf("Magnetometer [G]:\tX: %2d\tY: %2d\tZ: %2d\n", mag_value.x_axis, mag_value.y_axis, mag_value.z_axis); int16_t temp_value; lis3mdl_read_temp(&dev, &temp_value); printf("Temperature:\t\t%i°C\n", temp_value); xtimer_usleep(SLEEP); } return 0; }
static void _reset(cc430radio_t *dev) { DEBUG("%s:%s:%u\n", RIOT_FILE_RELATIVE, __func__, __LINE__); cc430radio_wakeup_from_rx(dev); cc430radio_cs(dev); cc430radio_strobe(dev, CC430RADIO_SRES); xtimer_usleep(100); }
static void *colllision_detection(void *arg) { uint32_t lw = xtimer_now(); while (1) { /* trigger sensor reading */ srf02_trigger(&dist_front, SRF02_MODE_REAL_CM); srf02_trigger(&dist_back, SRF02_MODE_REAL_CM); /* wait for results */ xtimer_usleep(SRF02_RANGE_DELAY); /* read distance data */ front_filter[filter_pos] = srf02_read(&dist_front); xtimer_usleep(1); /* hack, otherwise the 2nd srf02_read f***s up */ back_filter[filter_pos] = srf02_read(&dist_back); // printf(" f: %3i, b: %3i %i\n", (int)front_filter[filter_pos], (int)back_filter[filter_pos], filter_pos); filter_pos = (++filter_pos >= FILTER_SIZE) ? 0 : filter_pos; /* analyze data and trigger events base on it */ uint16_t fd = 0; uint16_t bd = 0; for (int i = 0; i < FILTER_SIZE; i++) { fd += front_filter[i]; bd += back_filter[i]; } if ((fd < (FILTER_SIZE * CONF_DIST_THOLD)) && (front_blocked == 0)) { front_blocked = 1; event(EVT_FRONT_BLOCKED); } else if ((fd >= (FILTER_SIZE * CONF_DIST_THOLD)) && (front_blocked == 1)) { front_blocked = 0; event(EVT_FRONT_FREE); } if ((bd < (FILTER_SIZE * CONF_DIST_THOLD)) && (back_blocked == 0)) { back_blocked = 1; event(EVT_BACK_BLOCKED); } else if ((bd >= (FILTER_SIZE * CONF_DIST_THOLD)) && (back_blocked == 1)) { back_blocked = 0; event(EVT_BACK_FREE); } xtimer_usleep_until(&lw, CONF_DIST_SENSE_DELAY); } return NULL; }
int main(void) { io1_xplained_t dev; float temperature; int result; puts("IO1 Xplained extention test application\n"); printf("+------------Initializing------------+\n"); result = io1_xplained_init(&dev, TEST_ADDR); if (result == -1) { puts("[Error] Cannot initialize the IO1 Xplained extension\n"); return 1; } else { printf("Initialization successful\n\n"); } printf("\n+--------Starting tests --------+\n"); while (1) { /* Get temperature in degrees celsius */ io1_xplained_read_temperature(&dev, &temperature); printf("Temperature [°C]: %.2f\n" "\n+-------------------------------------+\n", temperature); xtimer_usleep(SLEEP_1S); /* set led */ io1_xplained_set_led(); xtimer_usleep(SLEEP_1S); /* clear led */ io1_xplained_clear_led(); xtimer_usleep(SLEEP_1S); /* toggle led */ io1_xplained_toggle_led(); xtimer_usleep(SLEEP_1S); /* toggle led again */ io1_xplained_toggle_led(); xtimer_usleep(SLEEP_1S); } return 0; }
void nrf24l01p_transmit(const nrf24l01p_t *dev) { gpio_set(dev->ce); xtimer_usleep(DELAY_CE_HIGH_US); /* at least 10 us high */ gpio_clear(dev->ce); xtimer_spin(DELAY_CHANGE_TXRX_TICKS); }
uint16_t srf02_get_distance(srf02_t *dev, srf02_mode_t mode) { /* trigger a new reading */ srf02_trigger(dev, mode); /* give the sensor the required time for sampling */ xtimer_usleep(SRF02_RANGE_DELAY); /* get the results */ return srf02_read(dev); }
static void _power_up_reset(cc430radio_t *dev) { DEBUG("%s:%s:%u\n", RIOT_FILE_RELATIVE, __func__, __LINE__); //gpio_set(dev->params.cs); //gpio_clear(dev->params.cs); //gpio_set(dev->params.cs); xtimer_usleep(RESET_WAIT_TIME); _reset(dev); }
/************************************************************************************************ * @fn adc12_single_conversion * @brief Init ADC12. Do single conversion. Turn off ADC12. * @param none * @return none ************************************************************************************************/ uint16_t adc12_single_conversion(uint16_t ref, uint16_t sht, uint16_t channel) { /* Initialize the shared reference module */ REFCTL0 |= REFMSTR + ref + REFON; /* Enable internal reference (1.5V or 2.5V) */ /* Initialize ADC12_A */ ADC12CTL0 = sht + ADC12ON; /* Set sample time */ ADC12CTL1 = ADC12SHP; /* Enable sample timer */ ADC12MCTL0 = ADC12SREF_1 + channel; /* ADC input channel */ ADC12IE = 0x001; /* ADC_IFG upon conv result-ADCMEMO */ irq_enable(); /* Wait 66us to allow internal reference to settle */ xtimer_usleep(66); /* Start ADC12 */ ADC12CTL0 |= ADC12ENC; /* Clear data ready flag */ adc12_data_ready = 0; /* Sampling and conversion start */ ADC12CTL0 |= ADC12SC; /* Wait until ADC12 has finished */ xtimer_usleep(150); while (!adc12_data_ready); /* Shut down ADC12 */ ADC12CTL0 &= ~(ADC12ENC | ADC12SC | sht); ADC12CTL0 &= ~ADC12ON; /* Shut down reference voltage */ REFCTL0 &= ~(REFMSTR + ref + REFON); ADC12IE = 0; /* Return ADC result */ return adc12_result; }
int nrf24l01p_off(const nrf24l01p_t *dev) { char read; int status; nrf24l01p_read_reg(dev, REG_CONFIG, &read); status = nrf24l01p_write_reg(dev, REG_CONFIG, (read & ~PWR_UP)); xtimer_usleep(DELAY_CHANGE_PWR_MODE_US); return status; }
void ata8510_power_on(const ata8510_t *dev){ gpio_clear(dev->params.reset_pin); gpio_clear(dev->params.reset_pin); gpio_clear(dev->params.reset_pin); gpio_clear(dev->params.reset_pin); gpio_set(dev->params.reset_pin); gpio_set(dev->params.reset_pin); gpio_set(dev->params.reset_pin); gpio_set(dev->params.reset_pin); gpio_clear(dev->params.sleep_pin); xtimer_usleep(310); }
static void recover_i2c_bus(void) { /* Switch to software GPIO mode for bus recovery */ release_sda(); release_scl(); if (!bus_quiet()) { const uint_fast8_t try_limit = 200; uint_fast8_t n; for (n = 0; n < try_limit; n++) { if (bus_quiet()) { DEBUG("%s(): SDA released after%4u SCL pulses.\n", __FUNCTION__, n); break; } assert_scl(); #ifdef MODULE_XTIMER xtimer_usleep(scl_delay); #else thread_yield(); #endif release_scl(); #ifdef MODULE_XTIMER xtimer_usleep(scl_delay); #else thread_yield(); #endif } if (n >= try_limit) { DEBUG("%s(): Failed to release SDA after%4u SCL pulses.\n", __FUNCTION__, n); } } /* Return to hardware mode for the I2C pins */ gpio_hardware_control(I2C_0_SCL_PIN); gpio_hardware_control(I2C_0_SDA_PIN); }