/*
* GALSC_run_next_task()
*
* Remove the task at the head of the queue and execute it, freeing
* the queue entry. Return 1 if a task was executed, 0 if the queue
* is empty.
*
*/
bool GALSC_run_next_task () {
__nesc_atomic_t fInterruptFlags;
void (*func)(void);
// If there is an event in the GALSC queue, trigger the port
// associated with the event (activate the task). Otherwise, run
// any queued TOS tasks.
if (GALSC_eventqueue_count > 0) {
// If there are any buffered TinyGUYS, update them now.
if (GALSC_params_buffer_flag) {
fInterruptFlags = __nesc_atomic_start();
GALSC_copy_params();
__nesc_atomic_end(fInterruptFlags);
}
fInterruptFlags = __nesc_atomic_start();
func = GALSC_eventqueue[GALSC_eventqueue_head].tp;
GALSC_eventqueue[GALSC_eventqueue_head].tp = 0;
GALSC_eventqueue_head = ((GALSC_eventqueue_head + 1) >= GALSC_EVENTQUEUE_SIZE) ? 0 : GALSC_eventqueue_head + 1;
GALSC_eventqueue_count--;
__nesc_atomic_end(fInterruptFlags);
func(); // Called function will remove tokens from port queues.
return 1;
} else {
return TOSH_run_next_task();
}
}
bool TOSH_run_next_task ()
{
__nesc_atomic_t fInterruptFlags;
uint8_t old_full;
void (*func)(void);
fInterruptFlags = __nesc_atomic_start();
old_full = TOSH_sched_full;
func = TOSH_queue[old_full].tp;
if (func == NULL)
{
__nesc_atomic_sleep();
return 0;
}
#ifdef TASK_QUEUE_DEBUG
occupancy--;
#endif
TOSH_queue[old_full].tp = NULL;
TOSH_sched_full = (old_full + 1) & TOSH_TASK_BITMASK;
TOSH_queue[old_full].executeTime = OSCR0;
__nesc_atomic_end(fInterruptFlags);
func();
TOSH_queue[old_full].executeTime = OSCR0 - TOSH_queue[old_full].executeTime;
return 1;
}
void TOSH_reset_debug_counters() {
__nesc_atomic_t fInterruptFlags;
#ifdef TASK_QUEUE_DEBUG
fInterruptFlags = __nesc_atomic_start();
max_occupancy = 0;
__nesc_atomic_end(fInterruptFlags);
#endif
}
bool TOSH_run_next_task ()
{
__nesc_atomic_t fInterruptFlags;
uint8_t old_full;
void (*func)(void);
fInterruptFlags = __nesc_atomic_start();
old_full = TOSH_sched_full;
func = TOSH_queue[old_full].tp;
if (func == NULL)
{
__nesc_atomic_end(fInterruptFlags);
return 0;
}
TOSH_queue[old_full].tp = NULL;
TOSH_sched_full = (old_full + 1) & TOSH_TASK_BITMASK;
__nesc_atomic_end(fInterruptFlags);
func();
return 1;
}
//#line 31
//# 59 "/opt/tinyos-2.x-contrib/diku/common/lib/ReverseGPIOP.nc"
static /*inline*/ void /*PlatformLedsC.Led0_rev*/ReverseGPIOP__0__Out__toggle(void )
//#line 59
{
//#line 59
{ __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
//#line 59
{
//#line 59
/*PlatformLedsC.Led0_rev*/ReverseGPIOP__0__In__toggle();
}
//#line 60
__nesc_atomic_end(__nesc_atomic); }
}
//#line 159
static /*inline*/ error_t SchedulerBasicP__TaskBasic__postTask(uint8_t id)
{
{ __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
//#line 161
{
//#line 161
{
unsigned char __nesc_temp =
//#line 161
SchedulerBasicP__pushTask(id) ? SUCCESS : EBUSY;
{
//#line 161
__nesc_atomic_end(__nesc_atomic);
//#line 161
return __nesc_temp;
}
}
}
//#line 164
__nesc_atomic_end(__nesc_atomic); }
}
//#line 53
//# 52 "/opt/tinyos-2.x/tos/system/RealMainP.nc"
int main(void )
//#line 52
{
{ __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
{
{
}
//#line 60
;
RealMainP__Scheduler__init();
RealMainP__PlatformInit__init();
while (RealMainP__Scheduler__runNextTask()) ;
RealMainP__SoftwareInit__init();
while (RealMainP__Scheduler__runNextTask()) ;
}
//#line 77
__nesc_atomic_end(__nesc_atomic); }
__nesc_enable_interrupt();
RealMainP__Boot__booted();
RealMainP__Scheduler__taskLoop();
return -1;
}
//#line 138
static /*inline*/ void SchedulerBasicP__Scheduler__taskLoop(void )
{
for (; ; )
{
uint8_t nextTask;
{ __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
{
while ((nextTask = SchedulerBasicP__popTask()) == SchedulerBasicP__NO_TASK)
{
SchedulerBasicP__McuSleep__sleep();
}
}
//#line 150
__nesc_atomic_end(__nesc_atomic); }
SchedulerBasicP__TaskBasic__runTask(nextTask);
}
}
bool TOSH_run_next_task () {
__nesc_atomic_t fInterruptFlags;
uint8_t old_full;
void (*func)(void);
if (TOSH_sched_full == TOSH_sched_free) {
// dbg(DBG_SCHED, "TOSH_schedule_task: %d empty \n", TOSH_sched_full);
return 0;
}
else {
fInterruptFlags = __nesc_atomic_start();
old_full = TOSH_sched_full;
TOSH_sched_full++;
TOSH_sched_full &= TOSH_TASK_BITMASK;
func = TOSH_queue[(int)old_full].tp;
TOSH_queue[(int)old_full].tp = 0;
__nesc_atomic_end(fInterruptFlags);
func();
return 1;
}
}
/**
* BootLoader_State_Machine
*
* The state machine for the boot loader which performs certain tasks
* based on the current state of the boot loader. The current state must
* be changed appropriately before calling this fuction.
*
*/
void BootLoader_State_Machine ()
{
switch (CurrentState)
{
case NORMAL:
/*FIXME Move the code from main and post the state machine*/
break;
case CPY_TO_BOOT:
{
uint8_t buffer [61];
Read_Attribute_Value(BL_ATTR_TYP_PRIMARY_IMG_LOCATION, &GImgAddr);
Read_Attribute_Value(BL_ATTR_TYP_PRIMARY_IMG_CRC, &GImgCrc);
Read_Attribute_Value(BL_ATTR_TYP_PRIMARY_IMG_SIZE, &GImgSize);
__nesc_atomic_t atomic = __nesc_atomic_start();
if (Move_Image_To_Boot_Loc (CurrImageAddr, CurrImageSize) == FAIL)
Reboot_Device ();
__nesc_atomic_end (atomic);
TOGGLE_LED (YELLOW);
if(Change_BootLoader_State_Attribute (SET_LOADED_TO_GOLDEN) == SUCCESS)
{
sprintf (buffer, "Successfully copied image to boot location.\n");
Send_USB_Command_Packet (CMD_BOOTLOADER_MSG, 61, buffer);
TOS_post (&BootLoader_State_Machine);
}
else
{
/**
* If we cant switch state then its hard to determine the problem
* So let reboot and try to recover.
*/
sprintf (buffer, "Could not switch to SET_LOADED_TO_GOLDEN. Rebooting\n");
Send_USB_Error_Packet (ERR_FATAL_ERROR_ABORT, 60, buffer);
Reboot_Device ();
}
}
break;
case SET_LOADED_TO_GOLDEN:
{
uint8_t buffer [61];
result_t ret = SUCCESS;
/*It may not be required, but still we dont want an interrupt to stop us*/
TOGGLE_LED (GREEN);
__nesc_atomic_t atomic = __nesc_atomic_start();
ret = Map_Loaded_To_Golden ();
__nesc_atomic_end (atomic);
TOGGLE_LED (GREEN);
if (ret == SUCCESS)
{
sprintf (buffer, "Mapped Boot Image to golden. Booting New Image.\n");
Send_USB_Command_Packet (CMD_CREATED_GOLDEN_IMG, 61, buffer);
Reboot_Device ();
}
else
{
/* Very Bad, We dont know exactly where we failed. I Guess the
* best way is reset the whole primary to secondary switch and
* reboot.
*/
sprintf (buffer, "Mark loaded to golden failed. Trying to recover\n");
Send_USB_Error_Packet (ERR_FATAL_ERROR_ABORT, 60, buffer);
Reboot_Device ();
}
}
break;
case SET_BOOT_TO_GOLDEN:
{
Change_BootLoader_State_Attribute (NORMAL);
Reboot_Device ();
}
break;
case BOOT_IMAGE:
break;
case CODE_LOAD:
switch (CLoaderState)
{
case REQUEST_IMAGE_DETAIL:
{
USBCommand cmd;
if (!MMU_ENABLED)
{
MMU_ENABLED = TRUE;
Enable_MMU ();
}
cmd.type = CMD_GET_IMAGE_DETAILS;
Send_Command_Packet (&cmd, sizeof (USBCommand));
}
break;
case REQUEST_USB_PACKETS:
#ifdef MMU_ENABLE
Request_Next_Binary_Chunk ();
#else
Request_Next_Binary_Packet ();
#endif
break;
case VERIFY_CURRENT_BUFFER:
break;
case VERIFY_CURRENT_IMAGE:
Send_USB_Command_Packet (CMD_IMG_UPLOAD_COMPLETE, 0, NULL);
break;
default:
break;
}
break;
case VERIFY_IMAGE:
break;
case VERIFY_SELF_TEST:
/*Implemented in Recovery State Machine*/
break;
default:
/* This is fatal, It is very essential to investigate why
* this might have happened but at the same time we dont
* want to panic. The best is to go back and try normal
* operation.
*/
CurrentState = NORMAL;
break;
}
}
