ssize_t read(int fd,void * buffer,size_t n){
if(fd==frameBuf_FD){
memcpy(buffer,LCDstatefd,n);
LCDstatefd+=n;
return n;
}else if(fd==urandom_FD){
size_t c=n;
unsigned int * d=(unsigned int *)buffer;
while (c>=4){
*d++=sys_rand();
c-=4;
}
unsigned char * r=(unsigned char *)d;//remaindor
while(c--){
*r++=sys_rand();
}
return n;
}else if(fd==0){
//printf("Read %d bytes from stdin\n",n);
inputStrTiny(buffer,n,1);
}else if(fd>5)
return Bfile_ReadFile_OS(toNativeFD(fd),buffer, n,-1);
else
return -1;
}
void game_enemyspawn()
{
int i;
char wavemsg[64];
if(gamestate_init == true)
{
game_enemytotal = 0;
game_enemywaves = 0;
for(i=0;i<MAXENEMIES;i++)
{
obj_enemy[i].alive = false;
}
}
if(game_enemytotal == 0)
{
if(enemyspawnTimer == 0)
{
for(i=0;i<MAXENEMIES;i++)
{
if(obj_enemy[i].alive != true)
{
if(game_enemywaves < 5)
{
obj_enemy[i].dim.w = 64;
obj_enemy[i].dim.h = 32;
obj_enemy[i].type = 0;
}
else
{
obj_enemy[i].dim.w = 64;
obj_enemy[i].dim.h = 64;
obj_enemy[i].type = 1;
}
obj_enemy[i].alive = true;
game_enemytotal += 1;
obj_enemy[i].frame = 0;
obj_enemy[i].pathlength = 0;
obj_enemy[i].laserTimer = 0;
obj_enemy[i].dir = sys_rand(0,1);
obj_enemy[i].dim.x = sys_rand(0,SCREEN_WIDTH - obj_enemy[i].dim.w);
obj_enemy[i].dim.y = sys_rand(-192,-64);
}
}
}
if(enemyspawnTimer > 0 )
enemyspawnTimer -= 1;
}
else
{
enemyspawnTimer = 180;
}
if(enemyspawnTimer == 179 && game_enemytotal == 0)
{
game_enemywaves += 1;
sprintf(wavemsg,"Wave: %d",game_enemywaves);
game_setstatustext(wavemsg,120);
}
}
void game_enemyfire()
{
int i,j;
for(j=0;j<MAXENEMIES;j++)
{
if(obj_enemy[j].laserTimer == 0 && obj_enemy[j].alive && (obj_enemy[j].dim.y + obj_enemy[j].dim.h) >= 0)
{
for(i=0;i<MAXLASERS;i++)
{
obj_enemy[j].laz[i].dim.w = 8;
obj_enemy[j].laz[i].dim.h = 16;
if(obj_enemy[j].laz[i].alive != true)
{
obj_enemy[j].laz[i].alive = true;
obj_enemy[j].laz[i].dim.x = obj_enemy[j].dim.x + (obj_enemy[j].dim.w/2);
obj_enemy[j].laz[i].dim.y = obj_enemy[j].dim.y + obj_enemy[j].laz[i].dim.h;
if(obj_enemy[j].type == 0)
obj_enemy[j].laserTimer = sys_rand(100,250);
else if (obj_enemy[j].type == 1)
obj_enemy[j].laserTimer = sys_rand(50,100);
sound_playfx(snd_enemy_fire);
break;
}
}
}
if(obj_enemy[j].laserTimer > 0)
obj_enemy[j].laserTimer--;
}
}
static int8_t nbr_msg_handler(void *state, Message *msg)
{
nbr_state_t *s = (nbr_state_t*)state;
/**
* Switch to the correct message handler
*/
switch (msg->type){
case MSG_INIT:
{
s->nb_list = NULL;
s->nb_cnt = 0;
s->est_ticks = 0;
s->gCurrentSeqNo = 0;
sys_shm_open( sys_shm_name(NBHOOD_PID, SHM_NBR_LIST), s->nb_list );
sys_timer_start(BACKOFF_TIMER, sys_rand() % 1024L, TIMER_ONE_SHOT);
break;
}
case MSG_FINAL:
{
break;
}
case MSG_TIMER_TIMEOUT:
{
if( timer_get_tid( msg ) == BACKOFF_TIMER ) {
sys_timer_start(NEIGHBOR_DISCOVERY_TIMER, NEIGHBOR_TIMER_INTERVAL, TIMER_REPEAT);
} else {
//
// Send beacon packets
//
update_table( s );
sys_shm_update( sys_shm_name(NBHOOD_PID, SHM_NBR_LIST), s->nb_list );
send_beacon( s );
nb_debug(s);
}
break;
}
case MSG_BEACON_PKT:
{
//
// Process beacon packets
//
recv_beacon( s, msg );
break;
}
default:
return -EINVAL;
}
/**
* Return SOS_OK for those handlers that have successfully been handled.
*/
return SOS_OK;
}
//--------------------------------------------------------------------
// EXTERNAL FUNCTIONS
//--------------------------------------------------------------------
int8_t execute(dvm_state_t* dvm_st, DvmState *eventState)
{
DVMBasiclib_state_t *s = (&dvm_st->basiclib_st);
DvmContext *context = &(eventState->context);
while ((context->state == DVM_STATE_RUN) && (context->num_executed < DVM_CPU_SLICE)) {
DvmOpcode instr = getOpcode(dvm_st, context->which, context->pc);
DEBUG("-----------------------------------------------\n");
DEBUG("[BASIC_LIB] execute: (%d) PC: %d. INSTR: %d\n",context->which, context->pc, instr);
if(instr & LIB_ID_BIT)
{ //Extension Library opcode encountered
return SOS_OK;
}
context->num_executed++;
switch(instr)
{
case OP_START:
{
__asm __volatile("__sleep_measure_start:");
context->pc += 1;
break;
}
case OP_STOP:
{
context->pc += 1;
break;
}
case OP_HALT:
{
DEBUG("<<<<<<<<<<<=====================>>>>>>>>>>>\n");
DEBUG("[BASIC_LIB] execute: (%d): HALT executed.\n", (int)context->which);
haltContext(dvm_st, context);
context->state = DVM_STATE_HALT;
context->pc = 0;
break;
}
case OP_LED:
{
DvmStackVariable* arg = popOperand( eventState);
led_op(arg->value.var);
context->pc += 1;
break;
}
case OP_GETVAR + 0:
case OP_GETVAR + 1:
case OP_GETVAR + 2:
case OP_GETVAR + 3:
case OP_GETVAR + 4:
case OP_GETVAR + 5:
case OP_GETVAR + 6:
case OP_GETVAR + 7:
{
uint8_t arg = instr - OP_GETVAR;
DEBUG("[BASIC_LIB] execute: OPGETVAR (%d):: Pushing value %d.\n", (int)arg,(int)s->shared_vars[arg].value.var);
pushOperand( eventState, &s->shared_vars[arg]);
context->pc += 1;
break;
}
case OP_SETVAR + 0:
case OP_SETVAR + 1:
case OP_SETVAR + 2:
case OP_SETVAR + 3:
case OP_SETVAR + 4:
case OP_SETVAR + 5:
case OP_SETVAR + 6:
case OP_SETVAR + 7:
{
uint8_t arg = instr - OP_SETVAR;
DvmStackVariable* var = popOperand( eventState);
DEBUG("[BASIC_LIB] execute: OPSETVAR (%d):: Setting value to %d.\n",(int)arg,(int)var->value.var);
s->shared_vars[arg] = *var;
context->pc += 1;
break;
}
case OP_GETVARF + 0:
case OP_GETVARF + 1:
case OP_GETVARF + 2:
case OP_GETVARF + 3:
case OP_GETVARF + 4:
case OP_GETVARF + 5:
case OP_GETVARF + 6:
case OP_GETVARF + 7:
{ // Use for type casting an integer shared var to float
uint8_t arg = instr - OP_GETVARF;
int32_t res = 0;
uint16_t res_part = 0;
DEBUG("[BASIC_LIB] execute: OPGETVARF (%d):: Pushing value %d.\n", (int)arg,(int)s->shared_vars[arg].value.var);
res = (int32_t)(s->shared_vars[arg].value.var * FLOAT_PRECISION);
res_part = res & 0xFFFF;
pushValue( eventState, res_part, DVM_TYPE_FLOAT_DEC);
res_part = res >> 16;
pushValue( eventState, res_part, DVM_TYPE_FLOAT);
context->pc += 1;
break;
}
case OP_SETVARF + 0:
case OP_SETVARF + 1:
case OP_SETVARF + 2:
case OP_SETVARF + 3:
case OP_SETVARF + 4:
case OP_SETVARF + 5:
case OP_SETVARF + 6:
{ // Type-casting an integer to float and saving it in shared var
uint8_t arg = instr - OP_SETVARF;
DvmStackVariable* var = popOperand( eventState);
int32_t res = 0;
uint16_t res_part;
DEBUG("[BASIC_LIB] execute: OPSETVARF (%d):: Setting value to %d.\n",(int)arg,(int)var->value.var);
res = (int32_t)(var->value.var * FLOAT_PRECISION);
res_part = res & 0xFFFF;
s->shared_vars[arg+1].type = DVM_TYPE_FLOAT_DEC;
s->shared_vars[arg+1].value.var = res_part;
res_part = res >> 16;
s->shared_vars[arg].type = DVM_TYPE_FLOAT;
s->shared_vars[arg].value.var = res_part;
context->pc += 1;
break;
}
case OP_SETTIMER + 0:
case OP_SETTIMER + 1:
case OP_SETTIMER + 2:
case OP_SETTIMER + 3:
case OP_SETTIMER + 4:
case OP_SETTIMER + 5:
case OP_SETTIMER + 6:
case OP_SETTIMER + 7:
{
uint32_t msec;
uint8_t timerID = instr - OP_SETTIMER;
DvmStackVariable* arg = popOperand( eventState);
DEBUG("[BASIC_LIB] execute: Setting Timer %d period to %d.\n", timerID, arg->value.var);
//msec = 102 * arg->value.var + (4 * arg->value.var) / 10;
// Set the timer timeout argument in seconds
msec = arg->value.var * 4;// * 1000;
DEBUG("[BASIC_LIB] execute: <<<<< WARNING - Timer %d not being stopped >>>>\n", timerID);
// sys_timer_stop(timerID);
if (msec > 0) {
// Ram - Where is the init ??
sys_timer_start(timerID, msec, TIMER_REPEAT);
DEBUG("[BASIC_LIB] execute: Timer ID: %d started. Period: %d msec.\n", timerID, msec);
}
context->pc += 1;
break;
}
case OP_RAND:
{
DvmStackVariable* arg = popOperand( eventState);
uint16_t rnd;
rnd = sys_rand() % arg->value.var;
pushValue( eventState, rnd, DVM_TYPE_INTEGER);
context->pc += 1;
break;
}
/*
case OP_JMP: case OP_JNZ: case OP_JZ: case OP_JG:
case OP_JGE: case OP_JL: case OP_JLE: case OP_JE:
case OP_JNE:
case OP_ADD: case OP_SUB: case OP_DIV: case OP_MUL:
case OP_ABS: case OP_MOD: case OP_INCR: case OP_DECR:
{
mathlib_executeDL(s->mathlib_execute, eventState, instr);
break;
}
*/
// Math Lib
case OP_ADD:
case OP_SUB:
case OP_DIV:
case OP_MUL:
{
DvmStackVariable* arg1 = popOperand( eventState);
DvmStackVariable* arg2 = popOperand( eventState);
DvmStackVariable* arg3 = NULL, *arg4 = NULL;
int32_t fl_arg1, fl_arg2;
int32_t res = 0;
uint16_t res_part;
int16_t int_res = 0;
if (arg1->type == DVM_TYPE_FLOAT) {
fl_arg1 = convert_to_float(arg1, arg2);
arg3 = popOperand( eventState);
if (arg3->type == DVM_TYPE_FLOAT) {
// FLOAT <op> FLOAT
arg4 = popOperand( eventState);
fl_arg2 = convert_to_float(arg3, arg4);
if(instr == OP_ADD) {
res = (int32_t)(fl_arg1 + fl_arg2);
DEBUG("[BASIC_LIB] execute: FLOAT ADD FLOAT %d\n", res);
} else if(instr == OP_SUB) {
res = (int32_t)(fl_arg1 - fl_arg2);
DEBUG("[BASIC_LIB] execute: FLOAT SUB FLOAT %d\n", res);
} else if(instr == OP_DIV) {
res = (int32_t)((fl_arg1 * FLOAT_PRECISION) / fl_arg2);
DEBUG("[BASIC_LIB] execute: FLOAT DIV FLOAT: %d\n", res);
} else if(instr == OP_MUL) {
res = (int32_t)((fl_arg1 * fl_arg2) / FLOAT_PRECISION);
DEBUG("[BASIC_LIB] execute: FLOAT MULT FLOAT %d\n", res);
}
} else {
// FLOAT <OP> INTEGER
if(instr == OP_ADD) {
res = (int32_t)(fl_arg1 + (arg3->value.var * FLOAT_PRECISION));
DEBUG("[BASIC_LIB] execute: FLOAT ADD INT: %d\n", res);
} else if(instr == OP_SUB) {
res = (int32_t)(fl_arg1 - (arg3->value.var * FLOAT_PRECISION));
DEBUG("[BASIC_LIB] execute: FLOAT SUB INT: %d\n", res);
} else if(instr == OP_DIV) {
res = (int32_t)(fl_arg1 / arg3->value.var);
DEBUG("[BASIC_LIB] execute: FLOAT DIV INT: %d\n", res);
sys_led(LED_RED_TOGGLE);
#ifdef OUTLIER_SCRIPT_DBG
int32_t* post_avg;
post_avg = (int32_t*)sys_malloc(sizeof(int32_t));
*post_avg = res;
sys_post_uart(OUTLIER_DETECTION_PID, MSG_AVERAGE, sizeof(int32_t),
post_avg, SOS_MSG_RELEASE, UART_ADDRESS);
#endif
} else if(instr == OP_MUL) {
res = (int32_t)(fl_arg1 * arg3->value.var);
DEBUG("[BASIC_LIB] execute: FLOAT MULT INT %d\n", res);
}
}
res_part = res & 0xFFFF;
pushValue( eventState, res_part, DVM_TYPE_FLOAT_DEC);
res_part = res >> 16;
pushValue( eventState, res_part, DVM_TYPE_FLOAT);
context->pc += 1;
break;
} else if (arg2->type == DVM_TYPE_FLOAT) {
arg3 = popOperand( eventState);
fl_arg2 = convert_to_float(arg2, arg3);
if(instr == OP_ADD) {
res = (int32_t)((arg1->value.var * FLOAT_PRECISION) + fl_arg2) ;
DEBUG("[BASIC_LIB] execute: INT ADD FLOAT: %d\n", res);
} else if(instr == OP_SUB) {
res = (int32_t)((arg1->value.var * FLOAT_PRECISION) - fl_arg2);
DEBUG("[BASIC_LIB] execute: INT SUB FLOAT: %d\n", res);
} else if(instr == OP_DIV) {
res = (int32_t)((arg1->value.var * FLOAT_PRECISION) / fl_arg2);
DEBUG("[BASIC_LIB] execute: INT DIV FLOAT: %d\n", res);
} else if(instr == OP_MUL) {
res = (int32_t)((arg1->value.var * FLOAT_PRECISION) * fl_arg2);
DEBUG("[BASIC_LIB] execute: INT MULT FLOAT: %d\n", res);
}
res_part = res & 0xFFFF;
pushValue( eventState, res_part, DVM_TYPE_FLOAT_DEC);
res_part = res >> 16;
pushValue( eventState, res_part, DVM_TYPE_FLOAT);
context->pc += 1;
break;
}
if(instr == OP_ADD) {
int_res = arg1->value.var + arg2->value.var;
DEBUG("[BASIC_LIB] execute: INT ADD INT: %d\n", int_res);
} else if(instr == OP_SUB) {
int_res = arg1->value.var - arg2->value.var;
DEBUG("[BASIC_LIB] execute: INT SUB INT: %d\n", int_res);
} else if(instr == OP_DIV) {
int_res = (int16_t)(arg1->value.var / arg2->value.var);
DEBUG("[BASIC_LIB] execute: INT DIV INT: %d\n", int_res);
} else if(instr == OP_MUL) {
int_res = (int16_t)(arg1->value.var * arg2->value.var);
DEBUG("[BASIC_LIB] execute: INT MULT INT: %d\n", int_res);
}
pushValue( eventState, int_res, DVM_TYPE_INTEGER);
context->pc += 1;
break;
}
static int8_t generic_test_msg_handler(void *state, Message *msg)
{
app_state_t *s = (app_state_t *) state;
switch ( msg->type ) {
/* do any initialization steps here,
* in general it is good to set all the leds to off so that you can analyze what happens later more accurately
* also be sure to start and enable any timers which your driver might need
*/
case MSG_INIT:
sys_led(LED_GREEN_OFF);
sys_led(LED_YELLOW_OFF);
sys_led(LED_RED_OFF);
s->state = TEST_APP_INIT;
s->count = 0;
s->pid = msg->did;
sys_timer_start(TEST_APP_TID, TEST_APP_INTERVAL, SLOW_TIMER_REPEAT);
send_new_data(START_DATA, 0);
break;
case MSG_ERROR:
s->state = TEST_APP_INIT;
s->count = 0;
s->pid = msg->did;
sys_timer_start(TEST_APP_TID, TEST_APP_INTERVAL, SLOW_TIMER_REPEAT);
send_new_data(START_DATA, 0);
break;
case MSG_FINAL:
sys_timer_stop(TEST_APP_TID);
s->state = TEST_APP_FINAL;
send_new_data(FINAL_DATA, 1);
break;
/* here we handle messages of type MSG_TEST_DATA
* in most cases, only the base station node should be doing this since it is the only one connected to the uart
* if your test does not use multiple nodes, or your messages are sent via another module, this is not needed
*/
case MSG_TEST_DATA:
{
uint8_t *payload;
uint8_t msg_len;
msg_len = msg->len;
payload = sys_msg_take_data(msg);
sys_post_uart(
s->pid,
MSG_TEST_DATA,
msg_len,
payload,
SOS_MSG_RELEASE,
BCAST_ADDRESS);
}
break;
case MSG_TIMER_TIMEOUT:
{
switch(s->state){
case TEST_APP_INIT:
{
send_new_data(1, sys_rand());
s->count++;
}
break;
default:
return -EINVAL;
break;
}
}
break;
default:
return -EINVAL;
break;
}
return SOS_OK;
}
static int8_t test_tpsn_net_module_handler(void *state, Message *msg)
{
app_state_t *s = (app_state_t *) state;
MsgParam *p = (MsgParam*)(msg->data);
switch (msg->type)
{
case MSG_INIT:
{
s->pid = msg->did;
sys_register_isr(0, USERINT_FID);
s->state = 0;
// If master node, start the transmit_timer
if(sys_id() == 0) sys_timer_start(TRANSMIT_TIMER, TRANSMIT_INTERVAL, TIMER_REPEAT);
sys_led(LED_RED_OFF);
sys_led(LED_GREEN_OFF);
sys_led(LED_YELLOW_OFF);
break;
}
case MSG_GLOBAL_TIME_REPLY:
{
msg_global_time_t* msg_global_time = (msg_global_time_t*)msg->data;
s->time = msg_global_time->time;
s->refreshed = msg_global_time->refreshed;
sys_timer_start(DELAY_TIMER, sys_rand()%256, TIMER_ONE_SHOT);
break;
}
case MSG_GLOBAL_TIME_SEND:
{
msg_global_time_send_t* datamsg = (msg_global_time_send_t*) sys_msg_take_data(msg);
//sys_led(LED_YELLOW_TOGGLE);
sys_post_uart(s->pid, MSG_GLOBAL_TIME_SEND, sizeof(msg_global_time_send_t), datamsg, SOS_MSG_RELEASE, BCAST_ADDRESS);
break;
}
case MSG_TIMER_TIMEOUT:
{
switch(p->byte)
{
case TRANSMIT_TIMER:
{
if (s->state){
sys_led(LED_GREEN_OFF);
SETBITLOW(P2OUT, 3);
s->state = 0;
} else {
uint32_t timestamp;
msg_global_time_send_t* msg_global_time_send;
sys_led(LED_GREEN_ON);
SETBITHIGH(P2OUT, 3);
timestamp = sys_time32();
// Construct the packet and send it over uart
msg_global_time_send = (msg_global_time_send_t*)sys_malloc(sizeof(msg_global_time_send_t));
msg_global_time_send->addr = sys_id();
msg_global_time_send->time = timestamp;
msg_global_time_send->refreshed = 0;
sys_post_uart(s->pid, MSG_GLOBAL_TIME_SEND, sizeof(msg_global_time_send_t), msg_global_time_send, SOS_MSG_RELEASE, BCAST_ADDRESS);
s->state = 1;
}
break;
}
case DELAY_TIMER:
{
msg_global_time_send_t* msg_global_time_send = (msg_global_time_send_t*)sys_malloc(sizeof(msg_global_time_send_t));
sys_led(LED_GREEN_TOGGLE);
msg_global_time_send->addr = sys_id();
msg_global_time_send->time = s->time;
msg_global_time_send->refreshed = s->refreshed;
sys_post_net(s->pid, MSG_GLOBAL_TIME_SEND, sizeof(msg_global_time_send_t), msg_global_time_send, SOS_MSG_RELEASE, 0);
break;
}
}
break;
}
default:
return -EINVAL;
}
/**
* Return SOS_OK for those handlers that have successfully been handled.
*/
return SOS_OK;
}
void game_enemymove()
{
int movespeed;
int i;
for(i=0;i<MAXENEMIES;i++)
{
if(obj_enemy[i].alive == true)
{
if(obj_enemy[i].type == 0)
movespeed = 2;
else if(obj_enemy[i].type == 1)
movespeed = 3;
if(obj_enemy[i].pathlength == 0)
{
obj_enemy[i].pathlength = sys_rand(10,SCREEN_WIDTH/2);
}
if(obj_enemy[i].pathlength != 0)
{
if(obj_enemy[i].dir == 0)
{
if(obj_enemy[i].dim.x + obj_enemy[i].dim.w < SCREEN_WIDTH)
{
obj_enemy[i].dim.x += movespeed;
obj_enemy[i].pathlength--;
}
if(obj_enemy[i].dim.x + obj_enemy[i].dim.w >= SCREEN_WIDTH || obj_enemy[i].pathlength == 0)
{
obj_enemy[i].dir = 1;
obj_enemy[i].pathlength = 0;
}
}
else if(obj_enemy[i].dir == 1)
{
if(obj_enemy[i].dim.x > 0)
{
obj_enemy[i].dim.x -= movespeed;
obj_enemy[i].pathlength--;
}
if(obj_enemy[i].dim.x <= 0 || obj_enemy[i].pathlength == 0)
{
obj_enemy[i].dir = 0;
obj_enemy[i].pathlength = 0;
}
}
}
obj_enemy[i].dim.y += 1;
}
if(obj_enemy[i].dim.y > SCREEN_BOTTOM+obj_enemy[i].dim.h)
{
obj_enemy[i].alive = false;
game_enemytotal -= 1;
obj_enemy[i].dim.x = 0;
obj_enemy[i].dim.y = 0;
if(gamestate_over == false)
{
if(obj_enemy[i].type == 0)
obj_player.score -= 100;
else if(obj_enemy[i].type == 1)
obj_player.score -= 200;
}
if(obj_player.score < 0)
obj_player.score = 0;
break;
}
}
if(enemyTimer > 0)
enemyTimer--;
}
