Subversion Repositories Projects

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
1515 - 1
/*************************************************************************
2
Title:    Interrupt UART library with receive/transmit circular buffers
3
Author:   Peter Fleury <pfleury@gmx.ch>   http://jump.to/fleury
4
File:     $Id: uart.c,v 1.6.2.2 2009/11/29 08:56:12 Peter Exp $
5
Software: AVR-GCC 4.1, AVR Libc 1.4.6 or higher
6
Hardware: any AVR with built-in UART,
7
License:  GNU General Public License
8
 
9
DESCRIPTION:
10
    An interrupt is generated when the UART has finished transmitting or
11
    receiving a byte. The interrupt handling routines use circular buffers
12
    for buffering received and transmitted data.
13
 
14
    The UART_RX_BUFFER_SIZE and UART_TX_BUFFER_SIZE variables define
15
    the buffer size in bytes. Note that these variables must be a
16
    power of 2.
17
 
18
USAGE:
19
    Refere to the header file uart.h for a description of the routines.
20
    See also example test_uart.c.
21
 
22
NOTES:
23
    Based on Atmel Application Note AVR306
24
 
25
LICENSE:
26
    Copyright (C) 2006 Peter Fleury
27
 
28
    This program is free software; you can redistribute it and/or modify
29
    it under the terms of the GNU General Public License as published by
30
    the Free Software Foundation; either version 2 of the License, or
31
    any later version.
32
 
33
    This program is distributed in the hope that it will be useful,
34
    but WITHOUT ANY WARRANTY; without even the implied warranty of
35
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
36
    GNU General Public License for more details.
37
 
38
*************************************************************************/
39
 
40
#include <avr/io.h>
41
#include <avr/interrupt.h>
42
#include <avr/pgmspace.h>
43
#include "uart1.h"
44
#include "main.h"
45
 
46
//
47
//  constants and macros
48
//
49
 
50
 
51
// size of RX/TX buffers
52
#define UART_RX_BUFFER_MASK ( UART_RX_BUFFER_SIZE - 1)
53
#define UART_TX_BUFFER_MASK ( UART_TX_BUFFER_SIZE - 1)
54
 
55
#if ( UART_RX_BUFFER_SIZE & UART_RX_BUFFER_MASK )
56
#error RX buffer size is not a power of 2
57
#endif
58
 
59
#if ( UART_TX_BUFFER_SIZE & UART_TX_BUFFER_MASK )
60
#error TX buffer size is not a power of 2
61
#endif
62
 
63
 
64
// ATmega with two USART
65
 
66
#define ATMEGA_USART1
67
 
68
#define UART1_STATUS   UCSR1A
69
#define UART1_CONTROL  UCSR1B
70
#define UART1_DATA     UDR1
71
#define UART1_UDRIE    UDRIE1
72
 
73
 
74
 
75
//
76
//  module global variables
77
//
78
 
79
#if defined( ATMEGA_USART1 )
80
static volatile unsigned char UART1_TxBuf[UART_TX_BUFFER_SIZE];
81
static volatile unsigned char UART1_RxBuf[UART_RX_BUFFER_SIZE];
82
static volatile unsigned char UART1_TxHead;
83
static volatile unsigned char UART1_TxTail;
84
static volatile unsigned char UART1_RxHead;
85
static volatile unsigned char UART1_RxTail;
86
static volatile unsigned char UART1_LastRxError;
87
#endif
88
 
89
 
90
 
91
 
92
//
93
// these functions are only for ATmegas with two USART
94
//
95
 
96
 
97
#if defined( ATMEGA_USART1 )
98
 
99
//--------------------------------------------------------------
100
// Function: UART1 Receive Complete interrupt
101
// Purpose:  called when the UART1 has received a character
102
//--------------------------------------------------------------
103
ISR(USART1_RX_vect)
104
{
105
        unsigned char tmphead;
106
        unsigned char data;
107
        unsigned char usr;
108
        unsigned char lastRxError;
109
 
110
 
111
        // read UART status register and UART data register
112
        usr  = UART1_STATUS;
113
        data = UART1_DATA;
114
 
115
        lastRxError = (usr & (_BV(FE1)|_BV(DOR1)) );
116
 
117
        // calculate buffer index
118
        tmphead = ( UART1_RxHead + 1) & UART_RX_BUFFER_MASK;
119
 
120
        if ( tmphead == UART1_RxTail )
121
        {
122
                // error: receive buffer overflow
123
                lastRxError = UART_BUFFER_OVERFLOW >> 8;
124
        }
125
        else
126
        {
127
                // store new index
128
                UART1_RxHead = tmphead;
129
                // store received data in buffer
130
                UART1_RxBuf[tmphead] = data;
131
        }
132
        UART1_LastRxError = lastRxError;
133
}
134
 
135
 
136
//--------------------------------------------------------------
137
// Function: UART1 Data Register Empty interrupt
138
// Purpose:  called when the UART1 is ready to transmit the next byte
139
//--------------------------------------------------------------
140
ISR(USART1_UDRE_vect)
141
{
142
        unsigned char tmptail;
143
 
144
 
145
        if ( UART1_TxHead != UART1_TxTail)
146
        {
147
                // calculate and store new buffer index
148
                tmptail = (UART1_TxTail + 1) & UART_TX_BUFFER_MASK;
149
                UART1_TxTail = tmptail;
150
                // get one byte from buffer and write it to UART
151
                UART1_DATA = UART1_TxBuf[tmptail];  // start transmission
152
        }
153
        else
154
        {
155
                // tx buffer empty, disable UDRE interrupt
156
                UART1_CONTROL &= ~_BV(UART1_UDRIE);
157
        }
158
}
159
 
160
 
161
//--------------------------------------------------------------
162
// Function: uart1_init()
163
// Purpose:  initialize UART1 and set baudrate
164
// Input:       baudrate using macro UART_BAUD_SELECT()
165
// Returns:  none
166
//--------------------------------------------------------------
167
void uart1_init(unsigned int baudrate)
168
{
169
        UART1_TxHead = 0;
170
        UART1_TxTail = 0;
171
        UART1_RxHead = 0;
172
        UART1_RxTail = 0;
173
 
174
 
175
        // Set baud rate
176
        if ( baudrate & 0x8000 )
177
        {
178
                UART1_STATUS = (1<<U2X1);  //Enable 2x speed
179
                baudrate &= ~0x8000;
180
        }
181
        UBRR1H = (unsigned char)(baudrate>>8);
182
        UBRR1L = (unsigned char) baudrate;
183
 
184
        // Enable USART receiver and transmitter and receive complete interrupt
185
        UART1_CONTROL = _BV(RXCIE1)|(1<<RXEN1)|(1<<TXEN1);
186
 
187
        // Set frame format: asynchronous, 8data, no parity, 1stop bit
188
#ifdef URSEL1
189
        UCSR1C = (1<<URSEL1)|(3<<UCSZ10);
190
#else
191
        UCSR1C = (3<<UCSZ10);
192
#endif
193
}
194
 
195
 
196
//--------------------------------------------------------------
197
// Function: uart1_getc()
198
// Purpose:  return byte from ringbuffer
199
// Returns:  lower byte:  received byte from ringbuffer
200
//           higher byte: last receive error
201
//--------------------------------------------------------------
202
unsigned int uart1_getc(void)
203
{
204
        unsigned char tmptail;
205
        unsigned char data;
206
 
207
 
208
        if ( UART1_RxHead == UART1_RxTail )
209
        {
210
                return UART_NO_DATA;   // no data available
211
        }
212
 
213
        // calculate /store buffer index
214
        tmptail = (UART1_RxTail + 1) & UART_RX_BUFFER_MASK;
215
        UART1_RxTail = tmptail;
216
 
217
        // get data from receive buffer
218
        data = UART1_RxBuf[tmptail];
219
 
220
        return (UART1_LastRxError << 8) + data;
221
 
222
}
223
 
224
 
225
//--------------------------------------------------------------
226
// Function: uart1_putc()
227
// Purpose:  write byte to ringbuffer for transmitting via UART
228
// Input:    byte to be transmitted
229
// Returns:  1 on succes, 0 if remote not ready
230
//--------------------------------------------------------------
231
int uart1_putc(unsigned char data)
232
{
233
        unsigned char tmphead;
234
 
235
 
236
        tmphead = (UART1_TxHead + 1) & UART_TX_BUFFER_MASK;
237
 
238
        while ( tmphead == UART1_TxTail )
239
        {;}  // wait for free space in buffer
240
 
241
        UART1_TxBuf[tmphead] = data;
242
        UART1_TxHead = tmphead;
243
 
244
        // enable UDRE interrupt
245
        UART1_CONTROL |= _BV(UART1_UDRIE);
246
        return (UART1_LastRxError << 8) + data;
247
}
248
 
249
 
250
//--------------------------------------------------------------
251
// Function: uart1_puts()
252
// Purpose:  transmit string to UART1
253
// Input:    string to be transmitted
254
// Returns:  none
255
//--------------------------------------------------------------
256
void uart1_puts(const char *s )
257
{
258
        while (*s)
259
                uart1_putc(*s++);
260
}
261
 
262
 
263
//--------------------------------------------------------------
264
// Function: uart1_puts_p()
265
// Purpose:  transmit string from program memory to UART1
266
// Input:    program memory string to be transmitted
267
// Returns:  none
268
//--------------------------------------------------------------
269
void uart1_puts_p(const char *progmem_s )
270
{
271
        register char c;
272
        while ( (c = pgm_read_byte(progmem_s++)) )
273
                uart1_putc(c);
274
}
275
 
276
 
277
//--------------------------------------------------------------
278
// Function: uart1_available()
279
// Purpose:  Determine the number of bytes waiting in the receive buffer
280
// Input:    None
281
// Returns:  Integer number of bytes in the receive buffer
282
//--------------------------------------------------------------
283
int uart1_available(void)
284
{
285
        return (UART_RX_BUFFER_MASK + UART1_RxHead - UART1_RxTail) % UART_RX_BUFFER_MASK;
286
}
287
 
288
 
289
 
290
//--------------------------------------------------------------
291
// Function: uart1_flush()
292
// Purpose:  Flush bytes waiting the receive buffer.  Acutally ignores them.
293
// Input:    None
294
// Returns:  None
295
//--------------------------------------------------------------
296
void uart1_flush(void)
297
{
298
        UART1_RxHead = UART1_RxTail;
299
}
300
 
301
 
302
#endif
303