I have downloaded the port from micruim website for PIC24 and i have "clean" it, leaving the things that i would use (it includes the code for an eval-board). For now, i just want to make a led blik. Therefore, i want the main task that it's used to create "user tasks".
I've managed to build project, which did not build when i downloaded the original.
Even though it builds, the code gets stucks in a funcion called OSTimeDly(100), when it access the Scheduler function (OS_Sched())...

Has anyone worked with micrium, and even better, with the C24 PORT?

I've attached my project in case anyone might want to download it to try it. Micrium folder needs to be in C:\. The project is in C:\Micrium\Software\EvalBoards\Microchip\Explorer16\PIC24FJ128\MPLAB_C30\OS-Probe and the "user app" is app.c

 

Have you configured a timer to generate the system tik? (IRQ routine that calls an OS system routine that maintains system timers).

 

Hi John, thanks for the fast answer.
On the app not tht it is included in the PORT, it describes the problem, and i think it says the same thing you are saying:

If you enabled the statistic task by setting OS_TASK_STAT_EN in OS_CFG.H to 1) then, you
need to call it here. Please note that you need to make sure that you initialized and enabled
the µC/OS-II clock tick because OSStatInit() assumes the presence of clock ticks. In
other words, if the tick ISR is not active when you call OSStatInit(), your application will
end up in µC/OS-II’s idle task and not be able to run any other tasks.

I assume that the kernell itself configures the timer to generate the system tick....but i cannot figure it out where or if it does that.

 

MicroC/OS-II 2ed edition, pp 108:
You have to provide a timer driven interrupt routine that interrupts the processor every 1msec (or whatever you decide your systik is). This timer will be one of the PIC hardware timers configured to generate periodic interrupts. Depending on the actual port you are using, this may or may not be done for you (probably isn't).

The timer IRQ service routine calls OSTimeTick() once each timer IRQ to maintain the OS timers (including task delays, wait times etc).

You must not enable interrupts (and call OSTimeTick()) until you have called OSStart() (which inits the OS).

 

In bsp.h i have selected timer 2

#define BSP_OS_TMR_SEL 2 /* Select a timer for the OS Tick Interrupt (2 or 4) */

I saw step by step that the timer2 is well configured and the interrupts occurs in function:

void OS_Tick_ISR_Handler (void)
{
#if BSP_OS_TMR_SEL == 2
IFS0 &= ~T2IF;
#endif

#if BSP_OS_TMR_SEL == 4
IFS1 &= ~T4IF;
#endif

OSTimeTick();
}

In OSTimeTick(), it never returns to app.c where i called OSTimeDly();

By the way, I'm debuggin with MPLABSIM and I'm not sure if it would have anythiing to do with the problem. Do you think it could be a problem?

 

In OSTimeTick(), it never returns to app.c where i called OSTimeDly();

OSTimeTick() should be called only by the IRQ. I'm not sure I know what you mean that it should be returning to app.c

Before turning on the IRQs and calling OSTimeTick():
Call OSInit();
Have at least one task created by calling OSTaskCreate();
Call OSStart();
Then turn on the IRQs.

Also, the pseudocode for the IRQ handler shows calling OSIntEnter() and OSIntExit() to keep track of IRQ nesting.


MPSIM should be able to do the job. If you have built the OS source you should be able to step into OSTimeTick() (or manually stop it when its hung). If not, you can look at the object code in the Disassembly window. Look to see what its waiting for.

I've not used uCOS on the PIC so don't have any real concrete advice (and the book is an early edition that I am sure is out of date) but it sounds like an init issue from here.

Maybe you could revert to the uncleaned code, get it working or at least examine it and see what you are missing.

Good luck!

 

App.c is the file where the main it is supposed to be. This is my app.c

/*
*********************************************************************************************************
*                                               uC/OS-II
*                                         The Real-Time Kernel
*
*                               (c) Copyright 2006, Micrium, Weston, FL
*                                          All Rights Reserved
*
*
*                                      Microchip Application Code
*
* File : APP.C
* By   : Eric Shufo
*********************************************************************************************************
*/

#include <includes.h>


/*
*********************************************************************************************************
*                                                CONSTANTS
*********************************************************************************************************
*/

/*
*********************************************************************************************************
*                                                STACKS
*********************************************************************************************************
*/

#define  APP_TASK_START_STK_SIZE              128

/*
*********************************************************************************************************
*                                                VARIABLES
*********************************************************************************************************
*/

OS_STK    Start_TaskStk[APP_TASK_START_STK_SIZE];
OS_STK    DisplayStk[APP_TASK_START_STK_SIZE];


/*
*********************************************************************************************************
*                                            FUNCTION PROTOTYPES
*********************************************************************************************************
*/

void Displays(void *pdata);


/*
*********************************************************************************************************
*                                          STARTUP TASK
*
* Description : This is an example of a startup task.  As mentioned in the book's text, you MUST
*               initialize the ticker only once multitasking has started.
*
* Arguments   : p_arg   is the argument passed to 'AppStartTask()' by 'OSTaskCreate()'.
*
* Notes       : 1) The first line of code is used to prevent a compiler warning because 'p_arg' is not
*                  used.  The compiler should not generate any code for this statement.
*               2) Interrupts are enabled once the task start because the I-bit of the CCR register was
*                  set to 0 by 'OSTaskCreate()'.
*********************************************************************************************************
*/

void Task_START(void *p_arg)
{
    int        i_data;
    CPU_INT08U  i;
    CPU_INT08U  j;

   (void)p_arg;

    BSP_Init();                                                         /* Initialize BSP functions                                 */


//#if OS_TASK_STAT_EN > 0
//    OSStatInit();                                                       /* Determine CPU capacity                                   */
//#endif

    
    OSTaskCreate(Displays, (void *)0, &DisplayStk[0], 1);

    
    i_data = *((int *)p_arg);

    // task loop
    for(;;)
    {
        OSTimeDly(100);
    }
}

/*
*********************************************************************************************************
*                                                main()
*
* Description : This is the standard entry point for C code.
* Arguments   : none
*********************************************************************************************************
*/

CPU_INT16S  main (void)
{
    CPU_INT08U  err;
    int        i_data;

    BSP_IntDisAll();                                                    /* Disable all interrupts until we are ready to accept them */

    OSInit();                                                           /* Initialize "uC/OS-II, The Real-Time Kernel"              */

    OSTaskCreate(Task_START, (void *)0, &Start_TaskStk[0], 0);

    OSStart();                                                          /* Start multitasking (i.e. give control to uC/OS-II)       */

    return (-1);                                                        /* Return an error - This line of code is unreachable       */
}





void Displays(void *p_arg)
{
while(1)
    {
    PORTFbits.PORTF3=1;
    OSTimeDlyHMSM(0,0,1,0);
    PORTFbits.PORTF3=0;
    OSTimeDlyHMSM(0,0,2,0);
    }
}

In Tast_START(), it goes to OSTaskCreate(Displays, (void *)0, &DisplayStk[0], 1); and it never returns. Inside OSTaskCreate(Displays, (void *)0, &DisplayStk[0], 1), at same point, it calls the "OS Time Tick ISR Handler", which does this:

]
;********************************************************************************************************
;                                            OS Time Tick ISR Handler
;
; Description : This function services the OS Time Tick Interrupt when configured using Timer #2
;
; Notes       : All user interrupts should be defined as follows.
;********************************************************************************************************
;

__T2Interrupt:
    OS_REGS_SAVE                                                        ; 1) Save processor registers

    mov   #_OSIntNesting, w1
    inc.b [w1], [w1]                                                    ; 2) Call OSIntEnter() or increment OSIntNesting

    dec.b _OSIntNesting, wreg                                           ; 3) Check OSIntNesting. if OSIntNesting == 1, then save the stack pointer, otherwise jump to T2_Cont
    bra nz, T2_Cont
    mov _OSTCBCur, w0
    mov w15, [w0]

T2_Cont:
    call _OS_Tick_ISR_Handler                                           ; 4) Call YOUR ISR Handler (May be a C function). In this case, the OS Tick ISR Handler
    call _OSIntExit                                                     ; 5) Call OSIntExit() or decrement 1 from OSIntNesting

    OS_REGS_RESTORE                                                     ; 6) Restore registers

    retfie                                                              ; 7) Return from interrupt

It that what you meant by

You have to provide a timer driven interrupt routine that interrupts the processor every 1msec

??

 

T2_Cont:
call _OS_Tick_ISR_Handler ; 4) Call YOUR ISR Handler (May be a C function). In this case, the OS Tick ISR Handler

but if so, its a different name than OSTimeTik(). You might want to resolve that difference.

In Tast_START(), it goes to OSTaskCreate(Displays, (void *)0, &DisplayStk[0], 1); and it never returns. Inside OSTaskCreate(Displays, (void *)0, &DisplayStk[0], 1), at same point, it calls the "OS Time Tick ISR Handler", which does this:

I'm puzzled by this. If the OS Time Tick ISR Handler is a real IRQ service routine, why is it called at all by the background code? It should be called only as a result of a timer interrupt. I do note that the book says that instead of maintaining the system tik using a timer interrupt calling OSTimeTick(), you can do it instead at the task level by creating a very high priority task that presumably checks some timing reference and manually calls OSTimeTick(). The two methods are mutually exclusive. I wonder why the display task would be calling the tik when you have an interrupt to do it. Not only would timing be weird but if the tik routine was not reentrant.. KABOOM.

Other than that, I'm not up enough on uCOS to be of much help beyond what's here. Sorry!