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