E’ composta da un elettrodo di vetro sensibile al pH e un elettro di riferimento. Il primo contiene un vetro speciale che reagisce con gli ioni idrogeno presenti nella soluzione.

Quando l’elettrodo di vetro viene immerso nella soluzione, si crea una differenza di potenziale elettrico in base al pH della soluzione. L’elettrodo di riferimento fornisce un punto di riferimento stabile per la misurazione del pH.

Solitamente, viene utilizzato un elettrodo di riferimento a gel o a soluzione salina.

La sonda per pH è in grado di rilevare la differenza di potenziale elettrico tra l’elettrodo di vetro e l’elettrodo di riferimento. Questo potenziale viene convertito in un valore di pH tramite un circuito elettronico.

Prima dell’uso, è necessario calibrare lo strumento utilizzando soluzioni di pH noto (solitamente pH 4 e pH 7) per garantire accuratezza nelle misurazioni.

Particolare attenzione deve essere posta per la cura dell’elettrodo in vetro che deve essere conservato in una soluzione specifica e periodicamente pulito per rimuovere depositi che potrebbero influenzare le misurazioni.

La sonda non può essere collegata direttamente alla nostra scheda Arduino UNO R4, ma il segnale deve essere elevato e reso leggibile dal microcontrollore tramite una scheda di condizionamento del segnale (Fig. 3).

Fig. 3 La scheda che permette ad Arduino UNO R4 di interfacciarsi alla sonda per pH.

La sonda pH viene collegata al modulo di condizionamento attraverso un connettore BNC, che assicura una connessione stabile e affidabile.

Il modulo è dotato di un’uscita di tensione proporzionale al livello di pH misurato. Questo pin può essere collegato all’ingresso analogico di una scheda, come, nel nostro caso, Arduino UNO. Per il corretto funzionamento il modulo deve essere alimentato con una tensione di 5 Vdc e dato il basso consumo (tra i 5 e 10 mA) possiamo alimentarlo direttamente dal pin 5V della nostra UNO R4.

Per il corretto funzionamento è necessario attendere almeno 60 secondi per avere delle letture accurate.

Arduino UNO R4 Minima

La quarta versione dell’Arduino UNO, l’Arduino UNO R4 Minima, rappresenta un importante passo avanti nel campo del fai-da-te e dell’elettronica (Fig. 4).

Fig. 4 La board Arduino UNO R4 Minima.

Questa nuova versione monta un processore Arm Cortex-M4 a 32 bit, che garantisce una maggiore potenza di calcolo, e una quantità di memoria 16 volte superiore rispetto alle versioni precedenti.

Nonostante questi miglioramenti, le dimensioni e la compatibilità dei pin con i 5V rimangono invariate.

Ciò garantisce una transizione senza soluzione di continuità per gli shield e i progetti esistenti, sfruttando l’ecosistema esteso e unico già creato per l’Arduino UNO (Fig. 5).

Fig. 5 La pinout del nuovo Arduino è identica a quella della versione precedente.

La nuova versione offre anche un clock più veloce, consentendo di eseguire calcoli più precisi e gestire progetti complessi e sofisticati. Inoltre, è dotata di un connettore USB-C, che rappresenta uno standard più piccolo, potente e resistente rispetto ai connettori precedenti.

Per utilizzare la scheda Arduino UNO R4 Minima, è necessario installare il pacchetto della scheda UNO R4 Minima, che fa parte del core di Arduino per i dispositivi Renesas.

Per installarlo, sarà necessario disporre di una versione dell’IDE di Arduino, che è possibile scaricare dalla pagina del software di Arduino (https://docs.arduino.cc/software/ide-v2).
In questo articolo utilizzeremo l’ultima versione dell’IDE 2 (Fig. 6).

Fig.6 L’ultima versione dell’IDE disponibile è la 2.1.0.

Per installare il pacchetto della scheda, aprire il “Gestore Schede” dal menu a sinistra, cercare UNO R4 Minima e installare l’ultima versione (o la versione desiderata) (Fig. 7).

Fig. 7 Il pacchetto Arduino UNO R4 Boards da installare.

A questo punto collegando la board al computer verrà creata una porta seriale virtuale che potrete utilizzare per la programmazione dell’Arduino.

Il collegamento del micuratore di PH con Arduino R4

In questo progetto abbiamo utilizzato diversi componenti per creare un sistema di rilevazione del pH. Il componente principale, ovvero la sonda in grado di rilevare il pH, è stato collegato al suo circuito di condizionamento tramite connettore BNC. Come già accennato il circuito di condizionamento prende l’alimentazione direttamente dai pin 5V e GND della scheda Arduino UNO R4.

Il pin P0 del modulo di rilevazione pH è stato collegato al pin analogico A0 della scheda Arduino. Questa connessione consentirà alla main board di leggere i valori di pH rilevati dal sensore.

Il display OLED utilizzato prevede una connessione I2C che permette, con soli due fili, oltre all’alimentazione, di controllare il display.

I pin SDA e SCL del display sono stati quindi collegati ai pin SDA e SCL della scheda Arduino UNO R4, mentre l’alimentazione è stata presa dai pin 3,3V e GND.

Questa configurazione ci permetterà di rilevare il pH utilizzando la sonda e visualizzare i risultati sul display OLED. È importante seguire attentamente le istruzioni e i collegamenti riportati nello schema di cablaggio per garantire un corretto funzionamento del sistema.

schema di CABLAGGIO

Il firmware

Il codice scritto per Arduino UNO R4 permette di leggere i valori del sensore di pH e visualizzarli sul display OLED.

Vediamo il codice nel dettaglio.

Le prime righe di codice includono le librerie necessarie per il funzionamento del programma, in particolare viene inclusa la libreria Wire per l’I2C e le librerie di Adafruit Adafruit_GFX e Adafruit_SSD1306 per la gestione del display OLED.

Successivamente, sono definite alcune costanti e variabili utilizzate nel programma (Listato 1).

Listato 1

#define SensorPin 0 // il pin analogico di output del sensore di pH è collegato all’ingresso analogico 0 dell’Arduino
unsigned long int avgValue; // memorizza il valore medio dei feedback del sensore
float b;
int buf[10],temp;

#define SCREEN_WIDTH 128 // larghezza dello schermo OLED in pixel
#define SCREEN_HEIGHT 64 // altezza dello schermo OLED in pixel
#define OLED_RESET -1 // pin di reset (o -1 se la gestione del reset è condivisa)
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

La funzione setup() viene eseguita all’avvio e svolge un ruolo cruciale nell’inizializzazione del programma (Listato 2).

Listato 2

void setup() {
  pinMode(13, OUTPUT);
  Serial.begin(9600);
  Serial.println(“Ready”);

  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println(F(“SSD1306 allocation failed”));
    for (;;);
  }
  display.display();
  delay(2);
  display.clearDisplay();

  display.clearDisplay();
  display.setTextColor(WHITE);
  display.setTextSize(2);
  display.setCursor(10, 5);
  display.print(“PH Sensor”);
  display.display();
  delay(3000);
}

Prima di tutto, viene impostato il pin digitale 13 come output per controllare un LED. Successivamente, viene inizializzata la comunicazione seriale attraverso il monitor seriale a una velocità di trasmissione di 9600 baud.

Successivamente, il programma verifica se è possibile allocare correttamente la memoria per il display OLED SSD1306. Se la memoria non può essere allocata, viene visualizzato un messaggio di errore e il programma si interrompe.

Se invece il display può essere inizializzato correttamente, vengono eseguite una serie di comandi per configurarlo.

Viene effettuata una breve pausa, quindi il display viene cancellato e viene impostata la dimensione del testo su 2 e il cursore viene posizionato alla coordinate (10,5) del display.

Successivamente, viene visualizzato il testo “PH Sensor” chiamando la funzione display.display(). Viene inserita una pausa di 3 secondi per consentire all’utente di leggere il messaggio sul display prima che il programma passi alla funzione loop().

La funzione loop() è il cuore del programma Arduino e viene eseguita continuamente dopo la fase di setup (Listato 3).

Listato 3

void loop() {
    for (int i = 0; i & lt; 10; i++) //Ottenere 10 valori campione dal sensore per ottenere una misura più precisa
    {
      buf[i] = analogRead(SensorPin);
      delay(10);
    }
    for (int i = 0; i & lt; 9; i++) //Ordinare i valori analogici dal più piccolo al più grande
    {
      for (int j = i + 1; j & lt; 10; j++) {
        if (buf[i] & gt; buf[j]) {
          temp = buf[i];
          buf[i] = buf[j];
          buf[j] = temp;
        }
      }
    }
    avgValue = 0;
    for (int i = 2; i & lt; 8; i++) //take the average value of 6 center sample
      avgValue += buf[i];
    float phValue = (float) avgValue * 5.0 / 1024 / 6; //convert the analog into millivolt
    phValue = 3.5 * phValue; //convert the millivolt into pH value
    Serial.print(“pH: ”);
    Serial.print(phValue, 2);
    Serial.println(““);
    display.clearDisplay();
    display.setTextSize(2);
    display.setCursor(20, 5);
    display.println(“Ph Value”);
    display.setTextSize(3);
    display.setCursor(30, 35);
    display.print(phValue);
    display.display();
    digitalWrite(13, HIGH);
    delay(800);
    digitalWrite(13, LOW);

All’interno del loop, vengono acquisiti 10 valori campione dal sensore di pH tramite il pin analogico 0. Questi valori vengono successivamente ordinati in ordine crescente per poter calcolare il valore medio dei 6 campioni centrali al fine di ridurre il rumore.

Questo valore viene quindi convertito in millivolt e successivamente questi vengono trasformati nel valore di pH corrispondente.

Il valore di pH viene quindi stampato sul monitor seriale con due cifre decimali di precisione e visualizzato sul display OLED.

Infine, viene accesa e spenta una luce collegata al pin digitale 13 per fornire un feedback visivo. Il programma poi si mette in pausa per 800 millisecondi prima di iniziare un nuovo ciclo di loop, eseguendo le stesse operazioni di acquisizione e calcolo dei valori di pH. Questo ciclo si ripete indefinitamente finché l’Arduino rimane alimentato.