00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018 #include <avr/io.h>
00019 #include <avr/interrupt.h>
00020 #include <avr/signal.h>
00021
00022 #include "buffer.h"
00023 #include "uart.h"
00024
00025
00026
00027 volatile u08 uartReadyTx;
00028 volatile u08 uartBufferedTx;
00029
00030 cBuffer uartRxBuffer;
00031 cBuffer uartTxBuffer;
00032 unsigned short uartRxOverflow;
00033
00034 #ifndef UART_BUFFERS_EXTERNAL_RAM
00035
00036
00037 static char uartRxData[UART_RX_BUFFER_SIZE];
00038 static char uartTxData[UART_TX_BUFFER_SIZE];
00039 #endif
00040
00041 typedef void (*voidFuncPtru08)(unsigned char);
00042 volatile static voidFuncPtru08 UartRxFunc;
00043
00044
00045 void uartInit(void)
00046 {
00047
00048 uartInitBuffers();
00049
00050 UartRxFunc = 0;
00051
00052
00053 outb(UCR, BV(RXCIE)|BV(TXCIE)|BV(RXEN)|BV(TXEN));
00054
00055
00056 uartSetBaudRate(UART_DEFAULT_BAUD_RATE);
00057
00058 uartReadyTx = TRUE;
00059 uartBufferedTx = FALSE;
00060
00061 uartRxOverflow = 0;
00062
00063 sei();
00064 }
00065
00066
00067 void uartInitBuffers(void)
00068 {
00069 #ifndef UART_BUFFERS_EXTERNAL_RAM
00070
00071 bufferInit(&uartRxBuffer, uartRxData, UART_RX_BUFFER_SIZE);
00072
00073 bufferInit(&uartTxBuffer, uartTxData, UART_TX_BUFFER_SIZE);
00074 #else
00075
00076 bufferInit(&uartRxBuffer, (u08*) UART_RX_BUFFER_ADDR, UART_RX_BUFFER_SIZE);
00077
00078 bufferInit(&uartTxBuffer, (u08*) UART_TX_BUFFER_ADDR, UART_TX_BUFFER_SIZE);
00079 #endif
00080 }
00081
00082
00083 void uartSetRxHandler(void (*rx_func)(unsigned char c))
00084 {
00085
00086 UartRxFunc = rx_func;
00087 }
00088
00089
00090 void uartSetBaudRate(u32 baudrate)
00091 {
00092
00093 u16 bauddiv = ((F_CPU+(baudrate*8L))/(baudrate*16L)-1);
00094 outb(UBRRL, bauddiv);
00095 #ifdef UBRRH
00096 outb(UBRRH, bauddiv>>8);
00097 #endif
00098 }
00099
00100
00101 cBuffer* uartGetRxBuffer(void)
00102 {
00103
00104 return &uartRxBuffer;
00105 }
00106
00107
00108 cBuffer* uartGetTxBuffer(void)
00109 {
00110
00111 return &uartTxBuffer;
00112 }
00113
00114
00115 void uartSendByte(u08 txData)
00116 {
00117
00118 while(!uartReadyTx);
00119
00120 outb(UDR, txData);
00121
00122 uartReadyTx = FALSE;
00123 }
00124
00125
00126 int uartGetByte(void)
00127 {
00128 u08 c;
00129 if(uartReceiveByte(&c))
00130 return c;
00131 else
00132 return -1;
00133 }
00134
00135
00136 u08 uartReceiveByte(u08* rxData)
00137 {
00138
00139 if(uartRxBuffer.size)
00140 {
00141
00142 if(uartRxBuffer.datalength)
00143 {
00144
00145 *rxData = bufferGetFromFront(&uartRxBuffer);
00146 return TRUE;
00147 }
00148 else
00149 {
00150
00151 return FALSE;
00152 }
00153 }
00154 else
00155 {
00156
00157 return FALSE;
00158 }
00159 }
00160
00161
00162 void uartFlushReceiveBuffer(void)
00163 {
00164
00165
00166
00167 uartRxBuffer.datalength = 0;
00168 }
00169
00170
00171 u08 uartReceiveBufferIsEmpty(void)
00172 {
00173 if(uartRxBuffer.datalength == 0)
00174 {
00175 return TRUE;
00176 }
00177 else
00178 {
00179 return FALSE;
00180 }
00181 }
00182
00183
00184 u08 uartAddToTxBuffer(u08 data)
00185 {
00186
00187 return bufferAddToEnd(&uartTxBuffer, data);
00188 }
00189
00190
00191 void uartSendTxBuffer(void)
00192 {
00193
00194 uartBufferedTx = TRUE;
00195
00196 uartSendByte(bufferGetFromFront(&uartTxBuffer));
00197 }
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214
00215
00216
00217
00218
00219
00220
00221
00222
00223
00224
00225
00226
00227
00228
00229
00230
00231 UART_INTERRUPT_HANDLER(SIG_UART_TRANS)
00232 {
00233
00234 if(uartBufferedTx)
00235 {
00236
00237 if(uartTxBuffer.datalength)
00238 {
00239
00240 outb(UDR, bufferGetFromFront(&uartTxBuffer));
00241 }
00242 else
00243 {
00244
00245 uartBufferedTx = FALSE;
00246
00247 uartReadyTx = TRUE;
00248 }
00249 }
00250 else
00251 {
00252
00253
00254 uartReadyTx = TRUE;
00255 }
00256 }
00257
00258
00259 UART_INTERRUPT_HANDLER(SIG_UART_RECV)
00260 {
00261 u08 c;
00262
00263
00264 c = inb(UDR);
00265
00266
00267 if(UartRxFunc)
00268 {
00269
00270 UartRxFunc(c);
00271 }
00272 else
00273 {
00274
00275
00276
00277 if( !bufferAddToEnd(&uartRxBuffer, c) )
00278 {
00279
00280
00281 uartRxOverflow++;
00282 }
00283 }
00284 }