void vtHandleFatalError(int code,int line,char file[]) {
static unsigned int delayCounter = 0;
// There are lots of ways you can (and may want to) handle a fatal error
// In this implementation, I suspend tasks and then flash the LEDs. Note that the stop may not be
// immediate because this task has to be scheduled first for that to happen. In fact, one task might
// call this while another tries to get into
taskENTER_CRITICAL();
taskDISABLE_INTERRUPTS();
/* LEDs on ports 1 and 2 to output (1). */
// Note that all LED access is through the proper LPC library calls (or my own routines that call them)
vtInitLED();
for (;;) {
// Silly delay loop, but we really don't have much choice here w/o interrupts and FreeRTOS...
// This won't be okay to do *anywhere* else in your code
for (delayCounter=0;delayCounter<10000000;delayCounter++) {
}
// Turn off half and on half
vtLEDOn(0xAA);
vtLEDOff(0x55);
// Delay again
for (delayCounter=0;delayCounter<10000000;delayCounter++) {
}
// Toggle
vtLEDOff(0xAA);
vtLEDOn(0x55);
// Here is some dumb code to make sure that the three input parameters are not optimized away by the compiler
if ((code < -55) && (line < -55) && (file == NULL)) {
vtLEDOff(0x0); // We won't get here
}
// End of dumb code
}
// We will never get here
taskEXIT_CRITICAL();
}
int main()
{
// Initialize system.
init_syscalls();
// Set up the LED ports.
vtInitLED();
// Set up hardware.
setupHardware();
// Buffer for events messages.
char eventsMsg[QUEUE_BUF_LEN_LCD];
// LCD task.
startTaskLCD(&dataLCD, LCD_TASK_PRIORITY);
startTimerLCD(&dataLCD);
// Debug - initialize base.
sendValueMsgLCD(&dataLCD, MSG_TYPE_LCD_EVENTS, QUEUE_BUF_LEN_LCD, "Initializing system", portMAX_DELAY);
sendValueMsgLCD(&dataLCD, MSG_TYPE_LCD_EVENTS, QUEUE_BUF_LEN_LCD, "Initializing LEDs", portMAX_DELAY);
sendValueMsgLCD(&dataLCD, MSG_TYPE_LCD_EVENTS, QUEUE_BUF_LEN_LCD, "Initializing hardware", portMAX_DELAY);
sprintf(eventsMsg, "Starting %s", taskNameLCD);
sendValueMsgLCD(&dataLCD, MSG_TYPE_LCD_EVENTS, QUEUE_BUF_LEN_LCD, eventsMsg, portMAX_DELAY);
sprintf(eventsMsg, "Starting %s", timerNameLCD);
sendValueMsgLCD(&dataLCD, MSG_TYPE_LCD_EVENTS, QUEUE_BUF_LEN_LCD, eventsMsg, portMAX_DELAY);
// I2C task.
sprintf(eventsMsg, "Starting %s", taskNameI2C);
sendValueMsgLCD(&dataLCD, MSG_TYPE_LCD_EVENTS, QUEUE_BUF_LEN_LCD, eventsMsg, portMAX_DELAY);
if(vtI2CInit(&vtI2C0, 0, MONITOR_TASK_PRIORITY, I2C_BITRATE) != vtI2CInitSuccess)
{
sprintf(eventsMsg, "Unable to create queue for %s", taskNameI2C);
sendValueMsgLCD(&dataLCD, MSG_TYPE_LCD_EVENTS, QUEUE_BUF_LEN_LCD, eventsMsg, portMAX_DELAY);
VT_HANDLE_FATAL_ERROR(0);
}
// Command task.
sprintf(eventsMsg, "Starting %s", taskNameCommand);
sendValueMsgLCD(&dataLCD, MSG_TYPE_LCD_EVENTS, QUEUE_BUF_LEN_LCD, eventsMsg, portMAX_DELAY);
startTaskCommand(&dataCommand, COMMAND_TASK_PRIORITY, &vtI2C0, &dataLCD);
sprintf(eventsMsg, "Starting %s", timerNameCommand);
sendValueMsgLCD(&dataLCD, MSG_TYPE_LCD_EVENTS, QUEUE_BUF_LEN_LCD, eventsMsg, portMAX_DELAY);
startTimerCommand(&dataCommand);
// Locate task.
sprintf(eventsMsg, "Starting %s", taskNameLocate);
sendValueMsgLCD(&dataLCD, MSG_TYPE_LCD_EVENTS, QUEUE_BUF_LEN_LCD, eventsMsg, portMAX_DELAY);
startTaskLocate(&dataLocate, SENSOR_TASK_PRIORITY, &dataLCD, &dataCommand);
sprintf(eventsMsg, "Starting %s", timerNameLocate);
sendValueMsgLCD(&dataLCD, MSG_TYPE_LCD_EVENTS, QUEUE_BUF_LEN_LCD, eventsMsg, portMAX_DELAY);
startTimerLocate(&dataLocate);
// Sensors task.
sprintf(eventsMsg, "Starting %s", taskNameSensors);
sendValueMsgLCD(&dataLCD, MSG_TYPE_LCD_EVENTS, QUEUE_BUF_LEN_LCD, eventsMsg, portMAX_DELAY);
startTaskSensors(&dataSensors, SENSOR_TASK_PRIORITY, &vtI2C0, &dataLCD, &dataLocate);
sprintf(eventsMsg, "Starting %s", timerNameSensors);
sendValueMsgLCD(&dataLCD, MSG_TYPE_LCD_EVENTS, QUEUE_BUF_LEN_LCD, eventsMsg, portMAX_DELAY);
startTimerSensors(&dataSensors);
// Conductor task.
sprintf(eventsMsg, "Starting %s", taskNameConductor);
sendValueMsgLCD(&dataLCD, MSG_TYPE_LCD_EVENTS, QUEUE_BUF_LEN_LCD, eventsMsg, portMAX_DELAY);
startTaskConductor(&dataConductor, CONDUCTOR_TASK_PRIORITY, &vtI2C0, &dataLCD, &dataSensors, &dataLocate);
// Schedlar task.
sprintf(eventsMsg, "Starting %s", taskNameScheduler);
sendValueMsgLCD(&dataLCD, MSG_TYPE_LCD_EVENTS, QUEUE_BUF_LEN_LCD, eventsMsg, portMAX_DELAY);
vTaskStartScheduler();
// Shouldn't reach this part unless insufficient memory.
for(;;);
}
int main( void )
{
/* MTJ: initialize syscalls -- *must* be first */
// syscalls.c contains the files upon which the standard (and portable) C libraries rely
init_syscalls();
// Set up the LED ports and turn them off
vtInitLED();
/* Configure the hardware for use by this demo. */
prvSetupHardware();
#if USE_FREERTOS_DEMO == 1
/* Start the standard demo tasks. These are just here to exercise the
kernel port and provide examples of how the FreeRTOS API can be used. */
vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );
vCreateBlockTimeTasks();
vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );
vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );
vStartIntegerMathTasks( mainINTEGER_TASK_PRIORITY );
vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY );
vStartQueuePeekTasks();
vStartRecursiveMutexTasks();
vStartLEDFlashTasks( mainFLASH_TASK_PRIORITY );
#endif
// Not a standard demo -- but also not one of mine (MTJ)
/* Create the uIP task. The WEB server runs in this task. */
xTaskCreate( vuIP_Task, ( signed char * ) "uIP", mainBASIC_WEB_STACK_SIZE, ( void * ) NULL, mainUIP_TASK_PRIORITY, NULL );
// MTJ: My LCD demonstration task
#if USE_MTJ_LCD == 1
vStartLCDTask( mainLCD_TASK_PRIORITY,&vtLCDdata);
#endif
// MTJ: My i2cTemp demonstration task
#if USE_MTJ_V4Temp_Sensor == 1
vtI2C0.devNum = 0;
vtI2C0.taskPriority = mainI2CMONITOR_TASK_PRIORITY;
// Initialize I2C0
int retVal;
if ((retVal = vtI2CInit(&vtI2C0,100000)) != vtI2CInitSuccess) {
VT_HANDLE_FATAL_ERROR(retVal);
}
tempSensorParams.dev = &vtI2C0;
#if USE_MTJ_LCD == 1
tempSensorParams.lcdData = &vtLCDdata;
#else
tempSensorParams.lcdData = NULL;
#endif
//vStarti2cTempTask(mainI2CTEMP_TASK_PRIORITY,&tempSensorParams);
vStartSomeTask(mainI2CTEMP_TASK_PRIORITY, &tempSensorParams);
#endif
/* Create the USB task. MTJ: This routine has been modified from the original example (which is not a FreeRTOS standard demo) */
#if USE_MTJ_USE_USB == 1
initUSB(); // MTJ: This is my routine used to make sure we can do printf() with USB
xTaskCreate( vUSBTask, ( signed char * ) "USB", configMINIMAL_STACK_SIZE, ( void * ) NULL, mainUSB_TASK_PRIORITY, NULL );
#endif
/* Start the scheduler. */
// IMPORTANT: Once you start the scheduler, any variables on the stack from main (local variables in main) can be (will be...) writtenover
// because the stack is used by the interrupt handler
vTaskStartScheduler();
/* Will only get here if there was insufficient memory to create the idle
task. The idle task is created within vTaskStartScheduler(). */
for( ;; );
}
int main( void )
{
/* MTJ: initialize syscalls -- *must* be first */
// syscalls.c contains the files upon which the standard (and portable) C libraries rely
init_syscalls();
// Set up the LED ports and turn them off
vtInitLED();
/* Configure the hardware for use by this demo. */
prvSetupHardware();
#if USE_FREERTOS_DEMO == 1
/* Start the standard demo tasks. These are just here to exercise the
kernel port and provide examples of how the FreeRTOS API can be used. */
vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );
vCreateBlockTimeTasks();
vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );
vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );
vStartIntegerMathTasks( mainINTEGER_TASK_PRIORITY );
vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY );
vStartQueuePeekTasks();
vStartRecursiveMutexTasks();
vStartLEDFlashTasks( mainFLASH_TASK_PRIORITY );
#endif
#if USE_WEB_SERVER == 1
// Not a standard demo -- but also not one of mine (MTJ)
/* Create the uIP task. The WEB server runs in this task. */
xTaskCreate( vuIP_Task, ( signed char * ) "uIP", mainBASIC_WEB_STACK_SIZE, ( void * ) NULL, mainUIP_TASK_PRIORITY, NULL );
#endif
#if USE_MTJ_LCD == 1
// MTJ: My LCD demonstration task
StartLCDTask(&vtLCDdata,mainLCD_TASK_PRIORITY);
// LCD Task creates a queue to receive messages -- what it does with those messages will depend on how the task is configured (see LCDtask.c)
// Here we set up a timer that will send messages to the LCD task. You don't have to have this timer for the LCD task, it is just showing
// how to use a timer and how to send messages from that timer.
//Commented out by Matthew Ibarra 2/2/2013
//startTimerForLCD(&vtLCDdata);
#endif
#if USE_MTJ_V4Temp_Sensor == 1
// MTJ: My i2cTemp demonstration task
// First, start up an I2C task and associate it with the I2C0 hardware on the ARM (there are 3 I2C devices, we need this one)
// See vtI2C.h & vtI2C.c for more details on this task and the API to access the task
// Initialize I2C0 for I2C0 at an I2C clock speed of 100KHz
if (vtI2CInit(&vtI2C0,0,mainI2CMONITOR_TASK_PRIORITY,100000) != vtI2CInitSuccess) {
VT_HANDLE_FATAL_ERROR(0);
}
// Now, start up the task that is going to handle the temperature sensor sampling (it will talk to the I2C task and LCD task using their APIs)
#if USE_MTJ_LCD == 1
vStarti2cTempTask(&tempSensorData,mainI2CTEMP_TASK_PRIORITY,&vtI2C0,&vtLCDdata);
#else
vStarti2cTempTask(&tempSensorData,mainI2CTEMP_TASK_PRIORITY,&vtI2C0,NULL);
#endif
// Here we set up a timer that will send messages to the Temperature sensing task. The timer will determine how often the sensor is sampled
startTimerForTemperature(&tempSensorData);
// start up a "conductor" task that will move messages around
vStartConductorTask(&conductorData,mainCONDUCTOR_TASK_PRIORITY,&vtI2C0,&tempSensorData);
#endif
/* Create the USB task. MTJ: This routine has been modified from the original example (which is not a FreeRTOS standard demo) */
#if USE_MTJ_USE_USB == 1
initUSB(); // MTJ: This is my routine used to make sure we can do printf() with USB
xTaskCreate( vUSBTask, ( signed char * ) "USB", configMINIMAL_STACK_SIZE, ( void * ) NULL, mainUSB_TASK_PRIORITY, NULL );
#endif
/* Start the scheduler. */
// IMPORTANT: Once you start the scheduler, any variables on the stack from main (local variables in main) can be (will be...) written over
// because the stack is used by the interrupt handler
vTaskStartScheduler();
/* Will only get here if there was insufficient memory to create the idle
task. The idle task is created within vTaskStartScheduler(). */
for( ;; );
}
int main( void )
{
/* MTJ: initialize syscalls -- *must* be first */
// syscalls.c contains the files upon which the standard (and portable) C libraries rely
init_syscalls();
// Set up the LED ports and turn them off
vtInitLED();
/* Configure the hardware for use by this demo. */
prvSetupHardware();
#if USE_WEB_SERVER == 1
// Not a standard demo -- but also not one of mine (MTJ)
/* Create the uIP task. The WEB server runs in this task. */
xTaskCreate( vuIP_Task, ( signed char * ) "uIP", mainBASIC_WEB_STACK_SIZE, ( void * ) NULL, mainUIP_TASK_PRIORITY, NULL );
#endif
vStartLCDTask(&vtLCDdata,mainLCD_TASK_PRIORITY);
// LCD Task creates a queue to receive messages -- what it does with those messages will depend on how the task is configured (see LCDtask.c)
// Here we set up a timer that will send messages to the LCD task. You don't have to have this timer for the LCD task, it is just showing
// how to use a timer and how to send messages from that timer.
// First, start up an I2C task and associate it with the I2C0 hardware on the ARM (there are 3 I2C devices, we need this one)
// See vtI2C.h & vtI2C.c for more details on this task and the API to access the task
// Initialize I2C0 for I2C0 at an I2C clock speed of 100KHz
if (vtI2CInit(&vtI2C0,0,mainI2CMONITOR_TASK_PRIORITY,100000) != vtI2CInitSuccess) {
VT_HANDLE_FATAL_ERROR(0);
}
// start up a "conductor" task that will move messages around
vStartConductorTask(&conductorData,mainCONDUCTOR_TASK_PRIORITY,&vtI2C0,&i2cData,&motorControl,&irData,&speedData,&powerData,&vtLCDdata);
// Start the I2C task
starti2cTask(&i2cData,mainI2C_TASK_PRIORITY,&vtI2C0);
// Start the Motor Control task
vStartMotorControlTask(&motorControl,mainMOTOR_CONTROL_TASK_PRIORITY,&i2cData,&webData,&vtLCDdata);
// Start the Navigation task
vStartNavigationTask(&navData,mainNAVIGATION_TASK_PRIORITY,&motorControl,&vtLCDdata);
// Start the IR Control task
vStartIRTask(&irData,mainIR_CONTROL_TASK_PRIORITY,&navData);
// Start the Speed Limit task
vStartSpeedLimitTask(&speedData,mainSPEED_LIMIT_TASK_PRIORITY,&motorControl,&navData,&webData);
startTimerFori2c(&i2cData);
//startTimerForMotor(&motorControl);
/* Create the USB task. MTJ: This routine has been modified from the original example (which is not a FreeRTOS standard demo) */
#if USE_MTJ_USE_USB == 1
initUSB(); // MTJ: This is my routine used to make sure we can do printf() with USB
xTaskCreate( vUSBTask, ( signed char * ) "USB", configMINIMAL_STACK_SIZE, ( void * ) NULL, mainUSB_TASK_PRIORITY, NULL );
#endif
/* Start the scheduler. */
// IMPORTANT: Once you start the scheduler, any variables on the stack from main (local variables in main) can be (will be...) written over
// because the stack is used by the interrupt handler
vTaskStartScheduler();
/* Will only get here if there was insufficient memory to create the idle
task. The idle task is created within vTaskStartScheduler(). */
for( ;; );
}
