Table des matières:
- Provisions:
- Étape 1: Ce dont vous aurez besoin: Liste de pièces
- Étape 2: PRINCIPES DE BASE DE LA DVM
- Étape 3: Construction du circuit
- Étape 4: CODE DVM 2 canaux
- Étape 5: Étalonnage
- Étape 6: Échantillonnage, calcul de la moyenne et affichage
- Étape 7: Les programmes en programmable
- Étape 8: Vidéo du DVM programmable
Cet Instructable va vous apprendre à utiliser les ports analogiques Arduino.
Les voltmètres numériques (DVM) constituent un cas particulier des convertisseurs analogique-numérique (A / DC). Ils mesurent la tension. Ils sont généralement fonction d'un instrument à usage général appelé multimètre numérique (DMM), couramment utilisé pour mesurer les tensions dans les laboratoires et Sur le terrain. Les multimètres numériques affichent la tension mesurée à l'aide d'écrans LCD ou de diodes électroluminescentes pour afficher le résultat au format virgule flottante. Ils constituent un instrument de choix pour les mesures de tension dans toutes sortes de situations. Cette instruction vous montrera comment utiliser l’Arduino en tant que voltmètre numérique à courant continu.
Nous utiliserons les entrées analogiques Arduino pour mesurer des tensions continues comprises entre 0 et 5V et afficher les valeurs sur un écran couleur LCD TFT.
J'ai utilisé le Sainsmart Arduino Nano et le Arduino officiel UNO R3 pour voir s'il y avait des différences.
Les plages de tension que l’Arduino peut mesurer peuvent être facilement étendues en utilisant deux résistances pour créer un diviseur de tension.
Le diviseur de tension réduit littéralement la tension mesurée de sorte qu'il se situe dans la plage des entrées analogiques Arduino (c'est-à-dire 0 à 5 volts).
Vous pouvez ensuite programmer l'esquisse Arduino pour calculer les tensions réelles mesurées en multipliant l'entrée par le facteur mis à l'échelle.
Cela nous permettra de mesurer des tensions supérieures à 5 V CC. La tension CC maximale que nous pouvons mesurer en toute sécurité est d'environ 50 V CC avec les pièces utilisées dans cet instrument, mais peut être modifiée en fonction de vos besoins.
Provisions:
Étape 1: Ce dont vous aurez besoin: Liste de pièces
Le coût total est d'environ 35 dollars!
- Un Arduino (j'ai utilisé le Sainsmart Nano Clone, (13,99 $) et un UNO R3, mais je pense que n'importe qui fera l'affaire)
- Un PC avec l'IDE arduino et un port USB libre.
- Un câble USB pour votre Arduino
- Un écran LCD COULEUR TFT Sainsmart 1,8 "(12,99 $)
- 4 résistances de 1 Mega Ohm (marron, noir, vert) 1 pour chaque canal
- 4 résistances de 100 kilo ohms (marron, noir, jaune) 1 pour chaque canal
- 4 diodes zener 5,1 volts (en option |) pour une protection accrue des entrées analogiques Arduino
- Câbles de démarrage, beaucoup, de différentes tailles et couleurs
- Planche à pain sans soudure (J'utilise. Ma planche à pain de laboratoire d'expérimentateurs électroniques RadioShack)
- Un multimètre et / ou une référence de tension pour calibrer les sorties du DVM
Étape 2: PRINCIPES DE BASE DE LA DVM
Avant de commencer à élaborer le projet, examinons quelques principes de base et précautions concernant les mesures de tension avec un DVM.
Exactitude et précision
Notre DVM ne sera pas aussi précis et précis qu'une unité disponible dans le commerce, mais il sera certainement plus flexible.
Afin de rendre les lectures aussi précises que possible, nous devons prendre en compte deux éléments: la résolution d'entrée et l'étalonnage. La résolution d'entrée dépend du convertisseur A / N d'entrée analogique Arduinos, qui est de 10 bits sur les Arduino uno et nano. L'étalonnage dépendra de la qualité des composants utilisés et des références utilisées pour étalonner les mesures.
Impédance d'entrée
Les multimètres numériques commerciaux qui mesurent la tension continue auront généralement une impédance d'entrée très élevée de 10 MΩ ou plus (par exemple, la résistance entre les deux sondes de test du multimètre est de 10 MΩ ou plus).
Une impédance d'entrée élevée pour un voltmètre est nécessaire afin que le voltmètre n'affecte pas la valeur du circuit mesuré.
Si un voltmètre a une faible impédance d'entrée, il peut éventuellement changer la tension mesurée et vous donner des lectures incorrectes.
Cependant, une impédance d'entrée élevée présente également un inconvénient. Les sondes de test sont plus susceptibles de capter des interférences électromagnétiques (EMI), qui peuvent également compenser vos mesures et afficher des lectures "fantômes".
Bien qu’une impédance d’entrée élevée soit souhaitable, le circuit diviseur de tension que nous utiliserons donnera à notre voltmètre une impédance d’entrée d’environ 1 MΩ, ce qui est acceptable pour la plupart des mesures à basse tension et des circuits à faible impédance généralement construits par les amateurs électroniques.
Circuit diviseur de tension
Nous utiliserons deux résistances en série qui réduiront la tension d'entrée dans une plage comprise dans les limites de sécurité des spécifications d'entrée analogique Arduino. L'équation de base du diviseur de tension est la suivante:
V out = V in * R b / (R a + R b)
Si:
R a = 1 MΩ
R b = 100KΩ
V out = 5V (la tension maximale pour les broches d'entrée analogique arduino)
puis;
V in = 55V (la tension maximale pouvant être mesurée en toute sécurité)
Le circuit que nous utiliserons divisera la tension d’entrée par 11; (100K / (100K + 1M)) = (100/1100) = (1/11)
Contrainte de terrain commune
La plupart des systèmes DVMS commerciaux vous permettent de mesurer la tension sur tout composant, pas seulement à partir d'une référence à la terre. Notre voltmètre basé sur Arduino ne peut pas faire cela, il ne peut mesurer que depuis une référence à la terre car la broche Arduino GND est utilisée comme fil de sonde de test commun ou négatif (COM) d’un multimètre standard et doit être connectée à la masse du circuit sous. tester.
Protection d'entrée
Les valeurs de résistance que nous utilisons offrent une certaine protection contre les surtensions lors de la mesure de basses tensions et jusqu’à environ 55 volts. Pour protéger l’Arduino contre les surtensions accidentelles (> 55 VDC), nous pouvons, en option, utiliser des diodes zener de 5,1 volts en parallèle avec les résistances de 100 KΩ. Cela fournira une protection supplémentaire aux broches d’entrée analogique Arduino.
Tension nominale maximale
Comme expliqué précédemment, le point du réseau diviseur de résistance connecté à la broche d'entrée analogique Arduino est égal à la tension d'entrée divisée par 11 (55V ÷ 11 = 5V). La tension maximale pouvant être mesurée en toute sécurité est de 55 volts. La broche analogique Arduino sera à sa tension maximale de 5V.Mise en garde!!! n'essayez pas de mesurer des tensions supérieures à 55 volts ou vous pourriez endommager votre Arduino
Étape 3: Construction du circuit
Nous allons commencer par construire un diviseur de tension et le connecter à l'Arduino, tester le circuit avec un simple croquis et procéder à la construction du reste des circuits.
Une fois les entrées activées, nous installerons l’écran couleur LCD TFT 1,8 "et créerons un croquis pour y afficher la mesure en entrée.
Nous explorerons ensuite plusieurs options logicielles et matérielles pour améliorer ou personnaliser le DVM.
Commençons donc par construire le diviseur de tension sur la carte de connexion et le connecter à la broche A0 de l’Arduino.
Regardez le schéma de circuit et les autres images pour vous guider dans les étapes.
Une fois le circuit assemblé, branchez l’Arduino sur le port USB de votre PC et téléchargez le schéma de test suivant, qui affiche la tension connectée à la jambe de résistance 1Meg libre via le moniteur série.
Il suffit de copier et coller le dessin suivant dans l'IDE Arduino.
// ----------------- Sketch Start -----------------------------
/* -----------------------------------------------------------
Programme: SERIAL DVM
Description: voltmètre CC avec tension affichée sur le moniteur série
Pas encore de couleur LCD TFT!
Matériel: Arduino NANO ou Uno avec diviseur de tension sur A0.
Logiciel: écrit et développé à l'aide du logiciel Arduino 1.0.3
Rendez-vous amoureux:
Auteur:
--------------------------------------------------------------*/
// valeurs d'étalonnage du diviseur de tension
#define Dv1 11
// tension de référence ADC / valeur d'étalonnage
#define VREF 5
float V1 = {0.00};
void setup()
{
Serial.begin (9600);
}
boucle vide ()
{
V1 = analogRead (0);
Serial.print ("Voltage @ pin A0");
Serial.println ((((V1 * VREF) / 1023)) * Dv1, 2);
}
// ----------------- Fin de l'esquisse -----------------------------
Passons en revue ce qui se passe.
Le contrôleur Atmega utilisé pour l’Arduino contient un convertisseur analogique-numérique (A / N) intégré à 6 canaux. Le convertisseur a une résolution de 10 bits, ce qui renvoie un entier compris entre 0 et 1023 (210= 1024, 0 compte, donc 1023 pas) pour une valeur de 0 à 5 volts.
Nous voulons convertir la valeur renvoyée A / D en tension réelle que nous mesurons.
Nous devons multiplier le résultat par 5 et le diviser par 1023 pour ajuster la valeur renvoyée par le convertisseur A / N 10 bits.
Nous divisons également la tension par 11 avec le diviseur de tension. La tension que nous mesurons (et que nous voulons voir à l'écran) doit donc être multipliée par 11 pour compenser la division.
Nous faisons cela avec la formule suivante:
Vout = ((Vin * (5/1023)) * 11).
le code pour cela est:
Serial.println ((((V1 * VREF) / 1023)) * Dv1, 2);
Nous multiplions par 5 (VREF) et divisons par 1023 pour convertir la sortie A / D en une échelle comprise entre 0 et 5, puis nous multiplions par 11 (Dv1) pour compenser le diviseur de tension. La raison pour laquelle nous utilisons des variables pour le diviseur et les valeurs de tension, est que ces valeurs vont changer lorsque nous calibrons le DVM. Le "2" à la fin de la formule définit le nombre de chiffres à afficher après la virgule.
Si vous voulez que le programme se charge correctement, ouvrez le moniteur série en cliquant sur l’icône de grossissement dans le coin supérieur droit de l’IDE Arduino, vous devriez voir des données circuler. À l’aide d’un fil de liaison, essayez de connecter d’abord le pied libre de la résistance 1Meg à la broche GND, puis à la broche 5V. Vous devriez voir la lecture changer de 0 à 5v.
Maintenant, nous devons simplement répéter ce que nous avons fait pour le premier canal trois fois de plus pour avoir un DVM à 4 canaux, mais avant cela, connectons notre afficheur LCD couleur TFT à l’Arduino. Pour ce faire, vous aurez besoin de 7 fils de liaison:
Connectez ce qui suit avec les cavaliers
LCD TFT. Arduino
VCC 5V
GND Gnd
SCL 13
SDA 11
CS 10
RS / DC 9
RES 8
Remarque:
Contrairement à mes autres instructables, nous utiliserons l’interface SPI haute vitesse pour piloter l’affichage, le câblage des cavaliers est donc différent. Encore une fois, consultez les images pour vous guider si vous ne savez pas comment le câbler.
Vous aurez besoin d'installer deux bibliothèques pour utiliser l'affichage:
Adafruit_GFX.h La bibliothèque graphique principale
Adafruit_ST7735.h La bibliothèque spécifique au matériel
Téléchargez les bibliothèques et copiez-les dans le dossier de la bibliothèque Arduino.
Copiez et collez l'esquisse ci-dessous dans l'IDE Arduino. Le code DVM de l’esquisse est le même, mais avec l’ajout du code pour afficher la tension sur A0 sur l’écran LCD.
Compiler et télécharger l'esquisse sur l'Arduino.
// ----------------- Sketch Start -----------------------------
/*-----------------------------------------------------------
Programme: TFTLCDDVM
Description: voltmètre CC avec tension affichée
sur écran LCD couleur TFT à 2 décimales
Matériel: Arduino NANO avec diviseur de tension sur A0.
TFT LCD connecté
Logiciel: développé à l'aide du logiciel Arduino 1.0.3
Date: 10 mars 2014
Auteur: johnag
--------------------------------------------------------------*/
#define sclk 13
#define mosi 11
#define cs 10
#define dc 9
#define rst 8 // reset
#include // Bibliothèque graphique principale
#include // bibliothèque spécifique au matériel
#comprendre
Adafruit_ST7735 tft = Adafruit_ST7735 (cs, dc, rst);
// valeur d'étalonnage du diviseur de tension
#define Dv1 11
// tension de référence ADC
#define VREF 5
float V1 = {0.00};
void setup()
{
Serial.begin (9600);
tft.initR (INITR_BLACKTAB); // initialise une puce ST7735S, onglet noir
tft.fillScreen (ST7735_BLACK); // écran propre
tft.setTextColor (ST7735_WHITE);
tft.setTextSize (1);
tft.setCursor (10,0);
tft.println ("voltmètre CC");
tft.setTextColor (ST7735_RED);
tft.setCursor (0,140);
tft.println ("Attention tension maximale 55vdc");
}
boucle vide ()
{
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);
// tension 1 (broche A0)
// la tension est multipliée par le réseau de résistances
// facteur de division pour calculer la tension réelle
tft.setCursor (45, 40);
tft.println ("V1");
tft.setTextSize (1);
tft.println ("Voltage @ pin A0");
tft.setCursor (20, 80);
tft.setTextSize (2);
Serial.print ("Voltage @ pin A0");
Serial.println ((((V1 * VREF) / 1023)) * Dv1, 2);
tft.print ((((V1 * VREF) / 1023)) * Dv1, 2);
tft.print ("Vdc");
}
// --------------- Fin de l'esquisse ------------------------------- ---------
Étape 4: CODE DVM 2 canaux
Vous trouverez ci-dessous l'esquisse pour une copie DVM à 2 canaux et le coller dans l'IDE Arduino. Je laisserai le code pour le DVM à 4 canaux après la calibration.
// --------------------------- 2canal DVM start ------------------ ---
/*--------------------------------------------------------------------
Programme: voltmeter_LCD
Description: voltmètre à courant continu à 2 canaux avec affichage des tensions
sur LCD couleur TFT à 1 décimale
Matériel: Arduino NANO avec diviseurs de tension sur A0 et A1
TFT LCD connecté
Logiciel: développé à l'aide du logiciel Arduino 1.0.3
Date: 10 mars 2014
Auteur:
--------------------------------------------------------------*/
#define sclk 13
#define mosi 11
#define cs 10
#define dc 9
#define rst 8 // reset
#include // Bibliothèque graphique principale
#include // bibliothèque spécifique au matériel
#comprendre
Adafruit_ST7735 tft = Adafruit_ST7735 (cs, dc, rst);
// valeurs d'étalonnage du diviseur de tension
#define Dv1 11.00 // calculé en mesurant la tension à la jonction de la résistance
#define Dv2 11.25
// tension de référence ADC / valeur d'étalonnage
#define VREF 4.9
float V1 = {0.0};
float V2 = {0.0};
void setup()
{
tft.initR (INITR_BLACKTAB); // initialise une puce ST7735S, onglet noir
tft.fillScreen (ST7735_BLACK); // écran propre
tft.setTextColor (ST7735_WHITE);
tft.setTextSize (1);
tft.setCursor (5,0);
tft.println ("voltmètre à 2 canaux");
tft.setTextColor (ST7735_RED);
tft.setCursor (0,140);
tft.println ("Attention tension maximale 55vdc");
}
boucle vide ()
{
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);
// tension 1 (broche A0)
tft.setCursor (5, 40);
tft.setTextSize (1);
tft.println ("Voltage @ pin A0");
tft.setTextSize (2);
tft.setCursor (10, 50);
tft.print ("V1");
tft.print ((((V1 * VREF) / 1023)) * Dv1, 1);
tft.print ("V");
// tension 2 (broche A1)
tft.setCursor (5, 70);
tft.setTextSize (1);
tft.println ("Voltage @ 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");
}
// --------------------------- 2canal DVM END ------------------
Étape 5: Étalonnage
Étapes d'étalonnage:
- Mesurez la tension sur la broche 5v de l’Arduino avec votre multimètre et utilisez ce nombre dans le code comme valeur VREF. Par exemple, si vous avez mesuré 5,0 v, la ligne de l'esquisse définissant VREF devrait être #define VREF 5.0.
- Sur votre circuit diviseur de tension, branchez le pied libre de la résistance de 1meg sur la broche 5v de votre Arduino et mesurez la tension sur tout le diviseur de tension, puis sur la tension de la résistance 100 k. (d'abord de GND au 5v puis de GND au point de jonction de la résistance, à travers la résistance 100k). Divisez maintenant les deux tensions, par exemple, j'ai obtenu 5,0 pour la tension de GND à 5v et 0,46v pour la tension aux bornes de la résistance 100k, je divise donc 5 par 0,46: 5 / 0,46 = 10,869
- Placez cette valeur dans la ligne de définition de Dv1: #define Dv1 10.869.
- Téléchargez l'esquisse et vérifiez si la lecture affichée correspond à celle de votre multimètre.
- Répétez les étapes pour tous les diviseurs de tension et modifiez les valeurs en conséquence.
Étape 6: Échantillonnage, calcul de la moyenne et affichage
OK, nous avons donc calibré le DVM, mais les lectures semblent toujours un peu instables et légèrement décalées. Nous pouvons encore faire quelque chose à ce sujet. Au lieu d'afficher uniquement les données mesurées, pourquoi ne pas prélever plusieurs échantillons, les additionner et diviser la somme par le nombre d'échantillons prélevés. Cela nous donnera une moyenne des valeurs dans l'entrée et nous fournira une lecture plus stable. Permet de faire cela en utilisant le tandis queboucle.
L'esquisse ci-dessous utilise l'échantillonnage et la moyenne pour améliorer les valeurs affichées. Copiez-le et collez-le dans l'EDI Arduino, compilez-le et chargez-le.
// ----------------- Sketch Start -----------------------------
/*--------------------------------------------------------------
Programme: DVM 1 canal avec échantillonnage
Description: Lit la valeur sur l'entrée analogique A0 et calcule
la tension avec un diviseur de tension
réseau sur la broche A0 qui divise par 10.195 et une tension de référence de 5.0v.
Matériel: Arduinonano ou Uno avec diviseur de tension sur A0.
Logiciel: développé à l'aide du logiciel Arduino 1.0.3
Devrait être compatible avec Arduino 1.0 +
Date: 25 mars 2014
Auteur:
--------------------------------------------------------------*/
#define NUMSAMP 100 // nombre d'échantillons à prélever avant la moyenne et l'affichage
#define sclk 13
#define mosi 11
#define cs 10
#define dc 9
#define rst 8 // reset
#define Dv1 10.915 // Valeur du diviseur de tension
#define VREF 5.0 // Tension mesurée @Arduino 5V pin
#include // Bibliothèque graphique principale
#include // bibliothèque spécifique au matériel
#comprendre
Adafruit_ST7735 tft = Adafruit_ST7735 (cs, dc, rst);
int sum = 0; // Somme des échantillons prélevés
unsigned char Scount = 0; // Numéro de l'échantillon actuel
float AVvolts = 0,0; // tension moyenne calculée
void setup()
{// Configuration de l'affichage et de l'impression d'éléments statiques
tft.initR (INITR_BLACKTAB); // initialise une puce ST7735S, onglet noir
tft.fillScreen (ST7735_BLACK); // écran propre
tft.setTextColor (ST7735_WHITE);
tft.setTextSize (1);
tft.setCursor (10,0);
tft.println ("voltmètre CC");
tft.println ("");
tft.println ("");
tft.print ("Voltage @ pin A0");
tft.setTextColor (ST7735_RED);
tft.setCursor (0,140);
tft.println ("Attention tension maximale 55vdc");
}
boucle vide ()
{
// prend un certain nombre d'échantillons analogiques et les additionne
while (Scount <NUMSAMP) {
somme + = analogRead (A0); // lire et ajouter les exemples
Montant ++; // incrémente le nombre d'échantillons
délai (10); // Attendez 10 ms avant de lire l'échantillon suivant
}
AVvolts = ((float) sum / / float) NUMSAMP * VREF) / 1023; // calcule la tension moyenne
// Affiche la tension moyenne calculée
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");
Montant = 0;
somme = 0;
}
// ----------------- Fin de l'esquisse -----------------------------
Étape 7: Les programmes en programmable
Il y a 10 sortes de personnes, celles qui connaissent le binaire et celles qui ne le connaissent pas.
Jusqu'à présent, nous avons appris à assembler un Arduino et à ajouter des diviseurs de tension pour conditionner le signal d'entrée analogique (tension) en le réduisant à un niveau conforme aux paramètres de la spécification Arduino. Nous avons ensuite compilé et téléchargé des esquisses qui ont lu les signaux et les ont affichées sur le moniteur série et sur l’écran LCD TFT. À vous maintenant d’étudier le code et de poursuivre le travail. J'inclus le code pour les croquis plus compliqués qui fonctionneront avec le matériel que nous avons mis en place.
/*--------------------------------------------------------------
Programme: DVM 1 canal avec échantillonnage
Description: Lit la valeur de l’entrée analogique A0 et calcule la tension en supposant
il y a un diviseur de tension sur la broche A0 qui divise par 10.195
Matériel: Arduino NANO ou UNO avec diviseur de tension sur A0.
Logiciel: Écrit avec Arduino 1.0.3 IDE
Date: 25 mars 2014
Auteur:
--------------------------------------------------------------*/
// nombre d'échantillons analogiques à prendre par lecture
#define NSAMP 100
#define sclk 13
#define mosi 11
#define cs 10
#define dc 9
#define rst 8 // reset
#include // Bibliothèque graphique principale
#include // bibliothèque spécifique au matériel
#comprendre
Adafruit_ST7735 tft = Adafruit_ST7735 (cs, dc, rst);
int sum = 0; // somme des échantillons prélevés
unsigned char Scount = 0; // numéro de l'échantillon actuel
float V1 = 0,00; // tension moyenne calculée
float VMAX = 0,00;
float VMIN = 100,00;
float val = 0,00;
float VREF = 5,0;
float Dv1 = 10,935;
void setup()
{
tft.initR (INITR_BLACKTAB); // initialise une puce ST7735S, onglet noir
tft.fillScreen (ST7735_BLACK); // écran propre
tft.setTextColor (ST7735_GREEN);
tft.setTextSize (1);
tft.setCursor (10,0);
tft.println ("voltmètre CC");
tft.setTextColor (ST7735_WHITE);
tft.println ("Voltage @ pin A0");
tft.print ("Avec les valeurs MAX, MIN");
tft.setTextColor (ST7735_RED);
tft.setCursor (0,140);
tft.println ("Attention tension maximale 55vdc");
}
boucle vide ()
{
// prend un certain nombre d'échantillons analogiques et les additionne
while (Scount <NSAMP) {
sum + = analogRead (A0); // lit et ajoute les échantillons
val = (analogRead (A0)); // stockage temporaire pour MAX / MIN
tft.setCursor (45, 110);
tft.println (val);
if (val> VMAX) {// récupère la valeur MAX de l'échantillon
(VMAX = val);
}
if (val <VMIN) {// récupère la valeur MIN de l'échantillon
(VMIN = val);
}
Scount ++; // incrémenter le nombre d'échantillons
delay (10); // Attendez 10 ms avant de lire l'échantillon suivant
}
// Une fois l'échantillonnage effectué, calculez et affichez la tension moyenne calculée.
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); // calcule et affiche la tension maximale calculée.
tft.println ("Vdc");
tft.setCursor (20, 100);
tft.setTextColor (ST7735_GREEN, ST7735_BLACK);
tft.print ("VMIN");
tft.print ((float) VMIN * VREF / 1023 * Dv1); // calcule et affiche la tension minimale calculée.
tft.print ("Vdc");
Montant = 0; // réinitialiser le nombre d'échantillons
somme = 0; // réinitialiser la somme
}
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
/*--------------------------------------------------------------
Programme: voltmètre voltmètre
Description: voltmètre cc à 4 canaux avec affichage des tensions
sur LCD couleur TFT à 1 décimale, en utilisant l'échantillonnage et la moyenne
Matériel: Arduino NANO ou UNO avec diviseurs de tension sur A0 à A3.
TFT LCD connecté
Logiciel: développé à l'aide du logiciel Arduino 1.0.3
Date: 10 mars 2014
Auteur:
--------------------------------------------------------------*/
#define sclk 13
#define mosi 11
#define cs 10
#define dc 9
#define rst 8 // reset
#include // Bibliothèque graphique principale
#include // bibliothèque spécifique au matériel
#comprendre
Adafruit_ST7735 tft = Adafruit_ST7735 (cs, dc, rst);
// nombre d'échantillons analogiques à prendre par lecture, par canal
#define NSAMP 100 // nombre d'échantillons à prendre avant l'affichage
// valeurs d'étalonnage du diviseur de tension
#define Dv1 11.00
#define Dv2 11.001
#define Dv3 11.00
#define Dv4 10.985
// tension de référence ADC / valeur d'étalonnage
#define VREF 5.00
int sum 4 = {0}; // somme des échantillons prélevés
unsigned char Scount = 0; // numéro de l'échantillon actuel
float AVvolts 4 = {0.0}; // tensions calculées
char cnt1 = 0; // utilisé dans les boucles 'pour'
void setup()
{
tft.initR (INITR_BLACKTAB); // initialise une puce ST7735S, onglet noir
tft.fillScreen (ST7735_BLACK); // écran propre
tft.setTextColor (ST7735_WHITE);
tft.drawRoundRect (2, 20, 120, 110, 5, ST7735_WHITE);
tft.setTextSize (1);
tft.setCursor (5,0);
tft.println ("voltmètre à 4 canaux");
tft.setTextColor (0XFF00);
tft.setCursor (0,140);
tft.println ("Attention tension maximale 55vdc");
}
boucle vide ()
{
// prend un certain nombre d'échantillons analogiques et les additionne
while (Scount <NSAMP) {
// échantillonne chaque canal de A0 à A3
pour (cnt1 = 0; cnt1 <4; cnt1 ++) {
somme cnt1 + = analogRead (A0 + cnt1);
}
Montant ++;
délai (10);
}
// calcule la tension pour chaque canal
pour (cnt1 = 0; cnt1 <4; cnt1 ++) {
AVvolts cnt1 = (somme (float)) cnt1 / (float) NSAMP * VREF) / 1024.0;
}
// affichage des tensions sur l'écran TFT LCC
// tension 1 - V1 (broche A0
tft.setTextColor (ST7735_YELLOW, ST7735_BLACK); // définir la couleur pour V1
tft.setTextSize (2);
tft.setCursor (15, 40);
tft.print ("V1");
tft.print (AVvolts 0 * Dv1, 1);
tft.print ("V");
// tension 2 - V2 (broche A1)
tft.setTextColor (ST7735_GREEN, ST7735_BLACK); // définition de la couleur pour V2
tft.setCursor (15, 60);
tft.print ("V2");
tft.print (AVvolts 1 * Dv2, 1);
tft.print ("V");
// tension 3 - V3 (broche A2)
tft.setTextColor (ST7735_CYAN, ST7735_BLACK); // définition de la couleur pour V3
tft.setCursor (15, 80);
tft.print ("V3");
tft.print (AVvolts 2 * Dv3, 1);
tft.print ("V");
// tension 4 - V4 (broche A3)
tft.setTextColor (ST7735_WHITE, ST7735_BLACK); // définition de la couleur pour 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);
// réinitialiser le compte et les sommes
Montant = 0;
pour (cnt1 = 0; cnt1 <4; cnt1 ++) {
somme cnt1 = 0;
}
}