1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
|
#ifndef _ATMEGA128IO_H
#define _ATMEGA128IO_H
#define UART_BAUD_RATE 9600
#include <avr/io.h>
#include <avr/interrupt.h>
#include "defines.h"
/************************************************************************
Title: Interrupt UART library with receive/transmit circular buffers
Author: Peter Fleury <pfleury@gmx.ch> http://jump.to/fleury
File: $Id: uart.h,v 1.7.2.5 2005/08/14 11:25:41 Peter Exp $
Software: AVR-GCC 3.3
Hardware: any AVR with built-in UART, tested on AT90S8515 at 4 Mhz
Usage: see Doxygen manual
************************************************************************/
/**
* @defgroup pfleury_uart UART Library
* @code #include <uart.h> @endcode
*
* @brief Interrupt UART library using the built-in UART with transmit and receive circular buffers.
*
* This library can be used to transmit and receive data through the built in UART.
*
* An interrupt is generated when the UART has finished transmitting or
* receiving a byte. The interrupt handling routines use circular buffers
* for buffering received and transmitted data.
*
* The UART_RX_BUFFER_SIZE and UART_TX_BUFFER_SIZE constants define
* the size of the circular buffers in bytes. Note that these constants must be a power of 2.
* You may need to adapt this constants to your target and your application by adding
* CDEFS += -DUART_RX_BUFFER_SIZE=nn -DUART_RX_BUFFER_SIZE=nn to your Makefile.
*
* @note Based on Atmel Application Note AVR306
* @author Peter Fleury pfleury@gmx.ch http://jump.to/fleury
*/
/**@{*/
#if (__GNUC__ * 100 + __GNUC_MINOR__) < 304
#error "This library requires AVR-GCC 3.4 or later, update to newer AVR-GCC compiler !"
#endif
/*
** constants and macros
*/
/** @brief UART Baudrate Expression
* @param xtalcpu system clock in Mhz, e.g. 4000000L for 4Mhz
* @param baudrate baudrate in bps, e.g. 1200, 2400, 9600
*/
#define UART_BAUD_SELECT(baudRate,xtalCpu) ((xtalCpu)/((baudRate)*16l)-1)
/** @brief UART Baudrate Expression for ATmega double speed mode
* @param xtalcpu system clock in Mhz, e.g. 4000000L for 4Mhz
* @param baudrate baudrate in bps, e.g. 1200, 2400, 9600
*/
#define UART_BAUD_SELECT_DOUBLE_SPEED(baudRate,xtalCpu) (((xtalCpu)/((baudRate)*8l)-1)|0x8000)
/** Size of the circular receive buffer, must be power of 2 */
#ifndef UART_RX_BUFFER_SIZE
#define UART_RX_BUFFER_SIZE 32
#endif
/** Size of the circular transmit buffer, must be power of 2 */
#ifndef UART_TX_BUFFER_SIZE
#define UART_TX_BUFFER_SIZE 32
#endif
/* test if the size of the circular buffers fits into SRAM */
#if ( (UART_RX_BUFFER_SIZE+UART_TX_BUFFER_SIZE) >= (RAMEND-0x60 ) )
#error "size of UART_RX_BUFFER_SIZE + UART_TX_BUFFER_SIZE larger than size of SRAM"
#endif
/*
** high byte error return code of uart_getc()
*/
#define UART_FRAME_ERROR 0x0800 /* Framing Error by UART */
#define UART_OVERRUN_ERROR 0x0400 /* Overrun condition by UART */
#define UART_BUFFER_OVERFLOW 0x0200 /* receive ringbuffer overflow */
#define UART_NO_DATA 0x0100 /* no receive data available */
/*
** function prototypes
*/
/**
@brief Initialize UART and set baudrate
@param baudrate Specify baudrate using macro UART_BAUD_SELECT()
@return none
*/
extern void uart_init(unsigned int baudrate);
/**
* @brief Get received byte from ringbuffer
*
* Returns in the lower byte the received character and in the
* higher byte the last receive error.
* UART_NO_DATA is returned when no data is available.
*
* @param void
* @return lower byte: received byte from ringbuffer
* @return higher byte: last receive status
* - \b 0 successfully received data from UART
* - \b UART_NO_DATA
* <br>no receive data available
* - \b UART_BUFFER_OVERFLOW
* <br>Receive ringbuffer overflow.
* We are not reading the receive buffer fast enough,
* one or more received character have been dropped
* - \b UART_OVERRUN_ERROR
* <br>Overrun condition by UART.
* A character already present in the UART UDR register was
* not read by the interrupt handler before the next character arrived,
* one or more received characters have been dropped.
* - \b UART_FRAME_ERROR
* <br>Framing Error by UART
*/
extern unsigned int uart_getc(void);
/**
* @brief Put byte to ringbuffer for transmitting via UART
* @param data byte to be transmitted
* @return none
*/
extern void uart_putc(unsigned char data);
/**
* @brief Put string to ringbuffer for transmitting via UART
*
* The string is buffered by the uart library in a circular buffer
* and one character at a time is transmitted to the UART using interrupts.
* Blocks if it can not write the whole string into the circular buffer.
*
* @param s string to be transmitted
* @return none
*/
extern void uart_puts(const char *s );
/**
* @brief Put string from program memory to ringbuffer for transmitting via UART.
*
* The string is buffered by the uart library in a circular buffer
* and one character at a time is transmitted to the UART using interrupts.
* Blocks if it can not write the whole string into the circular buffer.
*
* @param s program memory string to be transmitted
* @return none
* @see uart_puts_P
*/
extern void uart_puts_p(const char *s );
/**
* @brief Macro to automatically put a string constant into program memory
*/
#define uart_puts_P(__s) uart_puts_p(PSTR(__s))
/** @brief Initialize USART1 (only available on selected ATmegas) @see uart_init */
extern void uart1_init(unsigned int baudrate);
/** @brief Get received byte of USART1 from ringbuffer. (only available on selected ATmega) @see uart_getc */
extern unsigned int uart1_getc(void);
/** @brief Put byte to ringbuffer for transmitting via USART1 (only available on selected ATmega) @see uart_putc */
extern void uart1_putc(unsigned char data);
/** @brief Put string to ringbuffer for transmitting via USART1 (only available on selected ATmega) @see uart_puts */
extern void uart1_puts(const char *s );
/** @brief Put string from program memory to ringbuffer for transmitting via USART1 (only available on selected ATmega) @see uart_puts_p */
extern void uart1_puts_p(const char *s );
/** @brief Macro to automatically put a string constant into program memory */
#define uart1_puts_P(__s) uart1_puts_p(PSTR(__s))
/**@}*/
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
// TWI-Driver
/*!
Struktur Definition
tx_type ist eine Datenstruktur um den TWI Treiber anzusprechen
und behinhaltet folgende Informationen:
Slave Adresse + Datenrichtung
Anzahl der zu uebertragendenden Bytes (Senden oder Empfangen)
Pointer auf den Sende- oder Empfangspuffer
*/
typedef struct
{
uint8 slave_adr; /*!< Slave Adresse and W/R byte */
uint8 size; /*!< Anzahl der Bytes, die gesendet oder empfagen werden sollen */
uint8 *data_ptr; /*!< Pointer zum Sende und Empfangs Puffer */
}tx_type;
/*!
* Hier wird der eigentliche TWI-Treiber angesprochen
* @param *data_pack Container mit den Daten fuer den Treiber
* @return Resultat der Aktion
*/
extern uint8 Send_to_TWI(tx_type *data_pack);
/*!
* Sende ein Byte
* @param data das zu uebertragende Byte
*/
extern uint8 Send_byte(uint8 data);
/*!
* Empfange ein Byte
* @param *rx_ptr Container f�r die Daten
* @param last_byte Flag ob noch Daten erwartet werden
* @return Resultat der Aktion
*/
extern uint8 Get_byte(uint8 *rx_ptr, uint8 last_byte);
/*!
* Sende Start Sequence
* @return Resultat der Aktion
*/
extern uint8 Send_start(void);
/*!
* Sende Slave Adresse
* @param adr die gewuenschte Adresse
* @return Resultat der Aktion
*/
extern uint8 Send_adr(uint8 adr);
/*!
* Sende Stop Sequence
*/
extern void Send_stop(void);
/*!
* Warte auf TWI interrupt
*/
extern void Wait_TWI_int(void);
/*!
* TWI Bus initialsieren
* @return Resultat der Aktion
*/
extern int8 Init_TWI(void);
/*!
* TWI Bus schliesen
* @return Resultat der Aktion
*/
extern int8 Close_TWI(void);
#define W 0 /*!< Daten Transfer Richtung Schreiben */
#define R 1 /*!< Daten Transfer Richtung Lesen */
#define OWN_ADR 60 /*!< Die eigene Slave Adresse */
#define SUCCESS 0xFF /*!< Status Code alles OK */
/*!
TWI Stautus Register Definitionen
*/
/*!< Genereller Master Statuscode */
#define START 0x08 /*!< START wurde uebertragen */
#define REP_START 0x10 /*!< Wiederholter START wurde uebertragen */
/*!< Master Sender Statuscode */
#define MTX_ADR_ACK 0x18 /*!< SLA+W wurde uebertragen und ACK empfangen */
#define MTX_ADR_NACK 0x20 /*!< SLA+W wurde uebertragen und NACK empfangen */
#define MTX_DATA_ACK 0x28 /*!< Datenbyte wurde uebertragen und ACK empfangen */
#define MTX_DATA_NACK 0x30 /*!< Datenbyte wurde uebertragen und NACK empfangen */
#define MTX_ARB_LOST 0x38 /*!< Schlichtung verloren in SLA+W oder Datenbytes */
/*!< Master Empfaenger Statuscode */
#define MRX_ARB_LOST 0x38 /*!< Schlichtung verloren in SLA+R oder NACK bit */
#define MRX_ADR_ACK 0x40 /*!< SLA+R wurde uebertragen und ACK empfangen */
#define MRX_ADR_NACK 0x48 /*!< SLA+R wurde uebertragen und NACK empfangen */
#define MRX_DATA_ACK 0x50 /*!< Datenbyte wurde empfangen und ACK gesendet */
#define MRX_DATA_NACK 0x58 /*!< Datenbyte wurde empfangen und NACK gesendet */
#endif
|
