uart irq_handler

Thanks Per.
I should have read docs before sent this thread. Sorry.
I've just do as you say, but i just looked at examples.
I'm a beginner and I also need to learn how to start to program. Thanks for the comprehension and for the help.
Could you only please give me a reference where i could read more over isr?

B.R.

Thank you Per.
Another thing: may I have your e-mail just to send you a copy of my program when i will correct it?? So you could teach me more and correct me

Thanks

No private tutoring.

If you want people to help you, you'll have to go through the forum so other people can also see and learn.

OK, no problem, i continue write on this thread.
I miss a thing: i set an event in the irq handler and, in the task1, i wait for the event to be set to start to execute it, that's clear. But then have i to clear the event? When i have to do it, just after i get what i want or at the end of the task?

Ok perfect, i understood.

So: i changed my source code but i still get no answers from the Uart Interrupt.

That's how i changed it reading the manual and looking at eamples as you suggested me.

/*----- Usart Interrupt Service routine----- */

void USART2_IRQHandler (void) {
        isr_evt_set (EVT_KEY,id_get);      /* Send event to 'getAhrs' */
}

/*----------------------------------------------------------------------------
*   Task getAhrs: receive the character from serial port and manage it
*---------------------------------------------------------------------------*/

__task void getAhrs(void){

        char current_char;

        while(1){

                os_evt_wait_or(EVT_KEY, 0xffff);        /*waiting for the event in the
                                                           interrupt to occour*/
                current_char = getkey();

                if(current_char){
                        GLCD_displayStringLn(Line6, "  Get some  ");
                }

Then the code goes on.. but the problem is here because i never get any character.

I think you should throw away the getkey() function, unless you modify it to pick up data from a circular receive buffer filled with data from the UART.

Your ISR should check the status flag of the UART, so it knows _why_ it gets activated.

You should let the ISR do the time-critical part - pick up the received character. It can then post this character using a mailbox. No need to post a pointer to a mail. The pointer value can be used as character value.

Or the ISR should insert the character in a ring buffer, and can then send an event notifying the consumer thread that there are one or more characters available to consume from the ring buffer.

Have you really looked at any example source code for an UART ISR for your processor? Not only do they check what needs servicing. They also acknowledge the interrupt source (sometimes by reading out the received data, ometimes by setting/clearing a specific bit in a UART register). And depending on processor core, they may need a special keyword to let the compiler produce a different set of enter/leave code compared to a "normal" function. The Cortex chips are an exception. Some other processors may have a specific assembler stub that gets activated first and then calls the ISR, also allowing the ISR to be a standard C function.

I've read about the last thing and i've seen that with the Cortex M3 i don't need to modify the assemler. When i debug the code i check the UART register and i've setted it right: the UART receive interrupt is enabled.

About te first part of the message:
do you mean that i've to catch the character directly in the isr from the USART->DR (data register) field and send it using a mailbox to the task getAhrs? And i've to do this after i checked that the flag that signal me that the register isn't empty is set to 1?

If having enabled a received FIFO in the UART, you _could_ just have the interrupt signal a thread that the UART has data to read out. But that is not good. And many processors will not support this because they will try to issue a new interrupt directly since the FIFO will still be almost full.

So the way you do it (with or without FIFO enabled) is to have the ISR pick up one or more characters from the UART and either send them as mailbox messages or place them in a ring buffer.

The task either waits for mailbox events (that contains the received data) or for an event that the ISR have added data to the ring buffer.

So the ISR checks the status flags of the UART and when it sees there is available data it directly unloads the data. This makes sure that the UART has room for more data even if the consumer thread has quite low priority and takes some time until it gets activated.

Remember that the RTOS will always select the highest prioritized thread that is ready to run - and that may not be your UART-processing thread.