hey guys, after a lot of guidance & iterations, i a code that typecast the data as pointer and pass it via mailbox. all was well upto one year. but yesterday, while testing, i found out that i receive a 0x00 from uart, which i dnt get into my rx_buf.
Just wanted to bring into notice this cautionary remark.
after a lot of guidance & iterations, i implemented a code that typecast the data (received on uart) as pointer and pass it via mailbox. all was well upto one year. but yesterday, while testing, i found out that i receive a 0x00 from uart, which i dnt get into my rx_buf. typecasting 0x00 to a pointer results to a NULL POINTER.
The implemented code, (now requires modification):
if ((tmp == UART_IIR_INTID_RDA)) // Receive Data Available or Character time-out { data = UART_ReceiveByte(DISPLAY_PORT_UART); if (isr_mbx_check (&MailDisplay) != 0) isr_mbx_send(&MailDisplay, (void *)data); }
The UART receives bytes.
The mailbox pointers are clearly larger than bytes.
So you can use (0x0100 | byte) to send your bytes. This makes sure that the full byte range can be sent without looking like a NULL pointer. And it's easy to strip out that extra bit when converting back to a byte again.
i wrote the modified code as
// in the interrupt routine if ((tmp == UART_IIR_INTID_RDA)) // Receive Data Available or Character time-out { *prx = UART_ReceiveByte(DISPLAY_PORT_UART); if (isr_mbx_check (&MailDisplay) != 0) isr_mbx_send(&MailDisplay, (void *)prx); } //in the receive task void *prx; ... os_mbx_wait(&MailDisplay, &prx, 0xFFFF); data = *(uint32_t*)prx;
what is the advantage of passing the data typecasted as pointer [using (0x0100 | byte)]?
The mailbox functions are just designed to distribute a pointer between sender and receiver. They don't care about the contents of the pointer.
When you move large data, then you have some form of array or pool of mails of a suitable type and send the pointer to that mail. And the receiver releases the mail back to the pool to be reused.
But a character is so small that it fits in the memory needed for a pointer. So the program do not need to invest in a pool of "character mails" and have the sender allocate a "character mail" and send the pointer to this single-character mail. And the receiver need not pick up a pointer to a one-character mail, process the single character and then release this single-character mail back to the pool. One important thing here is that allocating and releasing mails from the memory pool requires a lock mechanism which adds to the amount of work needed.
In short - you get a bit smaller code that consumes less memory and less CPU time. This obviously assuming that the UART sends one character at a time.
If using the FIFO functionality of the UART, then it might be more efficient to actually use a pool of mails - but each mail being able to store a character count, and multiple characters - maybe as many as one FIFO length. So the UART can allocate a single mail, and then clear out the receive FIFO and then post this single mail with maybe 1-16 characters.
In the end, it's a question of figuring out what is best matching the program needs. There are seldom just one possible solution.