OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [freertos-6.1.1/] [Demo/] [OpenRISC_SIM_GCC/] [main.c] - Diff between revs 622 and 649

Go to most recent revision | Show entire file | Details | Blame | View Log

Rev 622 Rev 649
Line 59... Line 59...
#include "spr_defs.h"
#include "spr_defs.h"
 
 
/* Scheduler header files. */
/* Scheduler header files. */
#include "FreeRTOS.h"
#include "FreeRTOS.h"
#include "task.h"
#include "task.h"
 
#include "queue.h"
 
 
 
/* Demo application includes. */
 
#include "serial.h"
 
#include "partest.h"
 
#include "flash.h"
 
#include "integer.h"
 
#include "blocktim.h"
 
#include "BlockQ.h"
 
#include "comtest2.h"
 
#include "dynamic.h"
 
 
 
/* BSP headers. */
 
#include "support.h"
 
#include "board.h"
#include "uart.h"
#include "uart.h"
#include "interrupts.h"
#include "gpio.h"
 
 
#define TASK_STACK_SIZE (configMINIMAL_STACK_SIZE)
#include "interrupts.h"
 
 
 
/* Demo application task priorities. */
 
#define mainCHECK_TASK_PRIORITY         ( tskIDLE_PRIORITY + 4 )
 
#define mainBLOCK_Q_PRIORITY            ( tskIDLE_PRIORITY + 2 )
 
#define mainLED_TASK_PRIORITY           ( tskIDLE_PRIORITY + 1 )
 
#define mainCOM_TEST_PRIORITY           ( tskIDLE_PRIORITY + 1 )
 
#define mainLCD_TASK_PRIORITY           ( tskIDLE_PRIORITY + 1 )
 
 
 
#define mainPRINT_STACK_SIZE            ( ( unsigned short ) 64 )
 
#define mainDEBUG_LOG_BUFFER_SIZE       ( ( unsigned short ) 256 )
 
 
 
/* How often should we check the other tasks? */
 
#define mainCHECK_TASK_CYCLE_TIME       ( 3000 )
 
 
 
/* Baud rate used by the comtest tasks. */
 
#define mainCOM_TEST_BAUD_RATE          ( 115200 )
 
 
 
/* The LED used by the comtest tasks. See the comtest.c file for more
 
information. */
 
#define mainCOM_TEST_LED                        ( 7 )
 
 
 
/*-----------------------------------------------------------*/
 
 
 
/*
 
 * The task that executes at the highest priority and checks the operation of
 
 * all the other tasks in the system.  See the description at the top of the
 
 * file.
 
 */
 
static void vCheckTask( void *pvParameters );
 
 
 
/*
 
 * ST provided routine to configure the processor.
 
 */
static void prvSetupHardware(void);
static void prvSetupHardware(void);
void vDemoTask(void *pvParameters);
 
void vClockTask(void *pvParameters);
 
 
 
void vApplicationTickHook(void);
 
void vApplicationIdleHook(void);
void vApplicationIdleHook(void);
 
void vApplicationTickHook( void );
void vApplicationStackOverflowHook(xTaskHandle *pxTask, signed char *pcTaskName);
void vApplicationStackOverflowHook(xTaskHandle *pxTask, signed char *pcTaskName);
 
void vApplicationMallocFailedHook( void );
 
 
 
/*-----------------------------------------------------------*/
 
 
int main(int argc, char **argv) {
/* Create all the demo application tasks, then start the scheduler. */
 
int main( int argc, char **argv )
 
{
        argc = argc;
        argc = argc;
        argv = argv;
        argv = argv;
 
 
        portBASE_TYPE delay[3] = {600, 400, 200};
        /* Perform any hardware setup necessary. */
 
 
        prvSetupHardware();
        prvSetupHardware();
 
        vParTestInitialise();
 
 
        xTaskCreate(vDemoTask , (signed char *)"vTask0", TASK_STACK_SIZE, (void*)&delay[0], 1, (xTaskHandle)NULL);
        /* Create the standard demo application tasks.  See the WEB documentation
        xTaskCreate(vDemoTask , (signed char *)"vTask1", TASK_STACK_SIZE, (void*)&delay[1], 2, (xTaskHandle)NULL);
        for more information on these tasks. */
        xTaskCreate(vDemoTask , (signed char *)"vTask2", TASK_STACK_SIZE, (void*)&delay[2], 3, (xTaskHandle)NULL);
        vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED );
        xTaskCreate(vClockTask, (signed char *)"vClock", TASK_STACK_SIZE, (void*)&delay[2], 3, (xTaskHandle)NULL);
        vStartLEDFlashTasks( mainLED_TASK_PRIORITY );
 
        vStartIntegerMathTasks( tskIDLE_PRIORITY );
 
 
 
        // vCreateBlockTimeTasks();
 
        // vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );
 
        // vStartDynamicPriorityTasks();
 
 
 
        /* Create the tasks defined within this file. */
 
        xTaskCreate( vCheckTask, ( signed char * ) "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL );
 
 
        vTaskStartScheduler();
        vTaskStartScheduler();
 
 
        // Control will not reach here
        /* Execution will only reach here if there was insufficient heap to
 
        start the scheduler. */
        return 0;
        return 0;
}
}
 
/*-----------------------------------------------------------*/
 
 
 
static void vCheckTask( void *pvParameters )
 
{
 
        static unsigned long ulErrorDetected = pdFALSE;
 
        portTickType xLastExecutionTime;
 
 
void vClockTask(void *pvParameters) {
        /* prevent compiler warning */
        pvParameters = pvParameters;
        pvParameters = pvParameters;
        unsigned portBASE_TYPE ticks = xTaskGetTickCount();
 
 
 
        int hour = 0;
        /* Initialise xLastExecutionTime so the first call to vTaskDelayUntil()
        int min = 0;
        works correctly. */
        int sec = -1;
        xLastExecutionTime = xTaskGetTickCount();
        while(1) {
 
                sec += 1;
 
                if(sec == 60) {
 
                        sec = 0;
 
                        min += 1;
 
                }
 
                if(min == 60) {
 
                        min = 0;
 
                        hour += 1;
 
                }
 
                if(hour == 24) {
 
                        hour = 0;
 
                }
 
 
 
                portENTER_CRITICAL();
        for( ;; )
                {
                {
                        uart_print_int(hour);
                /* Wait until it is time for the next cycle. */
                        uart_print_str(" : ");
                vTaskDelayUntil( &xLastExecutionTime, mainCHECK_TASK_CYCLE_TIME );
                        uart_print_int(min);
 
                        uart_print_str(" : ");
 
                        uart_print_int(sec);
 
                        uart_print_str(" , ");
 
                        uart_print_int(ticks);
 
                        uart_print_str("\n\r");
 
                }
 
                portEXIT_CRITICAL();
 
 
 
                vTaskDelay(1000);
                /* Has an error been found in any of the standard demo tasks? */
                ticks = xTaskGetTickCount();
 
 
                if( xAreIntegerMathsTaskStillRunning() != pdTRUE )
 
                {
 
                        ulErrorDetected = pdTRUE;
        }
        }
 
 
 
                /* FIXME, xAreComTestTasksStillRunning assumed that UART TX is loopbacked to RX
 
                but, current Or1ksim does not surrpot UART loopback. so, ignore it.*/
 
                if( xAreComTestTasksStillRunning() != pdTRUE )
 
                {
 
                        // ulErrorDetected = pdTRUE;
}
}
 
 
void vDemoTask(void *pvParameters) {
                // if( xAreBlockTimeTestTasksStillRunning() != pdTRUE )
        // unsigned portBASE_TYPE priority = uxTaskPriorityGet(NULL);
                // {
        unsigned portBASE_TYPE ticks = xTaskGetTickCount();
                //      ulErrorDetected = pdTRUE;
        portTickType delay = *((portTickType *)pvParameters);
                // }
 
 
        while(1) {
                // if( xAreBlockingQueuesStillRunning() != pdTRUE )
                portENTER_CRITICAL();
                // {
 
                //      ulErrorDetected = pdTRUE;
 
                // }
 
 
 
                // if( xAreDynamicPriorityTasksStillRunning() != pdTRUE )
 
                // {
 
                //      ulErrorDetected = pdTRUE;
 
                // }            
 
 
 
                if(ulErrorDetected == pdTRUE)
                {
                {
                        uart_print_str("vTask ");
                        // something was wrong. report negative indicator
                        uart_print_int(delay);
                        const char *message = "vCheckTask Error detected!\n\r";
                        uart_print_str(" : ");
                        vSerialPutString(NULL, (const signed char*)message, strlen(message));
                        // uart_print_int(priority);
 
                        // uart_print_str(" , ");
                        report(0xDEADBEEF);
                        uart_print_int(ticks);
 
                        uart_print_str(" \n\r");
 
                }
                }
                portEXIT_CRITICAL();
                else
                vTaskDelay(delay);
                {
                ticks = xTaskGetTickCount();
                        // we have no error. report positive indicator
 
                        const char *message = "vCheckTask OK!\n\r";
 
                        vSerialPutString(NULL, (const signed char*)message, strlen(message));
 
 
 
                        report(0x00000000);
 
                }
 
 
        }
        }
}
}
 
 
static void prvSetupHardware(void) {
/*-----------------------------------------------------------*/
 
 
 
void prvSetupHardware( void )
 
{
        // UART controller use 25 Mhz Wishbone bus clock, define in board.h
        // UART controller use 25 Mhz Wishbone bus clock, define in board.h
        uart_init(0);
        uart_init(0);
 
        uart_rxint_enable(0);
 
 
        // Initialize internal Programmable Interrupt Controller
        // Initialize internal Programmable Interrupt Controller
        int_init();
        int_init();
 
 
 
        // GPIO Initialize
 
        gpio_init(0);
 
 
 
        // set low 8 port is outout
 
        set_gpio_direction(0, 0xFFFFFF00);
}
}
 
/*-----------------------------------------------------------*/
 
 
void vApplicationTickHook(void) {
void vApplicationIdleHook( void )
        uart_print_str(".");
{
}
}
 
/*-----------------------------------------------------------*/
 
 
void vApplicationIdleHook(void) {
void vApplicationTickHook( void )
        uart_print_str(" i ");
{
}
}
 
/*-----------------------------------------------------------*/
 
 
void vApplicationStackOverflowHook(xTaskHandle *pxTask, signed char *pcTaskName) {
void vApplicationStackOverflowHook( xTaskHandle *pxTask, signed char *pcTaskName )
 
{
 
        /* prevent compiler warning */
        pxTask = pxTask;
        pxTask = pxTask;
        pcTaskName = pcTaskName;
        pcTaskName = pcTaskName;
 
 
        uart_print_str(" S \n\r");
        report(0x00000099);
 
}
 
/*-----------------------------------------------------------*/
 
 
 
void vApplicationMallocFailedHook( void )
 
{
 
        report(0x00000098);
}
}
 
/*-----------------------------------------------------------*/
 
 
 No newline at end of file
 No newline at end of file

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.