AVR Embedded Tutorial - UART: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		# UART polling
2	2
3	3		## ATmega328p (Arduino Uno/Nano)
4	4
5	5		A terminal with the following settings is required for serial output:
6	6
7	7		\| Setting \| Value \|
8	8		\|-----------\|-------\|
9	9		\| Baud Rate \| 9600 \|
10	10		\| Bits \| 8 \|
11	11		\| Stopbits \| 1 \|
12	12		\| Parity \| none \|
13	13
14		-	~~When pressing the <span class="kbd">Space Bar</span> in the terminal program, a "Hello World!" message is returned.~~
	14	+	When pressing the `Space Bar` in the terminal program, a "Hello World!" message is returned.
15	15
16	16		### Constants
17	17
18	18		``` pascal
19	19		const
20	20		CPU_Clock = 16000000; // Arduino clock frequency, default 16MHz.
21	21		Baud = 9600; // baud rate
22	22		Divider = CPU_Clock div(16 * baud) - 1;
23	23		```
24	24
25	25		Note: If the CPU clock is too slow for the baud rate, there are transmission errors. Example: With a clock of 1MHz, a baud rate of 9600 does not work. However, a 1MHz clock and 1200 baud will work.
26	26
27	27		### Initialization
28	28
29	29		Configure the UART interface.
30	30
31	31		``` pascal
32	32		procedure UARTInit;
33	33		begin
34	34		UBRR0 := divider; // Baud
35	35		UCSR0A := 0; // Normal speed
36	36		UCSR0B := (1 shl TXEN0) or (1 shl RXEN0); // Receive and send
37	37		UCSR0C := (%011 shl UCSZ0); // 8-bit word, 1 stop bit
38	38		end;
39	39		```
40	40
41	41		### Receive characters
42	42
43	43		``` pascal
44	44		function UARTReadChar : char;
45	45		begin
46	46		while UCSR0A and (1 shl RXC0) = 0 do
47	47		; // Wait for a character to arrive
48	48		Result := char(UDR0); // Read character
49	49		end;
50	50		```
51	51
52	52		### Send characters
53	53
54	54		``` pascal
55	55		procedure UARTSendChar(c : char);
56	56		begin
57	57		while UCSR0A and (1 shl UDRE0) = 0 do
58	58		; // Wait for the last character to be sent
59	59		UDR0 := byte(c); // Send character
60	60		end;
61	61		```
62	62
63	63		### Send string
64	64
65	65		``` pascal
66	66		procedure UARTSendString(s : ShortString);
67	67		var
68	68		i : integer;
69	69		begin
70	70		for i := 1 to Length(s) do
71	71		begin
72	72		UARTSendChar(s[i]); // send characters one by one
73	73		end;
74	74		end;
75	75		```
76	76
77	77		### Main loop
78	78
79	79		Here you wait until the space character arrives, then transmit "Hello World!".
80	80
81	81		``` pascal
82	82		program Project1;
83	83		begin
84	84		UARTInit;
85	85
86	86		repeat
87	87		if UARTReadChar = #32 then // #32 = space character
88	88		begin
89	89		UARTSendString('Hello World!'#13#10);
90	90		end;
91	91		until 1 = 2;
92	92		end.
93	93		```
94	94
95	95		## ATtiny2313
96	96
97	97		The registers on the ATtiny2313 have different names than on the ATmega328p.
98	98
99	99		- The 0 is omitted in the name.
100	100		- UBRR0 must be broken down into UBRRH and UBRRL .
101	101
102	102		It will look like this:
103	103
104	104		``` pascal
105	105		UBRRH := divider shr 8;
106	106		UBRRL := byte(divider);
107	107
108	108		UCSRB := (1 shl TXEN ) or (1 shl RXEN);
109	109		UCSRC := (%011 shl UCSZ);
110	110		```
111	111
112	112		(The code has not been tested)
113	113
114	114		# UART interrupt
115	115
116	116		With UART polling, a character may be lost. This can happen when a character arrives and you cannot pick it up in time. For this reason it is advisable to have the reception of characters controlled by an interrupt. At higher baud rates, this is mandatory.
117	117
118	118		A simple 16-character ring buffer is used.
119	119
120	120		The examples show this using an ATmega328p (Arduino Uno/Nano).
121	121
122	122		## Receive buffer
123	123
124	124		### Declaration
125	125
126	126		Declare a character buffer: here a 16 character buffer is created.
127	127
128	128		``` pascal
129	129		const
130	130		Crxlen = 16; // Buffer size
131	131		var
132	132		RXBuf : array[0..Crxlen - 1] of byte;
133	133		RXread : byte = 0;
134	134		RXwrite : byte = 0;
135	135		```
136	136
137	137		### Initialization
138	138
139	139		This is similar to polling, the difference is that RXCIE0 is used to indicate that an interrupt is triggered when a character is received.
140	140
141	141		``` pascal
142	142		procedure UARTInit;
143	143		begin
144	144		UBRR0 := divider;
145	145		UCSR0A := (0 shl U2X0);
146	146		UCSR0B := (1 shl TXEN0) or (1 shl RXEN0) or (1 shl RXCIE0);
147	147		UCSR0C := %011 shl UCSZ0;
148	148		end;
149	149		```
150	150
151	151		### Interrupt
152	152
153	153		When the interrupt is triggered, the character is copied from the UART into the character buffer.
154	154
155	155		``` pascal
156	156		procedure UART_RX_Receiving; public name 'USART__RX_ISR'; interrupt;
157	157		var
158	158		b : byte;
159	159		begin
160	160		// Read characters
161	161		b := UDR0;
162	162
163	163		// Write characters to buffer
164	164		if b <> 0 then
165	165		begin
166	166		RxBuf[Rxwrite] := b;
167	167		Inc(RXwrite);
168	168
169	169		if RXwrite >= Crxlen then
170	170		begin
171	171		RXwrite := 0;
172	172		end;
173	173		end;
174	174		end;
175	175		```
176	176
177	177		### Main loop
178	178
179	179		The main loop checks whether something is in the receive buffer, and if so, a character is read from it. In this example, the characters received are converted to uppercase letters and then output.
180	180
181	181		``` pascal
182	182		begin
183	183		// Initialize UART which is interrupt controlled
184	184		UARTInit;
185	185
186	186		// Enable interrupts
187	187		asm
188	188		sei
189	189		end;
190	190
191	191		// Main loop
192	192		repeat
193	193
194	194		// Is there a character in the buffer?
195	195		while RXwrite <> Rxread do
196	196		begin
197	197		// Disable interrupts
198	198		asm
199	199		cli
200	200		end;
201	201
202	202		// Read character from buffer
203	203		ch := RXBuf[rxread];
204	204		Inc(RXread);
205	205
206	206		if RXread >= Crxlen then
207	207		begin
208	208		RXread := 0;
209	209		end;
210	210
211	211		// Enable interrupts
212	212		asm
213	213		sei
214	214		end;
215	215
216	216		// Convert lowercase letters, into uppercase ones
217	217		if ch in[$61..$7A] then
218	218		begin
219	219		Dec(ch, 32);
220	220		end;
221	221
222	222		// Output character
223	223		UARTSendChar(char(ch));
224	224		end;
225	225		until 1 = 2;
226	226		end.
227	227		```
228	228
229	229		## Send buffer
230	230
231	231		### Declaration
232	232
233	233		Declare a send buffer: here a 16 character buffer is created.
234	234
235	235		``` pascal
236	236		const
237	237		CTXlen = 16; // Buffer size
238	238		var
239	239		TXBuf : array[0..CTXlen - 1] of byte;
240	240		TXread : byte = 0;
241	241		TXwrite : byte = 0;
242	242		```
243	243
244	244		### Initializarion
245	245
246	246		This is similar to the receive buffer. Important: the interrupt function must not be activated yet, because there is nothing to send yet.
247	247
248	248		``` pascal
249	249		procedure UARTInit;
250	250		begin
251	251		UBRR0 := divider;
252	252		UCSR0A := (0 shl U2X0);
253	253		UCSR0B := (1 shl TXEN0) or (1 shl RXEN0);
254	254		UCSR0C := %011 shl UCSZ0;
255	255		end;
256	256		```
257	257
258	258		### Interrupt
259	259
260	260		The interrupt is triggered as soon as a character has been sent to the UART.
261	261
262	262		As soon as the ring buffer is empty, the interrupt function is deactivated again.
263	263
264	264		The query of UDRE0 is not needed here, since the interrupt is only triggered when the buffer is empty.
265	265
266	266		``` pascal
267	267		procedure UART_UDRE_Send; public name 'USART__UDRE_ISR'; interrupt;
268	268		begin
269	269		// Send character
270	270		UDR0 := TXBuf[TXread];
271	271
272	272		// Move ring buffer
273	273		Inc(TXread);
274	274
275	275		// When pointer is at the end, start again
276	276		if TXread >= CTXlen then
277	277		begin
278	278		TXread :=0;
279	279		end;
280	280
281	281		// If the ring buffer is empty, an interrupt is no longer necessary
282	282		if TXread = TXwrite then
283	283		begin
284	284		UCSR0B := UCSR0B and not (1 shl UDRIE0);
285	285		end;
286	286		end;
287	287		```
288	288
289	289		### Send string
290	290
291	291		As soon as something is in the send buffer, the interrupt is not activated.
292	292
293	293		``` pascal
294	294		procedure UARTSendString(s : ShortString);
295	295		var
296	296		i : byte;
297	297		begin
298	298		// Fill the ring buffer with data
299	299		for i := 1 to Length(s) do
300	300		begin
301	301		TXBuf[TXwrite] := byte(s[i]);
302	302		Inc(TXwrite);
303	303
304	304		if TXwrite >= CTXlen then
305	305		begin
306	306		TXwrite := 0;
307	307		end;
308	308		end;
309	309
310	310		// Enable send interrupt
311	311		UCSR0B := UCSR0B or (1 shl UDRIE0);
312	312		end;
313	313		```
314	314
315	315		### Main loop
316	316
317	317		The string is output in the background. In the example, an LED flashes during output.
318	318
319	319		``` pascal
320	320		var
321	321		z : byte;
322	322		s : ShortString;
323	323		begin
324	324		DDRB := DDRB or (1 shl 5);
325	325
326	326		// Initialize UART that is interrupt controlled
327	327		UARTInit;
328	328
329	329		// Enable interrupts
330	330		asm
331	331		sei
332	332		end;
333	333
334	334		// Main loop
335	335		repeat
336	336		UARTSendString('Hello World');
337	337		UARTSendString('!'#13#10);
338	338
339	339		PORTB := PORTB or (1 shl 5);
340	340		mysleep(sl);
341	341
342	342		Str(z : 3, s);
343	343		UARTSendString(s + '.');
344	344		Inc(z);
345	345
346	346		PORTB := PORTB and not (1 shl 5);
347	347		mysleep(sl);
348	348
349	349		until 1 = 2;
350	350		end.
351	351		```
352	352
353	353		# UART emulation in software
354	354
355	355		It is also possible to emulate a UART interface using software.
356	356
357	357		This is practical if you have an AVR which has no/too few hardware UARTs.
358	358
359	359		Note: This code only works with a 16MHz CPU clock and 9600 baud. Simply adjusting baud and CPU_Clock is not enough because the formula still has an error.
360	360
361	361		Important: Interrupts must be blocked during the transmission.
362	362
363	363		Reading and writing at the same time does not work because there is no buffer.
364	364
365	365		Ideally, this can be used to output errors to a UART terminal.
366	366
367	367		## Constants
368	368
369	369		In this example, Pins 2 and 3 from Port D are used.
370	370
371	371		``` pascal
372	372		const
373	373		CPU_Clock = 16000000; // Arduino clock frequency, default 16MHz.
374	374		Baud = 9600; // Baud rate
375	375
376	376		TXpin = (1 shl 3); // Pin 3 (receive)
377	377		RXpin = (1 shl 2); // Pin 2 (send)
378	378
379	379		softDivider = CPU_Clock div(Baud * 22); // bit counter
380	380		```
381	381
382	382		## Set the receive pin to input
383	383
384	384		``` pascal
385	385		begin
386	386		DDRD := DDRD or TXpin;
387	387		...
388	388		// loop
389	389		...
390	390		end.
391	391		```
392	392
393	393		Note: If you want to use the same pins as for the hardware UART, pins 0 and 1 must be enabled on the Arduino.
394	394
395	395		``` pascal
396	396		begin
397	397		UCSR0B := 0; // Release blocked pins 0 and 1
398	398		...
399	399		// loop
400	400		...
401	401		end.
402	402		```
403	403
404	404		## Send characters
405	405
406	406		``` pascal
407	407		procedure UARTSoftSendByte(c : byte);
408	408		var
409	409		i, data : int16;
410	410		j : Int8;
411	411		begin
412	412		asm
413	413		cli // Disable interrupts
414	414		end;
415	415
416	416		Data := (c shl 1) or $FE00;
417	417
418	418		for j := 0 to 9 do // Output bits, including stop bit
419	419		begin
420	420		if(Data and 1) = 1 then
421	421		PORTD := PORTD or TXpin // HIGH
422	422		else
423	423		PORTD := PORTD and not TXpin; // LOW
424	424
425	425		Data := Data shr 1;
426	426
427	427		for i := 0 to softDivider do // One bit break
428	428		;
429	429		end;
430	430
431	431		asm
432	432		sei
433	433		end; // Enable interrupts
434	434		end;
435	435		```
436	436
437	437		## Receive characters
438	438
439	439		Note: If no character is received, the loop hangs forever.
440	440
441	441		``` pascal
442	442		function UARTSoftReadByte : byte;
443	443		var
444	444		i : Int16;
445	445		j : Int8;
446	446		begin
447	447		asm
448	448		cli // Disable interrupts
449	449		end;
450	450
451	451		Result := 0;
452	452
453	453		while PIND and RXpin > 0 do // Wait until the first falling edge
454	454		;
455	455
456	456		for i := 0 to softDivider div 2 do // Half a bit break
457	457		;
458	458
459	459		for j : = 0 to 7 do
460	460		begin
461	461		for i := 0 to softDivider do // One bit break
462	462		;
463	463
464	464		Result := Result shr 1;
465	465
466	466		if PIND and RXpin <> 0 then
467	467		Inc(Result, $80);
468	468		end;
469	469
470	470		for i := 0 to softDivider // One bit break
471	471		;
472	472
473	473		asm
474	474		sei // Enable interrupts
475	475		end;
476	476		end;
477	477		```
478	478
479	479		# See also
480	480
481	481		- [[AVR Embedded Tutorial\|AVR Embedded Tutorials]] - Overview
482	482
483	483		---
484	484		From the Free Pascal wiki, page "AVR Embedded Tutorial - UART", as it stood on 2022-01-07 after a change by VamLykTan, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).
485	485		Category: AVR
486	486		Category: Arduino
487	487		Category: Embedded
488	488		Category: Tutorials

Back to history