git.sur5r.net Git - freertos/blob - Demo/CORTUS_APS3_GCC/Demo/serial.c

   1 /*
   2     FreeRTOS V6.0.3 - Copyright (C) 2010 Real Time Engineers Ltd.
   3
   4     ***************************************************************************
   5     *                                                                         *
   6     * If you are:                                                             *
   7     *                                                                         *
   8     *    + New to FreeRTOS,                                                   *
   9     *    + Wanting to learn FreeRTOS or multitasking in general quickly       *
  10     *    + Looking for basic training,                                        *
  11     *    + Wanting to improve your FreeRTOS skills and productivity           *
  12     *                                                                         *
  13     * then take a look at the FreeRTOS eBook                                  *
  14     *                                                                         *
  15     *        "Using the FreeRTOS Real Time Kernel - a Practical Guide"        *
  16     *                  http://www.FreeRTOS.org/Documentation                  *
  17     *                                                                         *
  18     * A pdf reference manual is also available.  Both are usually delivered   *
  19     * to your inbox within 20 minutes to two hours when purchased between 8am *
  20     * and 8pm GMT (although please allow up to 24 hours in case of            *
  21     * exceptional circumstances).  Thank you for your support!                *
  22     *                                                                         *
  23     ***************************************************************************
  24
  25     This file is part of the FreeRTOS distribution.
  26
  27     FreeRTOS is free software; you can redistribute it and/or modify it under
  28     the terms of the GNU General Public License (version 2) as published by the
  29     Free Software Foundation AND MODIFIED BY the FreeRTOS exception.
  30     ***NOTE*** The exception to the GPL is included to allow you to distribute
  31     a combined work that includes FreeRTOS without being obliged to provide the
  32     source code for proprietary components outside of the FreeRTOS kernel.
  33     FreeRTOS is distributed in the hope that it will be useful, but WITHOUT
  34     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  35     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  36     more details. You should have received a copy of the GNU General Public
  37     License and the FreeRTOS license exception along with FreeRTOS; if not it
  38     can be viewed here: http://www.freertos.org/a00114.html and also obtained
  39     by writing to Richard Barry, contact details for whom are available on the
  40     FreeRTOS WEB site.
  41
  42     1 tab == 4 spaces!
  43
  44     http://www.FreeRTOS.org - Documentation, latest information, license and
  45     contact details.
  46
  47     http://www.SafeRTOS.com - A version that is certified for use in safety
  48     critical systems.
  49
  50     http://www.OpenRTOS.com - Commercial support, development, porting,
  51     licensing and training services.
  52 */
  53
  54 /*  Basic interrupt driven serial port driver for uart1.
  55 */
  56
  57 /* Standard includes. */
  58 #include <stdlib.h>
  59
  60 /* Kernel includes. */
  61 #include "FreeRTOS.h"
  62 #include "queue.h"
  63 #include "task.h"
  64
  65 /* Demo application includes. */
  66 #include <machine/uart.h>
  67 #include <machine/ic.h>
  68 #include "serial.h"
  69 /*-----------------------------------------------------------*/
  70
  71 #define comBLOCK_RETRY_TIME                             10
  72 /*-----------------------------------------------------------*/
  73
  74 void vUARTInterruptHandlerTxWrapper(void) __attribute((naked));
  75 void vUARTInterruptHandlerRxWrapper(void) __attribute((naked));
  76 /*-----------------------------------------------------------*/
  77
  78 /* Queues used to hold received characters, and characters waiting to be
  79 transmitted. */
  80 static xQueueHandle xRxedChars;
  81 static xQueueHandle xCharsForTx;
  82 extern unsigned portBASE_TYPE *pxVectorTable;
  83 /*-----------------------------------------------------------*/
  84
  85 xComPortHandle xSerialPortInitMinimal( unsigned long ulWantedBaud, unsigned portBASE_TYPE uxQueueLength )
  86 {
  87         /* Create the queues used to hold Rx and Tx characters. */
  88         xRxedChars = xQueueCreate( uxQueueLength, ( unsigned portBASE_TYPE ) sizeof( signed char ) );
  89         xCharsForTx = xQueueCreate( uxQueueLength + 1, ( unsigned portBASE_TYPE ) sizeof( signed char ) );
  90
  91         if( ( xRxedChars ) && ( xCharsForTx ) )
  92         {
  93                 /* Set up interrupts */
  94                 /* tx interrupt will be enabled when we need to send something */
  95                 uart1->tx_mask = 0;
  96                 uart1->rx_mask = 1;
  97                 irq[IRQ_UART1_TX].ien = 1;
  98                 irq[IRQ_UART1_TX].ipl = portSYSTEM_INTERRUPT_PRIORITY_LEVEL;
  99                 irq[IRQ_UART1_RX].ien = 1;
 100                 irq[IRQ_UART1_RX].ipl = portSYSTEM_INTERRUPT_PRIORITY_LEVEL;
 101         }
 102         return ( xComPortHandle ) 0;
 103 }
 104 /*-----------------------------------------------------------*/
 105
 106 signed portBASE_TYPE xSerialGetChar( xComPortHandle pxPort, signed char *pcRxedChar, portTickType xBlockTime )
 107 {
 108         /* The port handle is not required as this driver only supports uart1. */
 109         (void) pxPort;
 110
 111         /* Get the next character from the buffer.      Return false if no characters
 112            are available, or arrive before xBlockTime expires. */
 113         if( xQueueReceive( xRxedChars, pcRxedChar, xBlockTime ) )
 114         {
 115                 return pdTRUE;
 116         }
 117         else
 118         {
 119                 return pdFALSE;
 120         }
 121 }
 122
 123 /*-----------------------------------------------------------*/
 124
 125 void vSerialPutString( xComPortHandle pxPort, const signed char * const pcString, unsigned short usStringLength )
 126 {
 127         int i;
 128         signed char *pChNext;
 129
 130         /* Send each character in the string, one at a time. */
 131         pChNext = ( signed char * )pcString;
 132         for( i = 0; i < usStringLength; i++ )
 133         {
 134                 /* Block until character has been transmitted. */
 135                 while( xSerialPutChar( pxPort, *pChNext, comBLOCK_RETRY_TIME ) != pdTRUE ); pChNext++;
 136         }
 137 }
 138
 139 /*-----------------------------------------------------------*/
 140
 141 signed portBASE_TYPE xSerialPutChar( xComPortHandle pxPort, signed char cOutChar, portTickType xBlockTime )
 142 {
 143         ( void ) pxPort;
 144
 145         /* Place the character in the queue of characters to be transmitted. */
 146         if( xQueueSend( xCharsForTx, &cOutChar, xBlockTime ) != pdPASS )
 147         {
 148                 return pdFAIL;
 149         }
 150
 151         /* Turn on the Tx interrupt so the ISR will remove the character from the
 152            queue and send it. This does not need to be in a critical section as
 153            if the interrupt has already removed the character the next interrupt
 154            will simply turn off the Tx interrupt again. */
 155         uart1->tx_mask = 1;
 156
 157         return pdPASS;
 158 }
 159 /*-----------------------------------------------------------*/
 160
 161 void vSerialClose( xComPortHandle xPort )
 162 {
 163         /* Not supported as not required by the demo application. */
 164         ( void ) xPort;
 165 }
 166 /*-----------------------------------------------------------*/
 167
 168 void interrupt_handler( IRQ_UART1_TX )
 169 {
 170 static signed char cChar;
 171 static portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;
 172
 173         portSAVE_CONTEXT_REDUCED();
 174
 175         /* The interrupt was caused by the transmit fifo having space for at least one
 176         character. Are there any more characters to transmit? */
 177         if( xQueueReceiveFromISR( xCharsForTx, &cChar, &xHigherPriorityTaskWoken ) == pdTRUE )
 178         {
 179                 /* A character was retrieved from the queue so can be sent to the uart now. */
 180                 uart1->tx_data = cChar;
 181         }
 182         else
 183         {
 184                 /* Queue empty, nothing to send so turn off the Tx interrupt. */
 185                 uart1->tx_mask = 0;
 186         }
 187
 188         /* If an event caused a task to unblock then we call "Yield from ISR" to
 189         ensure that the unblocked task is the task that executes when the interrupt
 190         completes if the unblocked task has a priority higher than the interrupted
 191         task. */
 192         if( xHigherPriorityTaskWoken )
 193         {
 194                 portYIELD_FROM_ISR();
 195         }
 196         portRESTORE_CONTEXT_REDUCED();
 197 }
 198 /*-----------------------------------------------------------*/
 199
 200 void interrupt_handler( IRQ_UART1_RX )
 201 {
 202 static signed char cChar;
 203 static portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;
 204
 205         portSAVE_CONTEXT_REDUCED();
 206
 207         /* The interrupt was caused by the receiver getting data. */
 208         cChar = uart1->rx_data;
 209
 210         (void)xQueueSendFromISR(xRxedChars, &cChar, &xHigherPriorityTaskWoken);
 211
 212         /* If an event caused a task to unblock then we call "Yield from ISR" to
 213         ensure that the unblocked task is the task that executes when the interrupt
 214         completes if the unblocked task has a priority higher than the interrupted
 215         task. */
 216         if( xHigherPriorityTaskWoken )
 217         {
 218                 portYIELD_FROM_ISR();
 219         }
 220
 221         portRESTORE_CONTEXT_REDUCED();
 222 }
 223 /*-----------------------------------------------------------*/
 224
 225