Electronic – FreeRTOS: Task Creation Problem

cfreertosmicrocontrollerpic

I am creating 2 tasks, one controls a keypad the other a temperature sensor. Each task works individually. However when I try to create both task it does not seem to create the task, it keeps looping in main (discovered while debugging, the task was not being created because there was not enough memory allocated to the heap).
There is an LCD output which flickers when running. However the correct output is displaced when a single task is created. Code below.

main.c

    /*HEADER FILES*/
#include    "FreeRTOS.h"
#include    "task.h"
#include    "xlcd_GpE.h"
#include    "Keypad.h"
#include    "TempSensor.h"
#include    "timers.h"
#include    <p18f452.h>

/*PIC18 CONFIGURATION SETTINGS*/
#pragma config OSC = HS
#pragma config WDT = OFF
#pragma config LVP = OFF
#define XTAL_FREQ 4000000

/*VARIABLES*/

/*FUNCTION PROTOTYPES*/
void keypadTask (void *pvParameter);
void tempTask (void *pvParameter);
void keypadISR (void);

void main (void)
{
    INTCONbits.GIE = 0;

    configKeypad();
    InitLCD();
    xTaskCreate( tempTask, "TempTask", configMINIMAL_STACK_SIZE, NULL, 1, NULL);
    xTaskCreate( keypadTask, "keypadTask", configMINIMAL_STACK_SIZE, NULL, 1, NULL);

    vTaskStartScheduler();
}

temperature function in tempTask.c

    void tempTask(void *pvParameter) {

    for (;;) {


             if (xSemaphoreTake(tempSem, (TickType_t) 3000) == pdTRUE) {
            char tempLSB, tempMSB;
            char get[10];
            int k;

            if (owInit() == 1) {
                writeByte(0xCC);
                writeByte(0x44);
                Delay10TCYx(10);
                Nop();
                Nop();
                Nop();
                Nop();
                Nop();
            }
            if (owInit() == 1) {
                writeByte(0xCC);
                writeByte(0xBE);
                for (k = 0; k < 9; k++) {
                    get[k] = readByte();
                }
            }

            tempMSB = get[1];
            tempLSB = get[0];
            if (tempMSB <= 0x80) {
                tempLSB = (tempLSB / 2);
            }
            tempMSB = tempMSB & 0x80;
            if (tempMSB >= 0x80) {
                tempLSB = (~tempLSB) + 1;
            }
            if (tempMSB >= 0x80) {
                tempLSB = (tempLSB / 2);
            }
            if (tempMSB >= 0x80) {
                tempLSB = ((-1) * tempLSB);
            }
            while (BusyXLCD());
            SetDDRamAddr(0x00);
            while (BusyXLCD());
            putsXLCD(tempLSB);
            while (BusyXLCD());

        } else {
            while (BusyXLCD());
            SetDDRamAddr(0x40);
            while (BusyXLCD());
            putrsXLCD("DNG Temp Sem!");
            while (BusyXLCD());
        }
    }
}

keypad function in keypad.c

    void keypadTask(void *pvParameter) {

    keypadSem = xSemaphoreCreateCounting(1, 0);
    tempSem = xSemaphoreCreateCounting(1, 0);

    for (;;) {
        //vTaskDelay(10);
        if (xSemaphoreTake(keypadSem, (TickType_t) 2500) == pdTRUE) {
            int key = (BIT0 * 1 + BIT1 * 2 + BIT2 * 4 + BIT3 * 8);
            SetDDRamAddr(0x00);
            while (BusyXLCD());
            putrsXLCD("                ");
            switch (key) {
                case 0:
                    xSemaphoreGive(tempSem);
                    break;
                case 1:
                    while (BusyXLCD());
                    SetDDRamAddr(0x01);
                    while (BusyXLCD());
                    putrsXLCD("2");
                    while (BusyXLCD());
                    break;
                case 2:
                    while (BusyXLCD());
                    SetDDRamAddr(0x02);
                    while (BusyXLCD());
                    putrsXLCD("3");
                    while (BusyXLCD());
                    break;
                case 3:
                    while (BusyXLCD());
                    SetDDRamAddr(0x03);
                    while (BusyXLCD());
                    putrsXLCD("A");
                    while (BusyXLCD());
                    break;
                case (4):
                    while (BusyXLCD());
                    SetDDRamAddr(0x00);
                    while (BusyXLCD());
                    putrsXLCD("4");
                    while (BusyXLCD());
                    break;
                case (5):
                    while (BusyXLCD());
                    SetDDRamAddr(0x01);
                    while (BusyXLCD());
                    putrsXLCD("5");
                    while (BusyXLCD());
                    break;
                case (6):
                    while (BusyXLCD());
                    SetDDRamAddr(0x02);
                    while (BusyXLCD());
                    putrsXLCD("6");
                    while (BusyXLCD());
                    break;
                case (7):
                    while (BusyXLCD());
                    SetDDRamAddr(0x03);
                    while (BusyXLCD());
                    putrsXLCD("B");
                    while (BusyXLCD());
                    break;
                case (8):
                    while (BusyXLCD());
                    SetDDRamAddr(0x00);
                    while (BusyXLCD());
                    putrsXLCD("7");
                    while (BusyXLCD());
                    break;
                case (9):
                    while (BusyXLCD());
                    SetDDRamAddr(0x01);
                    while (BusyXLCD());
                    putrsXLCD("8");
                    while (BusyXLCD());
                    break;
                case (10):
                    while (BusyXLCD());
                    SetDDRamAddr(0x02);
                    while (BusyXLCD());
                    putrsXLCD("9");
                    while (BusyXLCD());
                    break;
                case (11):
                    while (BusyXLCD());
                    SetDDRamAddr(0x03);
                    while (BusyXLCD());
                    putrsXLCD("C");
                    while (BusyXLCD());
                    break;
                case (12):
                    while (BusyXLCD());
                    SetDDRamAddr(0x00);
                    while (BusyXLCD());
                    putrsXLCD("0");
                    while (BusyXLCD());
                    break;
                case (13):
                    while (BusyXLCD());
                    SetDDRamAddr(0x01);
                    while (BusyXLCD());
                    putrsXLCD("F");
                    while (BusyXLCD());
                    break;
                case (14):
                    while (BusyXLCD());
                    SetDDRamAddr(0x02);
                    while (BusyXLCD());
                    putrsXLCD("E");
                    while (BusyXLCD());
                    break;
                case (15):
                    while (BusyXLCD());
                    SetDDRamAddr(0x03);
                    while (BusyXLCD());
                    putrsXLCD("D");
                    while (BusyXLCD());
                    break;
                default:
                    while (BusyXLCD());
                    SetDDRamAddr(0x00);
                    while (BusyXLCD());
                    putrsXLCD("An Error!");
                    while (BusyXLCD());
                    break;
            }
        } else {
            while (BusyXLCD());
            SetDDRamAddr(0x00);
            while (BusyXLCD());
            putrsXLCD("DNG Keypad Sem!");
            while (BusyXLCD());
            INTCONbits.INT0F = 0;
        }
    }
    }

Best Answer

Confirming the task was actually being created by using the pdPASS was a great tool, from there, the answer was found in the FreeRTOS Reference Manual, under the vTaskCreate example. Problem was solved by changing configTOTAL_HEAP_SIZE from 512 to 1024, in the FreeRTOSconfig.h (for the PIC18f452)

    /* Define a structure called xStruct and a variable of type xStruct. These are just used to
demonstrate a parameter being passed into a task function. */
typedef struct A_STRUCT
{
 char cStructMember1;
 char cStructMember2;
} xStruct;

/* Define a variable of the type xStruct to pass as the task parameter. */
xStruct xParameter = { 1, 2 };

/* Define the task that will be created. Note the name of the function that implements the task
is used as the first parameter in the call to xTaskCreate() below. */
void vTaskCode( void * pvParameters )
{
xStruct *pxParameters;

 /* Cast the void * parameter back to the required type. */
 pxParameters = ( xStruct * ) pvParameters;

 /* The parameter can now be accessed as expected. */
 if( pxParameters->cStructMember1 != 1 )
 {
 /* Etc. */
 }

 /* Enter an infinite loop to perform the task processing. */
 for( ;; )
 {
 /* Task code goes here. */
 }
}
/* Define a function that creates a task. This could be called either before or after the
scheduler has been started. */
void vAnotherFunction( void )
{
TaskHandle_t xHandle;

 /* Create the task. */
 if( xTaskCreate(
 vTaskCode,                   /* Pointer to the function that implements the task. */
 "Demo task",                 /* Text name given to the task. */
 STACK_SIZE,                  /* The size of the stack that should be created for the task.
                              This is defined in words, not bytes. */
 (void*) &xParameter,        /* A reference to xParameters is used as the task parameter.
                              This is cast to a void * to prevent compiler warnings. */
 TASK_PRIORITY,              /* The priority to assign to the newly created task. */
 &xHandle                    /* The handle to the task being created will be placed in
 xHandle.                     */
 ) != pdPASS )
 {
 /* The task could not be created as there was insufficient heap memory remaining. If
 heap_1.c, heap_2.c or heap_4.c are included in the project then this situation can be
 trapped using the vApplicationMallocFailedHook() callback (or ‘hook’) function, and the
 amount of FreeRTOS heap memory that remains unallocated can be queried using the
 xPortGetFreeHeapSize() API function.*/
 }
 else
 {
 /* The task was created successfully. The handle can now be used in other API functions,
 for example to change the priority of the task.*/
 vTaskPrioritySet( xHandle, 2 );
 }
}

Related Solutions

PIC32 RTCC running too fast 1min = 10 sec

This doesn't answer your question, but might make the code a little easier for you to debug. The case statements are really long and may not be the best way to explain what you are doing with your outputs. I make no guarantees that the code is operational (I have not run it at all), but this should get you thinking about file size and readability.

Your singleminutes case statement has a truth table like this:

//    | out
//  in| 0 1 2 3 4
// ---------------
//  0 | 0 0 0 0 0
//  1 | 0 1 0 0 0
//  2 | 0 1 1 0 0
//  3 | 0 1 1 1 0
//  4 | 0 1 1 1 1

which might be better represented with output-centric code like this:

if (singleminutes >= 1)
    PPEins = 1;
else
    PPEins = 0;

if (singleminutes >= 2)
    PPZwei = 1;
else
    PPZwei = 0;

if (singleminutes >= 3)
    PPDrei = 1;
else
    PPDrei = 0;

if (singleminutes >= 4)
    PPVier = 1;
else
    PPVier = 0;

The nfminutes is a little more complicated, but here is the Truth Table:

//   | MHUhr PMFuenf PMZehn PMViertel PMZwanzig PMVor PMNach PMHalb |        |
// --|--------------------------------------------------------------|--------|-----
// 0 | 1     0       0      0         0         0     0      0      | 1000 0 |  000
// 1 | 0     1       0      0         0         0     1      0      | 0100 0 |  010
// 2 | 0     0       1      0         0         0     1      0      | 0010 0 |  010
// 3 | 0     0       0      1         0         0     1      0      | 0001 0 |  010
// 4 | 0     0       0      0         1         0     1      0      | 0000 1 |  010
// 5 | 0     1       0      0         0         1     0      1      | 0000 0 |  101
// 6 | 0     0       0      0         0         0     0      1      | 0000 0 |  001
// 7 | 0     1       0      0         0         0     1      1      | 0100 0 |  011
// 8 | 0     0       0      0         1         1     0      0      | 0000 1 |  100
// 9 | 0     0       0      1         0         1     0      0      | 0001 0 |  100
//10 | 0     0       1      0         0         1     0      0      | 0010 0 |  100
//11 | 0     1       0      0         0         1     0      0      | 0100 0 |  100

and again some output-centric code:

    // MHUhr PMFuenf PMZehn PMViertel PMZwanzig
if( nfminutes == 0 )
    MHUhr = 1;
else
    MHUhr = 0;

if(( nfminutes == 1 ) || (nfminutes == 5) || (nfminutes == 7) || (nfminutes == 11))
    PMFuenf = 1;
else
    PMFuenf = 0;

if(( nfminutes == 2 ) || (nfminutes == 10) )
    PMZehn = 1;
else
    PMZehn = 0;
if(( nfminutes == 3 ) || (nfminutes == 9) )
    PMViertel = 1;
else
    PMViertel = 0;

if(( nfminutes == 4 ) || (nfminutes == 8) )
    PMZwanzig = 1;
else
    PMZwanzig = 0;


// PMVor PMNach PMHalb
if( ((nfminutes >= 1 ) && (nfminutes <= 4 )) || (nfminutes == 7))
    PMNach = 1;
else
    PMNach = 0;

if( (nfminutes >= 5) && (nfminutes <= 7 )
    PMHalb = 1;
    else
        PMHalb = 0;
if(nfminutes >=8)
    PMVor  = 1;
else
    PMVor  = 0;

The code above might do well with some #defines too

#define UHR     0
#define PHUENF_NACH 1
#define ZEHN_NACH   2
...
if(nfminutes == UHR)

Again for hours. Truth Table:

      | 12  1  2  3  4  5  6  7  8  9 10 11
//----|------------------------------------
// 0  | 1  0  0  0  0  0  0  0  0  0  0  0 
// 1  | 0  1  0  0  0  0  0  0  0  0  0  0 
// 2  | 0  0  1  0  0  0  0  0  0  0  0  0 
// 3  | 0  0  0  1  0  0  0  0  0  0  0  0 
// 4  | 0  0  0  0  1  0  0  0  0  0  0  0 
// 5  | 0  0  0  0  0  1  0  0  0  0  0  0 
// 6  | 0  0  0  0  0  0  1  0  0  0  0  0 
// 7  | 0  0  0  0  0  0  0  1  0  0  0  0 
// 8  | 0  0  0  0  0  0  0  0  1  0  0  0 
// 9  | 0  0  0  0  0  0  0  0  0  1  0  0 
// 10 | 0  0  0  0  0  0  0  0  0  0  1  0 
// 11 | 0  0  0  0  0  0  0  0  0  0  0  1

and code. Slightly different structure with all outputs being cleared, then only the correct output turned on.

// one-hot, clear all will not cause a glitch
PHZwoelf    = 0;
PHEins      = 0;
PHZwei      = 0;
PHDrei      = 0;
PHVier      = 0;
PHFuenf     = 0;
PHSechs     = 0;
PHSieben    = 0;
PHAcht      = 0;
PHNeun      = 0;
PHZehn      = 0;
PHElf       = 0;

if( hours == 0 )
    PHZwoelf = 1;   
if( hours == 1 )
    PHEins = 1;
if( hours == 2 )
    PHZwei = 1; 
if( hours == 3 )
    PHDrei = 1; 
if( hours == 4 )
    PHVier = 1; 
if( hours == 5 )
    PHFuenf = 1;    
if( hours == 6 )
    PHSechs = 1;    
if( hours == 7 )
    PHSieben = 1;   
if( hours == 8 )
    PHAcht = 1; 
if( hours == 9 )
    PHNeun = 1; 
if( hours == 10 )
    PHZehn = 1; 
if( hours == 11 )
    PHElf = 1;

All this also allows you to do your input calculations together before your case statements.

// update single minutes
int singleminutes = (int) (unbcd(tm.min)%5);    // 1, 2, 3, 4
// update 5 minutes
int nfminutes = (int) (unbcd(tm.min)/5);    // Fuenf Nach, Zehn Nach, ...
// update hours
int hours = (int) (unbcd(tm.hour)%12);      // 12, 1, 2, 3, 4...
if(nfminutes>=5) hours++;           // 7:25 = Fuenf Vor Halb Acht (8)

Electronic – Queues in FreeRTOS

There two basic approaches that come to mind.

1) Use a queue as outlined by the OP.

According to the FreeRTOS API documentation for xQueueSend, all of the data from your screenData structure is copied into the queue (see description for the pvItemToQueue argument: "A pointer to the item that is to be placed on the queue. The size of the items the queue will hold was defined when the queue was created, so this many bytes will be copied from pvItemToQueue into the queue storage area." This means your assumption is incorrect. After the code execution returns from the xQueueSend call, you can modify data without fear of overwriting what was just queued up.

2) Use a mutual exclusion semaphore or mutex.

(read more about FreeRTOS mutex implementation in the API documentation of xSemaphoreCreateMutex) to synchronize access to the display between different tasks.

The main trade-offs to consider in choosing between a queue or a mutex are as follows:

Using a queue will buffer the data and not block any tasks from executing unless your queue becomes full but requires you to allocate more memory (10 * sizeof(screenData) in this case).

Using a mutex does not require the memory allocation but will block execution of tasks if more than one is trying to access the display at the same time.

Best Answer

Related Solutions

PIC32 RTCC running too fast 1min = 10 sec

Electronic – Queues in FreeRTOS

Related Topic