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