Introduzione
Il frequenzimetro digitale con ESP32 è uno strumento semplice ma molto utile in ogni laboratorio di elettronica. Nel mondo dell’elettronica e della progettazione di circuiti, la necessità di misurare con precisione le frequenze dei segnali digitali è fondamentale. Tuttavia, gli strumenti di misura professionali, come i frequenzimetri digitali, possono risultare costosi e fuori dalla portata di hobbisti, studenti e piccoli laboratori. Fortunatamente, grazie ai moderni microcontrollori come l’ESP32, è possibile realizzare un frequenzimetro digitale a basso costo che offre buone prestazioni.
Il progetto che presentiamo sfrutta l’ESP32, un potente microcontrollore dotato di molteplici funzionalità, tra cui il modulo LEDC per la generazione di segnali PWM e la capacità di misurare frequenze digitali con alta precisione. Utilizzando un display TFT da 2.8 pollici con driver ILI9341, il risultato è uno strumento di misurazione compatto, versatile e, soprattutto, economico. Questo frequenzimetro digitale è ideale per chiunque abbia bisogno di uno strumento affidabile per testare e calibrare circuiti elettronici senza dover investire in apparecchiature costose.
In generale, un frequenzimetro digitale trova applicazione in una vasta gamma di scenari. Nei circuiti digitali, può essere utilizzato per verificare la frequenza dei clock di microcontrollori, oscillatori e segnali di comunicazione. Nei circuiti analogici, può aiutare a caratterizzare la risposta in frequenza di filtri, amplificatori e altri componenti. Inoltre, è utile nella didattica e nella sperimentazione, offrendo agli studenti uno strumento pratico per comprendere meglio il comportamento dei segnali periodici e la teoria delle frequenze.
La costruzione di questo progetto non richiede competenze avanzate in elettronica o programmazione. Grazie alle librerie open-source e alla comunità di sviluppatori, è possibile configurare e utilizzare l’ESP32 in modo relativamente semplice. Il progetto utilizza la libreria TFT_eSPI per la gestione del display TFT e la libreria FreqCountESP per la misurazione delle frequenze, garantendo precisione e facilità d’uso.
In questo articolo, esploreremo in dettaglio i componenti necessari, il funzionamento del frequenzimetro digitale e come assemblare e programmare il dispositivo. Alla fine, avrai uno strumento di misurazione potente e versatile, costruito con un budget ridotto, che ti permetterà di esplorare e analizzare una vasta gamma di segnali digitali con facilità e precisione.
Come al solito useremo l’IDE Platformio per la creazione del progetto.
La libreria FreqCountESP
La libreria FreqCountESP è uno strumento essenziale per realizzare un frequenzimetro digitale con l’ESP32. Sviluppata specificamente per sfruttare le capacità del microcontrollore ESP32, questa libreria consente di misurare con precisione la frequenza di segnali digitali in ingresso. La sua progettazione è stata ottimizzata per garantire un’elevata accuratezza e per semplificare l’implementazione nel codice, rendendola ideale per hobbisti e sviluppatori.
FreqCountESP utilizza i timer interni dell’ESP32 per contare il numero di transizioni di segnale (cambi di stato da basso ad alto o viceversa) che si verificano su un determinato pin GPIO in un intervallo di tempo predefinito. Questa tecnica permette di calcolare la frequenza del segnale in modo preciso e affidabile. La libreria supporta misurazioni in un’ampia gamma di frequenze, rendendola versatile per diverse applicazioni.
Uno dei principali vantaggi della FreqCountESP è la sua facilità d’uso. L’interfaccia della libreria è progettata per essere intuitiva, permettendo di iniziare rapidamente con poche righe di codice. Dopo aver incluso la libreria nel progetto, è sufficiente configurare il pin di ingresso e avviare il conteggio della frequenza. La libreria gestisce automaticamente i dettagli complessi del conteggio delle transizioni e del calcolo della frequenza, restituendo il valore misurato in hertz.
Inoltre, la libreria è ben documentata e supportata dalla comunità, offrendo esempi pratici e suggerimenti per l’ottimizzazione delle misurazioni. Questo supporto rende FreqCountESP una scelta eccellente per chiunque desideri aggiungere funzionalità di misurazione della frequenza a un progetto basato su ESP32.
In sintesi, la libreria FreqCountESP rappresenta una soluzione potente e conveniente per la misurazione delle frequenze dei segnali digitali con l’ESP32. La sua precisione, combinata con la semplicità di utilizzo, la rende uno strumento indispensabile per sviluppatori e appassionati di elettronica che desiderano creare un frequenzimetro digitale efficace e a basso costo.
La libreria FreqCountESP non si basa sulla FFT (Fast Fourier Transform) per misurare la frequenza dei segnali digitali. Invece, utilizza un metodo di conteggio diretto delle transizioni di segnale (da basso ad alto o da alto a basso) che avvengono su un pin GPIO dell’ESP32. Questo approccio è semplice e diretto, particolarmente adatto per segnali digitali a onda quadra.
Dettagli sul metodo di misurazione
- Conteggio delle transizioni: la libreria sfrutta i timer interni dell’ESP32 per contare il numero di transizioni del segnale su un determinato pin GPIO in un intervallo di tempo predefinito. Ogni cambiamento di stato del segnale (da LOW a HIGH o da HIGH a LOW) viene registrato.
- Intervallo di tempo: l’intervallo di tempo durante il quale vengono contate le transizioni è critico per la precisione della misurazione. Un intervallo più lungo permette una misurazione più precisa delle frequenze basse, mentre per frequenze alte l’intervallo può essere ridotto.
- Calcolo della frequenza: alla fine dell’intervallo di tempo, il numero di transizioni contate viene utilizzato per calcolare la frequenza del segnale.
Vantaggi del metodo di conteggio diretto
- Semplicità: non richiede complesse trasformazioni matematiche come la FFT, rendendo il codice più semplice e più veloce da eseguire. Questo è particolarmente utile per applicazioni in tempo reale dove la rapidità di risposta è cruciale.
- Precisione: per segnali digitali a onda quadra, il metodo di conteggio diretto può fornire misurazioni molto precise. Questo perché il metodo misura direttamente il numero di cicli del segnale, riducendo le possibili fonti di errore associate all’approssimazione delle frequenze con la FFT.
- Efficienza: utilizzando i timer hardware dell’ESP32, il carico sul processore principale è minimo. Questo permette all’ESP32 di svolgere altre operazioni contemporaneamente alla misurazione della frequenza, migliorando l’efficienza complessiva del sistema.
- Facilità di implementazione: la libreria FreqCountESP è progettata per essere facile da usare. Con poche righe di codice, è possibile iniziare a misurare la frequenza dei segnali digitali, rendendola accessibile anche a chi ha poca esperienza con la programmazione dei microcontrollori.
Introduzione alla FFT
Dato che l’abbiamo nominata, spendiamo due parole sulla FFT. La FFT, acronimo di Fast Fourier Transform, è un algoritmo fondamentale in molte applicazioni di elaborazione del segnale, analisi dei dati e ingegneria. La FFT permette di trasformare un segnale dal dominio del tempo al dominio della frequenza, scomponendolo nelle sue componenti sinusoidali di diverse frequenze. Questo processo è noto come analisi spettrale e consente di comprendere quali frequenze sono presenti in un segnale e con quale intensità.
Cos’è la Trasformata di Fourier?
Prima di parlare della FFT, è utile capire la Trasformata di Fourier. La Trasformata di Fourier è un’operazione matematica che trasforma un segnale continuo nel dominio del tempo in un segnale nel dominio della frequenza. La versione discreta di questa trasformata, chiamata DFT (Discrete Fourier Transform), è applicabile a segnali digitali, che sono campionati a intervalli discreti.
Vantaggi della FFT
La FFT è un’implementazione veloce della DFT. Mentre la DFT ha una complessità computazionale di O(N2), dove N è il numero di punti del segnale, la FFT riduce questa complessità a O(N log N). Questo rende la FFT molto più efficiente e pratica per l’analisi di segnali di grandi dimensioni, permettendo elaborazioni in tempo reale su dispositivi con risorse limitate, come microcontrollori e sistemi embedded.
Applicazioni della FFT
La FFT trova applicazione in una vasta gamma di campi, tra cui:
- Elaborazione del segnale audio: analisi della frequenza, riduzione del rumore, equalizzazione e compressione del suono.
- Comunicazioni digitali: modulazione e demodulazione di segnali, analisi dello spettro di frequenza.
- Immagini e video: compressione dei dati, filtraggio e miglioramento delle immagini.
- Diagnostica e manutenzione predittiva: analisi delle vibrazioni e monitoraggio delle condizioni in macchinari e strutture.
Limitazioni della FFT
Nonostante la sua potenza, la FFT ha alcune limitazioni. La precisione della trasformata dipende dalla lunghezza del segnale e dalla frequenza di campionamento. Inoltre, la FFT assume che il segnale sia periodico e ripetuto all’infinito, il che può introdurre artefatti se il segnale non soddisfa questa condizione. Questi artefatti possono essere mitigati tramite tecniche di windowing, che consistono nell’applicare una finestra al segnale per ridurre le discontinuità ai bordi.
Confronto tra conteggio diretto e FFT
Nel contesto del nostro frequenzimetro digitale basato su ESP32, il metodo di conteggio diretto delle transizioni è più appropriato per segnali digitali a onda quadra. La FFT, pur essendo estremamente potente e versatile, sarebbe eccessiva e meno efficiente per questa applicazione specifica. Tuttavia, per applicazioni che richiedono l’analisi spettrale di segnali complessi con molteplici componenti di frequenza, la FFT rappresenta uno strumento indispensabile.
In conclusione
La FFT è un potente strumento di analisi dei segnali che trasforma un segnale dal dominio del tempo al dominio della frequenza. Sebbene non sia necessario per un frequenzimetro digitale semplice come quello descritto in questo articolo, la FFT offre capacità analitiche avanzate per una vasta gamma di applicazioni. Comprendere i concetti fondamentali della FFT fornisce una solida base per esplorare applicazioni più complesse in futuro, quando sarà necessario esaminare la composizione in frequenza di segnali complessi.
Cos’è ILI9341 Display LCD TFT SPI 2.8″?
Il ILI9341 Display LCD TFT SPI 2.8″ è un tipo di schermo a cristalli liquidi (LCD) a colori ad alta risoluzione progettato per fornire un’interfaccia visiva in progetti elettronici. Comunica col microcontrollore tramite interfaccia SPI dedicata. Oltre alla visualizzazione a colori, dispone di un touchscreen resistivo che consente l’interazione diretta con l’utente (tramite interfaccia SPI dedicata), e di uno slot per schede SD (Secure Digital) che consente di memorizzare e accedere facilmente ai dati (tramite interfaccia SPI dedicata).
Caratteristiche tecniche:
Dimensioni dello schermo: 2.8 pollici (diagonale)
Risoluzione: 320 x 240 pixel
Controller: ILI9341, un popolare controller per display TFT che supporta la comunicazione tramite SPI (Serial Peripheral Interface)
Interfaccia: SPI (Serial Peripheral Interface) per la comunicazione con microcontrollori e altri dispositivi
Touchscreen: resistivo, che consente l’interazione diretta con l’utente attraverso la pressione
Slot per schede SD: per l’accesso a schede di memoria SD tramite l’interfaccia SPI, consentendo la memorizzazione e l’accesso ai dati
Colori: supporta la visualizzazione di 65.536 colori (16-bit)
Angolo di visione: buono, con una visione chiara da diverse angolazioni
Retroilluminazione: retroilluminazione a LED per una luminosità uniforme e regolabile
Compatibilità: compatibile con una vasta gamma di microcontrollori e schede di sviluppo
Funzionalità e utilizzo: il ILI9341 Display LCD TFT SPI 2.8″ con touchscreen resistivo e alloggio per SD card può essere utilizzato in una varietà di applicazioni, tra cui:
- Creazione di interfacce utente interattive per dispositivi embedded e progetti IoT
- Visualizzazione di testo, grafici e immagini con la possibilità di interazione tramite touchscreen
- Implementazione di sistemi di registrazione dati che utilizzano lo slot per schede SD per archiviare e accedere ai dati
- Realizzazione di dispositivi multimediali portatili, come lettori video e visualizzatori di immagini, con la possibilità di memorizzare i file multimediali sulla scheda SD
Vantaggi:
- Interazione utente: il touchscreen resistivo consente un’interazione diretta e intuitiva con l’interfaccia utente.
- Memorizzazione esterna: lo slot per schede SD offre la possibilità di memorizzare una grande quantità di dati esternamente al dispositivo principale (per esempio immagini da usare come sfondo o come icone).
- Versatilità: grazie alla sua interfaccia SPI e alle sue caratteristiche tecniche avanzate, è adatto a una vasta gamma di applicazioni nell’ambito dell’elettronica e dell’informatica embedded.
Limitazioni:
- Complessità della programmazione: potrebbe richiedere una certa familiarità con la programmazione embedded e le librerie grafiche per sfruttare appieno le sue funzionalità.
- Dimensioni limitate dello schermo: le dimensioni del display potrebbero essere limitate per alcune applicazioni che richiedono una visualizzazione più ampia.
In sintesi, il ILI9341 Display LCD TFT SPI 2.8″ con touchscreen resistivo e alloggio per SD card è una scelta versatile per progetti embedded che richiedono una visualizzazione a colori di alta qualità, interazione utente e capacità di memorizzazione esterna. Con le sue caratteristiche avanzate e la compatibilità con una vasta gamma di microcontrollori, è ideale per una varietà di applicazioni nell’ambito dell’elettronica e dell’informatica embedded.
Le librerie grafiche utilizzate: TFT_eSPI e TFT_eWidget
Libreria TFT_eSPI: La libreria TFT_eSPI è una libreria grafica altamente ottimizzata progettata per fornire un’interfaccia semplice e potente per la gestione dei display TFT a colori con microcontrollori basati su architettura ESP8266 e ESP32. Ecco alcune delle caratteristiche principali della libreria TFT_eSPI:
- Compatibilità: supporta una vasta gamma di display TFT con controller compatibili con SPI, tra cui il popolare controller ILI9341 utilizzato nei display TFT da 2.8″.
- Alta velocità: sfrutta le funzionalità hardware dei microcontrollori ESP8266 e ESP32 per ottenere prestazioni elevate e tempi di aggiornamento rapidi dello schermo.
- Risparmio di memoria: è progettata per occupare meno spazio in memoria possibile, consentendo l’utilizzo di altre risorse del microcontrollore per funzionalità aggiuntive.
- Supporto touchscreen: integra funzionalità di gestione del touchscreen resistivo, consentendo l’interazione utente tramite tocchi e pressioni sul display.
- Gestione avanzata del colore: offre un’ampia gamma di funzionalità per la gestione dei colori, inclusa la visualizzazione di immagini a colori, la creazione di grafici e molto altro ancora.
- Libreria di grafica: fornisce una varietà di funzioni e metodi per disegnare forme geometriche, testo e altri elementi grafici sul display TFT.
Libreria TFT_eWidget: La libreria TFT_eWidget è una libreria aggiuntiva progettata per semplificare ulteriormente lo sviluppo di interfacce utente interattive sui display TFT utilizzando la libreria TFT_eSPI. Ecco alcune delle caratteristiche principali della libreria TFT_eWidget:
- Componenti UI predefiniti: fornisce una vasta gamma di componenti di interfaccia utente (UI), come pulsanti, barre di scorrimento, caselle di testo e molto altro ancora, che possono essere facilmente integrati nei progetti.
- Personalizzazione avanzata: consente una personalizzazione completa dei componenti UI, inclusa la modifica del colore, delle dimensioni e dello stile per adattarsi alle esigenze specifiche del progetto.
- Facile integrazione: grazie alla sua interfaccia intuitiva e ai metodi di programmazione semplici, consente un’integrazione rapida e senza problemi dei componenti UI nei progetti esistenti.
- Supporto touchscreen: gestisce automaticamente l’interazione utente tramite il touchscreen resistivo, consentendo l’utilizzo intuitivo dei componenti UI attraverso tocchi e pressioni sul display.
In sintesi, le librerie TFT_eSPI e TFT_eWidget offrono un’esperienza di sviluppo completa e potente per la creazione di interfacce utente interattive su display TFT con microcontrollori ESP8266 e ESP32. Con le loro caratteristiche avanzate e la facilità d’uso, sono ideali per una vasta gamma di applicazioni nell’ambito dell’elettronica embedded e dell’IoT.
Interfaccia SPI
Il display, il touchscreen e il lettore SD card usano ciascuno delle interfacce SPI dedicate. Esso è un protocollo seriale di comunicazione a 4 fili comunemente utilizzato in progetti embedded. Questi quattro fili sono:
- MISO (Master In Slave Out): questo è il pin attraverso il quale il modulo riceve dati dal dispositivo master, che di solito è l’Arduino o un altro microcontrollore.
- MOSI (Master Out Slave In): questo è il pin attraverso il quale il modulo invia dati al dispositivo master.
- SCK (Serial Clock): questo è il pin del clock che sincronizza la trasmissione dei dati tra il modulo e il dispositivo master.
- CS (Chip Select): questo pin viene utilizzato per selezionare il modulo e inizializzare le operazioni di invio/ricezione dei dati.
Di che componenti abbiamo bisogno per il frequenzimetro digitale con ESP32?
La lista dei componenti non è particolarmente lunga:
- una breadboard per connettere la NodeMCU ESP32 agli altri componenti
- alcuni fili DuPont (maschio – maschio, maschio – femmina, femmina – femmina)
- un ILI9341 Display LCD TFT SPI 2.8″
- e, ovviamente, una NodeMCU ESP32 !
Il modello di ESP32 scelto per questo progetto è quello dell’azienda AZ-Delivery.
Realizzazione del progetto
Lo schema elettrico
Prima di realizzare il circuito vero e proprio diamo un’occhiata al pinout della board:
I collegamenti tra il display e il modulo ESP32 seguiranno le indicazioni di questa tabella:
| DISPLAY | ESP32 |
| MISO | GPIO19 |
| LED | 3.3V |
| SCK | GPIO18 |
| MOSI | GPIO23 |
| D/C | GPIO04 |
| RESET | GPIO22 |
| CS | GPIO05 |
| GND | GND |
| VCC | 5V |
In questo progetto non useremo nè il touchscreen nè il modulo SD card incorporato nel display.
Nell’immagine seguente è visibile lo schema elettrico realizzato con Fritzing:
Per chi lo preferisse, di seguito vediamo lo schema elettrico realizzato tramite EasyEda:
Lo sketch
Creiamo il progetto PlatformIO
Abbiamo già visto la procedura di creazione di un progetto PlatformIO nell’articolo Come creare un progetto per NodeMCU ESP8266 con PlatformIO.
Anche se si riferisce alla board ESP8266, la procedura è simile.
Semplicemente, nella scelta della piattaforma, dovrai scegliere la AZ-Delivery ESP-32 Dev Kit C V4.
Non installare nessuna delle librerie indicate nell’articolo.
Ora modifica il file platformio.ini per aggiungere queste due righe:
monitor_speed = 115200
upload_speed = 921600
in modo che il file abbia un aspetto del genere:
[env:az-delivery-devkit-v4]
platform = espressif32
board = az-delivery-devkit-v4
monitor_speed = 115200
upload_speed = 921600
framework = arduino
Le librerie (FreqCountESP, TFT_eSPI e TFT_eWidget) le possiamo installare direttamente modificando il file platformio.ini nel modo seguente:
[env:az-delivery-devkit-v4]
platform = espressif32
board = az-delivery-devkit-v4
framework = arduino
monitor_speed = 115200
upload_speed = 921600
lib_deps = https://github.com/kapraran/FreqCountESP.git
bodmer/TFT_eSPI@^2.5.43
bodmer/TFT_eWidget@^0.0.6
Inoltre dobbiamo sostituire un file nella libreria TFT_eSPI dopo che è stata installata. Si tratta del file User_Setup.h che puoi scaricare dal link qui sotto:
e, una volta scompattato, mettere nella cartella di progetto NOME_DEL_PROGETTO/.pio/libdeps/az-delivery-devkit-v4/TFT_eSPI/ questo file scaricato (dopo magari aver rinominato il vecchio file come User_Setup.h_OLD giusto per conservarlo).
NOTA BENE: il path NOME_DEL_PROGETTO/.pio/libdeps/az-delivery-devkit-v4/TFT_eSPI/ è lo stesso sia per Linux che per Windows.
Per finire bisogna scaricare dal link qui sotto il file Free_Fonts.h e copiarlo nella cartella include del progetto:
Puoi scaricare il progetto dal link seguente:
decomprimerlo, prendere il file main.cpp e sostituirlo al posto di quello che hai nel progetto precedentemente creato.
Vediamo ora come funziona lo sketch.
Inizialmente vengono incluse le librerie necessarie:
#include <Arduino.h>
#include <Arduino.h>
#include "Free_Fonts.h" // Include the header file attached to this sketch
#include <TFT_eSPI.h>
#include <TFT_eWidget.h>
#include <SPI.h>
#include "FreqCountESP.h"
Vengono poi definiti lo schema dei colori dell’indicatore grafico e la frequenza del suo aggiornamento:
// Meter colour schemes
#define RED2RED 0
#define GREEN2GREEN 1
#define BLUE2BLUE 2
#define BLUE2RED 3
#define GREEN2RED 4
#define RED2GREEN 5
#define TFT_GREY 0x2104 // Dark grey 16-bit colour
#define LOOP_PERIOD 100 // Display updates every 100 ms
int colour = TFT_BLUE;
Poi si definisce l’oggetto tft che gestisce il display:
TFT_eSPI tft = TFT_eSPI();
Segue la funzione rainbow che stabilisce i colori dei vari quadranti dell’indicatore circolare mostrato dal display e indicante valori di frequenza più o meno grandi:
// #########################################################################
// Return a 16-bit rainbow colour
// #########################################################################
unsigned int rainbow(byte value)
{
// Value is expected to be in range 0-127
// The value is converted to a spectrum colour from 0 = blue through to 127 = red
byte red = 0; // Red is the top 5 bits of a 16-bit colour value
byte green = 0;// Green is the middle 6 bits
byte blue = 0; // Blue is the bottom 5 bits
byte quadrant = value / 32;
if (quadrant == 0) {
blue = 31;
green = 2 * (value % 32);
red = 0;
}
if (quadrant == 1) {
blue = 31 - (value % 32);
green = 63;
red = 0;
}
if (quadrant == 2) {
blue = 0;
green = 63;
red = value % 32;
}
if (quadrant == 3) {
blue = 0;
green = 63 - 2 * (value % 32);
red = 31;
}
return (red << 11) + (green << 5) + blue;
}
La funzione ringMeter disegna materialmente l’indicatore circolare del valore di frequenza sullo schermo:
// #########################################################################
// Draw the meter on the screen, returns x coord of righthand side
// #########################################################################
int ringMeter(int value, int vmin, int vmax, int x, int y, int r, const char *units, byte scheme, int flag)
{
// Minimum value of r is about 52 before value text intrudes on ring
// drawing the text first is an option
x += r; y += r; // Calculate coords of centre of ring
int w = r / 3; // Width of outer ring is 1/4 of radius
int angle = 180; // Half the sweep angle of meter (300 degrees)
int v = map(value, vmin, vmax, -angle, angle); // Map the value to an angle v
byte seg = 3; // Segments are 3 degrees wide = 100 segments for 300 degrees
byte inc = 6; // Draw segments every 3 degrees, increase to 6 for segmented ring
// Variable to save "value" text colour from scheme and set default
colour = TFT_BLUE;
// Draw colour blocks every inc degrees
for (int i = -angle+inc/2; i < angle-inc/2; i += inc) {
// Calculate pair of coordinates for segment start
float sx = cos((i - 90) * 0.0174532925);
float sy = sin((i - 90) * 0.0174532925);
uint16_t x0 = sx * (r - w) + x;
uint16_t y0 = sy * (r - w) + y;
uint16_t x1 = sx * r + x;
uint16_t y1 = sy * r + y;
// Calculate pair of coordinates for segment end
float sx2 = cos((i + seg - 90) * 0.0174532925);
float sy2 = sin((i + seg - 90) * 0.0174532925);
int x2 = sx2 * (r - w) + x;
int y2 = sy2 * (r - w) + y;
int x3 = sx2 * r + x;
int y3 = sy2 * r + y;
if ((i < v) && (flag == 0)) { // Fill in coloured segments with 2 triangles
switch (scheme) {
case 0: colour = TFT_RED; break; // Fixed colour
case 1: colour = TFT_GREEN; break; // Fixed colour
case 2: colour = TFT_BLUE; break; // Fixed colour
case 3: colour = rainbow(map(i, -angle, angle, 0, 127)); break; // Full spectrum blue to red
case 4: colour = rainbow(map(i, -angle, angle, 70, 127)); break; // Green to red (high temperature etc.)
case 5: colour = rainbow(map(i, -angle, angle, 127, 63)); break; // Red to green (low battery etc.)
default: colour = TFT_BLUE; break; // Fixed colour
}
tft.fillTriangle(x0, y0, x1, y1, x2, y2, colour);
tft.fillTriangle(x1, y1, x2, y2, x3, y3, colour);
//text_colour = colour; // Save the last colour drawn
}
else // Fill in blank segments if flag = 1
{
tft.fillTriangle(x0, y0, x1, y1, x2, y2, TFT_GREY);
tft.fillTriangle(x1, y1, x2, y2, x3, y3, TFT_GREY);
}
}
// Convert value to a string
char buf[10];
byte len = 3; if (value > 999) len = 7;
dtostrf(value, len, 0, buf);
buf[len] = ' '; buf[len+1] = 0; // Add blanking space and terminator, helps to centre text too!
// Set the text colour to default
tft.setTextSize(0);
tft.setTextColor(TFT_WHITE, TFT_BLACK);
// Uncomment next line to set the text colour to the last segment value!
tft.setTextColor(colour, TFT_BLACK);
tft.setTextDatum(MC_DATUM);
// Print value, if the meter is large then use big font 8, othewise use 4
if (r > 84) {
tft.setTextPadding(55*2); // Allow for 3 digits each 55 pixels wide
tft.drawString(buf, x, y, 4); // Value in middle
}
else {
tft.setTextPadding(3 * 14); // Allow for 3 digits each 14 pixels wide
tft.drawString(buf, x, y, 4); // Value in middle
}
tft.setTextSize(0);
tft.setTextPadding(0);
// Print units, if the meter is large then use big font 4, othewise use 2
tft.setTextColor(TFT_WHITE, TFT_BLACK);
// if (r > 84) tft.drawString(units, x, y + 60, 4); // Units display
// else tft.drawString(units, x, y + 15, 2); // Units display
tft.drawString(units, x, y + 25, 4);
// Calculate and return right hand side x coordinate
return x + r;
}
Incontriamo poi la variabile frequency che conserverà il valore misurato di frequenza, la costante inputPin che definisce il GPIO 33 (che useremo come ingresso del segnale), la variabile timerMs che definisce un timer per la libreria FreqCountESP e le costanti minimumFrequency e maximumFrequency che riportano il minimo e il massimo valore di frequenza misurabile che verranno passati alla funzione ringMeter per indicarle gli estremi (in modo che adatti la rappresenzatione grafica dell’indicatore circolare al valore della frequenza misurata):
uint32_t frequency = 0;
static const int inputPin = 33;
int timerMs = 1000;
static const int minimumFrequency = 1; // (HZ)
static const int maximumFrequency = 1000000; // (HZ) (max 1MHz)
Da prove fatte con un generatore di segnale ad onda quadra ho constatato che il frequenzimetro riesce ad arrivare al valore di 1 MHz e oltre pur con un certo scostamento dal valore reale. Quindi al crescere della frequenza oltre certi limiti, il valore misurato perde in accuratezza. Questo valore può variare per eventuali tolleranze dei componenti e anche per la lunghezza dei collegamenti. Quindi potremmo avere prototipi diversi che, a parità di frequenza in ingresso, mostreranno valori di frequenza misurata differenti (con uno scostamento di qualche decina/centinaia di Hz).
Incontriamo poi la funzione setup che inizializza la porta seriale, inizializza il display e ne setta l’orientazione, il colore di sfondo e il font da usare e viene inizializzata la FreqCountESP:
Serial.begin(115200);
delay(2000);
tft.begin();
tft.setRotation(1);
tft.fillScreen(TFT_BLACK);
tft.setFreeFont(FF18);
FreqCountESP.begin(inputPin, timerMs);
Incontriamo poi la funzione loop che inizia con un blocco che si occupa della misurazione della frequenza in ingresso:
if (FreqCountESP.available())
{
frequency = FreqCountESP.read();
Serial.println(frequency);
}
definisce la posizione del grafico:
// Set the the position, gap between meters, and inner radius of the meters
int xpos = 0, ypos = 5, gap = 4, radius = 52;
// Draw a large meter
xpos = 480/2 - 160, ypos = 0, gap = 15, radius = 100;
e, infine, disegna l’analogue meter circolare e stampa, sempre con la stessa funzione, il valore di frequenza misurato:
// Comment out above meters, then uncomment the next line to show large meter
ringMeter(frequency,minimumFrequency,maximumFrequency, xpos,ypos,radius," Hz",BLUE2RED, 0); // Draw analogue meter
Video del funzionamento
Nel video seguente collauderemo il nostro frequenzimetro con un generatore di segnali da laboratorio. Sul generatore viene selezionata l’onda quadra con la sua ampiezza da 3Vpp e un offset di 1.5V in modo da avere un’onda quadra che varia fra 0V (che rappresenta lo 0 logico) e 3V (che rappresenta l’1 logico):
In un precedente articolo, Generatore di onde quadre con ESP32: una soluzione economica per il testing di circuiti, abbiamo realizzato un semplice generatore di onde quadre con l’ESP32 che genera onde quadre di diverse frequenze (fino a 1 kHz nella versione proposta nell’articolo). Possiamo utilizzarlo per collaudare il nostro frequenzimetro collegando i due circuiti in questo modo e portando la variabile maximumFrequency a 1000 per adattare il fondo scala del frequenzimetro alla massima frequenza generata che è (se non è stato modificato lo sketch) pari proprio a 1 kHz.
Il video seguente mostra il funzionamento:
Newsletter
Se vuoi essere aggiornato sui nuovi articoli, iscriviti alla newsletter. Prima dell’iscrizione alla newsletter leggi la pagina Privacy Policy (UE)
Se ti vuoi disiscrivere dalla newsletter clicca sul link che troverai nella mail della newsletter.