int main( void )
{
#ifdef DEBUG
debug();
#endif
//**********************************
// USED FOR FreeRTOS+TRACE
//**********************************
vTraceInitTraceData();
uiTraceStart();
//**********************************
/* Set up the clocks and memory interface. */
prvSetupHardware();
/* Create the 'check' task, which is also defined within this file. */
xTaskCreate( prvCheckTask, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL );
/* Start the scheduler. */
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 )
{
/* Initialise the trace recorder and create the label used to post user
events to the trace recording on each tick interrupt. */
vTraceInitTraceData();
xTickTraceUserEvent = xTraceOpenLabel( "tick" );
/* Start the trace recording - the recording is written to a file if
configASSERT() is called. */
printf( "\r\nTrace started. Hit a key to dump trace file to disk.\r\n" );
uiTraceStart();
/* The mainCREATE_SIMPLE_BLINKY_DEMO_ONLY setting is described at the top
of this file. */
#if ( mainCREATE_SIMPLE_BLINKY_DEMO_ONLY == 1 )
{
main_blinky();
}
#else
{
main_full();
}
#endif
return 0;
}
int main( void )
{
/* This demo uses heap_5.c, so start by defining some heap regions. This
is only done to provide an example as this demo could easily create one
large heap region instead of multiple smaller heap regions - in which case
heap_4.c would be the more appropriate choice. No initialisation is
required when heap_4.c is used. */
prvInitialiseHeap();
/* Initialise the trace recorder and create the label used to post user
events to the trace recording on each tick interrupt. */
vTraceInitTraceData();
xTickTraceUserEvent = xTraceOpenLabel( "tick" );
/* Start the trace recording - the recording is written to a file if
configASSERT() is called. */
printf( "\r\nTrace started. Hit a key to dump trace file to disk (does not work from Eclipse console).\r\n" );
fflush( stdout );
uiTraceStart();
/* The mainCREATE_SIMPLE_BLINKY_DEMO_ONLY setting is described at the top
of this file. */
#if ( mainCREATE_SIMPLE_BLINKY_DEMO_ONLY == 1 )
{
main_blinky();
}
#else
{
main_full();
}
#endif
return 0;
}
/* Main ----------------------------------------------------------------------*/
int main(void)
{
SystemInit();
prvHardwareInit();
vTraceInitTraceData();
c_common_usart_puts(USART2, "Programa iniciado!\n\r");
vTraceConsoleMessage("Starting application...");
//sprintf(str, "Line, %d \n\r", __LINE__);
//c_common_usart_puts(USART2, str);
if (! uiTraceStart() )
vTraceConsoleMessage("Could not start recorder!");
/* create tasks */
xTaskCreate(blink_led_task, (signed char *)"Blink led", configMINIMAL_STACK_SIZE, (void *)NULL, tskIDLE_PRIORITY+1, NULL);
xTaskCreate(sonar_task, (signed char *)"Sonar task", configMINIMAL_STACK_SIZE, (void *)NULL, tskIDLE_PRIORITY+1, NULL);
//xTaskCreate(echo_task, (signed char *)"Echo task", configMINIMAL_STACK_SIZE, (void *)NULL, tskIDLE_PRIORITY+1, NULL);
//xTaskCreate(blctrl_task, (signed char *)"blctrl task" , configMINIMAL_STACK_SIZE, (void *)NULL, tskIDLE_PRIORITY+1, NULL);
//xTaskCreate(uart_task , (signed char *)"UART task", configMINIMAL_STACK_SIZE, (void *)NULL, tskIDLE_PRIORITY+1, NULL);
//xTaskCreate(rc_servo_task , (signed char *)"Servo task", configMINIMAL_STACK_SIZE, (void *)NULL, tskIDLE_PRIORITY+1, NULL);
/* Start the scheduler. */
vTaskStartScheduler();
/* should never reach here! */
for(;;);
}
int main(void)
{
/* This demo uses heap_5.c, so start by defining some heap regions. This
is only done to provide an example as this demo could easily create one
large heap region instead of multiple smaller heap regions */
prvInitialiseHeap();
/* Initialise the trace recorder and create the label used to post user
events to the trace recording on each tick interrupt. */
vTraceInitTraceData();
xTickTraceUserEvent = xTraceOpenLabel("tick");
vSemaphoreCreateBinary(xSemaphore);
xQueue = xQueueCreate(4, sizeof(struct Message*));
/* Create the task, storing the handle. */
xTaskCreate((pdTASK_CODE)matrix_task, (signed char *)"Matrix", 1000, NULL, 3, &matrix_handle);
xTaskCreate((pdTASK_CODE)reader_task, (signed char *)"Reader", 1000, NULL, 3, &reader_handle);
//This starts the real-time scheduler
vTaskStartScheduler();
for (;; );
return 0;
}
int main( void )
{
const uint32_t ulLongTime_ms = 250UL;
/* Initialise the trace recorder and create the label used to post user
events to the trace recording on each tick interrupt. */
vTraceInitTraceData();
xTickTraceUserEvent = xTraceOpenLabel( "tick" );
/* Create the queue used to pass messages from the queue send task to the
queue receive task. */
xQueue = xQueueCreate( mainQUEUE_LENGTH, sizeof( unsigned long ) );
/* Give the queue a name for the FreeRTOS+Trace log. */
vTraceSetQueueName( xQueue, "DemoQ" );
/* Start the two tasks as described in the comments at the top of this
file. */
xTaskCreate( prvQueueReceiveTask, /* The function that implements the task. */
"Rx", /* The text name assigned to the task - for debug only as it is not used by the kernel. */
configMINIMAL_STACK_SIZE, /* The size of the stack to allocate to the task. Not actually used as a stack in the Win32 simulator port. */
NULL, /* The parameter passed to the task - not used in this example. */
mainQUEUE_RECEIVE_TASK_PRIORITY, /* The priority assigned to the task. */
NULL ); /* The task handle is not required, so NULL is passed. */
xTaskCreate( prvQueueSendTask, "TX", configMINIMAL_STACK_SIZE, NULL, mainQUEUE_SEND_TASK_PRIORITY, NULL );
/* Create the task that handles the CLI on a UDP port. The port number
is set using the configUDP_CLI_PORT_NUMBER setting in FreeRTOSConfig.h. */
xTaskCreate( vUDPCommandInterpreterTask, "CLI", configMINIMAL_STACK_SIZE, NULL, mainUDP_CLI_TASK_PRIORITY, NULL );
/* Register commands with the FreeRTOS+CLI command interpreter. */
vRegisterCLICommands();
/* Start the tasks and timer running. */
vTaskStartScheduler();
/* If all is well, the scheduler will now be running, and the following
line will never be reached. If the following line does execute, then
there was insufficient FreeRTOS heap memory available for the idle and/or
timer tasks to be created. See the memory management section on the
FreeRTOS web site for more details (this is standard text that is not not
really applicable to the Win32 simulator port). */
for( ;; )
{
Sleep( ulLongTime_ms );
}
}
int main( void )
{
/* Prepare the trace recorder library. */
#if configINCLUDE_TRACE_RELATED_CLI_COMMANDS == 1
vTraceInitTraceData();
#endif
/* The examples assume that all priority bits are assigned as preemption
priority bits. */
NVIC_SetPriorityGrouping( 0UL );
/* Start the timer that just toggles an LED to show the demo is running. */
vLEDsInitialise();
/* Start the tasks that implements the command console on the UART, as
described above. */
vCDCCommandConsoleStart( mainCDC_COMMAND_CONSOLE_STACK_SIZE, mainCDC_COMMAND_CONSOLE_TASK_PRIORITY );
/* Register CLI commands. */
vRegisterCLICommands();
/* Initialise the network interface. Tasks that use the network are
created in the network event hook when the network is connected and ready
for use. The address values passed in here are used if ipconfigUSE_DHCP is
set to 0, or if ipconfigUSE_DHCP is set to 1 but a DHCP server cannot be
contacted. */
FreeRTOS_IPInit( ucIPAddress, ucNetMask, ucGatewayAddress, ucDNSServerAddress, ucMACAddress );
/* If the trace recorder code is included... */
#if configINCLUDE_TRACE_RELATED_CLI_COMMANDS == 1
{
extern xQueueHandle xNetworkEventQueue;
/* Name the queue for viewing in FreeRTOS+Trace. */
vTraceSetQueueName( xNetworkEventQueue, "IPStackEvent" );
}
#endif /* configINCLUDE_TRACE_RELATED_CLI_COMMANDS == 1 */
/* Start the FreeRTOS scheduler. */
vTaskStartScheduler();
/* The following line should never execute. If it does, it means there was
insufficient FreeRTOS heap memory available to create the Idle and/or timer
tasks. See the memory management section on the http://www.FreeRTOS.org web
site for more information. */
for( ;; );
}
int main(void)
{
/* This demo uses heap_5.c, so start by defining some heap regions. This
is only done to provide an example as this demo could easily create one
large heap region instead of multiple smaller heap regions */
prvInitialiseHeap();
/* Initialise the trace recorder and create the label used to post user
events to the trace recording on each tick interrupt. */
vTraceInitTraceData();
xTickTraceUserEvent = xTraceOpenLabel("tick");
//This starts the real-time scheduler
vTaskStartScheduler();
for (;; );
return 0;
}
int main(void)
{
vTraceInitTraceData ();
if (!uiTraceStart())
vTraceConsoleMessage("Could not start recorder!");
/* Create IPC variables */
pbq = xQueueCreate(10, sizeof(int));
if (pbq == 0) {
while(1); /* fatal error */
}
/* Create tasks */
xTaskCreate(
ToggleLED_Timer, /* Function pointer */
"Task1", /* Task name - for debugging only*/
configMINIMAL_STACK_SIZE, /* Stack depth in words */
(void*) NULL, /* Pointer to tasks arguments (parameter) */
tskIDLE_PRIORITY + 2UL, /* Task priority*/
NULL /* Task handle */
);
xTaskCreate(
DetectButtonPress,
"Task2",
configMINIMAL_STACK_SIZE,
(void*) NULL,
tskIDLE_PRIORITY + 2UL,
NULL);
xTaskCreate(
ToggleLED_IPC,
"Task3",
configMINIMAL_STACK_SIZE,
(void*) NULL,
tskIDLE_PRIORITY + 2UL,
NULL);
/* Start the RTOS Scheduler */
vTaskStartScheduler();
/* HALT */
while(1);
}
/*---------------------------------------------------------------------------*/
T_uezError UEZSystemInit(void)
{
// Initialize the memory system
UEZMemInit();
// Setup handles system that RTOS sits on top of
uEZHandleTableInit();
// Setup the GPIO table
UEZGPIOReset();
// Start the task system
#if FREERTOS_PLUS_TRACE
vTraceInitTraceData();
#endif
UEZTaskInit();
return UEZ_ERROR_NONE;
}
void SYS_Initialize ( void* data )
{
/* Core Processor Initialization */
SYS_CLK_Initialize( NULL );
sysObj.sysDevcon = SYS_DEVCON_Initialize(SYS_DEVCON_INDEX_0, (SYS_MODULE_INIT*)&sysDevconInit);
SYS_DEVCON_PerformanceConfig(SYS_CLK_SystemFrequencyGet());
SYS_DEVCON_JTAGDisable();
SYS_PORTS_Initialize();
/* Initialize Drivers */
// DRV_SPI0_Initialize();
// DRV_SPI1_Initialize();
//DRV_I2C1_Initialize();
SYS_INT_VectorPrioritySet(INT_VECTOR_T2, INT_PRIORITY_LEVEL1);
SYS_INT_VectorSubprioritySet(INT_VECTOR_T2, INT_SUBPRIORITY_LEVEL0);
/*Initialize CAN0 */
DRV_CAN0_Initialize();
//For Debugging
// SYS_PORTS_PinDirectionSelect(PORTS_ID_0, SYS_PORTS_DIRECTION_OUTPUT, PORT_CHANNEL_G, PORTS_BIT_POS_8);
// SYS_PORTS_PinClear(PORTS_ID_0, PORT_CHANNEL_G, PORTS_BIT_POS_8);
// SYS_PORTS_PinDirectionSelect(PORTS_ID_0, SYS_PORTS_DIRECTION_OUTPUT, PORT_CHANNEL_E, PORTS_BIT_POS_8);
// SYS_PORTS_PinClear(PORTS_ID_0, PORT_CHANNEL_E, PORTS_BIT_POS_8);
/* Indicate initializing */
led_on(LED_RED);
/* Initialize PMP0 */
DRV_PMP0_Initialize();
DRV_PMP0_ModeConfig();
/* Initialize System Services */
SYS_INT_Initialize();
/* Initialize Middleware */
/* Set priority of USB interrupt source */
SYS_INT_VectorPrioritySet(INT_VECTOR_USB1, INT_PRIORITY_LEVEL4);
/* Wait FPGA_DONE*/
// while(!FpgaDone);
/* Set Sub-priority of USB interrupt source */
SYS_INT_VectorSubprioritySet(INT_VECTOR_USB1, INT_SUBPRIORITY_LEVEL0);
/* Initialize the USB device layer */
sysObj.usbDevObject0 = USB_DEVICE_Initialize (USB_DEVICE_INDEX_0 , ( SYS_MODULE_INIT* ) & usbDevInitData);
/* Enable Global Interrupts */
SYS_INT_Enable();
#ifdef DEBUG_PERCEPIO
/* Initialize Percepio */
vTraceInitTraceData();
if(uiTraceStart() != 1) {
while(true);
}
#endif
/* Initialize the Application */
APP_Initialize();
APP1_Initialize();
APP2_Initialize();
Xcp_Initialize();
}
void RTOSTRC_Init(void) {
vTraceInitTraceData();
if (uiTraceStart()==0) {
for(;;); /* error */
}
}
int main( void )
{
BaseType_t res = pdPASS;
rtc_t rtc;
TickType_t xTimeNow;
/* Seed the random number generator. */
xTimeNow = 0;//xTaskGetTickCount();
prvSRand( 0);
#if configUSE_TRACE_FACILITY == 1
vTraceInitTraceData();
vTraceSetISRProperties(TIID_EthRx, "i_EthRx", IPRI_EthRx);
vTraceSetISRProperties(TIID_EthTx, "i_EthTx", IPRI_EthTx);
vTraceSetISRProperties(TIID_EthSys, "i_EthSys", IPRI_EthSys);
vTraceSetISRProperties(TIID_Tmr0, "i_Tmr0", IPRI_Tmr0);
vTraceSetISRProperties(TIID_Tmr1, "i_Tmr1", IPRI_Tmr1);
vTraceSetISRProperties(TIID_Tmr2, "i_Tmr2", IPRI_Tmr2);
vTraceSetISRProperties(TIID_rtc, "i_rtc", IPRI_rtc);
vTraceSetISRProperties(TIID_uart0, "i_uart0", IPRI_uart0);
vTraceSetISRProperties(TIID_uart1, "i_uart1", IPRI_uart1);
vTraceSetISRProperties(TIID_button0, "i_swb0", IPRI_button0);
vTraceSetISRProperties(TIID_button1, "i_swb1", IPRI_button1);
vTraceSetISRProperties(TIID_button2, "i_swb2", IPRI_button2);
// uiTraceStart();
// vTraceStop()
#endif
#if INCLUDE_CONSOLE == 1 || INCLUDE_MODEM == 1 // Include serial port 0 or serial port 1
initSerial();
#endif
#if INCLUDE_RTC == 1 // Include Realtime Clock
initRTC();
#endif
#if INCLUDE_BUTTONS == 1
initButtons();
#endif
#if INCLUDE_NETWORK
/* Initialise the RTOS's TCP/IP stack. The tasks that use the network
are created in the vApplicationIPNetworkEventHook() hook function
below. The hook function is called when the network connects. */
res = FreeRTOS_IPInit( ucIPAddress, ucNetMask, ucGatewayAddress, ucDNSServerAddress, ucMACAddress );
//vRegisterSampleCLICommands();
vRegisterTCPCLICommands();
vRegisterMonitorCLICommands();
// Commandline interface (Telnet port 5010)
vStartTCPCommandInterpreterTask( 2048, 5010, tskIDLE_PRIORITY + 1);
#endif
#ifdef INCLUDE_MONITOR
// Demo Sysinfo
// Connect putty 115200,8,1,n (ansi terminal) to get the status informations
res = xTaskCreate( sysinfo, "SysInfo", configMINIMAL_STACK_SIZE*2, (void *)portMAX_DELAY, PRIO_SYSINFO, NULL);
#endif
#if INCLUDE_LED5x7 == 1
initLED5x7();
res = xTaskCreate( TaskLED, "TaskLED", configMINIMAL_STACK_SIZE, (void *)portMAX_DELAY, PRIO_LED, NULL);
#endif
#ifdef CPM22
memset(cpmmem,0,sizeof(cpmmem));
res = xTaskCreate( prvTCPCpmIOTask, "CPMIO", configMINIMAL_STACK_SIZE*2, (void*)cpmmem, PRIO_CPMIO, NULL);
#endif
vTaskStartScheduler();
return res;
}
