Orto idroponico verticale con Arduino – seconda parte

Nell’introduzione pre-pasquale dell’Orto idroponico verticale con Arduino ho accennato all’uso di alcuni sensori che ti permettono di monitorare le condizioni climatiche dell’ambiente e le proprietà dell’acqua di irrigazione.

in questo articolo riprendo con l’analisi del primo dei sensori che abbiamo utilizzato: il sensore EC.

Il primo passo che ho fatto quando ho sentito parlare di questo sensore è stato ricercare su wikipedia cosa fosse un sensore EC e cosa potesse misurare, ho trovato:

An electrical conductivity meter (EC meter) measures the electrical conductivity in a solution. It is commonly used in hydroponics, aquaculture and freshwater systems to monitor the amount of nutrients, salts or impurities in the water.

Compreso, almeno a grandi linee, quale fosse lo scopo del sensore e la sua utilità nell’Orto idroponico verticale con Arduino ho iniziato a pensare come realizzarne uno o dove acquistarne uno già pronto.

Nella ricerca di informazioni e di chiarimenti ho scoperto che tra i frequentatori di WeMake ed al progetto dell’orto c’e Paolo Bonelli un appassionato arduino e conoscitore di chimica Ph, EC, ecc.. autore di un progetto “Acid Carousel” per il monitoraggio accurato delle acque, interamente realizzato con arduino e tagliato a laser.

Tornando al sensore EC ho chiesto a Paolo dei consigli ed ho ottenuto le risposte ed il sensore finito .. in pieno stile maker e con grande spirito di condivisione.

Cosa occorre per realizzare il tuo sensore EC laser cut

Paolo ha realizzato il sensore utilizzando:

• n.1 resistenza da 470 ohm;
• n.1 basetta di plexyglass tagliata ed incisa a laser;
• n.2 viti di acciaio inossidabile;
• n.2 bulloni di acciaio inossidabile;
• n.1 cavo trifilare;
• n.1 bacchetta di colla a caldo per sigillare il retro del sensore;

Il sensore EC per l’orto idroponico verticale con arduino

Per la realizzazione del sensore EC, Paolo, ha disegnato e tagliato a laser le basette necessarie, puoi scaricare qui i due file condivisi da Paolo:

• conducibilimetro dxf
• conducibilimetro svg

spiegandomi che la distanza tra i due bulloni influenza il comportamento del sensore come i materiali impiegati ed il tipo di vite, tolleranza della resistenza e cavi utilizzati.

Per scongiurare almeno il primo fattore ha preferito affidare al taglio laser la basetta in modo da essere certo che tra due sensori la distanza tra le viti sia sempre uguale.

Con l’uso della funzione engrave del laser ha anche realizzato degli incavi nelle basette in cui alloggiare i cavi di connessione e la resistenza:

poi ha assemblato il tutto:

sigillando con la colla a caldo il retro del sensore per renderlo isolato e lasciare che solo la parte esposta delle viti sia in contatto con il liquido da misurare:

Un po di teoria prima dei test

Paolo ha dedicato alcune ore non solo alla costruzione dei sensori per l’orto idroponico verticale ma sopratutto alla taratura del sensore ed a spiegare il principio di funzionamento e le formule che poi ha applicato allo sketch:

E’ questo che accade quando si incontrano appassionati con grandi conoscenze e voglia di condividerle con chi è disposto ad accrescere le proprie conoscenze.

Lo sketch di test

Paolo ha realizzato uno sketch di test per due sensori, i due che avremmo utilizzato nell’Orto Idroponico e me lo ha dato perché potessi adattarlo all’orto.

Iniziamo dallo sketch di Paolo, l’originale:

/*   Conduttimetro
Collegamenti hardware
sensore    rosso              blu                bianco
           P1 ------O  O------P2-----RRRRR-------P3        Lato sensore
   0       D2    elettrodi    A0    470 ohm      D3        Lato Arduino
   1       D8    elettrodi    A1    470 ohm      D9        Lato Arduino
*/ 
byte nsens = 2;
byte P1[] = {51,50};
byte P2[] = {A15,A14};
byte P3[] = {53,52};
// parametri di taratura in uS/cm
float A[] = {870.43,822.71};
float B[] = {-1.194,-1.190};
//  resistenza fissa tra P1 e P3
float R1 = 470.;  // ohm
//  inizializzo resistenza tra i due elettrodi
float RS[] = {0,0};
//  inizializzo conducibilità specifica
float CS[] = {0,0};
//  variabili di lavoro
byte isens = 0;
byte n = 50;

#define ECHO;

void setup () {  
    Serial.begin(9600);
    delay(100);
    //  setta come output le  porte digitali
    for(byte isens = 0; isens < nsens ; isens++){
      pinMode(P1[isens],OUTPUT);
      pinMode(P3[isens],OUTPUT);
    }
}

//////////////////////////////////////////////////////////
void loop () {
  
  Serial.print( "Loop sensore 1: " );
  Serial.println( readEC( 0 ) );
  Serial.print( "Loop sensore 2: " );
  Serial.println( readEC( 1 ) );
 
  delay( 100 );
}

//////////////////////////////////////////////////////////
float readEC( byte isens ) {
  
  float RS1 = 0.;
  float RS2 = 0.;
  float VCC = 5000.;
  float Vconv = VCC/1024.;
  float V1 = 0.;
  float V2 = 0.;
  float VSG = 0.;
  
  float runningAvg1 = 0.;
  float runningAvg2 = 0.;
  float runningAvg3 = 0.;
  
  //  ciclo di misura su un sensore
  for(byte i = 0; i < n; i++) {
    digitalWrite(P1[isens],HIGH);
    digitalWrite(P3[isens],LOW);
    runningAvg1 = runningAvg1 + Vconv*analogRead(P2[isens]);         
    digitalWrite(P1[isens],LOW);
    runningAvg2 = runningAvg2 + Vconv*analogRead(P2[isens]);         
    digitalWrite(P3[isens],HIGH);
    runningAvg3 = runningAvg3 + Vconv*analogRead(P2[isens]);         
  }
  VSG = runningAvg2/n;
  V1  = runningAvg1/n;      
  V2  = runningAvg3/n;      
  //  compute RH and VS
  if(V1 < 2.){
    RS[isens] = 60000.;
    CS[isens] = 0.;
  } else {
    //  correggo con la galvanica
    V1 = V1-VSG;
    V2 = V2-VSG;
    //  primo calcolo di RS
    RS1 = R1*(VCC-V1)/V1; 
    //  secondo calcolo di RS e media tra i due (RS in kohm)
    RS2 = R1*V2/(VCC-V2);
    RS[isens] = (RS1 + RS2)/2000.;
    //  calcolo CS secondo i parametri di taratura
    if( RS[isens] < 0.5) { CS[isens] = 1300; } 
    else{ CS[isens] = A[isens]*pow(RS[isens],B[isens]); }          
  }
    
  #ifdef DEBUG
      Serial.print(" sensore # ");
      Serial.print(isens);
      Serial.print("  Galvanica: ");
      Serial.print(VSG,2);
      Serial.print("  V1 = ");
      Serial.print(V1,0);
      Serial.print(" V2 = ");
      Serial.print(V2,0);
      Serial.print("  RS1 = ");
      Serial.print(RS1,0);
      Serial.print("  RS2 = ");
      Serial.print(RS2,0);
      Serial.print("  RS = ");
      Serial.print(RS[isens],3);
      Serial.print("  CS = ");
      Serial.print(CS[isens],0);
      Serial.println();
  #endif  
  
  return CS[isens];
}

le righe di commento 001-007 contengono delle informazioni importanti in merito alla connessione di ciascun sensore ad arduino. Nota che nessun pin è connesso a +5v o Gnd ma ogni pin estremo è connesso ad un pin digitale ed i pin di misura sono connessi a pin analogici, il motivo è che nessun terminale del sensore deve sempre essere connesso all’alimentazione positiva o negativa del circuito ma dovrai alternare l’alimentazione positiva e negativa sugli elettrodi per evitare gli errori dovuti alla corrente galvanica ( approfondimento );

linee 008-011: definisci delle variabili di tipo byte in cui specifichi il numero di sensori ( nel nostro caso 2 ) e i pin a cui sono connessi i rispettivi P1,P2 e P3 ( ricorda che per il progetto Orto Idroponico Verticale abbiamo utilizzato un Arduino Mega sia per necessità di più ingressi sia per la sua maggiore memoria );

linee 013-014: imposta due parametri di taratura per ciascun sensore: parametro A e B che ti serviranno poi per il corretto calcolo di EC rilevato dal sensore, per la taratura Paolo ha utilizzato diversi tipi di acque di cui erano note le caratteristiche EC eseguite in laboratorio;

linea 016: definisci il valore della resistenza che hai utilizzato sui sensori, nel nostro caso sono entrambe da 470ohm;

linea 018: inizializza il valore di resistenza dei due elettrodi a 0;

linea 020: inizializza il valore di conducibilità specifica di ciascun sensore a 0;

linee 022-023: imposta il contatore isens a 0 con cui partirai nei cicli for su tutti i sensori e la variabile n con cui definisci il numero di misurazioni da eseguire;

linee 027-035: la funzione setup() non è complessa e oramai, se hai seguito i miei appunti su corso base sai anche cosa accade senza necessità che te lo rispieghi;

linee 038-046: anche le linee della loop() sono molto chiare e semplici per cui evito di ripetere sempre le medesime informazioni, le uniche linee su cui puoi soffermarti sono la linea 041 e la linea 043 che richiamanlo la funzione readEC() ciascuna passando l’indice del sensore che desideri sia interrogato e del quale ti interessa il valore misurato;

linee 051-061: sei già all’interno della funzione readEC il cui compito è eseguire la misurazione e restituire alla loop() il valore EC misurato dal sensore richiesto. In queste linee definisci alcune delle variabili di tipo float che ti serviranno per calcolare il valore EC da restituire;

linea 064: imposta un ciclo for che eseguirà una sequenza di operazioni, descritte nelle linee sotto, da 0 ad n dove n è il numero di campionamenti che ti interessa e che hai definito alla linea 023;

linee 065-066: imposta ad HIGH il P1 ed a LOW il P3;

linea 067: misura e calcola il valore runningAvg1 come somma del suo precedente valore misurato nel ciclo for e del prodotto tra Vconv ed il valore letto sul pin analogico P2 relativo al sensore di cui ti interessa la misura;

linea 068: imposta a LOW il valore del pin relativo al contatto P1;

linea 069: misura e calcola il valore runningAvg2 similmente a come hai già fatto per runningAvg1 in quanto in questa condizione la polarizzazione di P1 è LOW come quella di P3;

linea 070: imposta ad HIGH P3;

linea 071: misura e calcola il valore runningAvg3 similmente a come hai già fatto per runningAvg1 in quanto in questa condizione la polarizzazione di P1 è LOW e quella di P3 è HIGH;

linee 073-075: calcola il valore reale di VSG,V1 e V2 dividendo i rispettivi runningAvg per il numero di campionamenti;

linee 077-080: se il valore di V1 è inferiore a 2.0 imposta sia RS sia CS ai rispettivi valori indicati, RS = 60000 e CS = 0;

linee 082-083: se il valore di V1 è maggiore di 2 correggi la misura influenzata dalla corrente galvanica sottraendo sia da V1 sia da V2 il valore VSG;

linea 085: calcola il valore di RS1 come il prodotto della resistenza per il rapporto tra la differenza di potenziale VCC-V1 e V1 stesso;

linea 087: esegui un calcolo simile per RS2 invertendo la posizione di V2 nel rapporto;

linea 088: esegui la media tra RS1 ed RS2 riassegnando il valore alla variabile RS;

linea 090: se il valore di RS è inferiore 0.5 allora il valore di CS è il massimo misurabile ossia 1300 Siemens ( 1.3 microSiemens )

linea 091: con un valre di RS maggiore di 0.5 applichi la formula:

CS[isens] = A[isens]*pow(RS[isens],B[isens]);

ossia CS è uguale al prodotto del valore di taratura A, relativo al sensore di cui ti interessa la misura, per RS elevato alla potenza del suo corrispettivo B. La funzione pow restituisce il valore del primo parametro elevato alla potenza del secondo;

linee 094-112: invia al monitor seriale il risultato dei valori letti e dei calcoli eseguiti per poter fare un debug dei parametri prima di inserire lo sketch in quello dell’Orto idroponico verticale con arduino;

linea 114: restituisci alla funzione loop() il solo risultato relativo al valore di CS richiesto.

Ora sei pronto per eseguire il test dei tuoi sensori EC autocostruiti e passare al test.

Buon orto idroponico verticale.