int mpu9150_init(mpu9150_t *dev, i2c_t i2c, mpu9150_hw_addr_t hw_addr, mpu9150_comp_addr_t comp_addr) { char temp; dev->i2c_dev = i2c; dev->hw_addr = hw_addr; dev->comp_addr = comp_addr; dev->conf = DEFAULT_STATUS; /* Initialize I2C interface */ if (i2c_init_master(dev->i2c_dev, I2C_SPEED_FAST)) { DEBUG("[Error] I2C device not enabled\n"); return -1; } /* Acquire exclusive access */ i2c_acquire(dev->i2c_dev); /* Reset MPU9150 registers and afterwards wake up the chip */ i2c_write_reg(dev->i2c_dev, dev->hw_addr, MPU9150_PWR_MGMT_1_REG, MPU9150_PWR_RESET); hwtimer_wait(HWTIMER_TICKS(MPU9150_RESET_SLEEP_US)); i2c_write_reg(dev->i2c_dev, dev->hw_addr, MPU9150_PWR_MGMT_1_REG, MPU9150_PWR_WAKEUP); /* Release the bus, it is acquired again inside each function */ i2c_release(dev->i2c_dev); /* Set default full scale ranges and sample rate */ mpu9150_set_gyro_fsr(dev, MPU9150_GYRO_FSR_2000DPS); mpu9150_set_accel_fsr(dev, MPU9150_ACCEL_FSR_2G); mpu9150_set_sample_rate(dev, MPU9150_DEFAULT_SAMPLE_RATE); /* Disable interrupt generation */ i2c_acquire(dev->i2c_dev); i2c_write_reg(dev->i2c_dev, dev->hw_addr, MPU9150_INT_ENABLE_REG, REG_RESET); /* Initialize magnetometer */ if (compass_init(dev)) { i2c_release(dev->i2c_dev); return -2; } /* Release the bus, it is acquired again inside each function */ i2c_release(dev->i2c_dev); mpu9150_set_compass_sample_rate(dev, 10); /* Enable all sensors */ i2c_acquire(dev->i2c_dev); i2c_write_reg(dev->i2c_dev, dev->hw_addr, MPU9150_PWR_MGMT_1_REG, MPU9150_PWR_PLL); i2c_read_reg(dev->i2c_dev, dev->hw_addr, MPU9150_PWR_MGMT_2_REG, &temp); temp &= ~(MPU9150_PWR_ACCEL | MPU9150_PWR_GYRO); i2c_write_reg(dev->i2c_dev, dev->hw_addr, MPU9150_PWR_MGMT_2_REG, temp); i2c_release(dev->i2c_dev); hwtimer_wait(HWTIMER_TICKS(MPU9150_PWR_CHANGE_SLEEP_US)); return 0; }
void sender(void) { unsigned int i = 0; msg_t mesg; transceiver_command_t tcmd; radio_packet_t p; mesg.type = SND_PKT; mesg.content.ptr = (char *) &tcmd; tcmd.transceivers = TRANSCEIVER_NATIVE; tcmd.data = &p; p.length = PACKET_SIZE; p.dst = 0; puts("Start sending packets"); while (1) { /* filling uint8_t buffer with uint16_t sequence number */ snd_buffer[0] = (i & 0xFF00) >> 8; snd_buffer[1] = i & 0x00FF; p.data = snd_buffer; i++; msg_send(&mesg, transceiver_pid); hwtimer_wait(HWTIMER_TICKS(SENDING_DELAY)); } }
void cc2420_reset(void) { P4OUT |= CC2420_VREGEN_PIN; P4OUT &= ~CC2420_RESETn_PIN; hwtimer_wait(500); P4OUT |= CC2420_RESETn_PIN; }
int main(void) { int radio_pid; uint8_t i; for (i = 0; i < SND_BUFFER_SIZE; i++) { memset(snd_buffer[i], i, CC1100_MAX_DATA_LENGTH); } thread_create(shell_stack_buffer, SHELL_STACK_SIZE, PRIORITY_MAIN-2, CREATE_STACKTEST, shell_runner, "shell"); radio_pid = thread_create(radio_stack_buffer, RADIO_STACK_SIZE, PRIORITY_MAIN-2, CREATE_STACKTEST, radio, "radio"); transceiver_init(TRANSCEIVER_CC1100); transceiver_start(); transceiver_register(TRANSCEIVER_CC1100, radio_pid); sender(NULL); printf("Config:\n"); printf("\tid: %u\n", sysconfig.id); printf("\taddr: %u\n", sysconfig.radio_address); printf("\tchannel: %u\n", sysconfig.radio_channel); while (1) { extern void thread_print_all(void); thread_print_all(); print_buffer(NULL); hwtimer_wait(50000); } }
void cc110x_cs(void) { volatile int retry_count = 0; /* Switch MISO/GDO1 to GPIO input mode */ gpio_init_in(CC110X_GDO1, GPIO_NOPULL); /* CS to low */ gpio_clear(CC110X_CS); /* Wait for SO to go low (voltage regulator * has stabilized and the crystal is running) */ while (gpio_read(CC110X_GDO1)) { /* Wait ~500us and try again */ hwtimer_wait(CS_SO_WAIT_TIME); if (gpio_read(CC110X_GDO1)) { retry_count++; if (retry_count > CC1100_GDO1_LOW_RETRY) { puts("[CC1100 SPI] fatal error\n"); break; } gpio_set(CC110X_CS); gpio_clear(CC110X_CS); } } /* Switch MISO/GDO1 to SPI mode */ spi_conf_pins(CC110X_SPI); }
int main(void) { int16_t a; msg_t mesg; transceiver_command_t tcmd; printf("\n\tmain(): initializing transceiver\n"); transceiver_init(TRANSCEIVER_NATIVE); printf("\n\tmain(): starting transceiver\n"); transceiver_start(); #ifndef SENDER printf("\n\tmain(): starting radio thread\n"); kernel_pid_t radio_pid = thread_create( radio_stack_buffer, sizeof(radio_stack_buffer), PRIORITY_MAIN - 2, CREATE_STACKTEST, radio, NULL, "radio"); transceiver_register(TRANSCEIVER_NATIVE, radio_pid); #endif #ifdef SENDER a = SENDER_ADDR; #elif defined ADDR a = ADDR; #else a = DEFAULT_RCV_ADDR; #endif tcmd.transceivers = TRANSCEIVER_NATIVE; tcmd.data = &a; mesg.content.ptr = (char *) &tcmd; mesg.type = SET_ADDRESS; printf("[nativenet] trying to set address %" PRIi16 "\n", a); msg_send_receive(&mesg, &mesg, transceiver_pid); #ifdef SENDER hwtimer_wait(HWTIMER_TICKS(SECOND)); sender(); #else hwtimer_wait(HWTIMER_TICKS(WAIT_TIME * SECOND)); receiving = 0; printf("Missed %u of %u packets after %u seconds\n", missed_cnt, (last_seq - first), WAIT_TIME); #endif return 0; }
int reboot_arch(int mode) { printf("Going into reboot, mode %i\n", mode); /* wait 1 ms to make sure the printf is finished */ hwtimer_wait(HWTIMER_TICKS(1000)); NVIC_SystemReset(); return -1; }
void nrf24l01p_transmit(nrf24l01p_t *dev) { gpio_set(dev->ce); hwtimer_wait(DELAY_CE_HIGH_US); /* at least 10 us high */ gpio_clear(dev->ce); hwtimer_spin(DELAY_CHANGE_TXRX_US); }
void cc2420_init(int tpid) { uint16_t reg; transceiver_pid = tpid; cc2420_spi_init(); hwtimer_wait(CC2420_WAIT_TIME); cc2420_reset(); cc2420_strobe(CC2420_STROBE_XOSCON); //enable crystal while((cc2420_strobe(NOBYTE) & 0x40) == 0); //wait for crystal to be stable hwtimer_wait(CC2420_WAIT_TIME); reg = cc2420_read_reg(CC2420_REG_MDMCTRL0); reg |= CC2420_ADR_DECODE; //enable adr decode reg |= CC2420_AUTOACK; //enable auto ack reg |= CC2420_AUTOCRC; //enable auto crc reg &= ~(CC2420_RES_FRM_MODE); //disable reserved frames cc2420_write_reg(CC2420_REG_MDMCTRL0, reg); /* Change default values as recomended in the data sheet, */ /* RX bandpass filter = 1.3uA. */ reg = cc2420_read_reg(CC2420_REG_RXCTRL1); reg |= CC2420_RXBPF_LOCUR; cc2420_write_reg(CC2420_REG_RXCTRL1, reg); /* Set the FIFOP threshold to maximum. */ cc2420_write_reg(CC2420_REG_IOCFG0, 127); /* Turn off "Security enable" (page 32). */ reg = cc2420_read_reg(CC2420_REG_SECCTRL0); reg &= ~CC2420_RXFIFO_PROTECTION; cc2420_write_reg(CC2420_REG_SECCTRL0, reg); /* set output power to 0dbm */ cc2420_write_reg(CC2420_REG_TXCTRL, 0xA0FF); cc2420_set_channel(CC2420_DEFAULT_CHANNR); cc2420_set_pan(0x1111); DEBUG("CC2420 initialized and set to channel %i and pan %i\n", radio_channel, radio_pan); cc2420_init_interrupts(); cc2420_switch_to_rx(); }
/** * Configure bypass mode * Caution: This internal function does not acquire exclusive access to the I2C bus. * Acquisation and release is supposed to be handled by the calling function. */ static void conf_bypass(mpu9150_t *dev, uint8_t bypass_enable) { char data; i2c_read_reg(dev->i2c_dev, dev->hw_addr, MPU9150_USER_CTRL_REG, &data); if (bypass_enable) { data &= ~(BIT_I2C_MST_EN); i2c_write_reg(dev->i2c_dev, dev->hw_addr, MPU9150_USER_CTRL_REG, data); hwtimer_wait(HWTIMER_TICKS(MPU9150_BYPASS_SLEEP_US)); i2c_write_reg(dev->i2c_dev, dev->hw_addr, MPU9150_INT_PIN_CFG_REG, BIT_I2C_BYPASS_EN); } else { data |= BIT_I2C_MST_EN; i2c_write_reg(dev->i2c_dev, dev->hw_addr, MPU9150_USER_CTRL_REG, data); hwtimer_wait(HWTIMER_TICKS(MPU9150_BYPASS_SLEEP_US)); i2c_write_reg(dev->i2c_dev, dev->hw_addr, MPU9150_INT_PIN_CFG_REG, REG_RESET); } }
static void reset(void) { cc110x_wakeup_from_rx(); #ifdef MODULE_CC110x_SPI cc110x_spi_select(); #endif cc110x_strobe(CC1100_SRES); hwtimer_wait(RTIMER_TICKS(100)); }
int main(void) { printf("when the race condition is hit, hwtimer will wait a very very long time...\n"); while (1) { for (unsigned long i = 256; i; i = i >> 1) { printf("wait %lu\n", i); hwtimer_wait(i); } } }
static void power_up_reset(void) { #ifdef MODULE_CC110x_SPI cc110x_spi_unselect(); cc110x_spi_cs(); cc110x_spi_unselect(); #endif hwtimer_wait(RESET_WAIT_TIME); reset(); radio_state = RADIO_IDLE; }
/************************************************************************************************ * @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 */ enableIRQ(); /* Wait 2 ticks (66us) to allow internal reference to settle */ hwtimer_wait(2); /* Start ADC12 */ ADC12CTL0 |= ADC12ENC; /* Clear data ready flag */ adc12_data_ready = 0; /* Sampling and conversion start */ ADC12CTL0 |= ADC12SC; /* Wait until ADC12 has finished */ hwtimer_wait(5); 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(nrf24l01p_t *dev) { char read; int status; nrf24l01p_read_reg(dev, REG_CONFIG, &read); status = nrf24l01p_write_reg(dev, REG_CONFIG, (read & ~PWR_UP)); hwtimer_wait(DELAY_CHANGE_PWR_MODE_US); return status; }
void sixlowpan_mac_send_ieee802154_frame(const ieee_802154_long_t *addr, const uint8_t *payload, uint8_t length, uint8_t mcast) { uint16_t daddr; /* TODO: check if dedicated response struct is necessary */ msg_t transceiver_rsp; r_src_addr = local_address; mesg.type = SND_PKT; mesg.content.ptr = (char *) &tcmd; tcmd.transceivers = transceiver_type; tcmd.data = &p; ieee802154_frame_t frame; memset(&frame, 0, sizeof(frame)); set_ieee802154_fcf_values(&frame, IEEE_802154_LONG_ADDR_M, IEEE_802154_LONG_ADDR_M); set_ieee802154_frame_values(&frame); memcpy(&(frame.dest_addr[0]), &(addr->uint8[0]), 8); memcpy(&(frame.src_addr[0]), &(iface.laddr.uint8[0]), 8); daddr = HTONS(addr->uint16[3]); frame.payload = (uint8_t *)payload; // payload won't be changed so cast is legal. frame.payload_len = length; uint8_t hdrlen = get_802154_hdr_len(&frame); memset(&buf, 0, PAYLOAD_SIZE); init_802154_frame(&frame, (uint8_t *)&buf); memcpy(&buf[hdrlen], frame.payload, frame.payload_len); /* set FCS */ /* RSSI = 0 */ buf[frame.payload_len+hdrlen] = 0; /* FCS Valid = 1 / LQI Correlation Value = 0 */ buf[frame.payload_len+hdrlen+1] = 0x80; DEBUG("IEEE802.15.4 frame - FCF: %02X %02X DPID: %02X SPID: %02X DSN: %02X\n", buf[0], buf[1], frame->dest_pan_id, frame->src_pan_id, frame->seq_nr); p.length = hdrlen + frame.payload_len + IEEE_802154_FCS_LEN; if (mcast == 0) { p.dst = daddr; } else { p.dst = 0; } p.data = buf; msg_send_receive(&mesg, &transceiver_rsp, transceiver_pid); hwtimer_wait(5000); }
int main(void) { puts("FLASH!"); int *bad; int *foo; hwtimer_init(); printf("%04X\n", WDMOD); hwtimer_wait(1000 * 1000); memcpy(bad, foo, 1000); return 0; }
/** * @set TX mode */ int cmd_send(int argc, char **argv) { (void) argc; (void) argv; puts("Send"); int status = 0; char tx_buf[NRF24L01P_MAX_DATA_LENGTH]; /* fill TX buffer with numbers 32..1 */ for (int i = 0; i < sizeof(tx_buf); i++) { tx_buf[i] = NRF24L01P_MAX_DATA_LENGTH - i; } /* power on the device */ if (nrf24l01p_on(&nrf24l01p_0) < 0) { puts("Error in nrf24l01p_on"); return; } /* setup device as transmitter */ if (nrf24l01p_set_txmode(&nrf24l01p_0) < 0) { puts("Error in nrf24l01p_set_txmode"); return; } /* load data to transmit into device */ if (nrf24l01p_preload(&nrf24l01p_0, tx_buf, NRF24L01P_MAX_DATA_LENGTH) < 0) { puts("Error in nrf24l01p_preload"); return; } /* trigger transmitting */ nrf24l01p_transmit(&nrf24l01p_0); /* wait while data is pysically transmitted */ hwtimer_wait(DELAY_DATA_ON_AIR); /* get status of the transceiver */ status = nrf24l01p_get_status(&nrf24l01p_0); if (status < 0) { puts("Error in nrf24l01p_get_status"); } if (status & TX_DS) { puts("Sent Packet"); } /* setup device as receiver */ if (nrf24l01p_set_rxmode(&nrf24l01p_0) < 0) { puts("Error in nrf24l01p_set_rxmode"); return 1; } return 0; }
uint32_t srf02_get_distance(uint8_t ranging_mode) { bool status = false; uint8_t reg_size = 1; uint8_t range_high_byte = 0; uint8_t range_low_byte = 0; uint8_t rx_buff[reg_size]; uint8_t tx_buff[reg_size]; uint32_t distance = 0; tx_buff[0] = ranging_mode; status = i2c_write(SRF02_I2C_INTERFACE, SRF02_DEFAULT_ADDR, SRF02_COMMAND_REG, tx_buff, reg_size); if (!status) { puts("Write the ranging command to the i2c-interface is failed"); distance = UINT32_MAX; return distance; } hwtimer_wait(HWTIMER_TICKS(65000)); status = i2c_read(SRF02_I2C_INTERFACE, SRF02_DEFAULT_ADDR, SRF02_RANGE_HIGH_BYTE, rx_buff, reg_size); if (!status) { puts("Read the high echo byte from the i2c-interface is failed"); distance = UINT32_MAX; return distance; } range_high_byte = rx_buff[0]; status = i2c_read(SRF02_I2C_INTERFACE, SRF02_DEFAULT_ADDR, SRF02_RANGE_LOW_BYTE, rx_buff, reg_size); if (!status) { puts("Read the low echo byte from the i2c-interface is failed"); distance = UINT32_MAX; return distance; } range_low_byte = rx_buff[0]; distance = (range_high_byte << 8) | range_low_byte; //printf("%u | %u\n", range_high_byte, range_low_byte); return distance; }
int mpu9150_set_gyro_power(mpu9150_t *dev, mpu9150_pwr_t pwr_conf) { char pwr_2_setting; if (dev->conf.gyro_pwr == pwr_conf) { return 0; } /* Acquire exclusive access */ if (i2c_acquire(dev->i2c_dev)) { return -1; } /* Read current power management 2 configuration */ i2c_read_reg(dev->i2c_dev, dev->hw_addr, MPU9150_PWR_MGMT_2_REG, &pwr_2_setting); /* Prepare power register settings */ if (pwr_conf == MPU9150_SENSOR_PWR_ON) { /* Set clock to pll */ i2c_write_reg(dev->i2c_dev, dev->hw_addr, MPU9150_PWR_MGMT_1_REG, MPU9150_PWR_PLL); pwr_2_setting &= ~(MPU9150_PWR_GYRO); } else { /* Configure power management 1 register */ if ((dev->conf.accel_pwr == MPU9150_SENSOR_PWR_OFF) && (dev->conf.compass_pwr == MPU9150_SENSOR_PWR_OFF)) { /* All sensors turned off, put the MPU-9150 to sleep */ i2c_write_reg(dev->i2c_dev, dev->hw_addr, MPU9150_PWR_MGMT_1_REG, BIT_PWR_MGMT1_SLEEP); } else { /* Reset clock to internal oscillator */ i2c_write_reg(dev->i2c_dev, dev->hw_addr, MPU9150_PWR_MGMT_1_REG, MPU9150_PWR_WAKEUP); } pwr_2_setting |= MPU9150_PWR_GYRO; } /* Enable/disable gyroscope standby in power management 2 register */ i2c_write_reg(dev->i2c_dev, dev->hw_addr, MPU9150_PWR_MGMT_2_REG, pwr_2_setting); /* Release the bus */ i2c_release(dev->i2c_dev); dev->conf.gyro_pwr = pwr_conf; hwtimer_wait(HWTIMER_TICKS(MPU9150_PWR_CHANGE_SLEEP_US)); return 0; }
int main(void) { int radio_pid; uint8_t i; for (i = 0; i < SND_BUFFER_SIZE; i++) { memset(snd_buffer[i], i, CC1100_MAX_DATA_LENGTH); } thread_create(shell_stack_buffer, SHELL_STACK_SIZE, PRIORITY_MAIN-1, CREATE_STACKTEST, shell_runner, "shell"); radio_pid = thread_create(radio_stack_buffer, RADIO_STACK_SIZE, PRIORITY_MAIN-2, CREATE_STACKTEST, radio, "radio"); transceiver_init(TRANSCEIVER_CC1100); transceiver_start(); transceiver_register(TRANSCEIVER_CC1100, radio_pid); while (1) { // LED_GREEN_TOGGLE; hwtimer_wait(1000 * 1000); } }
void ping(radio_address_t addr, uint8_t channr) { cc1100_set_packet_handler(protocol_id, pong_handler); cc1100_set_channel(channr); cc1100_set_address(r_address); while(1) { vtimer_now(&start); int trans_ok = cc1100_send_csmaca(addr, protocol_id, 2, pipa->payload, sizeof(pipa->payload)); if(trans_ok < 0) { print_failed(); } hwtimer_wait(500000); } }
int mpu9150_set_compass_power(mpu9150_t *dev, mpu9150_pwr_t pwr_conf) { char pwr_1_setting, usr_ctrl_setting, s1_do_setting; if (dev->conf.compass_pwr == pwr_conf) { return 0; } /* Acquire exclusive access */ if (i2c_acquire(dev->i2c_dev)) { return -1; } /* Read current user control configuration */ i2c_read_reg(dev->i2c_dev, dev->hw_addr, MPU9150_USER_CTRL_REG, &usr_ctrl_setting); /* Prepare power register settings */ if (pwr_conf == MPU9150_SENSOR_PWR_ON) { pwr_1_setting = MPU9150_PWR_WAKEUP; s1_do_setting = MPU9150_COMP_SINGLE_MEASURE; usr_ctrl_setting |= BIT_I2C_MST_EN; } else { pwr_1_setting = BIT_PWR_MGMT1_SLEEP; s1_do_setting = MPU9150_COMP_POWER_DOWN; usr_ctrl_setting &= ~(BIT_I2C_MST_EN); } /* Configure power management 1 register if needed */ if ((dev->conf.gyro_pwr == MPU9150_SENSOR_PWR_OFF) && (dev->conf.accel_pwr == MPU9150_SENSOR_PWR_OFF)) { i2c_write_reg(dev->i2c_dev, dev->hw_addr, MPU9150_PWR_MGMT_1_REG, pwr_1_setting); } /* Configure mode writing by slave line 1 */ i2c_write_reg(dev->i2c_dev, dev->hw_addr, MPU9150_SLAVE1_DATA_OUT_REG, s1_do_setting); /* Enable/disable I2C master mode */ i2c_write_reg(dev->i2c_dev, dev->hw_addr, MPU9150_USER_CTRL_REG, usr_ctrl_setting); /* Release the bus */ i2c_release(dev->i2c_dev); dev->conf.compass_pwr = pwr_conf; hwtimer_wait(HWTIMER_TICKS(MPU9150_PWR_CHANGE_SLEEP_US)); return 0; }
void sender(char *count) { unsigned int c = 3; unsigned int i; mesg.type = SND_PKT; mesg.content.ptr = (char*) &tcmd; tcmd.transceivers = TRANSCEIVER_CC1100; tcmd.data = &p; p.length = CC1100_MAX_DATA_LENGTH; p.dst = 0; for (i = 0; i < c; i++) { puts("."); p.data = snd_buffer[i % SND_BUFFER_SIZE]; msg_send(&mesg, transceiver_pid, 1); hwtimer_wait(50000); } }
int main(void) { puts("hwtimer test application..."); puts(""); puts(" Timers should print \"callback x\" once when they run out."); printf(" The order for x is 1, n-1, n-2, ..., 2 where n is the number of available hardware timers (%u on this platform).\n", HWTIMER_MAXTIMERS); puts(" One timer should fire every second until all timers have run out."); puts(" Additionally the message \"hwtimer set.\" should be printed once 1 second from now."); puts(""); puts("Setting timers:"); puts(""); unsigned long delay = BASE_DELAY + ((HWTIMER_MAXTIMERS - 1) * DELTA_DELAY); /* make the first timer first to fire so timers do not run out linearly */ char *msgn = msg; snprintf(msgn, MSGLEN, "callback %2x", 1); hwtimer_set(HWTIMER_TICKS(BASE_DELAY), callback, (void *) msgn); printf("set %s\n", msgn); /* set up to HWTIMER_MAXTIMERS-1 because hwtimer_wait below also * needs a timer */ for (int i = 1; i < (HWTIMER_MAXTIMERS - 1); i++) { msgn = msg + (i * MSGLEN); delay -= DELTA_DELAY; snprintf(msgn, MSGLEN, "callback %2x", i + 1); hwtimer_set(HWTIMER_TICKS(delay), callback, (void *) msgn); printf("set %s\n", msgn); } puts(""); puts("All timers set."); puts(""); hwtimer_wait(HWTIMER_TICKS(1000UL * 1000UL)); puts("hwtimer set."); thread_sleep(); return 0; }
void srf02_start_ranging(uint16_t ranging_mode) { uint32_t distance = 0; while (1) { distance = srf02_get_distance(ranging_mode); if (distance != UINT32_MAX) { switch (ranging_mode) { case SRF02_REAL_RANGING_MODE_CM : printf("distance = %lu cm\n", distance); break; case SRF02_REAL_RANGING_MODE_INCH : printf("distance = %lu inch\n", distance); break; case SRF02_REAL_RANGING_MODE_MICRO_SEC: // dist_m = 0.000172 distance_micro_sec (air) printf("distance = %lu micro_sec\n", distance); break; case SRF02_FAKE_RANGING_MODE_CM: case SRF02_FAKE_RANGING_MODE_INCH: case SRF02_FAKE_RANGING_MODE_MICRO_SEC: printf("distance fake ranging = %lu \n", distance); break; default: printf("distance = %lu cm\n", distance); } hwtimer_wait(HWTIMER_TICKS(50000)); } else { break; } } puts("The SRF02 range sampling is ended!!"); }
int mpu9150_set_accel_power(mpu9150_t *dev, mpu9150_pwr_t pwr_conf) { char pwr_1_setting, pwr_2_setting; if (dev->conf.accel_pwr == pwr_conf) { return 0; } /* Acquire exclusive access */ if (i2c_acquire(dev->i2c_dev)) { return -1; } /* Read current power management 2 configuration */ i2c_read_reg(dev->i2c_dev, dev->hw_addr, MPU9150_PWR_MGMT_2_REG, &pwr_2_setting); /* Prepare power register settings */ if (pwr_conf == MPU9150_SENSOR_PWR_ON) { pwr_1_setting = MPU9150_PWR_WAKEUP; pwr_2_setting &= ~(MPU9150_PWR_ACCEL); } else { pwr_1_setting = BIT_PWR_MGMT1_SLEEP; pwr_2_setting |= MPU9150_PWR_ACCEL; } /* Configure power management 1 register if needed */ if ((dev->conf.gyro_pwr == MPU9150_SENSOR_PWR_OFF) && (dev->conf.compass_pwr == MPU9150_SENSOR_PWR_OFF)) { i2c_write_reg(dev->i2c_dev, dev->hw_addr, MPU9150_PWR_MGMT_1_REG, pwr_1_setting); } /* Enable/disable accelerometer standby in power management 2 register */ i2c_write_reg(dev->i2c_dev, dev->hw_addr, MPU9150_PWR_MGMT_2_REG, pwr_2_setting); /* Release the bus */ i2c_release(dev->i2c_dev); dev->conf.accel_pwr = pwr_conf; hwtimer_wait(HWTIMER_TICKS(MPU9150_PWR_CHANGE_SLEEP_US)); return 0; }
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 cc110x_rx_handler(void) { uint8_t res = 0; // Possible packet received, RX -> IDLE (0.1 us) rflags.CAA = 0; rflags.MAN_WOR = 0; cc110x_statistic.packets_in++; res = receive_packet((uint8_t*)&(cc110x_rx_buffer[rx_buffer_next].packet), sizeof(cc110x_packet_t)); if (res) { // If we are sending a burst, don't accept packets. // Only ACKs are processed (for stopping the burst). // Same if state machine is in TX lock. if (radio_state == RADIO_SEND_BURST || rflags.TX) { cc110x_statistic.packets_in_while_tx++; return; } cc110x_rx_buffer[rx_buffer_next].rssi = rflags._RSSI; cc110x_rx_buffer[rx_buffer_next].lqi = rflags._LQI; cc110x_strobe(CC1100_SFRX); // ...for flushing the RX FIFO // Valid packet. After a wake-up, the radio should be in IDLE. // So put CC1100 to RX for WOR_TIMEOUT (have to manually put // the radio back to sleep/WOR). //cc110x_spi_write_reg(CC1100_MCSM0, 0x08); // Turn off FS-Autocal cc110x_write_reg(CC1100_MCSM2, 0x07); // Configure RX_TIME (until end of packet) cc110x_strobe(CC1100_SRX); hwtimer_wait(IDLE_TO_RX_TIME); radio_state = RADIO_RX; #ifdef DBG_IGNORE if (is_ignored(cc110x_rx_buffer[rx_buffer_next].packet.phy_src)) { LED_RED_TOGGLE; return; } #endif /* notify transceiver thread if any */ if (transceiver_pid) { msg_t m; m.type = (uint16_t) RCV_PKT_CC1100; m.content.value = rx_buffer_next; msg_send_int(&m, transceiver_pid); } /* shift to next buffer element */ if (++rx_buffer_next == RX_BUF_SIZE) { rx_buffer_next = 0; } return; } else { // No ACK received so TOF is unpredictable rflags.TOF = 0; // CRC false or RX buffer full -> clear RX FIFO in both cases cc110x_strobe(CC1100_SIDLE); // Switch to IDLE (should already be)... cc110x_strobe(CC1100_SFRX); // ...for flushing the RX FIFO // If packet interrupted this nodes send call, // don't change anything after this point. if (radio_state == RADIO_AIR_FREE_WAITING) { cc110x_strobe(CC1100_SRX); hwtimer_wait(IDLE_TO_RX_TIME); return; } // If currently sending, exit here (don't go to RX/WOR) if (radio_state == RADIO_SEND_BURST) { cc110x_statistic.packets_in_while_tx++; return; } // No valid packet, so go back to RX/WOR as soon as possible cc110x_switch_to_rx(); } }
void ng_at86rf2xx_reset(ng_at86rf2xx_t *dev) { #if CPUID_ID_LEN uint8_t cpuid[CPUID_ID_LEN]; eui64_t addr_long; #endif /* trigger hardware reset */ gpio_clear(dev->reset_pin); hwtimer_wait(HWTIMER_TICKS(RESET_DELAY)); gpio_set(dev->reset_pin); /* reset options and sequence number */ dev->seq_nr = 0; dev->options = 0; /* set short and long address */ #if CPUID_ID_LEN cpuid_get(cpuid); #if CPUID_ID_LEN < 8 /* in case CPUID_ID_LEN < 8, fill missing bytes with zeros */ for (int i = CPUID_ID_LEN; i < 8; i++) { cpuid[i] = 0; } #else for (int i = 8; i < CPUID_ID_LEN; i++) { cpuid[i & 0x07] ^= cpuid[i]; } #endif /* make sure we mark the address as non-multicast and not globally unique */ cpuid[0] &= ~(0x01); cpuid[0] |= 0x02; /* copy and set long address */ memcpy(&addr_long, cpuid, 8); ng_at86rf2xx_set_addr_long(dev, NTOHLL(addr_long.uint64.u64)); ng_at86rf2xx_set_addr_short(dev, NTOHS(addr_long.uint16[0].u16)); #else ng_at86rf2xx_set_addr_long(dev, NG_AT86RF2XX_DEFAULT_ADDR_LONG); ng_at86rf2xx_set_addr_short(dev, NG_AT86RF2XX_DEFAULT_ADDR_SHORT); #endif /* set default PAN id */ ng_at86rf2xx_set_pan(dev, NG_AT86RF2XX_DEFAULT_PANID); /* set default channel */ ng_at86rf2xx_set_chan(dev, NG_AT86RF2XX_DEFAULT_CHANNEL); /* set default TX power */ ng_at86rf2xx_set_txpower(dev, NG_AT86RF2XX_DEFAULT_TXPOWER); /* set default options */ ng_at86rf2xx_set_option(dev, NG_AT86RF2XX_OPT_AUTOACK, true); ng_at86rf2xx_set_option(dev, NG_AT86RF2XX_OPT_CSMA, true); ng_at86rf2xx_set_option(dev, NG_AT86RF2XX_OPT_TELL_RX_START, false); ng_at86rf2xx_set_option(dev, NG_AT86RF2XX_OPT_TELL_RX_END, true); /* set default protocol */ #ifdef MODULE_NG_SIXLOWPAN dev->proto = NG_NETTYPE_SIXLOWPAN; #else dev->proto = NG_NETTYPE_UNDEF; #endif /* enable safe mode (protect RX FIFO until reading data starts) */ ng_at86rf2xx_reg_write(dev, NG_AT86RF2XX_REG__TRX_CTRL_2, NG_AT86RF2XX_TRX_CTRL_2_MASK__RX_SAFE_MODE); #ifdef MODULE_NG_AT86RF212B ng_at86rf2xx_set_freq(dev,NG_AT86RF2XX_FREQ_915MHZ); #endif /* don't populate masked interrupt flags to IRQ_STATUS register */ uint8_t tmp = ng_at86rf2xx_reg_read(dev, NG_AT86RF2XX_REG__TRX_CTRL_1); tmp &= ~(NG_AT86RF2XX_TRX_CTRL_1_MASK__IRQ_MASK_MODE); ng_at86rf2xx_reg_write(dev, NG_AT86RF2XX_REG__TRX_CTRL_1, tmp); /* enable interrupts */ ng_at86rf2xx_reg_write(dev, NG_AT86RF2XX_REG__IRQ_MASK, NG_AT86RF2XX_IRQ_STATUS_MASK__TRX_END); /* clear interrupt flags */ ng_at86rf2xx_reg_read(dev, NG_AT86RF2XX_REG__IRQ_STATUS); /* go into RX state */ ng_at86rf2xx_set_state(dev, NG_AT86RF2XX_STATE_RX_AACK_ON); DEBUG("ng_at86rf2xx_reset(): reset complete.\n"); }