Quality RTOS & Embedded Software

 Real time embedded FreeRTOS RSS feed 
Real time embedded FreeRTOS mailing list 
Quick Start Supported MCUs PDF Books Trace Tools Ecosystem TCP & FAT Training




Loading

STM32 CAN receive interrupt issues

Posted by Srikanth on July 5, 2012
Hi All,

I have an issue with CAN interrupt in STM32 Cortex-M3 and couldn't figure out what is wrong. Here is my code design:
///////CAN Receive interrupt////////////////////
{
CAN_Receive(CAN1, CAN_FIFO0, &RxMsg);
/***Do some processing on received message***/
portBASE_TYPE xHigherPriorityTaskWoken = 0;
xSemaphoreGiveFromISR(SEM_DEVICE_COMP_TASK_ID, &xHigherPriorityTaskWoken);
}
//////Task waiting on semaphore////// - Task created using "xTaskCreate()" & priority set as "3", Stack size as 256 bytes
{
Wakes up this task and process received data & do a CAN Tx message which causes other node to send back another CAN message
}
/////////////////CAN interrupt is set as follows///////////////
{
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_InitStructure.NVIC_IRQChannel = USB_LP_CAN1_RX0_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = configLIBRARY_KERNEL_INTERRUPT_PRIORITY;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
}
Also used NVIC_PriorityGroupConfig( NVIC_PriorityGroup_4 );
Used defaults settings for Freertos as below:
/* This is the raw value as per the Cortex-M3 NVIC. Values can be 255 (lowest) to 0 (1?) (highest). */
#define configKERNEL_INTERRUPT_PRIORITY 255
#define configMAX_SYSCALL_INTERRUPT_PRIORITY 191 /* equivalent to 0xb0, or priority 11. */
/* This is the value being used as per the ST library which permits 16 priority values, 0 to 15. This must correspond to the configKERNEL_INTERRUPT_PRIORITY setting. Here 15 corresponds to the lowest NVIC value of 255. */
#define configLIBRARY_KERNEL_INTERRUPT_PRIORITY 15

In a slower message communication it works, but if I send lots of messages to STM32 it fails. It doesn't receive all & CAN receive interrupt doesn't work anymore. Ideally I want ISR to be completed & then run the task. Don't want to interrupt ISR. Any help would be appreciated.

Thanks,
SKV

RE: STM32 CAN receive interrupt issues

Posted by Richard on July 6, 2012
From a kernel usage point of view, I cannot see anything obviously wrong, but I don't know what the call:

CAN_Receive(CAN1, CAN_FIFO0, &RxMsg);

does - although that it outside the scope of FreeRTOS support I have some comments.

It looks like CAN_Receive is placing data into RxMsg? How does the task that handles the CAN data read the data received by the interrupt - is RxMsg simply a global variable? Is there anything to prevent another interrupt (when interrupts are coming in a bit faster) overwriting the data in RxMsg either before the task has processes it, or worse still, while the task is still processing it?

“Ideally I want ISR to be completed & then run the task”


The task can't possible run before the ISR has completed, and if you want the task to run immediately after the ISR completes ensure the priority of the task is relatively high (compared to other tasks in the system) and call

portEND_SWITCHING_ISR( xHigherPriorityTaskWoken );


as the last line in your interrupt handler.

[if you post more code, please ensure the code is inside the codify tags to make it easier to read - the little icon above the text input box with "<>" on it).

Regards.


RE: STM32 CAN receive interrupt issues

Posted by cd334 on July 6, 2012
Hi all!

I've an other idea:
Don't process the CAN message in the interrupt. Make a queue and send the message to a task through queue. And in this task process the message.
If the message processing in interrupt too long, then the input FIFO in the uC CAN pherpherie is full, then you can lost messages.

///////CAN Receive interrupt////////////////////
{
portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;

CanRxMsg RxMsg;

CAN_Receive(CAN1, CAN_FIFO0, &RxMsg);

xQueueSendFromISR( xQueue_CAN_RX, &RxMsg, &xHigherPriorityTaskWoken );

portEND_SWITCHING_ISR( xHigherPriorityTaskWoken );
}

RE: STM32 CAN receive interrupt issues

Posted by Srikanth on July 6, 2012
Richard & cd334,

Thanks for your suggestions. CAN_Receive() is ST library function & if copies received data to RxMsg a global buffer.
At this point I am not worried about the data integrity (may be later) because there are only 2 nodes on CAN bus & I am trying to establish a reliable messaging scheme here. The idea is Node1 sends data and Node 2 responds with an ack, during this time Node1 is in waiting state & once it receives Ack it send another packet & it goes on like that for about 18 messages.

On Node2 it receives msg in an interrupt handler posts a semaphore & the task waiting on this semaphore wakes up & sends ACK.

I have tested this on an Eval board before porting to Freertos. In eval board it worked just fine with out any RTOS & tasks.

The issue I am seeing here is, it starts working good for about 8 of 18 packets & from there on no more receive interrupts getting generated in STM32. The tasks are still working good.

At this point I don't know where to look for. Any ideas???
What happens when it receives a CAN message when RTOS is executing a critical section?

Regards,
SKV

RE: STM32 CAN receive interrupt issues

Posted by Richard Damon on July 7, 2012
One thought is that you may want to try stopping the processor after things sop working and with a debugger look at the status registers to see if the can controller is locked in an error state.

It wouldn't hurt to also check that everything in the hardware is setup right. One thought, especially if it normally processes the same number of message each time, is to check if the hardware is being used in a fifo mode and something isn't freeing buffers back to the controller.

RE: STM32 CAN receive interrupt issues

Posted by Srikanth on July 11, 2012
After some more testing I found it is going to HardFault_Handler() and I added code in HardFault_Handler() to capture different registers and one of them is PC where the fault occurred and it always pointing to

pxItemToRemove->pxPrevious->pxNext = pxItemToRemove->pxNext;


in vListRemove() in list.c file.
Any idea what is going on??

If I don't post semaphore in interrupt handler then everything works fine, but I don't want that way.

One more thing to notify here is the same semaphore is used in different places (All other places are Non ISR) because this task needs to wake-up for other functionality also.

Thanks,


[ Back to the top ]    [ About FreeRTOS ]    [ Sitemap ]    [ ]




Copyright (C) 2004-2010 Richard Barry. Copyright (C) 2010-2016 Real Time Engineers Ltd.
Any and all data, files, source code, html content and documentation included in the FreeRTOSTM distribution or available on this site are the exclusive property of Real Time Engineers Ltd.. See the files license.txt (included in the distribution) and this copyright notice for more information. FreeRTOSTM and FreeRTOS.orgTM are trade marks of Real Time Engineers Ltd.

Latest News:

FreeRTOS V9.0.0 is now available for download.


Free TCP/IP and file system demos for the RTOS


Sponsored Links

⇓ Now With No Code Size Limit! ⇓
⇑ Free Download Without Registering ⇑


FreeRTOS Partners

ARM Connected RTOS partner for all ARM microcontroller cores

Renesas Electronics Gold Alliance RTOS Partner.jpg

Microchip Premier RTOS Partner

RTOS partner of NXP for all NXP ARM microcontrollers

Atmel RTOS partner supporting ARM Cortex-M3 and AVR32 microcontrollers

STMicro RTOS partner supporting ARM7, ARM Cortex-M3, ARM Cortex-M4 and ARM Cortex-M0

Xilinx Microblaze and Zynq partner

Silicon Labs low power RTOS partner

Altera RTOS partner for Nios II and Cortex-A9 SoC

Freescale Alliance RTOS Member supporting ARM and ColdFire microcontrollers

Infineon ARM Cortex-M microcontrollers

Texas Instruments MCU Developer Network RTOS partner for ARM and MSP430 microcontrollers

Cypress RTOS partner supporting ARM Cortex-M3

Fujitsu RTOS partner supporting ARM Cortex-M3 and FM3

Microsemi (previously Actel) RTOS partner supporting ARM Cortex-M3

Atollic Partner

IAR Partner

Keil ARM Partner

Embedded Artists