ADC - Prezentacja wyniku na LCD

Autor: drzasiek
Redakcja: dondu


Drzaśkowy pamiętnik: Spis treści

Uruchomiłem już przetwornik, udało się zmierzyć poziomy napięć i odczytać je za pomocą LED. Jednak odczyt napięcia za pomocą diod ma zbyt małą rozdzielczość i jest bardzo niewygodny, gdy chce się zmierzyć dokładnie wartość napięcia.

Postanowiłem zatem wykorzystać popularny, tani i łatwo dostępny alfanumeryczny LCD 2x16 znaków z najpopularniejszym sterownikiem HD44780. Nie będę tutaj opisywał działania i komunikacji z tym sterownikiem. Jest tego całe mnóstwo w sieci, więc skorzystałem z biblioteki i opisu autora tej strony: radzio.dxp.pl

Problem znaku zapytania
Jeżeli zamiast poprawnego wyniku na LCD otrzymujesz znak zapytania powinieneś w opcjach kompilatora dodać odpowiednie biblioteki i parametry. Jak to zrobić opisuje ten artykuł: Problem znaku zapytania podczas konwersji float do znaków ASCII w celu wyświetlenia na np. LCD itp.

W oparciu o schemat na stronie i mój poprzedni układ do pomiaru napięcia zaprojektowałem schemat całości:

Pobierz schemat: schemat1.rar

Bardzo istotną sprawą dla dokładności pomiarów jest sposób podłączenia mikrokontrolera i filtracja zakłóceń. Wszystko omówione jest tutaj: ADC - Dokładność vs podłączanie

Na początek postanowiłem spróbować wyświetlić na LCD 10 bitową wartość pomiaru:

//Pomiar napięcia przetwornikiem A/C i prezentacja wyniku na LCD 2x16 HD44780

#include <avr/io.h>
#include <util/delay.h>
#include "HD44780.h"

//definicja ADCIN (wejście ADC)
#define ADCIN PC5 

void main(void)
{
   char wynik[4];//bufor

   LCD_Initalize();   //inicjalizacja LCD
   LCD_GoTo(0, 0);      //Ustawienie kursora w pozycji (0,0)
   LCD_WriteText("ADC test: 10 bit");

   //Inicjalizacja ADC
   ADCSRA = (1<<ADEN)    //włączenie ADC
            |(1<<ADPS0)  //ADPS2:0: ustawienie preskalera na 128
            |(1<<ADPS1)
            |(1<<ADPS2); 
                      

   //Wybór napięcia referencyjnego
   //wewnętrzne 2.56V z zewnętrznym kondensatorem na pinie AREF
   ADMUX = (1<<REFS1) | (1<<REFS0) 
             
    //wybór kanału pomiarowego na pinie ADC5
    |(1<<MUX2) | (1<<MUX0); 


   DDRC &=~ (1<<ADCIN); //Ustawienie Wejścia ADC


  for(;;)
  {
   ADCSRA |= (1<<ADSC);//ADSC: Uruchomienie pojedynczej konwersji

   while(ADCSRA & (1<<ADSC)); //czeka na zakończenie konwersji

   LCD_GoTo(5, 1);         //Ustawienie kursora w pozycji (5,1)
   LCD_WriteText("    ");   //Czyszczenie poprzednij wartości
   itoa(ADC,wynik,10);      //konwersja wyniku do tablicy char
   LCD_GoTo(5, 1);         //Ustawienie kursora w pozycji (5,1)
   LCD_WriteText(wynik);   //Wyświetlenie wyniku
   _delay_ms(500);         //opóźnienie
  }
}

Projekt składa się z 2 plików źródłowych main.c i HD44780.c i jednego pliku nagłówkowego HD44780.h z wyżej podanej strony. Pobierz cały projekt: prog1.rar


W efekcie na wyświetlaczu LCD wyświetlana była wartość pomiaru w zakresie 0-1023.

Ale to ciągle są tylko wartości wyniku z ADC. Jak to się ma do napięcia na wejściu przetwornika?

W datasheet mikrokontrolera odnalazłem wzór określający w jaki sposób przetwornik ADC oblicza wynik pomiaru:

Zatem po przekształceniu otrzymuję wzór na obliczenie wartości napięcia mierzonego:

Przy 10 bitowej rozdzielczości i Vref=2,56V wartość napięcia zmierzonego wyniesie:

Korzystając z wewnętrznego napięcia referencyjnego 2,56V mogłem mierzyć napięcia z zakresu: 0-2,56V przy 10 bitowej rozdzielczości, co daje rozdzielczość napięciową:

Zatem mogłem sobie pozwolić na pomiar napięcia praktycznie z dokładnością do 3 miejsc po przecinku.

Napięcie referencyjne wynosi 2,56V, więc jak widać ze wzoru musiałbym mnożyć wartość całkowitą przez 2,56 czyli kompilator zaokrągliłby to do 2. Następnie dzielenie małej liczby przez 1024 znowu spowoduje dość spore zaokrąglenia i w efekcie uzyskałbym zły pomiar.

Uznałem więc, że wygodnie będzie mi przechowywać i obliczać wynik na zmiennej typu float. I choć operacje na typach zmiennopozycyjnych są dość wolne, tutaj nie miałem jakichś wygórowanych wymagań, co do szybkości działania więc mogłem sobie na to pozwolić.

Procedury obliczeń na liczbach zmiennopozycyjnych znajdują się w bibliotece libm.a.

Dowiedziałem się też o ciekawej (choć „zasobożernej”) funkcji sprintf() formatującej różne typy zmiennych (w tym float) do łańcucha znakowego.

Do tego potrzebne było dodanie do projektu biblioteki np. libprintf_flt.a

Instrukcję jak dodać dwie powyższe biblioteki znajdziesz w tym artykule: Problem znaku zapytania podczas konwersji float do znaków ASCII w celu wyświetlenia na np. LCD itp.


Nowy kod:

//Pomiar napięcia przetwornikiem A/C i prezentacja wyniku na LCD 2x16 HD44780

#include <avr/io.h>
#include <util/delay.h>
#include "HD44780.h"


//definicja napiecia referencyjnego
#define VREF 2.56
//definicja ADCIN (wejście ADC)
#define ADCIN PC5 

void main(void)
{
   char wynik[]="           ";//bufor tekstowy, wyczyszczenie bufora
   float adc;//zmienna do obliczeń napięcia
   
   

   LCD_Initalize();      //inicjalizacja LCD
   LCD_GoTo(0, 0);      //Ustawienie kursora w pozycji (0,0)
   LCD_WriteText("ADC test: 10 bit");

   //Inicjalizacja ADC
   ADCSRA =   (1<<ADEN) //włączenie ADC
            |(1<<ADPS0) //ADPS2:0: ustawienie preskalera na 128
            |(1<<ADPS1)
            |(1<<ADPS2);
   
   //- wybór wewnętrznego napięcia referencyjnego 2,56V z zewnętrznym 
   //   kondensatorem na pinie AREF
   //- wybór kanału pomiarowego na pinie ADC5 
   ADMUX  =    (1<<REFS1) | (1<<REFS0) // 2,56V + kondensator
             |(1<<MUX2) | (1<<MUX0);   // wybór kanału ADC5

   
   DDRC &=~ (1<<ADCIN);               //Ustawienie Wejścia ADC

  for(;;)
  {
      ADCSRA |= (1<<ADSC);//ADSC: Uruchomienie pojedynczej konwersji

      while(ADCSRA & (1<<ADSC)); //czeka na zakończenie konwersji

      adc=ADC*VREF/1024;      //przeliczenie wartości na napięcie
      sprintf(wynik,"U=%1.3f [V]",adc);   //konwersja na łańcuch znakowy      
      LCD_GoTo(3, 1);         //Ustawienie kursora w pozycji (1,1)
      LCD_WriteText(wynik);   //Wyświetlenie wyniku
      _delay_ms(500);         //opóźnienie
  }
}

Pobierz program: prog2.rar

W ten sposób uzyskałem prosty woltomierz:

Zauważyłem, że wynik jednak troszkę odbiega od prawdziwego. Spowodowane jest to niedokładnością wewnętrznego napięcia referencyjnego Vref, o czym możesz przeczytać tutaj: ADC - Dokładność vs podłączanie

Dokonałem zatem kalibracji pomiarów poprzez podłączenie do wejścia znanego mi napięcia i następnie doświadczalnie zmieniłem wartość napięcia referencyjnego w programie:

#define VREF 2.56

na taką wartość, by wynik prezentowany na wyświetlaczu był jak najbliższy wartości prawdziwej. Można także zmierzyć multimetrem napięcie na pinie AREF i podstawić do powyższej definicji.


Jak zwiększyć zakres pomiarowy?
Zakres napięcia wejściowego jest jednak dość mały: 0-2.56V. By móc mierzyć większe napięcia zdecydowałem się zwiększyć wartość napięcia referencyjnego.

Zerknąłem więc do datasheet i sprawdziłem jakie mam możliwości:

Jak widać mogę albo podłączyć zewnętrzne napięcie referencyjne (nie przekraczające napięcia zasilania mikrokontrolera), albo wybrać programowo napięcie zasilania jako napięcie referencyjne, czyli w moim przypadku 5V.

I znowu sporo na ten temat można przeczytać tutaj: ADC - Dokładność vs podłączanie

Wybrałem więc programowo napięcie zasilania AVcc, jako napięcie odniesienia Vref.

Zmiany w programie to:

zmiana

#define VREF 2.56

na

#define VREF 5.0

oraz zmiana

ADMUX  =    (1<<REFS1) | (1<<REFS0) | (1<<MUX2) | (1<<MUX0);

na

ADMUX  =    (1<<REFS0) | (1<<MUX2) | (1<<MUX0);

Kod po zmianach:

//Pomiar napięcia przetwornikiem A/C i prezentacja wyniku na LCD 2x16 HD44780

#include <avr/io.h>
#include <util/delay.h>
#include "HD44780.h"


//definicja napięcia referencyjnego
#define VREF 5.0
//definicja ADCIN (wejście ADC)
#define ADCIN PC5 

void main(void)
{
   char wynik[]="           ";//bufor tekstowy, wyczyszczenie bufora
   float adc;//zmienna do obliczeń napięcia
   
   

   LCD_Initalize();   //inicjalizacja LCD
   LCD_GoTo(0, 0);      //Ustawienie kursora w pozycji (0,0)
   LCD_WriteText("ADC test: 10 bit");

   //Inicjalizacja ADC
   ADCSRA =   (1<<ADEN) //włączenie ADC
            |(1<<ADPS0) //ADPS2:0 ustawienie preskalera na 128
            |(1<<ADPS1)
            |(1<<ADPS2);
                      

   ADMUX  =    (1<<REFS0)          //VCC jako napięcie referencyjne
            |(1<<MUX2) | (1<<MUX0); //wybór kanału pomiarowego ADC5

   DDRC &=~ (1<<ADCIN);               //Ustawienie Wejścia ADC

  for(;;)
  {
      ADCSRA |= (1<<ADSC);//ADSC: Uruchomienie pojedynczej konwersji
   
      while(ADCSRA & (1<<ADSC)); //czeka na zakończenie konwersji

      adc=ADC*VREF/1024;      //przeliczenie wartości na napięcie
      sprintf(wynik,"U=%1.3f [V]",adc);   //konwersja na łańcuch znakowy      
      LCD_GoTo(3, 1);         //Ustawienie kursora w pozycji (1,1)
      LCD_WriteText(wynik);   //Wyświetlenie wyniku
      _delay_ms(500);         //opóźnienie
  }
}

Pobierz program: prog3.rar


Czy coś  Ci się "rzuciło w oczy"?
Skoro zwiększyłem zakres mierzonego napięcia, ale nadal mierzę je z 10 bitową rozdzielczością, to coś musiało ulec zmianie. Tym czymś jest:

Mała modyfikacja schematu
Skoro mogłem mierzyć już napiecia z zakresu 0-5V usunąłem rezystor R2, który był w szeregu z potencjometrem, aby uyskać pełny zakres napięć na potencjometrze:

I to wszystko dało taki efekt:

---

Przetwornik w trybie free Run, obsługa w przerwaniu

Ciągłe wyzwalanie pomiaru w pętli głównej jak i oczekiwanie na zakończenie kolejnych konwersji może być trochę kłopotliwe. Dlatego następną rzeczą jaką zrobiłem było wykorzystanie trybu Free Run (pomiar ciągły) i odczyt wartości w przerwaniu.

Za tryb Free Run odpowiada bit ADFR rejestru ADCSRA:

Bit 5 – ADFR: ADC Free Running Select

Potrzeba też uruchomić zgłaszanie przerwań przez ADC po zakończonej konwersji za co odpowiada bit ADIE rejestru ADCSRA:

Bit 3 – ADIE: ADC Interrupt Enable

W trybie Free Run bit ADSC rozpoczyna pierwszą konwersję.

//Pomiar napięcia przetwornikiem A/C i prezentacja wyniku na LCD 2x16 HD44780

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>   
#include "HD44780.h"


//definicja napiecia referencyjnego
#define VREF 5.05
//definicja ADCIN (wejście ADC)
#define ADCIN PC5 

volatile float adc;//zmienna do obliczeń napięcia

void main(void)
{
   char wynik[]="           ";//bufor tekstowy, wyczyszczenie bufora
   
   LCD_Initalize();   //inicjalizacja LCD
   LCD_GoTo(0, 0);      //Ustawienie kursora w pozycji (0,0)
   LCD_WriteText("ADC test: 10 bit");

   //Inicjalizacja ADC
   ADCSRA = (1<<ADEN) //włączenie ADC
            |(1<<ADFR) //włączenie trybu Free run
            |(1<<ADIE) //uruchomienie zgłaszania przerwań
            |(1<<ADSC) //rozpoczęcie konwersji
            |(1<<ADPS0)   //ADPS2:0: ustawienie preskalera na 128
            |(1<<ADPS1)
            |(1<<ADPS2);
                      

   ADMUX  =    (1<<REFS0) //VCC jako napięcie referencyjne
            |(1<<MUX2) | (1<<MUX0); //wybór kanału pomiarowego ADC5

   DDRC &=~ (1<<ADCIN); //ustawienie wejścia ADC

   sei(); //Globalne uruchomienie przerwań 

  for(;;)//główna pętla programu
  {
      sprintf(wynik,"U=%1.3f [V]",adc);   //konwersja na łańcuch znakowy      
      LCD_GoTo(3, 1);         //Ustawienie kursora w pozycji (1,1)
      LCD_WriteText(wynik);   //Wyświetlenie wyniku
      _delay_ms(500);         //opóźnienie
  }
}



ISR(ADC_vect)//obsługa przerwania po zakończeniu konwersji ADC
{
  adc=ADC*VREF/1024;      //przeliczenie wartości na napięcie
}

Pobierz program: prog4.rar

I w ten sposób nie musiałem w pętli głównej uruchamiać pomiaru za każdym razem i czekać, aż konwersja się zakończy. Na potrzeby takiego prostego woltomierza, to nie miało większego znaczenia, ale gdy liczy się ściśle określona częstotliwość zapisywania próbek np. do bufora jest to dość istotne.


Efekt końcowy
Przyjemny mały woltomierz, a satysfakcja wielka!





Co dalej?
W kolejnej części opiszę jak skorzystałem z wyniku w rozdzielczości 8 bitowej, jak multipleksować kanały oraz coś o szybkości próbkowania.



Przeczytaj także:

• ADC - Dokładność vs podłączanie
• Zakłócenia w pracy mikrokontrolerów
• Lekceważyć, czy nie?