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
|
/* ---------------------------------------------------------------------------- */
/* Atmel Microcontroller Software Support */
/* SAM Software Package License */
/* ---------------------------------------------------------------------------- */
/* Copyright (c) 2015, Atmel Corporation */
/* */
/* All rights reserved. */
/* */
/* Redistribution and use in source and binary forms, with or without */
/* modification, are permitted provided that the following condition is met: */
/* */
/* - Redistributions of source code must retain the above copyright notice, */
/* this list of conditions and the disclaimer below. */
/* */
/* Atmel's name may not be used to endorse or promote products derived from */
/* this software without specific prior written permission. */
/* */
/* DISCLAIMER: THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR */
/* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE */
/* DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR ANY DIRECT, INDIRECT, */
/* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT */
/* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, */
/* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF */
/* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING */
/* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, */
/* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
/* ---------------------------------------------------------------------------- */
/**
* \file
*
* Implementation of UART (Universal Asynchronous Receiver Transmitter)
* controller.
*
*/
/*------------------------------------------------------------------------------
* Headers
*----------------------------------------------------------------------------*/
#include "chip.h"
#include <assert.h>
#include <string.h>
/*------------------------------------------------------------------------------
* Exported functions
*----------------------------------------------------------------------------*/
/**
* \brief Configures an UART peripheral with the specified parameters.
*
*
* \param uart Pointer to the UART peripheral to configure.
* \param mode Desired value for the UART mode register (see the datasheet).
* \param baudrate Baudrate at which the UART should operate (in Hz).
* \param masterClock Frequency of the system master clock (in Hz).
*/
void UART_Configure(Uart *uart,
uint32_t mode,
uint32_t baudrate,
uint32_t masterClock)
{
/* Reset and disable receiver & transmitter*/
uart->UART_CR = UART_CR_RSTRX | UART_CR_RSTTX
| UART_CR_RXDIS | UART_CR_TXDIS | UART_CR_RSTSTA;
uart->UART_IDR = 0xFFFFFFFF;
/* Configure mode*/
uart->UART_MR = mode;
/* Configure baudrate*/
uart->UART_BRGR = (masterClock / baudrate) / 16;
uart->UART_CR = UART_CR_TXEN | UART_CR_RXEN;
}
/**
* \brief Enables or disables the transmitter of an UART peripheral.
*
*
* \param uart Pointer to an UART peripheral
* \param enabled If true, the transmitter is enabled; otherwise it is
* disabled.
*/
void UART_SetTransmitterEnabled(Uart *uart, uint8_t enabled)
{
if (enabled)
uart->UART_CR = UART_CR_TXEN;
else
uart->UART_CR = UART_CR_TXDIS;
}
/**
* \brief Enables or disables the receiver of an UART peripheral
*
*
* \param uart Pointer to an UART peripheral
* \param enabled If true, the receiver is enabled; otherwise it is disabled.
*/
void UART_SetReceiverEnabled(Uart *uart, uint8_t enabled)
{
if (enabled)
uart->UART_CR = UART_CR_RXEN;
else
uart->UART_CR = UART_CR_RXDIS;
}
/**
* \brief Return 1 if a character can be read in UART
* \param uart Pointer to an UART peripheral.
*/
uint32_t UART_IsRxReady(Uart *uart)
{
return (uart->UART_SR & UART_SR_RXRDY);
}
/**
* \brief Reads and returns a character from the UART.
*
* \note This function is synchronous (i.e. uses polling).
* \param uart Pointer to an UART peripheral.
* \return Character received.
*/
uint8_t UART_GetChar(Uart *uart)
{
while (!UART_IsRxReady(uart));
return uart->UART_RHR;
}
/**
* \brief Return 1 if a character can be send to UART
* \param uart Pointer to an UART peripheral.
*/
uint32_t UART_IsTxReady(Uart *uart)
{
return (uart->UART_SR & UART_SR_TXRDY);
}
/**
* \brief Return 1 if a character can be send to UART
* \param uart Pointer to an UART peripheral.
*/
static uint32_t UART_IsTxSent(Uart *uart)
{
return (uart->UART_SR & UART_SR_TXEMPTY);
}
/**
* \brief Sends one packet of data through the specified UART peripheral. This
* function operates synchronously, so it only returns when the data has been
* actually sent.
*
* \param uart Pointer to an UART peripheral.
* \param c Character to send
*/
void UART_PutChar(Uart *uart, uint8_t c)
{
/* Wait for the transmitter to be ready*/
while (!UART_IsRxReady(uart) && !UART_IsTxSent(uart));
/* Send character*/
uart->UART_THR = c;
/* Wait for the transfer to complete*/
while (!UART_IsTxSent(uart));
}
/**
* \brief Get present status
* \param uart Pointer to an UART peripheral.
*/
uint32_t UART_GetStatus(Uart *uart)
{
return uart->UART_SR;
}
/**
* \brief Enable interrupt
* \param uart Pointer to an UART peripheral.
* \param mode Interrupt mode.
*/
void UART_EnableIt(Uart *uart, uint32_t mode)
{
uart->UART_IER = mode;
}
/**
* \brief Disable interrupt
* \param uart Pointer to an UART peripheral.
* \param mode Interrupt mode.
*/
void UART_DisableIt(Uart *uart, uint32_t mode)
{
uart->UART_IDR = mode;
}
/**
* \brief Return interrupt mask
* \param uart Pointer to an UART peripheral.
*/
uint32_t UART_GetItMask(Uart *uart)
{
return uart->UART_IMR;
}
void UART_SendBuffer(Uart *uart, uint8_t *pBuffer, uint32_t BuffLen)
{
uint8_t *pData = pBuffer;
uint32_t Len = 0;
for (Len = 0; Len < BuffLen; Len++) {
UART_PutChar(uart, *pData);
pData++;
}
}
void UART_ReceiveBuffer(Uart *uart, uint8_t *pBuffer, uint32_t BuffLen)
{
uint32_t Len = 0;
for (Len = 0; Len < BuffLen; Len++) {
*pBuffer = UART_GetChar(uart);
pBuffer++;
}
}
void UART_CompareConfig(Uart *uart, uint8_t Val1, uint8_t Val2)
{
uart->UART_CMPR = (UART_CMPR_VAL1(Val1) | UART_CMPR_VAL2(Val2));
}
|
