Use of free() in PIC Microcontroller Programming

cmicrocontrollermplab

In my Microcontroller PIC18f4550 code, I am using a function which returns an array, I know, C doesn't allow to return an array so I am just returning the address using pointers. Now after the address is returned and performing some action on them, I am freeing the address value I stored in the pointer variable so that the function can be called again and new array address can be passed.

My code(Just to explain):-

int *a,ans[5];

while(1)
{
a=returnarray();
for(j=1;j<5;j++)
       {
          ans[j]=*(a+j);
       }
free(a);
}

My problem:-

I am using MPLABX with XC8 compiler and I am getting error shown on the free() statement, so is there a substitute for this function that I can use here or is there any other way I can perform this task.

Thank you.

Best Answer

free() is always used in combination with malloc(). They both concern dynamic memory on the heap. If you look at section 5.5.7 of the XC8 C Compiler User's Guide:

Dynamic memory allocation, (heap-based allocation using malloc, etc.) is not supported on any 8-bit device. This is due to the limited amount of data memory, and that this memory is banked. The wasteful nature of dynamic memory allocation does not suit itself to the 8-bit PIC device architectures.

If you set the right, high, level of optimization (presuming you have the standard / pro version of the compiler), the compiler might see when the memory isn't needed anymore and rewrite it if necessary. This is only possible if your code is not too complicated.

With a low level of optimization, the compiler won't recognise this and the variable will behave as normally, its memory will be freed when the function in which it's a local variable returns (as with all variables on the stack). If this is in the main() function or we're talking about a global variable, that means never.

Related Solutions

Electronic – the reason the PIC16 multitasking RTOS kernel doesn’t work

What you are trying to do is tricky, but very educational (if you are prepared to spend a lot of effort).

First, you must realise that this kind of PC-only (as opposed to PC+SP) task switching (which is the only thing you can do on a plain 12 or 14-bit PIC core) will only work when all the yield() statements in a task are in the same funtion: they can't be in a called function, and the compiler must not have messed with the function structure (as optimization might do).

currentTask->pch = PCLATH;\
currentTask->pcl = PCL + 8;\
asm("goto _taskswitcher");

You seem to assume that PCLATH is the upper bits of the program counter, as PCL is the lower bits. This is NOT the case. When you write to PCL the PCLATH bits are written to the PC, but the upper PC bits are never (implicitly) written to PCLATH. Re-read the relevant section of the datasheet.
Even if PCLATH was the upper bits of the PC, this would get you into trouble when the instruction after the goto is on not on the same 256-instruction 'page' as the first instruction.
the plain goto will not work when _taskswitcher is not in the current PCLATH page, you will need an LGOTO or equivalent.

A solution to your PCLATH problem is to declare a label after the goto, and write the lower and upper bits of that label to your pch and pcl locations. But I am not sure you can declare a 'local' label in inline assembly. You sure can in plain MPASM (Olin will smile).

Lastly, to this kind of context switching you must save and restore ALL context that the compiler might depend on, which might include

indirection register(s)
status flags
scratch memory locations
local variables that might overlap in memory because the compiler does not realise that your tasks must be independent
other things I can't imagine right now but the compiler author might use in the next version of the compiler (they tend to be very imaginative)

The PIC architecture is more problematic in this respect because a lot of resources are loacted all over the memory map, where more traditional architectures have them in registers or on the stack. As a consequence, PIC compilers often do not generate reentrant code, which is what you definitely need to do the things you want (again, Olin will probaly smile and assemble along.)

If you are into this for the joy of writng an task switcher I suggest that you swicth to a CPU that has a more traditional organization, like an ARM or Cortex. If you are stuck with your feet in a concrete plate of PICs, study existing PIC switchers (for instance salvo/pumkin?).

Electronic – Interrupt Service Routine in C – function at specific address

You'll find the information you need in the compiler's manual: MPLAB C18 C COMPILER USER'S GUIDE.

From page 37 of the user's guide:

MPLAB C18 does not automatically place an ISR at the interrupt vector. Commonly, a GOTO instruction is placed at the interrupt vector for transferring control to the ISR proper. For example:

void lowPriorityISR(void);

#pragma code low_vector=0x18
void interrupt_at_low_vector(void) { 
    _asm GOTO lowPriorityISR _endasm 
}
#pragma code

#pragma interruptlow lowPriorityISR
void lowPriorityISR() {
}

When implementing a high priority ISR, you cannot use the interrupthigh pragma as you would expect. You'll have to use the interrupt pragma instead, as is described here.

If you can change the compiler: using interrupts is easier in the Microchip XC8 or HI-TECH PICC compilers.

Best Answer

Related Solutions

Electronic – the reason the PIC16 multitasking RTOS kernel doesn’t work

Electronic – Interrupt Service Routine in C – function at specific address

Related Topic