Spisu treści:
- Kieszonkowe dzieci:
- Krok 1: czego potrzebujesz: lista części
- Krok 2: PODSTAWOWE ZASADY DVM
- Krok 3: Budowa obwodu
- Krok 4: 2-kanałowy kod DVM
- Krok 5: Kalibracja
- Krok 6: Próbkowanie, uśrednianie i wyświetlanie
- Krok 7: Programy w programowaniu
- Krok 8: Wideo programowalnego DVM
Ten Instructable nauczy Cię, jak korzystać z portów analogowych Arduino.
Cyfrowe woltomierze (DVM) są specjalnym przypadkiem przetworników analogowo-cyfrowych A / DC. - mierzą napięcie - i są zwykle funkcją ogólnego przeznaczenia o nazwie multimetr cyfrowy (DMM), powszechnie używanego do pomiaru napięć w laboratoriach i w polu. DMM wyświetlają zmierzone napięcie za pomocą LCD lub diod LED, aby wyświetlić wynik w formacie zmiennoprzecinkowym. Są one najczęściej wybieranym narzędziem do pomiarów napięcia we wszystkich sytuacjach. Ta instrukcja pokaże Ci, jak używać Arduino jako DC DVM (Direct Current Digital Volt Meter).
Będziemy używać wejść analogowych Arduino do pomiaru napięcia DC w zakresie od 0 do 5 V i wyświetlania wartości na kolorowym wyświetlaczu TFT LCD.
Użyłem Sainsmart Arduino Nano i Official Arduino UNO R3, aby sprawdzić, czy są jakieś różnice.
Zakresy napięcia, które może mierzyć Arduino, można łatwo rozszerzyć za pomocą dwóch rezystorów, aby utworzyć dzielnik napięcia.
Dzielnik napięcia dosłownie skaluje mierzone napięcie, więc znajduje się w zakresie wejść analogowych Arduino (np. 0 do 5 woltów).
Możesz następnie zaprogramować szkic Arduino, aby obliczyć rzeczywiste napięcia mierzone przez pomnożenie wejścia przez współczynnik skalowany.
Pozwoli nam to mierzyć napięcia większe niż 5 V DC, maksymalne napięcie DC, które możemy bezpiecznie zmierzyć, wynosi ~ 50 VDC z częściami użytymi w tym instruktażu, ale można je zmodyfikować do własnych potrzeb.
Kieszonkowe dzieci:
Krok 1: czego potrzebujesz: lista części
Całkowity koszt to około 35 dolarów!
- An Arduino (użyłem Sainsmart Nano Clone, (13,99 $) i UNO R3, ale myślę, że każdy zrobi)
- Komputer PC z arduino IDE i bezpłatnym portem USB.
- Kabel USB do Arduino
- Wyświetlacz LCD TFT COLOR Sainsmart 1,8 "(12,99 USD) Wyświetlacz
- Rezystory 4 x 1 Mega Ohm (brązowy, czarny, zielony) 1 dla każdego kanału
- 4 x 100 Kilo Ohm Rezystory (brązowy, czarny, żółty) 1 dla każdego kanału
- 4 diody Zenera o napięciu 5,1 V (opcja |) dla dodatkowej ochrony wejść analogowych Arduino
- Kable rozruchowe, wiele z nich, różne rozmiary i kolory
- Solderless Breadboard (używam. My RadioShack elektroniczny eksperymentator do chleba)
- Multimetr i / lub napięcie odniesienia do kalibracji wyjść DVM
Krok 2: PODSTAWOWE ZASADY DVM
Zanim zaczniemy wspólnie projekt, przejrzyjmy kilka podstawowych zasad i środków ostrożności dotyczących pomiarów napięcia za pomocą DVM.
Dokładność i precyzja
Nasz DVM nie będzie tak dokładny lub precyzyjny jak komercyjnie dostępna jednostka, ale z pewnością będzie bardziej elastyczny.
Aby odczyty były jak najdokładniejsze, musimy wziąć pod uwagę dwie rzeczy: rozdzielczość wejściową i kalibrację. Rozdzielczość wejściowa zależy od analogowego wejścia analogowego A / D Arduinos, które ma 10 bitów na Arduino uno i nano. Kalibracja będzie zależeć od jakości użytych komponentów i odwołań używanych do kalibracji pomiarów.
Impedancja wejściowa
Komercyjne multimetry cyfrowe, które mierzą napięcie DC, będą zwykle miały bardzo wysoką impedancję wejściową 10 MΩ lub większą (i.e rezystancja między dwoma sondami pomiarowymi multimetru wynosi 10 MΩ lub więcej.)
Potrzebna jest wysoka impedancja wejściowa dla woltomierza, aby woltomierz nie wpływał na wartość mierzonego obwodu.
Jeśli woltomierz ma niską impedancję wejściową, może ewentualnie zmienić mierzone napięcie i dać błędne odczyty..
Wadą jest jednak także wysoka impedancja wejściowa; Sondy testowe są bardziej podatne na wychwytywanie zakłóceń elektromagnetycznych (EMI), które mogą również kompensować pomiary i wyświetlać odczyty „fantomowe”.
Chociaż pożądana jest wysoka impedancja wejściowa, obwód dzielnika napięcia, którego będziemy używać, da naszej woltomierzowi impedancję wejściową około 1MΩ, co jest dopuszczalne w przypadku większości pomiarów niskiego napięcia i obwodów o niskiej impedancji, zwykle budowanych przez hobbystów elektronicznych.
Obwód dzielnika napięcia
Użyjemy dwóch szeregowo oporników, które zmniejszą napięcie wejściowe do zakresu w bezpiecznych granicach specyfikacji wejścia analogowego Arduino. Podstawowe równanie dzielnika napięcia to:
V out = V in * R b / (R a + R b)
Jeśli:
R a = 1 MΩ
R b = 100 KΩ
V out = 5V (maksymalne napięcie dla pinów wejścia analogowego arduino)
następnie;
V in = 55V (maksymalne napięcie, które można bezpiecznie zmierzyć)
Obwód, który wykorzystamy, podzieli napięcie wejściowe o 11; (100K / (100K + 1M)) = (100/1100) = (1/11)
Wspólne ograniczenie naziemne
Większość komercyjnych DVMS pozwala mierzyć napięcie na dowolnym elemencie, nie tylko z punktu odniesienia masy. Nasz woltomierz oparty na Arduino nie może tego zrobić, może mierzyć tylko z masy, ponieważ pin Arduino GND jest używany jako ujemny lub wspólny (COM) przewód sondy pomiarowej standardowego multimetru i powinien być podłączony do masy obwodu pod test.
Ochrona wejścia
Wartości rezystorów, których używamy, zapewniają pewną ochronę przed przepięciem podczas pomiaru niskich napięć i do około 55 woltów. Aby zabezpieczyć Arduino przed przypadkowym przepięciem (> 55 VDC), możemy opcjonalnie użyć diod Zenera 5,1 V równolegle z rezystorami 100 KΩ. Zapewni to dodatkową ochronę pinom wejścia analogowego Arduino.
Maksymalne napięcie znamionowe
Jak wyjaśniono wcześniej, punkt na sieci dzielnika rezystorów połączony z pinem wejścia analogowego Arduino jest równy napięciu wejściowemu podzielonemu przez 11 (55V ÷ 11 = 5V). Maksymalne napięcie, które można bezpiecznie zmierzyć, wynosi 55 woltów, pin analogowy Arduino będzie miał maksymalne napięcie 5V.Uwaga!!! nie próbuj mierzyć napięć wyższych niż 55 V lub możesz uszkodzić Arduino
Krok 3: Budowa obwodu
Zaczniemy od zbudowania jednego dzielnika napięcia i podłączenia go do Arduino, przetestowania obwodu prostym szkicem i przystąpienia do budowy pozostałych obwodów.
Po uruchomieniu wejść zainstalujemy kolorowy wyświetlacz TFT LCD o przekątnej 1,8 cala i napiszemy szkic, aby wyświetlić na nim pomiar wejściowy.
Następnie zbadamy kilka opcji oprogramowania i sprzętu, aby ulepszyć lub dostosować DVM.
Zacznijmy więc od zbudowania dzielnika napięcia na płycie breadboard i połączenia go z pinem A0 Arduino.
Spójrz na schemat połączeń i inne zdjęcia, aby poprowadzić Cię krokami.
Gdy obwód zostanie połączony, podłącz Arduino do portu USB komputera i prześlij poniższy szkic testowy, który wyświetli napięcie podłączone do wolnej nogi rezystora 1Meg za pośrednictwem monitora szeregowego.
Wystarczy skopiować i wkleić następujący szkic do Arduino IDE.
// ----------------- Początek szkicu -----------------------------
/* -----------------------------------------------------------
Program: SERIAL DVM
Opis: woltomierz DC z napięciem wyświetlanym na monitorze szeregowym
Brak kolorowego wyświetlacza TFT LCD!
Sprzęt: Arduino NANO lub Uno z dzielnikiem napięcia na A0.
Oprogramowanie: napisane i opracowane przy użyciu oprogramowania Arduino 1.0.3
Data:
Autor:
--------------------------------------------------------------*/
// wartości kalibracji dzielnika napięcia
#define Dv1 11
// Napięcie odniesienia ADC / wartość kalibracji
#define VREF 5
float V1 = {0.00};
void setup ()
{
Serial.begin (9600);
}
void loop ()
{
V1 = analogRead (0);
Serial.print („Napięcie @ pin A0”);
Serial.println ((((V1 * VREF) / 1023)) * Dv1, 2);
}
// ----------------- Koniec szkicu -----------------------------
Przyjrzyjmy się, co się dzieje;
Sterownik Atmega zastosowany w Arduino zawiera wbudowany 6-kanałowy przetwornik analogowo-cyfrowy (A / D). Konwerter ma 10-bitową rozdzielczość, która zwraca liczbę całkowitą od 0 do 1023 (210= 1024, 0 zliczeń, czyli 1023 kroki) dla wartości od 0 do 5 woltów.
Chcemy przekonwertować wartość A / D na rzeczywiste napięcie, które mierzymy.
Musimy pomnożyć wynik przez 5 i podzielić przez 1023, aby dostosować wartość zwracaną przez 10-bitowy przetwornik A / C.
Dzielimy napięcie przez 11 przez dzielnik napięcia, więc napięcie, które mierzymy (i chcemy zobaczyć na wyświetlaczu), należy pomnożyć przez 11, aby skompensować podział.
Robimy to za pomocą następującej formuły:
Vout = ((Vin * (5/1023)) * 11).
kod tego jest:
Serial.println ((((V1 * VREF) / 1023)) * Dv1, 2);
Mnożymy przez 5 (VREF) i dzielimy przez 1023, aby przekształcić wyjście A / D w skalę między O i 5, a następnie pomnożymy przez 11 (Dv1), aby skompensować dzielnik napięcia. Powodem, dla którego używamy zmiennych dla wartości dzielnika i napięcia, jest to, że te wartości zmienią się podczas kalibracji DVM. „2” na końcu formuły określa liczbę cyfr do wyświetlenia po przecinku.
Jeśli program ładuje się poprawnie, otwórz monitor szeregowy, klikając ikonę powiększania w prawym górnym rogu arduino IDE, powinieneś zobaczyć przepływ danych. Używając przewodu połączeniowego, spróbuj najpierw połączyć wolną nogę rezystora 1Meg z pinem GND, a następnie z pinem 5V. Powinieneś zobaczyć zmianę odczytu od 0 do 5v.
Teraz musimy powtórzyć to, co zrobiliśmy dla pierwszego kanału jeszcze trzy razy, aby mieć 4-kanałowy DVM, ale zanim to zrobimy, połączmy nasz TFT COLOR LCD DISPLAY z Arduino. Do tego będziesz potrzebował 7 przewodów połączeniowych:
Połącz następujące elementy z zworkami
TFT LCD. Arduino
VCC 5V
GND Gnd
SCL 13
SDA 11
CS 10
RS / DC 9
RES 8
Uwaga:
W przeciwieństwie do moich innych instrukcji, będziemy używać szybkiego interfejsu SPI do sterowania wyświetlaczem, tak aby przewody zworek były inne. Ponownie sprawdź zdjęcia, aby pomóc Ci, jeśli nie wiesz, jak je podłączyć.
Aby korzystać z wyświetlacza, musisz zainstalować dwie biblioteki:
Adafruit_GFX.h Biblioteka grafiki Core
Adafruit_ST7735.h Biblioteka specyficzna dla sprzętu
Pobierz biblioteki i skopiuj je do folderu biblioteki Arduino.
Skopiuj i wklej poniższy szkic do IDE Arduino. Kod szkicu DVM jest taki sam, ale z dodaniem kodu wyświetlającego napięcie na A0 na wyświetlaczu LCD.
Skompiluj i prześlij szkic do Arduino.
// ----------------- Początek szkicu -----------------------------
/*-----------------------------------------------------------
Program: TFTLCDDVM
Opis: woltomierz DC z wyświetlonym napięciem
na kolorowym wyświetlaczu TFT LCD do 2 miejsc po przecinku
Sprzęt: Arduino NANO z dzielnikiem napięcia na A0.
TFT LCD podłączony
Oprogramowanie: Opracowane przy użyciu oprogramowania Arduino 1.0.3
Data: 10 marca 2014 r
Autor: johnag
--------------------------------------------------------------*/
#define sclk 13
#define mosi 11
#define cs 10
#define dc 9
#define rst 8 // reset
#include // Podstawowa biblioteka graficzna
#include // Biblioteka specyficzna dla sprzętu
#zawierać
Adafruit_ST7735 tft = Adafruit_ST7735 (cs, dc, rst);
// wartość kalibracji dzielnika napięcia
#define Dv1 11
// Napięcie odniesienia ADC
#define VREF 5
float V1 = {0.00};
void setup ()
{
Serial.begin (9600);
tft.initR (INITR_BLACKTAB); // zainicjuj chip ST7735S, czarna zakładka
tft.fillScreen (ST7735_BLACK); // czysty ekran
tft.setTextColor (ST7735_WHITE);
tft.setTextSize (1);
tft.setCursor (10,0);
tft.println („DC woltomierz DVM”);
tft.setTextColor (ST7735_RED);
tft.setCursor (0,140);
tft.println („Caution max voltage 55vdc”);
}
void loop ()
{
V1 = analogRead (0);
tft.drawLine (0, 20, tft.width () - 1, 20, ST7735_WHITE);
tft.drawLine (0, 130, tft.width () - 1, 130, ST7735_WHITE);
tft.setTextColor (ST7735_YELLOW, ST7735_BLACK);
tft.setTextSize (2);
// napięcie 1 (pin A0)
// napięcie jest mnożone przez sieć rezystorów
// współczynnik podziału do obliczenia rzeczywistego napięcia
tft.setCursor (45, 40);
tft.println („V1”);
tft.setTextSize (1);
tft.println („Napięcie @ pin A0”);
tft.setCursor (20, 80);
tft.setTextSize (2);
Serial.print („Napięcie @ pin A0”);
Serial.println ((((V1 * VREF) / 1023)) * Dv1, 2);
tft.print ((((V1 * VREF) / 1023)) * Dv1, 2);
tft.print („Vdc”);
}
// --------------- Koniec szkicu ------------------------------- ---------
Krok 4: 2-kanałowy kod DVM
Poniżej znajduje się szkic 2-kanałowej kopii DVM i wklej ją do Arduino IDE. Zostawię kod dla 4-kanałowego DVM po zakończeniu kalibracji.
// --------------------------- Uruchomienie 2 kanałów DVM ------------------ ---
/*--------------------------------------------------------------------
Program: voltmeter_LCD
Opis: 2-kanałowy woltomierz DC z wyświetlanymi napięciami
na kolorowym wyświetlaczu TFT LCD do 1 miejsca po przecinku
Sprzęt: Arduino NANO z dzielnikami napięcia na A0 i A1
TFT LCD podłączony
Oprogramowanie: Opracowane przy użyciu oprogramowania Arduino 1.0.3
Data: 10 marca 2014 r
Autor:
--------------------------------------------------------------*/
#define sclk 13
#define mosi 11
#define cs 10
#define dc 9
#define rst 8 // reset
#include // Podstawowa biblioteka graficzna
#include // Biblioteka specyficzna dla sprzętu
#zawierać
Adafruit_ST7735 tft = Adafruit_ST7735 (cs, dc, rst);
// wartości kalibracji dzielnika napięcia
#define Dv1 11.00 // obliczony przez pomiar napięcia na złączu rezystora
#define Dv2 11.25
// Napięcie odniesienia ADC / wartość kalibracji
#define VREF 4.9
float V1 = {0.0};
float V2 = {0.0};
void setup ()
{
tft.initR (INITR_BLACKTAB); // zainicjuj chip ST7735S, czarna zakładka
tft.fillScreen (ST7735_BLACK); // czysty ekran
tft.setTextColor (ST7735_WHITE);
tft.setTextSize (1);
tft.setCursor (5,0);
tft.println („2-kanałowy woltomierz”);
tft.setTextColor (ST7735_RED);
tft.setCursor (0,140);
tft.println („Caution max voltage 55vdc”);
}
void loop ()
{
V1 = analogRead (A0);
V2 = analogRead (A1);
tft.drawLine (0, 20, tft.width () - 1, 20, ST7735_WHITE);
tft.drawLine (0, 130, tft.width () - 1, 130, ST7735_WHITE);
tft.setTextColor (ST7735_YELLOW, ST7735_BLACK);
// napięcie 1 (pin A0)
tft.setCursor (5, 40);
tft.setTextSize (1);
tft.println („Napięcie @ pin A0”);
tft.setTextSize (2);
tft.setCursor (10, 50);
tft.print („V1”);
tft.print ((((V1 * VREF) / 1023)) * Dv1, 1);
tft.print („V”);
// napięcie 2 (styk A1)
tft.setCursor (5, 70);
tft.setTextSize (1);
tft.println („Napięcie @ pin A1”);
tft.setTextSize (2);
tft.setTextColor (ST7735_GREEN, ST7735_BLACK);
tft.setCursor (10, 80);
tft.print („V2”);
tft.print ((((V2 * VREF) / 1023)) * Dv2, 1);
tft.print („V”);
}
// --------------------------- 2 kanałowy DVM END ------------------
Krok 5: Kalibracja
Kroki kalibracji:
- Zmierz napięcie na pinie 5v w Arduino za pomocą multimetru i użyj tego numeru w kodzie jako wartości VREF. na przykład, jeśli zmierzyłeś 5,0 V, to linia na szkicu, która definiuje VREF, powinna być #define VREF 5.0.
- Na obwodzie dzielnika napięcia podłącz wolną nogę na rezystorze 1meg do styku 5V twojego Arduino i zmierz napięcie na całym dzielniku napięcia, a następnie napięcie na rezystorze 100k. (najpierw z GND do 5v, następnie z GND do punktu połączenia rezystora, przez rezystor 100k). Teraz podziel dwa napięcia, na przykład, dostałem 5.0 dla napięcia od GND do 5v i 0.46v dla napięcia na rezystorze 100k, więc podzielę 5 przez 0.46: 5 / 0.46 = 10.869
- Umieść tę wartość w linii definicji Dv1: #define Dv1 10.869.
- Prześlij szkic i sprawdź, czy odczyt na wyświetlaczu odpowiada odczytowi na multimetrze.
- Powtórz kroki dla wszystkich dzielników napięcia i odpowiednio zmień wartości.
Krok 6: Próbkowanie, uśrednianie i wyświetlanie
OK, więc skalibrowaliśmy DVM, ale odczyty wciąż wydają się trochę niestabilne i lekko przesunięte. Wciąż możemy coś z tym zrobić. Zamiast tylko wyświetlać zmierzone dane, dlaczego nie weźmiemy kilku próbek, nie dodamy ich i nie podzielimy sumy przez liczbę pobranych próbek. To da nam średnią wartości na wejściu i zapewni nam bardziej stabilny odczyt. Zróbmy to za pomocą podczaspętla.
Poniższy szkic wykorzystuje próbkowanie i uśrednianie, aby poprawić wyświetlane wartości. Skopiuj i wklej do IDE Arduino i skompiluj i załaduj.
// ----------------- Początek szkicu -----------------------------
/*--------------------------------------------------------------
Program: 1 kanałowy DVM z próbkowaniem
Opis: Odczytuje wartość z wejścia analogowego A0 i oblicza
napięcie za pomocą dzielnika napięcia
sieć na pinie A0, która dzieli się przez 10.195 i napięcie odniesienia 5.0v.
Sprzęt: Arduinonano lub Uno z dzielnikiem napięcia na A0.
Oprogramowanie: Opracowane przy użyciu oprogramowania Arduino 1.0.3
Powinien być kompatybilny z Arduino 1.0 +
Data: 25 marca 2014 r
Autor:
--------------------------------------------------------------*/
#define NUMSAMP 100 // liczba próbek do uśrednienia i wyświetlenia
#define sclk 13
#define mosi 11
#define cs 10
#define dc 9
#define rst 8 // reset
#define Dv1 10.915 // Wartość dzielnika napięcia
#define VREF 5.0 // Zmierzone napięcie @Arduino 5V pin
#include // Podstawowa biblioteka graficzna
#include // Biblioteka specyficzna dla sprzętu
#zawierać
Adafruit_ST7735 tft = Adafruit_ST7735 (cs, dc, rst);
int sum = 0; // Suma pobranych próbek
unsigned char Scount = 0; // Numer bieżącej próbki
float AVvolts = 0.0; // Obliczone średnie napięcie
void setup ()
{// Konfiguracja wyświetlania i drukowanie statycznych elementów
tft.initR (INITR_BLACKTAB); // zainicjuj chip ST7735S, czarna zakładka
tft.fillScreen (ST7735_BLACK); // czysty ekran
tft.setTextColor (ST7735_WHITE);
tft.setTextSize (1);
tft.setCursor (10,0);
tft.println („DC woltomierz DVM”);
tft.println ("");
tft.println ("");
tft.print („Napięcie @ pin A0”);
tft.setTextColor (ST7735_RED);
tft.setCursor (0,140);
tft.println („Caution max voltage 55vdc”);
}
void loop ()
{
// weź kilka próbek analogowych i dodaj je
while (Scount <NUMSAMP) {
sum + = analogRead (A0); // przeczytaj i dodaj próbki
Scount ++; // zwiększ liczbę próbek
opóźnienie (10); // Odczekaj 10 mS przed odczytaniem następnej próbki
}
AVvolts = ((float) suma / (float) NUMSAMP * VREF) / 1023; // oblicz średnie napięcie
// Wyświetl obliczone średnie napięcie
tft.setTextColor (ST7735_YELLOW, ST7735_BLACK);
tft.setTextSize (2);
tft.setCursor (45, 50);
tft.println („V1”);
tft.setCursor (10, 80);
tft.setTextSize (2);
tft.print (AVvolts * Dv1);
tft.println („Vdc”);
Scount = 0;
suma = 0;
}
// ----------------- Koniec szkicu -----------------------------
Krok 7: Programy w programowaniu
Jest 10 rodzajów ludzi, którzy znają binarnie i ci, którzy tego nie wiedzą.
Do tej pory nauczyliśmy się, jak połączyć Arduino i dodać dzielniki napięcia, aby kondycjonować analogowy sygnał wejściowy (napięcie), redukując sygnał do poziomu, który mieści się w parametrach specyfikacji Arduino. Następnie skompilowaliśmy i przesłaliśmy kilka szkiców, które odczytują sygnały i wyświetlają je na monitorze szeregowym i wyświetlaczu TFT LCD. Teraz musisz zbadać kod i kontynuować pracę. Dołączam kod do innych szkiców, które będą uruchamiane wraz ze sprzętem, który zestawiliśmy.
/*--------------------------------------------------------------
Program: 1 kanałowy DVM z próbkowaniem
Opis: Odczytuje wartość z wejścia analogowego A0 i oblicza napięcie przyjmując
na pinie A0 znajduje się dzielnik napięcia, który dzieli się przez 10.195
Sprzęt: Arduino NANO lub UNO z dzielnikiem napięcia na A0.
Oprogramowanie: Napisane przy użyciu Arduino 1.0.3 IDE
Data: 25 marca 2014 r
Autor:
--------------------------------------------------------------*/
// liczba próbek analogowych do odczytania
#define NSAMP 100
#define sclk 13
#define mosi 11
#define cs 10
#define dc 9
#define rst 8 // reset
#include // Podstawowa biblioteka graficzna
#include // Biblioteka specyficzna dla sprzętu
#zawierać
Adafruit_ST7735 tft = Adafruit_ST7735 (cs, dc, rst);
int sum = 0; // suma pobranych próbek
unsigned char Scount = 0; // numer bieżącej próbki
pływak V1 = 0,00; // obliczone Średnie napięcie
pływak VMAX = 0,00;
float VMIN = 100,00;
float val = 0,00;
pływak VREF = 5,0;
pływak Dv1 = 10,935;
void setup ()
{
tft.initR (INITR_BLACKTAB); // zainicjuj chip ST7735S, czarna zakładka
tft.fillScreen (ST7735_BLACK); // czysty ekran
tft.setTextColor (ST7735_GREEN);
tft.setTextSize (1);
tft.setCursor (10,0);
tft.println („DC woltomierz DVM”);
tft.setTextColor (ST7735_WHITE);
tft.println („Napięcie @ pin A0”);
tft.print („Z MAX, wartości MIN”);
tft.setTextColor (ST7735_RED);
tft.setCursor (0,140);
tft.println („Caution max voltage 55vdc”);
}
void loop ()
{
// weź kilka próbek analogowych i dodaj je
while (Scount <NSAMP) {
sum + = analogRead (A0); // odczyt i dodanie próbek
val = (analogRead (A0)); // przechowywanie temp dla MAX / MIN
tft.setCursor (45, 110);
tft.println (val);
if (val> VMAX) {// pobierz wartość MAX próbki
(VMAX = val);
}
if (val <VMIN) {// pobierz wartość MIN próbki
(VMIN = val);
}
Scount ++; // zwiększ liczbę próbek
delay (10); // Odczekaj 10 mS przed odczytaniem następnej próbki
}
// Po wykonaniu próbkowania oblicz i wyświetl obliczone średnie napięcie
V1 = ((float) sum / (float) NSAMP * VREF * Dv1) / 1024.0;
tft.setTextColor (ST7735_YELLOW, ST7735_BLACK);
tft.setCursor (45, 40);
tft.setTextSize (2);
tft.println („V1”);
tft.setCursor (10, 60);
tft.print (V1);
tft.println („Vdc”);
tft.setCursor (20, 90);
tft.setTextSize (1);
tft.setTextColor (0xff00, ST7735_BLACK);
tft.print („VMAX”);
tft.print ((float) VMAX * VREF / 1023 * Dv1); // oblicz i wyświetl obliczone maksymalne napięcie
tft.println („Vdc”);
tft.setCursor (20, 100);
tft.setTextColor (ST7735_GREEN, ST7735_BLACK);
tft.print („VMIN”);
tft.print ((float) VMIN * VREF / 1023 * Dv1); // oblicz i wyświetl obliczone napięcie minimalne
tft.print („Vdc”);
Scount = 0; // zresetuj licznik próbek
suma = 0; // suma resetowania
}
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
/*--------------------------------------------------------------
Program: woltomierz woltomierzowy z 4 kanałami
Opis: 4-kanałowy woltomierz DC z wyświetlanymi napięciami
na kolorowym wyświetlaczu TFT LCD do 1 miejsca po przecinku, z wykorzystaniem próbkowania i uśredniania
Sprzęt: Arduino NANO lub UNO z dzielnikami napięcia od A0 do A3.
TFT LCD podłączony
Oprogramowanie: Opracowane przy użyciu oprogramowania Arduino 1.0.3
Data: 10 marca 2014 r
Autor:
--------------------------------------------------------------*/
#define sclk 13
#define mosi 11
#define cs 10
#define dc 9
#define rst 8 // reset
#include // Podstawowa biblioteka graficzna
#include // Biblioteka specyficzna dla sprzętu
#zawierać
Adafruit_ST7735 tft = Adafruit_ST7735 (cs, dc, rst);
// liczba próbek analogowych do pobrania na odczyt, na kanał
#define NSAMP 100 // liczba próbek do wyświetlenia przed wyświetleniem
// wartości kalibracji dzielnika napięcia
#define Dv1 11.00
#define Dv2 11.001
#define Dv3 11.00
#define Dv4 10.985
// Napięcie odniesienia ADC / wartość kalibracji
#define VREF 5.00
int sum 4 = {0}; // sumy pobranych próbek
unsigned char Scount = 0; // numer bieżącej próbki
float AVvolts 4 = {0.0}; // obliczone napięcia
char cnt1 = 0; // używane w pętlach 'for'
void setup ()
{
tft.initR (INITR_BLACKTAB); // zainicjuj chip ST7735S, czarna zakładka
tft.fillScreen (ST7735_BLACK); // czysty ekran
tft.setTextColor (ST7735_WHITE);
tft.drawRoundRect (2, 20, 120, 110, 5, ST7735_WHITE);
tft.setTextSize (1);
tft.setCursor (5,0);
tft.println („4-kanałowy woltomierz”);
tft.setTextColor (0XFF00);
tft.setCursor (0,140);
tft.println („Caution max voltage 55vdc”);
}
void loop ()
{
// weź kilka próbek analogowych i dodaj je
while (Scount <NSAMP) {
// próbkuj każdy kanał A0 do A3
for (cnt1 = 0; cnt1 <4; cnt1 ++) {
suma cnt1 + = analogRead (A0 + cnt1);
}
Scount ++;
opóźnienie (10);
}
// oblicz napięcie dla każdego kanału
for (cnt1 = 0; cnt1 <4; cnt1 ++) {
AVvolts cnt1 = ((float) sum cnt1 / (float) NSAMP * VREF) / 1024.0;
}
// wyświetlanie napięć na wyświetlaczu TFT LCC
// napięcie 1 - V1 (styk A0
tft.setTextColor (ST7735_YELLOW, ST7735_BLACK); // ustaw kolor dla V1
tft.setTextSize (2);
tft.setCursor (15, 40);
tft.print („V1”);
tft.print (AVvolts 0 * Dv1, 1);
tft.print („V”);
// napięcie 2 - V2 (styk A1)
tft.setTextColor (ST7735_GREEN, ST7735_BLACK); // ustaw kolor dla V2
tft.setCursor (15, 60);
tft.print („V2”);
tft.print (AVvolts 1 * Dv2, 1);
tft.print („V”);
// voltge 3 - V3 (pin A2)
tft.setTextColor (ST7735_CYAN, ST7735_BLACK); // ustaw kolor dla V3
tft.setCursor (15, 80);
tft.print („V3”);
tft.print (AVvolts 2 * Dv3, 1);
tft.print („V”);
// napięcie 4 - V4 (pin A3)
tft.setTextColor (ST7735_WHITE, ST7735_BLACK); // ustaw kolor dla V4
tft.setCursor (15, 100);
tft.print („V4”);
tft.print (AVvolts 3 * Dv4, 2);
tft.print („V”);
tft.drawRoundRect (2, 20, 120, 110, 5, ST7735_WHITE);
// zresetuj liczbę i sumy
Scount = 0;
for (cnt1 = 0; cnt1 <4; cnt1 ++) {
suma cnt1 = 0;
}
}