static void restartInterval( uint8_t new_tou ) { int32_t tou_interval = 0; int32_t rand_val = 0; ker_timer_stop( KER_DFT_LOADER_PID, TOU_TID ); ker_timer_stop( KER_DFT_LOADER_PID, TRAN_TID ); ker_timer_stop( KER_DFT_LOADER_PID, DATA_TID ); if ( new_tou < TOU_MAX ) { st.tou = new_tou; } else { st.tou = TOU_MAX; } st.tran_count = 0; st.data_count = 0; tou_interval = TOU_INTERVAL * (1L << st.tou); ker_timer_start( KER_DFT_LOADER_PID, TOU_TID, tou_interval ); if ( st.net_state & SEND_DATA ) { //! pick random timeout between tou_interval / 2 and tou_interval rand_val = ker_rand() % (tou_interval / 2); rand_val += (tou_interval / 2); ker_timer_start( KER_DFT_LOADER_PID, DATA_TID, rand_val ); } else { //! pick random timeout between tou_interval / 2 and tou_interval rand_val = ker_rand() % (tou_interval / 2); rand_val += (tou_interval / 2); ker_timer_start( KER_DFT_LOADER_PID, TRAN_TID, rand_val ); } }
int8_t module(void *state, Message *msg) #endif { app_state *s = (app_state*) state; switch (msg->type){ case MSG_INIT: { s->pid = msg->did; if (ker_hipri_int_register(s->pid)==-EINVAL) { post_short(RAGOBOT_CB2BUS_PID, s->pid, MSG_DECKLIGHT6, ON, 0, 0); post_short(RAGOBOT_CB2BUS_PID, s->pid, MSG_LOAD, 0, 0, 0); } break; } case MSG_HIPRI_INT: { post_short(RAGOBOT_CB2BUS_PID, s->pid, MSG_DECKLIGHT1, TOGGLE, 0, 0); post_short(RAGOBOT_CB2BUS_PID, s->pid, MSG_LOAD, 0, 0, 0); break; } case MSG_FINAL: { ker_timer_stop(s->pid, 0); ker_hipri_int_deregister(s->pid); break; } } return SOS_OK; }
static int8_t handle_version_data( Message *msg ) { msg_version_data_t *pkt = (msg_version_data_t *) msg->data; if( st.net_state & SEND_DATA ) { /* * We have data to send */ if( pkt->version == st.version_data->version) { st.data_count ++; if( st.data_count >= OVERHEARD_K ) { st.net_state &= ~SEND_DATA; ker_timer_stop( KER_DFT_LOADER_PID, DATA_TID ); } return SOS_OK; } } if( pkt->version > st.version_data->version ) { restartInterval( 0 ); ker_free(st.version_data); st.version_data = (msg_version_data_t*) ker_msg_take_data(KER_DFT_LOADER_PID, msg); process_version_data( st.version_data, msg->saddr ); } return SOS_OK; }
int8_t ker_sys_timer_stop(uint8_t tid) { sos_pid_t my_id = ker_get_current_pid(); if( (ker_timer_stop(my_id, tid) != SOS_OK) || (ker_timer_release(my_id, tid) != SOS_OK) ) { return ker_mod_panic(my_id); } return SOS_OK; }
//! Free the first timer block beloning to pid in the timer_pool int8_t ker_timer_release(sos_pid_t pid, uint8_t tid) { sos_timer_t* tt; //! First stop the timer if it is running ker_timer_stop(pid, tid); //! Get the timer block from the pool tt = alloc_from_timer_pool(pid, tid); if (tt == NULL) return -EINVAL; //! Deep free of the timer ker_free(tt); return SOS_OK; }
static void check_map_and_post() { if(fst == NULL) { return; } if(check_map(&fst->map)) { fst->retx = 0; #ifdef SOS_SIM /* * We update module version here */ // TODO: figure out the right place... //set_version_to_sim(fst->map.mod_id, fst->map.version); #endif DEBUG_PID(KER_FETCHER_PID, "Request Done!!!\n"); ker_timer_stop(KER_FETCHER_PID, FETCHER_REQUEST_TID); send_fetcher_done(); } }
static int8_t handle_version_adv( Message *msg ) { msg_version_adv_t *pkt = (msg_version_adv_t *) msg->data; if( pkt->version > st.version_data->version ) { // Someone has new version, tell them we don't have quickly... restartInterval( 0 ); } else if( pkt->version < st.version_data->version ) { if( ( st.net_state & SEND_DATA ) == 0 ) { st.net_state |= SEND_DATA; restartInterval( 0 ); } } else { st.tran_count += 1; if( st.tran_count >= OVERHEARD_K ) { ker_timer_stop( KER_DFT_LOADER_PID, TRAN_TID ); } } return SOS_OK; }
static int8_t module(void *state, Message *msg) { app_state_t *s = (app_state_t*) state; switch (msg->type) { case MSG_INIT: { s->pid = msg->did; s->count = 0; s->state[0] = MOTOR_FULL_SPEED; s->state[1] = RGT_REV_NORMAL; s->state[2] = LFT_REV_NORMAL; s->state[3] = LFT_STOP; s->state[4] = RGT_STOP; ker_timer_init(s->pid, MCONTROL_TEST_TIMER, TIMER_REPEAT); ker_timer_start(s->pid, MCONTROL_TEST_TIMER, TIMER_INTERVAL); break; } case MSG_TIMER_TIMEOUT: { post_short(RAGOBOT_CB2BUS_PID, s->pid, MSG_BARBINARY, 0, s->state[s->count], 0); post_short(RAGOBOT_CB2BUS_PID, s->pid, MSG_LOAD, 0, 0, 0); post_short(RAGOBOT_MCONTROL_PID, s->pid, MSG_CHANGE_SPEED, s->state[s->count], 0, 0); s->count = (s->count+1) % 5; break; } case MSG_FINAL: { ker_timer_stop(s->pid, 0); break; } } return SOS_OK; }
SOS_MODULE int8_t module(void *state, Message *msg) #endif { app_state *s = (app_state*) state; MsgParam *p = (MsgParam*)(msg->data); switch (msg->type) { case MSG_INIT: { s->pid = msg->did; s->count = 0; s->state[0] = MOTOR_FULL_SPEED; s->state[1] = RGT_REV_NORMAL; s->state[2] = LFT_REV_NORMAL; s->state[3] = LFT_STOP; s->state[4] = RGT_STOP; ker_timer_start(s->pid, MCONTROL_TEST_TIMER, TIMER_REPEAT, TIMER_INTERVAL); break; } case MSG_TIMER_TIMEOUT: { post_short(RAGOBOT_MCONTROL_PID, s->pid, MSG_CHANGE_SPEED, s->state[s->count], 0, 0); s->count = (s->count+1) % 5; break; } case MSG_FINAL: { ker_timer_stop(s->pid, 0); break; } } return SOS_OK; }
//! Assumption - This function is never called from an interrupt context int8_t ker_timer_init(sos_pid_t pid, uint8_t tid, uint8_t type) { sos_timer_t* tt; tt = find_timer_in_periodic_pool(pid, tid); if (tt != NULL) { tt->type = type; list_insert_tail(&timer_pool, (list_link_t*)tt); return SOS_OK; } //! re-initialize an existing timer by stoping it and updating the type tt = find_timer_block(pid, tid); if (tt != NULL){ ker_timer_stop(pid,tid); tt->type = type; return SOS_OK; } //! Search if pre-initialized timer exists tt = alloc_from_timer_pool(pid, tid); //! Look for pre-allocated timers or try to get dynamic memory if (tt == NULL){ tt = alloc_from_preallocated_timer_pool(pid); if (tt == NULL){ tt = (sos_timer_t*)malloc_longterm(sizeof(sos_timer_t), TIMER_PID); } //! Init will fail if the system does not have sufficient resources if (tt == NULL) return -ENOMEM; } //! Fill up the data structure and insert into the timer pool tt->pid = pid; tt->tid = tid; tt->type = type; list_insert_tail(&timer_pool, (list_link_t*)tt); return SOS_OK; }
static inline void send_fragment() { uint16_t frag_id; uint8_t i, j; uint8_t mask = 1; uint8_t ret; fetcher_fragment_t *out_pkt; fetcher_cam_t *cam; if ( send_state.map == NULL ) { ker_timer_stop(KER_FETCHER_PID, FETCHER_TRANSMIT_TID); return; } cam = (fetcher_cam_t *) ker_shm_get( KER_FETCHER_PID, send_state.map->key); if ( cam == NULL ) { // file got deleted. give up! free_send_state_map(); return; } if ( send_state.frag != NULL) { //! timer fires faster than data reading. Highly unlikely... //! but we still handle it. return; } //! search map and find one fragment to send for(i = 0; i < send_state.map->bitmap_size; i++) { //! for each byte if(send_state.map->bitmap[i] != 0) { break; } } if(i == send_state.map->bitmap_size) { /* * Did not find any block... */ free_send_state_map(); return; } //sos_assert(i < send_state.map->bitmap_size); frag_id = i * 8; mask = 1; for(j = 0; j < 8; j++, mask = mask << 1) { if(mask & (send_state.map->bitmap[i])) { send_state.map->bitmap[i] &= ~(mask); break; } } //sos_assert(j < 8); frag_id += j; print_bitmap(send_state.map); out_pkt = (fetcher_fragment_t*)ker_malloc(sizeof(fetcher_fragment_t), KER_FETCHER_PID); if(out_pkt == NULL){ DEBUG_PID(KER_FETCHER_PID,"malloc fetcher_fragment_t failed\n"); goto send_fragment_postproc; } out_pkt->frag_id = ehtons(frag_id); out_pkt->key = ehtons(send_state.map->key); ret = ker_codemem_read(cam->cm, KER_FETCHER_PID, out_pkt->fragment, FETCHER_FRAGMENT_SIZE, frag_id * (code_addr_t)FETCHER_FRAGMENT_SIZE); if(ret == SOS_SPLIT) { send_state.frag = out_pkt; } else if(ret != SOS_OK){ DEBUG_PID(KER_FETCHER_PID, "codemem_read failed\n"); ker_free(out_pkt); goto send_fragment_postproc; } //DEBUG("out_pkt has addr %x\n", (int)out_pkt); DEBUG_PID(KER_FETCHER_PID, "send_fragment: frag_id = %d to %d\n", frag_id, send_state.dest); ret = post_auto(KER_FETCHER_PID, KER_FETCHER_PID, MSG_FETCHER_FRAGMENT, sizeof(fetcher_fragment_t), out_pkt, SOS_MSG_RELEASE | SOS_MSG_RELIABLE, send_state.dest); if( ret == SOS_OK ) { send_state.num_msg_in_queue++; } send_fragment_postproc: if(check_map(send_state.map)) { //! no more fragment to send free_send_state_map(); } }
static void free_send_state_map() { ker_free(send_state.map); send_state.map = NULL; ker_timer_stop(KER_FETCHER_PID, FETCHER_TRANSMIT_TID); }
SOS_MODULE int8_t module(void *state, Message *msg) { app_state *s = (app_state*) state; switch (msg->type){ case MSG_INIT: { s->pid = msg->did; s->port = 1; if (ker_pushbutton_register(s->pid)==-EINVAL) {led_red_on();} s->state = OPTIONS; ker_serial_write(s->pid, s->port, "*****WELCOME TO RAGOBOT V1.0*****\n\r", 35, 0); ker_timer_start(s->pid, 0, TIMER_ONE_SHOT, 1000); break; } case MSG_TIMER_TIMEOUT: { if(s->state == OPTIONS) { s->state = READ; ker_serial_write(s->pid, s->port, "Please Select From The Following Options:\n\r1. HELLO\n\r2. COOL\n\r", 62, 0); if (ker_serial_read(s->pid, s->port, 1) != SOS_OK) led_yellow_on(); } break; } case MSG_UART1_READ_DONE: { if (*(msg->data) == '1') { ker_serial_write(s->pid, s->port, "> Hi, My name is Ragobot.\n\r", 27, 0); } else if (*(msg->data) == '2') { ker_serial_write(s->pid, s->port, "> Yes, Ragobots are cool!\n\r", 27, 0); } else { ker_serial_write(s->pid, s->port, "> Invalid Selection. Please Try Again.\n\r", 40, 0); } s->state = OPTIONS; ker_timer_start(s->pid, 0, TIMER_ONE_SHOT, 1000); break; } case MSG_PUSHBUTTON_PRESSED: { s->port = (s->port + 1) % numports; s->state = OPTIONS; ker_serial_write(s->pid, s->port, "*****WELCOME TO RAGOBOT V1.0*****\n\r", 35, 0); ker_timer_start(s->pid, 0, TIMER_ONE_SHOT, 1000); break; } case MSG_FINAL: { ker_timer_stop(s->pid, 0); ker_pushbutton_deregister(s->pid); break; } } return SOS_OK; }
static int8_t simple_msg_handler(void *state, Message *msg) { app_state_t *s = (app_state_t*)state; /** Switch to the correct message handler * * This module handles three types of messages: * * \li MSG_INIT to start a timer and allocated a buffer * * \li MSG_TIMER_TIMEOUT to periodicly write a value to the buffer. Note * that we are expecting that the timer will have timer with ID equal to * SIMPLE_TID * * \li MSG_FINAL to stop the timer and deallocate the buffer * */ switch (msg->type){ case MSG_INIT: { // I'm alive! LED_DBG(LED_GREEN_TOGGLE); s->pid = msg->did; s->state = (uint8_t *) ker_malloc(sizeof(uint8_t), s->pid); *(s->state) = 0; ker_timer_init(s->pid, SIMPLE_TID, TIMER_REPEAT); ker_timer_start(s->pid, SIMPLE_TID, 1000); break; } case MSG_FINAL: { // Bye bye! ker_free(s->state); ker_timer_stop(s->pid, SIMPLE_TID); break; } case MSG_TIMER_TIMEOUT: { MsgParam* params = (MsgParam*)(msg->data); if (params->byte == SIMPLE_TID) { // Blink the LED if (*(s->state) == 1) { LED_DBG(LED_YELLOW_OFF); } else { LED_DBG(LED_YELLOW_ON); } // Update the state *(s->state) += 1; if (*(s->state) > 1) { *(s->state) = 0; } } break; } default: return -EINVAL; } return SOS_OK; }
static int8_t module(void *state, Message *msg) { lightshow_state *s = (lightshow_state*) state; MsgParam *p = (MsgParam*)(msg->data); uint8_t decklights_count; uint8_t bargraph_count; uint8_t headlights_count; uint16_t color = BLACK; switch (msg->type){ case MSG_INIT: { s->decklights_state = DISABLE; s->bargraph_state = DISABLE; s->headlights_state = DISABLE; s->light_state = DISABLE; s->count = 0; ker_timer_init(RAGOBOT_LIGHTSHOW_PID, 0, TIMER_REPEAT); break; } case MSG_LIGHTSHOW_START: { if (s->light_state == DISABLE) { s->light_state = ENABLE; ker_timer_start(RAGOBOT_LIGHTSHOW_PID, 0, 80); } break; } case MSG_TIMER_TIMEOUT: { if (s->decklights_state == ENABLE) { decklights_count = s->count % 10; if (decklights_count == 0) { post_short(RAGOBOT_CB2BUS_PID, RAGOBOT_LIGHTSHOW_PID, MSG_DECKLIGHT3, OFF, 0, 0); post_short(RAGOBOT_CB2BUS_PID, RAGOBOT_LIGHTSHOW_PID, MSG_DECKLIGHT2, ON, 0, 0); } else if (decklights_count == 1 || decklights_count == 9) { post_short(RAGOBOT_CB2BUS_PID, RAGOBOT_LIGHTSHOW_PID, MSG_DECKLIGHT2, OFF, 0, 0); post_short(RAGOBOT_CB2BUS_PID, RAGOBOT_LIGHTSHOW_PID, MSG_DECKLIGHT3, ON, 0, 0); post_short(RAGOBOT_CB2BUS_PID, RAGOBOT_LIGHTSHOW_PID, MSG_DECKLIGHT4, OFF, 0, 0); } else if (decklights_count == 2 || decklights_count == 8) { post_short(RAGOBOT_CB2BUS_PID, RAGOBOT_LIGHTSHOW_PID, MSG_DECKLIGHT3, OFF, 0, 0); post_short(RAGOBOT_CB2BUS_PID, RAGOBOT_LIGHTSHOW_PID, MSG_DECKLIGHT4, ON, 0, 0); post_short(RAGOBOT_CB2BUS_PID, RAGOBOT_LIGHTSHOW_PID, MSG_DECKLIGHT5, OFF, 0, 0); } else if (decklights_count == 3 || decklights_count == 7) { post_short(RAGOBOT_CB2BUS_PID, RAGOBOT_LIGHTSHOW_PID, MSG_DECKLIGHT4, OFF, 0, 0); post_short(RAGOBOT_CB2BUS_PID, RAGOBOT_LIGHTSHOW_PID, MSG_DECKLIGHT5, ON, 0, 0); post_short(RAGOBOT_CB2BUS_PID, RAGOBOT_LIGHTSHOW_PID, MSG_DECKLIGHT6, OFF, 0, 0); } else if (decklights_count == 4 || decklights_count == 6) { post_short(RAGOBOT_CB2BUS_PID, RAGOBOT_LIGHTSHOW_PID, MSG_DECKLIGHT5, OFF, 0, 0); post_short(RAGOBOT_CB2BUS_PID, RAGOBOT_LIGHTSHOW_PID, MSG_DECKLIGHT6, ON, 0, 0); post_short(RAGOBOT_CB2BUS_PID, RAGOBOT_LIGHTSHOW_PID, MSG_DECKLIGHT1, OFF, 0, 0); } else if (decklights_count == 5) { post_short(RAGOBOT_CB2BUS_PID, RAGOBOT_LIGHTSHOW_PID, MSG_DECKLIGHT6, OFF, 0, 0); post_short(RAGOBOT_CB2BUS_PID, RAGOBOT_LIGHTSHOW_PID, MSG_DECKLIGHT1, ON, 0, 0); } } if (s->bargraph_state == ENABLE) { bargraph_count = s->count % 18; if (bargraph_count < 10) post_short(RAGOBOT_CB2BUS_PID, RAGOBOT_LIGHTSHOW_PID, MSG_BARPOSITION, bargraph_count, 0, 0); else post_short(RAGOBOT_CB2BUS_PID, RAGOBOT_LIGHTSHOW_PID, MSG_BARPOSITION, 18-bargraph_count, 0, 0); } if (s->headlights_state == ENABLE) { headlights_count = s->count % 8; if (headlights_count == 0) color = BLACK; else if (headlights_count == 2) color = GREEN; else if (headlights_count == 4) color = ORANGE; else if (headlights_count == 6) color = RED; post_short(RAGOBOT_CB2BUS_PID, RAGOBOT_LIGHTSHOW_PID, MSG_HEADLIGHT, FRONT_LEFT, color, 0); post_short(RAGOBOT_CB2BUS_PID, RAGOBOT_LIGHTSHOW_PID, MSG_HEADLIGHT, FRONT_RIGHT, color, 0); post_short(RAGOBOT_CB2BUS_PID, RAGOBOT_LIGHTSHOW_PID, MSG_HEADLIGHT, BACK_LEFT, color, 0); post_short(RAGOBOT_CB2BUS_PID, RAGOBOT_LIGHTSHOW_PID, MSG_HEADLIGHT, BACK_RIGHT, color, 0); } post_short(RAGOBOT_CB2BUS_PID, RAGOBOT_LIGHTSHOW_PID, MSG_LOAD, 0, 0, 0); s->count += 1; break; } case MSG_LIGHTSHOW_DECKLIGHTS: { if (p->byte != ENABLE && p->byte != DISABLE) return -EINVAL; s->decklights_state = p->byte; break; } case MSG_LIGHTSHOW_HEADLIGHTS: { if (p->byte != ENABLE && p->byte != DISABLE) return -EINVAL; s->headlights_state = p->byte; break; } case MSG_LIGHTSHOW_BARGRAPH: { if (p->byte != ENABLE && p->byte != DISABLE) return -EINVAL; s->bargraph_state = p->byte; break; } case MSG_LIGHTSHOW_STOP: case MSG_FINAL: { if (s->light_state == ENABLE) { s->light_state = DISABLE; ker_timer_stop(RAGOBOT_LIGHTSHOW_PID, 0); } } default: break; } return SOS_OK; }