[2] STM32 Nucleo F411RE - ADC

W tym poście chciałbym omówić zasadę działania przetwornika analogo-cyfrowego ADC. Działanie będzie przedstawione w oparciu o płytkę Nucleo z mikrokontrolerem STM32F4. 

[Źródło: http://www.st.com/en/evaluation-tools/nucleo-f411re.html]

Wstęp

W zastosowanym na płytce mikrokontrolerze wbudowano jeden 12 bitowy przetwornik ADC, który został wyprowadzony na 16 wyjść GPIO. Uzyskano to poprzez zastosowanie na wejściu przetwornika multipleksera, którego zadaniem jest rozdzielenie linii sygnałów.

Przetwornik jest 12-bitowy wobec tego dane będą mapowane na 4096 wartości (2^12).

Kanały przetwornika są podłączone w następujący sposób:

• ADC0 - PA0
• ADC1 - PA1
• ADC2 - PA2
• ADC3 - PA3
• ADC4 - PA4
• ADC5 - PA5
• ADC6 - PA6
• ADC7 - PA7
• ADC8 - PB0
• ADC9 - PB1
• ADC10 - PC0
• ADC11 - PC1
• ADC12 - PC2
• ADC13 - PC3
• ADC14 - PC4
• ADC15 - PC5

W zastosowanym mikrokontrolerze wartość 1.2 V jest napięciem referencyjnym.

Program 1

W tym programie zaprezentuje sposób obsługi ADC. Dane będą odczytywane z potencjometru. Został on podłączony do pinu PA0, zasilany jest napięciem 3.3V.

Piny mają tolerancję 0 do 3.3V, dlatego na wejście ADC lepiej nie podłączać napięcia wyższego ponieważ można uszkodzić mikrokontroler. Jeśli natomiast chcemy podłączyć napięcie spoza zakresu wtedy należy zastosować dzielnik napięcia.

1. #include "stm32f4xx_adc.h"
2. #include "stm32f4xx_gpio.h"
3. #include "stm32f4xx_rcc.h"
5. int WartoscPrzetwornik = 0;
7. void ADC_Konfiguracja();
8. int ADC_Konwersja();
10. int main(void)
11. {
12.  //Konfiguracja
13.  ADC_Konfiguracja();
14.     while(1)
15.     {
16.      WartoscPrzetwornik = ADC_Konwersja();
17.     }
18. }
20. int ADC_Konwersja()
21. {
22.   //Rozpoczęcie konwersji
23.   ADC_SoftwareStartConv(ADC1);
24.   //Odczekanie na wykonanie resetu
25.   while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC));
26.   //Zwrócenie przetworzonych danych
27.   return ADC_GetConversionValue(ADC1);
28. }
29. void ADC_Konfiguracja()
30. {
31.  //Struktura dla ADC oraz GPIO
32.   ADC_InitTypeDef ADC_init_structure;
33.   GPIO_InitTypeDef GPIO_initStructre;
35.   //Konfiguracja zegarów dla ADC oraz dla portu GPIOA
36.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1,ENABLE);
37.   RCC_AHB1PeriphClockCmd(RCC_AHB1ENR_GPIOAEN,ENABLE);
39.   //Konfiguracja pinu PA0
40.   GPIO_initStructre.GPIO_Pin = GPIO_Pin_0;
41.   //Włączenie pinu w trybie analogowym
42.   GPIO_initStructre.GPIO_Mode = GPIO_Mode_AN;
43.   GPIO_initStructre.GPIO_PuPd = GPIO_PuPd_NOPULL;
44.   GPIO_Init(GPIOA, &GPIO_initStructre);
46.   //ADC Konfiguracja
47.   ADC_DeInit();
48.   //Przetworzone dane wyrównane do prawej
49.   ADC_init_structure.ADC_DataAlign = ADC_DataAlign_Right;
50.   //Napięcie wyjściowe przetwarzane z maksymalną rodzielczością tj. 12b
51.   ADC_init_structure.ADC_Resolution = ADC_Resolution_12b;
52.   //Włączona konwersja ciągła
53.   ADC_init_structure.ADC_ContinuousConvMode = ENABLE;
55.   ADC_init_structure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_T1_CC1;
56.   //Bez wyzwalania zewnętrznego
57.   ADC_init_structure.ADC_ExternalTrigConvEdge = ADC_ExternalTrigConvEdge_None;
58.   //Liczba konwersji
59.   ADC_init_structure.ADC_NbrOfConversion = 1;
60.   //Pomiar tylko jednego kanału, skanowanie kanałów zostało wyłączone
61.   ADC_init_structure.ADC_ScanConvMode = DISABLE;
62.   //Inicjalizacja
63.   ADC_Init(ADC1,&ADC_init_structure);
65.   //Włączenie konwersji
66.   ADC_Cmd(ADC1,ENABLE);
68.   //Wybranie kanału z którego nastąpi odczyt
69.   ADC_RegularChannelConfig(ADC1,ADC_Channel_0, 1, ADC_SampleTime_144Cycles);
70. }

W celu obserwacji zmiennej wykorzystałem opcję Debug w programie SystemWorkbench. Na rysunku 1.1. przedstawiłem otrzymane prze zemnie wyniki pomiarów. Najniższą wartością była 1, najwyższą 4095. Dodatkowo przedstawiłem dwie wartości z pomiarów w środku stawki.

Rys. 1.1. Wyniki pomiarów

Program 2

W programie drugim wykorzystam ten sam sposób pomiaru ADC, także za pomocą potencjometru. Tym razem natomiast wynik będzie wyświetlany na komputerze poprzez port USART. 

Do wysłania danych wykorzystamy funckję printf, która znacznie uprości sposób przesłania informacji do komputera. Funkcja printf będzie wywoływać funkcję __io_putchar() dla każdego bajtu jaki będzie wysyłany do komputera. Ona będzie wchodzić w funkcję send_char(), gdzie program będzie sprawdzał czy bufor nadawczy jest pusty a następnie wykonywał funckję wysłania danych na wybrany port UART.

Rys. 1.2. Wynik działania programu

Poniżej wklejam pełny program:

1. #include "stm32f4xx_adc.h"
2. #include "stm32f4xx_gpio.h"
3. #include "stm32f4xx_rcc.h"
4. #include "stm32f4xx_usart.h"
6. int WartoscPrzetwornik = 0;
8. void ADC_Konfiguracja();
9. int ADC_Konwersja();
10. void USART_Initialize(void);
11. void GPIO_Initialize(void);
12. void send_char(char);
13. int __io_putchar(int);
14. void DelayMain(void);
16. int main(void)
17. {
18.  ADC_Konfiguracja();
19.  GPIO_Initialize();
20.  USART_Initialize();
21.  printf("Konwersja ADC potencjometr!\n");
22.     while(1)
23.     {
24.      WartoscPrzetwornik = ADC_Konwersja();
26.      printf("Adc = %d wynosi %.3fV \n", WartoscPrzetwornik, WartoscPrzetwornik * 3.3f / 4096.0f);
27.      DelayMain();
28.      DelayMain();
29.     }
30. }
32. int ADC_Konwersja()
33. {
34.   //Rozpoczęcie konwersji
35.   ADC_SoftwareStartConv(ADC1);
36.   //Odczekanie na wykonanie resetu
37.   while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC));
38.   //Zwrócenie przetworzonych danych
39.   return ADC_GetConversionValue(ADC1);
40. }
41. void ADC_Konfiguracja()
42. {
43.  //Struktura dla ADC oraz GPIO
44.   ADC_InitTypeDef ADC_init_structure;
45.   GPIO_InitTypeDef GPIO_initStructre;
47.   //Konfiguracja zegarów dla ADC oraz dla portu GPIOA
48.   RCC->APB2ENR |= RCC_APB2ENR_ADC1EN;
49.   RCC_AHB1PeriphClockCmd(RCC_AHB1ENR_GPIOAEN,ENABLE);
51.   //Konfiguracja pinu PA0
52.   GPIO_initStructre.GPIO_Pin = GPIO_Pin_0;
53.   //Włączenie pinu w trybie analogowym
54.   GPIO_initStructre.GPIO_Mode = GPIO_Mode_AN;
55.   GPIO_initStructre.GPIO_PuPd = GPIO_PuPd_NOPULL;
56.   GPIO_Init(GPIOA, &GPIO_initStructre);
58.   //ADC Konfiguracja
59.   ADC_DeInit();
60.   //Przetworzone dane wyrównane do prawej
61.   ADC_init_structure.ADC_DataAlign = ADC_DataAlign_Right;
62.   //Napięcie wyjściowe przetwarzane z maksymalną rodzielczością tj. 12b
63.   ADC_init_structure.ADC_Resolution = ADC_Resolution_12b;
64.   //Włączona konwersja ciągła
65.   ADC_init_structure.ADC_ContinuousConvMode = ENABLE;
67.   ADC_init_structure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_T1_CC1;
68.   //Bez wyzwalania zewnętrznego
69.   ADC_init_structure.ADC_ExternalTrigConvEdge = ADC_ExternalTrigConvEdge_None;
70.   //Liczba konwersji
71.   ADC_init_structure.ADC_NbrOfConversion = 1;
72.   //Pomiar tylko jednego kanału, skanowanie kanałów zostało wyłączone
73.   ADC_init_structure.ADC_ScanConvMode = DISABLE;
74.   //Inicjalizacja
75.   ADC_Init(ADC1,&ADC_init_structure);
77.   //Włączenie konwersji
78.   ADC_Cmd(ADC1,ENABLE);
80.   //Wybranie kanału z którego nastąpi odczyt
81.   ADC_RegularChannelConfig(ADC1,ADC_Channel_0, 1, ADC_SampleTime_144Cycles);
82. }
83. void USART_Initialize(void)
84. {
85.   //konfiguracja układu USART
86.   USART_InitTypeDef USART_InitStructure;
88.   //Włączenie zegara dla USART1
89.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
91.   //Ustawienie prędkości transmisji 9600bps
92.   USART_InitStructure.USART_BaudRate = 9600;
93.   //Długosc wysylanego slowa
94.   USART_InitStructure.USART_WordLength = USART_WordLength_8b;
95.   //Ustawienie jednego bitu stopu
96.   USART_InitStructure.USART_StopBits = USART_StopBits_1;
97.   //Kontrola parzystości wyłączona
98.   USART_InitStructure.USART_Parity = USART_Parity_No;
99.   //Wylaczenie kontroli przepływu danych
100.   USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
101.   //Tryb pracy linii odpowiednio odbior i nadawanie
102.   USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
104.   //Konfiguracja układu
105.   USART_Init(USART1, &USART_InitStructure);
106.   //Włączenie USART1
107.   USART_Cmd(USART1, ENABLE);
108. }
109. void GPIO_Initialize(void)
110. {
111.   //konfigurowanie portow GPIO
112.   GPIO_InitTypeDef  GPIO_InitStructure;
113.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
115.   //TX dla pinu PA9
116.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
117.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
118.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
119.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
120.   GPIO_Init(GPIOA, &GPIO_InitStructure);
122.   //RX dla pinu PA10
123.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
124.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
125.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
126.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
127.   GPIO_Init(GPIOA, &GPIO_InitStructure);
129.   //Włączenie transmisji na podanych pinach
130.   GPIO_PinAFConfig(GPIOA, GPIO_PinSource9, GPIO_AF_USART1);
131.   GPIO_PinAFConfig(GPIOA, GPIO_PinSource10, GPIO_AF_USART1);
132. }
133. void send_char(char c)
134. {
135.  while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
136.  USART_SendData(USART1, c);
137. }
139. int __io_putchar(int c)
140. {
141.  send_char(c);
142.  return c;
143. }
144. void DelayMain(void)
145. {
146.  volatile uint32_t i;
147.  for (i = 0; i != 0xFFFFF; i++);
148.  for (i = 0; i != 0xFFFFF; i++);
149.  for (i = 0; i != 0xFFFFF; i++);
150. }