AVR Embedded Tutorial - Analog Read: what changed

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

Old	New		Line
1	1		# Analog Read
2	2
3	3		This code is for an Atmega328/Arduino runnning at 16MHz. How to control the UART can be found here:
4	4
5		-	~~` `[[AVR Embedded Tutorial - UART\|UART UARTInit and UARTSendString (...]]~~
	5	+	```
	6	+	UART UARTInit and UARTSendString (...
	7	+	```
6	8
7	9		The ATmega328 can measure with 10-bit accuracy, so a value between 0..1023 is output.
8	10
9	11		## Polling method
10	12
11	13		### Initialize ADC
12	14
13	15		Configure analog reading. AVcc is used as the reference voltage, this is the easiest way. This must be configured with ADMUX.
14	16
15	17		The following reference voltages can be configured with ADMUX:
16	18
17	19		\| Bit 7 \| Bit 6 \| Description \|
18	20		\|-------\|-------\|-------------\|
19	21		\| 0 \| 0 \| Pin AREF \|
20	22		\| 0 \| 1 \| Use AVcc \|
21	23		\| 1 \| 0 \| \- \|
22	24		\| 1 \| 1 \| 2.56V \|
23	25
24	26		The converter is started with ADCSRA.
25	27
26	28		``` pascal
27	29		procedure ADC_Init;
28	30		begin
29	31		ADMUX := (1 shl REFS); // Use AVcc for reference
30	32		ADCSRA := (1 shl ADEN) or %111; // Switch on converter, divider 128
31	33		end;
32	34		```
33	35
34	36		### Measuring
35	37
36	38		The procedure for measuring is as follows.
37	39
38	40		- Specify the port.
39	41		- Wait until the measurement is complete.
40	42		- Read out the measured value.
41	43
42	44		With ADMUX you have to enter the reference voltage again because it shares the register with the reference. You could also do an OR operation with ADMUX .
43	45
44	46		``` pascal
45	47		function ADC_Read(Port : byte) : integer;
46	48		begin
47	49		ADMUX := (1 shl REFS) or (Port and $0F); // Specify port
48	50		ADCSRA := ADCSRA or ( 1 shl ADSC ); // Start measuring
49	51
50	52		while (ADCSRA and (1 shl ADSC)) <> 0 do // Wait until measured
51	53		begin
52	54		end;
53	55
54	56		Result := ADC; // Read out the measured value
55	57		end;
56	58		```
57	59
58	60		If you always read in from the same port, you only have to call up the ADMUX line once. You can also start measuring directly after the while loop which saves a few clock cycles.
59	61
60	62		### Output via UART
61	63
62	64		Buffer variables for the measurement data.
63	65
64	66		``` pascal
65	67		var
66	68		Data : integer;
67	69		s : string[10];
68	70		```
69	71
70	72		The measurement data is then output in an endless loop.
71	73
72	74		``` pascal
73	75		begin
74	76		// Initialize UART
75	77		UARTInit;
76	78
77	79		// Initialize ADC
78	80		ADC_Init;
79	81
80	82		// Allow interrupt
81	83		asm Sei end;
82	84
83	85		// output measured values.
84	86		repeat
85	87		Data := ADC_Read(0);
86	88		str(Data : 6, s);
87	89		UARTSendString(s);
88	90		until 1 = 2;
89	91		end.
90	92		```
91	93
92	94		## Interrupt method
93	95
94	96		The advantage of the interrupt-controlled method is that you do not have to wait until the measurement is finished, so you have time for other things.
95	97
96	98		### Initialisation
97	99
98	100		The difference:
99	101
100	102		- With ADMUX you enter the input port at the beginning.
101	103		- At ADCSRA you have to start the first measurement with ADSC.
102	104		- With ADIE you communicate that the conversion interrupt is controlled.
103	105
104	106		``` pascal
105	107		procedure ADC_Init;
106	108		const
107	109		Port = 0;
108	110
109	111		begin
110	112		ADMUX := (1 shl REFS) or (Port and $0F);
111	113		ADCSRA := %111 or (1 shl ADEN) or (1 shl ADSC) or (1 shl ADIE);
112	114		end;
113	115		```
114	116
115	117		### Output measured value in the interrupt
116	118
117	119		``` pascal
118	120		procedure ADC_Ready public name 'ADC_ISR'; interrupt;
119	121		var
120	122		Data : integer;
121	123		s : string[10];
122	124
123	125		begin
124	126		Data := ADC;
125	127		ADCSRA := ADCSRA or (1 shl ADSC);
126	128		str(Data : 6, s);
127	129		UARTSendString(s);
128	130		end;
129	131		```
130	132
131	133		> Tip: Interrupt routines should be kept short. This does not mean that you cannot do any processing in an interrupt routine, but you do need to ensure that when the next interrupt occurs, the last one is not still running.
132	134
133	135		### Main program
134	136
135	137		Since the measurement is interrupt-controlled, the main loop remains empty. It is important to switch on the interrupts.
136	138
137	139		``` pascal
138	140		begin
139	141		// Initialize UART
140	142		UARTInit;
141	143
142	144		// ADC
143	145		ADC_Init;
144	146
145	147		// Allow interrupt
146	148		asm Sei end;
147	149
148	150		// main loop
149	151		repeat
150	152		// Do something
151	153		until 1 = 2;
152	154		end.
153	155		```
154	156
155	157		# See also
156	158
157	159		- [[AVR Embedded Tutorial\|AVR Embedded Tutorials]] - Overview
158	160
159	161		---
160	162		From the Free Pascal wiki, page "AVR Embedded Tutorial - Analog Read", as it stood on 2020-01-24 after a change by Trev, 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).
161	163		Category: AVR
162	164		Category: Arduino
163	165		Category: Embedded
164	166		Category: Tutorials

Back to history