int main(void) { hdc1000_t dev; uint16_t rawtemp, rawhum; int temp, hum; puts("HDC1000 Temperature and Humidity Sensor driver test application\n"); printf("Initializing HDC1000 sensor at I2C_%i... ", TEST_HDC1000_I2C); if (hdc1000_init(&dev, TEST_HDC1000_I2C, TEST_HDC1000_ADDR) == 0) { puts("[OK]\n"); } else { puts("[Failed]"); return -1; } while (1) { if (hdc1000_startmeasure(&dev)) { puts("Start measure failed."); return -1; } vtimer_usleep(HDC1000_CONVERSION_TIME); hdc1000_read(&dev, &rawtemp, &rawhum); printf("Raw data T: %5i RH: %5i\n", rawtemp, rawhum); hdc1000_convert(rawtemp, rawhum, &temp, &hum); printf("Data T: %d RH: %d\n", temp, hum); vtimer_usleep(SLEEP); } return 0; }
void blink(void) { struct timeval tiv; uint32_t wait; /* everyone needs to wait for microseconds=0 before starting to blink */ rtc_time(&tiv); vtimer_usleep( (uint32_t)(( 1000*1000 - tiv.tv_usec ) * VTIMER_FACTOR )); //hwtimer_spin( HWTIMER_TICKS( ( 1000*1000 - tiv.tv_usec ) * VTIMER_FACTOR ) ); printf("blink thread synced to zero\n"); while(1){ //rtc_time(&tiv); //printf("blink time usec: %lu\n", tiv.tv_usec); /* do the blink */ LED_RED_ON; //hwtimer_spin( HWTIMER_TICKS( BLINK_DURATION )); vtimer_usleep( BLINK_DURATION ); LED_RED_OFF; wait = timesync_get_master_offset(); if ( wait && ! timesync_get_synced() ){ /* be careful with debug output here, as it affects delay as well! */ //rtc_time(&tiv); //printf("(pseudo) adjusting clock from %i\n", (int) tiv.tv_usec); vtimer_usleep( (uint32_t)((wait+PROC_DELAY) * VTIMER_FACTOR) ); printf("D: waited %lu us.\n", (uint32_t)((wait+PROC_DELAY) * VTIMER_FACTOR)); timesync_set_synced(1); //rtc_time(&tiv); //printf("(pseudo) adjusting clock to %i\n", (int)tiv.tv_usec); } vtimer_usleep( BLINK_PAUSE-BLINK_DURATION); } }
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"); vtimer_usleep(1000 * 1000); } #else thread_create( pir_handler_stack, sizeof(pir_handler_stack), THREAD_PRIORITY_MAIN - 1, CREATE_WOUT_YIELD | CREATE_STACKTEST, pir_handler, NULL, "pir_handler"); #endif return 0; }
int main(void) { int res; int pos = (STEP_LOWER_BOUND + STEP_UPPER_BOUND) / 2; int step = STEP; puts("\nRIOT RC servo test"); puts("Connect an RC servo or scope to PWM_0 channel 0 to see anything"); res = servo_init(&servo, DEV, CHANNEL, SERVO_MIN, SERVO_MAX); if (res < 0) { puts("Errors while initializing servo"); return -1; } puts("Servo initialized."); while (1) { servo_set(&servo, pos); pos += step; if (pos <= STEP_LOWER_BOUND || pos >= STEP_UPPER_BOUND) { step = -step; } vtimer_usleep(WAIT); } return 0; }
void l2_ping(radio_address_t addr, uint16_t count, uint32_t interval, const char *payload, uint8_t payload_len, uint8_t probe_only) { l2_ping_type_t pt; probe_only ? (pt = L2_PROBE) : (pt = L2_PING); if (!interval) { interval = L2_PING_DEFAULT_INTERVAL; } mutex_lock(&ping_sender_mutex); l2_ping_stats.dst = addr; l2_ping_stats.ping_count = 0; l2_ping_stats.pong_count = 0; l2_ping_stats.last_rtt = timex_set(0, 0); l2_ping_stats.avg_rtt = timex_set(0, 0); l2_ping_stats.max_rtt = timex_set(0, 0); l2_ping_stats.min_rtt = timex_set(UINT32_MAX, UINT32_MAX); for (unsigned i = 1; (count == 0) || (i <= count); i++) { vtimer_now(&start); if (send_l2_packet(addr, pt, i, payload, payload_len)) { ping_sent = 1; l2_ping_stats.ping_count++; } if ((!count) || (i <= count)) { vtimer_usleep(interval); } } mutex_unlock(&ping_sender_mutex); }
void etx_clock(void) { /* * Manages the etx_beacon thread to wake up every full second +- jitter */ /* * The jittercorrection and jitter variables keep usecond values divided * through 1000 to fit into uint8 variables. * * That is why they are multiplied by 1000 when used for hwtimer_wait. */ uint8_t jittercorrection = ETX_DEF_JIT_CORRECT; uint8_t jitter = (uint8_t) (rand() % ETX_JITTER_MOD); while (true) { thread_wakeup(etx_beacon_pid); /* * Vtimer is buggy, but I seem to have no hwtimers left, so using this * for now. */ vtimer_usleep( ((ETX_INTERVAL - ETX_MAX_JITTER)*MS)+ jittercorrection*MS + jitter*MS - ETX_CLOCK_ADJUST); //hwtimer_wait( // HWTIMER_TICKS(((ETX_INTERVAL - ETX_MAX_JITTER)*MS) + jittercorrection*MS + jitter*MS - ETX_CLOCK_ADJUST)); jittercorrection = (ETX_MAX_JITTER) - jitter; jitter = (uint8_t) (rand() % ETX_JITTER_MOD); } }
void at86rf231_switch_to_rx(void) { at86rf231_disable_interrupts(); // Send a FORCE TRX OFF command at86rf231_reg_write(AT86RF231_REG__TRX_STATE, AT86RF231_TRX_STATE__FORCE_TRX_OFF); // Reset IRQ to TRX END only at86rf231_reg_write(AT86RF231_REG__IRQ_MASK, AT86RF231_IRQ_STATUS_MASK__TRX_END); // Read IRQ to clear it at86rf231_reg_read(AT86RF231_REG__IRQ_STATUS); // Enable IRQ interrupt at86rf231_enable_interrupts(); // Start RX at86rf231_reg_write(AT86RF231_REG__TRX_STATE, AT86RF231_TRX_STATE__RX_ON); // wait until it is on RX_ON state uint8_t status; uint8_t max_wait = 100; // TODO : move elsewhere, this is in 10us do { status = at86rf231_get_status(); vtimer_usleep(10); if (!--max_wait) { printf("at86rf231 : ERROR : could not enter RX_ON mode"); break; } } while ((status & AT86RF231_TRX_STATUS_MASK__TRX_STATUS) != AT86RF231_TRX_STATUS__RX_ON); }
void acc_thread(void) { int16_t acc_data[6]; int16_t norm; int state = ACC_POS_0; int count = 0; /* initialize the acceleration sensor */ puts("acc: will initialize SMB380 driver now"); SMB380_init_simple(100, SMB380_BAND_WIDTH_375HZ, SMB380_RANGE_2G); puts("acc: SMB380 initialized"); /* detect data */ while (1) { /* wait according to the sampling interval */ vtimer_usleep(SAMPLING_INTERVAL * 1000); /* get acceleration values */ SMB380_getAcceleration(SMB380_X_AXIS, &acc_data[SMB380_X_AXIS], &acc_data[SMB380_X_AXIS + 3]); SMB380_getAcceleration(SMB380_Y_AXIS, &acc_data[SMB380_Y_AXIS], &acc_data[SMB380_Y_AXIS + 3]); SMB380_getAcceleration(SMB380_Z_AXIS, &acc_data[SMB380_Z_AXIS], &acc_data[SMB380_Z_AXIS + 3]); /* evaluate the new data */ norm = math_modulus(acc_data, 3); if (norm > LOWER_TH && norm < UPPER_TH) { /* sensor is stable, evaluate all three axes */ for (int i = 0; i < 3; i++) { if (acc_data[i] > AXIS_TH) { if (state == i) { if (count <= REP_COUNT) { count++; } } else { state = i; count = 0; } } else if (acc_data[i] < -AXIS_TH) { if (state == (i + 3)) { if (count <= REP_COUNT) { count++; } } else { state = i + 3; count = 0; } } } } if (count == REP_COUNT && acc_current_pos != state) { printf("acc: new state: %i\n", state); acc_current_pos = state; } } }
int main(void) { puts("PIR motion sensor test application\n"); printf("Initializing red LED at GPIO_%i... ", GPIO_LED_RED); led_red = GPIO_LED_RED; if (gpio_init_out(led_red, GPIO_NOPULL) == 0) { puts("[OK]\n"); } else { puts("[Failed]"); return 1; } gpio_clear(led_red); printf("Initializing green LED at GPIO_%i... ", GPIO_LED_GREEN); led_green = GPIO_LED_GREEN; if (gpio_init_out(led_green, GPIO_NOPULL) == 0) { puts("[OK]\n"); } else { puts("[Failed]"); return 1; } gpio_clear(led_green); printf("Initializing PIR sensor at GPIO_%i... ", PIR_GPIO); if (pir_init(&pir, PIR_GPIO) == 0) { puts("[OK]\n"); } else { puts("[Failed]"); return 1; } kernel_pid_t pir_handler_pid = thread_create( pir_handler_stack, sizeof(pir_handler_stack), PRIORITY_MAIN - 1, CREATE_WOUT_YIELD | CREATE_STACKTEST, pir_handler, NULL, "pir_handler"); #if TEST_PIR_POLLING puts("Checking sensor state every half second."); pir_event_t status_old; while (1) { pir_event_t status = pir_get_status(&pir); if (status != status_old) { msg_t m = { .type = status, .content.ptr = (void*)&pir, }; msg_send(&m, pir_handler_pid, 0); } status_old = status; vtimer_usleep(1000 * 500); } #endif return 0; }
int main(void) { lsm303dlhc_t dev; int16_t temp_value; lsm303dlhc_3d_data_t mag_value; lsm303dlhc_3d_data_t acc_value; puts("LSM303DLHC temperature test application\n"); printf("Initializing LSM303DLHC sensor at I2C_%i... ", TEST_LSM303DLHC_I2C); if (lsm303dlhc_init(&dev, TEST_LSM303DLHC_I2C, TEST_LSM303DLHC_ACC_PIN, TEST_LSM303DLHC_MAG_PIN, TEST_LSM303DLHC_ACC_ADDR, ACC_S_RATE, ACC_SCALE, TEST_LSM303DLHC_MAG_ADDR, MAG_S_RATE, MAG_GAIN) == 0) { puts("[OK]\n"); } else { puts("[Failed]"); return 1; } while (1) { if (lsm303dlhc_read_acc(&dev, &acc_value) == 0) { printf("Accelerometer x: %i y: %i z: %i\n", acc_value.x_axis, acc_value.y_axis, acc_value.z_axis); } else { puts("\nFailed reading accelerometer values\n"); } if (lsm303dlhc_read_temp(&dev, &temp_value) == 0) { printf("Temperature value: %i degrees\n", temp_value); } else { puts("\nFailed reading value\n"); } if (lsm303dlhc_read_mag(&dev, &mag_value) == 0) { printf("Magnetometer x: %i y: %i z: %i\n", mag_value.x_axis, mag_value.y_axis, mag_value.z_axis); } else { puts("\nFailed reading magnetometer values\n"); } vtimer_usleep(SLEEP); } return 0; }
void *ccnl_riot_relay_helper_start(void *arg) { (void) arg; unsigned long us = CCNL_CHECK_RETRANSMIT_USEC; mutex_lock(&theRelay->stop_lock); while (!theRelay->halt_flag) { mutex_lock(&theRelay->global_lock); ccnl_run_events(); mutex_unlock(&theRelay->global_lock); vtimer_usleep(us); } mutex_unlock(&theRelay->stop_lock); return NULL; }
int main(void) { hih6130_t dev; puts("HIH6130 sensor driver test application\n"); printf("Initializing I2C_%i... ", TEST_HIH6130_I2C); if (i2c_init_master(TEST_HIH6130_I2C, I2C_SPEED_FAST) < 0) { puts("[Failed]"); return -1; } puts("[OK]"); printf("Initializing HIH6130 sensor at I2C_%i, address 0x%02x... ", TEST_HIH6130_I2C, TEST_HIH6130_ADDR); hih6130_init(&dev, TEST_HIH6130_I2C, TEST_HIH6130_ADDR); puts("[OK]"); while (1) { float hum = 0.f; float temp = 0.f; int status; float integral = 0.f; float fractional; vtimer_usleep(SLEEP); status = hih6130_get_humidity_temperature_float(&dev, &hum, &temp); if (status < 0) { printf("Communication error: %d\n", status); continue; } else if (status == 1) { puts("Stale values"); } /* Several platforms usually build with nano.specs, (without float printf) */ /* Split value into two integer parts for printing. */ fractional = modff(hum, &integral); printf("humidity: %4d.%04u %%", (int)integral, (unsigned int)abs(fractional * 10000.f)); fractional = modff(temp, &integral); printf(" temperature: %4d.%04u C\n", (int)integral, (unsigned int)abs(fractional * 10000.f)); } return 0; }
void sender(char *count) { unsigned int c, 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; c = atoi(count + strlen("snd ")); for (i = 0; i < c; i++) { puts("."); p.data = snd_buffer[i % SND_BUFFER_SIZE]; msg_send(&mesg, transceiver_pid, 1); vtimer_usleep(sending_delay); } }
static void *rt_timer_over(void *arg) { (void) arg; rpl_routing_entry_t *rt; while (1) { rpl_dodag_t *my_dodag = rpl_get_my_dodag(); if (my_dodag != NULL) { rt = rpl_get_routing_table(); for (uint8_t i = 0; i < RPL_MAX_ROUTING_ENTRIES; i++) { if (rt[i].used) { if (rt[i].lifetime <= 1) { memset(&rt[i], 0, sizeof(rt[i])); } else { rt[i].lifetime--; } } } /* Parent is NULL for root too */ if (my_dodag->my_preferred_parent != NULL) { if (my_dodag->my_preferred_parent->lifetime <= 1) { puts("parent lifetime timeout"); rpl_parent_update(NULL); } else { my_dodag->my_preferred_parent->lifetime--; } } } /* Wake up every second */ vtimer_usleep(1000000); } return NULL; }
void leader_elect(){ char msg_buffer[strlen(PREAMBLE) + strlen(MSG) + strlen(LE) + UID_LEN + ROUND_LEN]; gossip_node_t* node; for(int i=0;i<ROUNDS;i++){ sprintf(msg_buffer, "%s%s%s%0" ROUND_LEN_STR "i%0" UID_LEN_STR "i", PREAMBLE, MSG, LE, election_round, leader); node = gossip_get_neighbour(RANDOM); if(!node){ WARN("W: no neighbours, election failed.\n"); return; } gossip_send(node, msg_buffer, strlen(msg_buffer)); vtimer_usleep(1000*1000*10); } if( leader_get_leader() == gossip_id ){ timesync_set_trusted(1); timesync_set_synced(1); } leader_set_active(0); }
int main(void) { int res; puts("SRF02 ultrasonic ranger test application\n"); printf("Initializing SRF02 sensor at I2C_%i... ", TEST_SRF02_I2C); res = srf02_init(&srf02_0, TEST_SRF02_I2C, SRF02_DEFAULT_ADDR, TEST_SRF02_SPEED); if (res < 0) { printf("[Failed]"); return 1; } else { puts("[Ok]\n"); while(1) { uint16_t distance = srf02_get_distance(&srf02_0, TEST_MODE); printf("distance = %i cm\n", distance); vtimer_usleep(SLEEP); } } }
int main(void) { LED_RED_ON; #ifdef LED_GREEN_OFF LED_GREEN_OFF; #endif timer_over_pid = thread_create(timer_over_buf, KERNEL_CONF_STACKSIZE_MAIN, PRIORITY_MAIN-1, CREATE_WOUT_YIELD | CREATE_STACKTEST, blinker, "blinker"); while(1) { #ifdef LED_GREEN_TOGGLE LED_GREEN_TOGGLE; #endif vtimer_usleep(SEC); } return 0; }
/** * @print register */ void print_register(char reg, int num_bytes) { vtimer_init(); char buf_return[num_bytes]; int ret; gpio_clear(CS_PIN); vtimer_usleep(1); ret = spi_transfer_regs(SPI_PORT, (CMD_R_REGISTER | (REGISTER_MASK & reg)), 0, buf_return, num_bytes); gpio_set(CS_PIN); if (ret < 0) { printf("Error in read access\n"); } else { if (num_bytes < 2) { printf("0x%x returned: ", reg); for (int i = 0; i < num_bytes; i++) { prtbin(buf_return[i]); } } else { printf("0x%x returned: ", reg); for (int i = 0; i < num_bytes; i++) { printf("%x ", buf_return[i]); } printf("\n\n"); } } }
void sleep_now(char *str) { int time; sscanf(str, "sleep %i", &time); vtimer_usleep(time*1000*1000); }
static void do_sleep(int factor) { uint32_t timeout_us = (genrand_uint32() % 100000) * factor; /* PRINTF("sleep for % 8i µs.", timeout_us); */ vtimer_usleep(timeout_us); }
void boot_server(char *str) { bootstrapping(NULL); vtimer_usleep(1000*1000*2); init_tcp_server_thread(NULL); }
void boot_client(char *str) { init_tcp_cht(NULL); vtimer_usleep(1000*1000*2); connect_tcp("connect_tcp 2"); }
int handle_new_tcp_connection(socket_internal_t *current_queued_int_socket, socket_internal_t *server_socket, uint8_t pid) { msg_t msg_recv_client_ack, msg_send_client_ack; socket_t *current_queued_socket = ¤t_queued_int_socket->socket_values; uint8_t send_buffer[BUFFER_SIZE]; ipv6_hdr_t *temp_ipv6_header = ((ipv6_hdr_t *)(&send_buffer)); tcp_hdr_t *syn_ack_packet = ((tcp_hdr_t *)(&send_buffer[IPV6_HDR_LEN])); current_queued_int_socket->recv_pid = thread_getpid(); #ifdef TCP_HC current_queued_int_socket->socket_values.tcp_control.tcp_context.hc_type = FULL_HEADER; memcpy(¤t_queued_int_socket->socket_values.tcp_control.tcp_context.context_id, &server_socket->socket_values.tcp_control.tcp_context.context_id, sizeof(server_socket->socket_values.tcp_control.tcp_context.context_id)); #endif /* Remember current time */ timex_t now; vtimer_now(&now); current_queued_int_socket->socket_values.tcp_control.last_packet_time = now; current_queued_int_socket->socket_values.tcp_control.no_of_retries = 0; /* Set message type to Retry for while loop */ msg_recv_client_ack.type = TCP_RETRY; while (msg_recv_client_ack.type == TCP_RETRY) { /* Send packet */ send_tcp(current_queued_int_socket, syn_ack_packet, temp_ipv6_header, TCP_SYN_ACK, 0); /* wait for ACK from Client */ msg_receive(&msg_recv_client_ack); if (msg_recv_client_ack.type == TCP_TIMEOUT) { /* Set status of internal socket back to LISTEN */ server_socket->socket_values.tcp_control.state = LISTEN; close_socket(current_queued_int_socket); return -1; } } tcp_hdr_t *tcp_header; tcp_header = ((tcp_hdr_t *)(msg_recv_client_ack.content.ptr)); /* Check for consistency */ if (tcp_header->ack_nr != current_queued_socket->tcp_control.send_nxt + 1) { printf("TCP packets not consistent!\n"); } /* Got ack, connection established, refresh local and foreign tcp socket * status */ set_tcp_cb(¤t_queued_socket->tcp_control, tcp_header->seq_nr + 1, current_queued_socket->tcp_control.rcv_wnd, tcp_header->ack_nr, tcp_header->ack_nr, tcp_header->window); #ifdef TCP_HC /* Copy TCP context information into new socket */ memset(&server_socket->socket_values.tcp_control.tcp_context, 0, sizeof(tcp_hc_context_t)); #endif /* Update connection status information */ current_queued_socket->tcp_control.state = ESTABLISHED; /* Set status of internal socket back to LISTEN */ server_socket->socket_values.tcp_control.state = LISTEN; /* send a reply to the TCP handler after processing every information from * the TCP ACK packet */ msg_reply(&msg_recv_client_ack, &msg_send_client_ack); /* Reset PID to an unlikely value */ current_queued_int_socket->recv_pid = 255; /* Waiting for Clients ACK waiting period to time out */ vtimer_usleep(TCP_SYN_INITIAL_TIMEOUT / 2); destiny_socket_print_sockets(); return current_queued_int_socket->socket_id; }
int main(void) { lis3dh_t dev; lis3dh_data_t acc_data; int16_t temperature; puts("LIS3DH accelerometer driver test application\n"); printf("Initializing SPI_%i... ", TEST_LIS3DH_SPI); if (spi_init_master(TEST_LIS3DH_SPI, SPI_CONF_SECOND_FALLING, SPI_SPEED_10MHZ) == 0) { puts("[OK]"); } else { puts("[Failed]\n"); return 1; } puts("Initializing LIS3DH sensor... "); if (lis3dh_init(&dev, TEST_LIS3DH_SPI, TEST_LIS3DH_CS, TEST_LIS3DH_INT1, TEST_LIS3DH_INT2, 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("Disable FIFO mode... "); if (lis3dh_set_fifo(&dev, 0) == 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("LIS3DH init done.\n"); while (1) { lis3dh_read_xyz(&dev, &acc_data); if (lis3dh_read_xyz(&dev, &acc_data) != 0) { puts("Reading acceleration data... "); puts("[Failed]\n"); return 1; } if (lis3dh_read_aux_adc3(&dev, &temperature) != 0) { puts("Reading temperature data... "); puts("[Failed]\n"); return 1; } printf("Sensor data - X: %6i Y: %6i Z: %6i Temp: %6i\n", acc_data.acc_x, acc_data.acc_y, acc_data.acc_z, temperature); vtimer_usleep(SLEEP); } return 0; }
void led_thread(void) { msg_t msg; int ret; color_hsv_t hsv_0; color_hsv_t hsv_1; color_rgb_t rgb; float step_h = 1.0f; float step_s = 0.02f; float step_v = 0.02f; int step = 0; int state = 1; int limit = 1; color_rgb_t *sequ = cd_sequ; rgbled_t led; /* initialize RGB-LED */ rgbled_init(&led, PWM_0, 0, 1, 2); while (1) { /* see if something has come up */ if (state == limit) { notify_done(); ++state; } if (state >= limit) { ret = msg_receive(&msg); } else { ret = msg_try_receive(&msg); } /* if message was receive, act on it */ if (ret == 1) { printf("led: got message %i\n", msg.type); if (msg.type != last_cmd) { switch (msg.type) { case MSG_GAME_START: puts("led: starting game"); sequ = cd_sequ; state = 1; limit = GAME_LED_COUNTDOWN_LEN; last_cmd = msg.type; break; case MSG_GAME_SCORE: printf("led: displaying score: %i\n", (unsigned int)msg.content.value); if (PLAYER == msg.content.value) { puts("led: WIN sequence"); sequ = win_sequ; limit = GAME_LED_WIN_LEN; } else if (msg.content.value == GAME_STATE_DRAW) { puts("led: DRAW sequence"); sequ = draw_sequ; limit = GAME_LED_DRAW_LEN; } else { puts("led: LOSE sequence"); sequ = lose_sequ; limit = GAME_LED_LOSE_LEN; } state = 1; last_cmd = msg.type; break; } } } if (state < limit) { /* update color */ if (step == 0) { printf("led: setting color fr 0x%02x 0x%02x 0x%02x\n", sequ[state - 1].r, sequ[state - 1].g, sequ[state - 1].b); printf("led: setting color to 0x%02x 0x%02x 0x%02x\n", sequ[state].r, sequ[state].g, sequ[state].b); color_rgb2hsv(&sequ[state - 1], &hsv_0); color_rgb2hsv(&sequ[state ], &hsv_1); step_h = (hsv_0.h - hsv_1.h) / STEPS; step_s = (hsv_0.s - hsv_1.s) / STEPS; step_v = (hsv_0.v - hsv_1.v) / STEPS; printf("led: steps are h+= %i s+= %i v+= %i\n", (int)(step_h * 100),(int)(step_s * 100), (int)(step_v * 100)); } /* set color */ color_hsv2rgb(&hsv_0, &rgb); rgbled_set(&led, &rgb); ++step; hsv_0.h += step_h; hsv_0.s += step_s; hsv_0.v += step_v; /* check if transition is finished */ if (step == STEPS) { step = 0; ++state; } } /* wait for next step */ vtimer_usleep(PAUSE); } }
int main(void) { adt7310_t dev; puts("ADT7310 temperature driver test application\n"); printf("Initializing SPI_%i... ", TEST_ADT7310_SPI); if (spi_init_master(TEST_ADT7310_SPI, SPI_CONF, SPI_SPEED) == 0) { puts("[OK]"); } else { puts("[Failed]\n"); return 1; } puts("Initializing ADT7310 sensor... "); if (adt7310_init(&dev, TEST_ADT7310_SPI, TEST_ADT7310_CS) == 0) { puts("[OK]"); } else { puts("[Failed]\n"); return 1; } puts("ADT7310 init done.\n"); while (1) { puts("Set mode to continuous, 16 bit... "); if (adt7310_set_config(&dev, ADT7310_MODE_CONTINUOUS | ADT7310_CONF_RESOLUTION(1)) == 0) { puts("[OK]"); } else { puts("[Failed]\n"); return 1; } for (int i = 0; i < READINGS_CONT; ++i) { printf("%4d: ", i); if (test_adt7310_sample_print(&dev) != 0) { return 1; } vtimer_usleep(SLEEP_CONT); } puts("Set mode to 1SPS, 13 bit... "); if (adt7310_set_config(&dev, ADT7310_MODE_1SPS) == 0) { puts("[OK]"); } else { puts("[Failed]\n"); return 1; } for (int i = 0; i < READINGS_1SPS; ++i) { printf("%4d: ", i); if (test_adt7310_sample_print(&dev) != 0) { return 1; } vtimer_usleep(SLEEP_1SPS); } } return 0; }
void blinker(void) { while(1) { LED_RED_TOGGLE; vtimer_usleep(SEC); } }