Sensore TDS

Buongiorno a tutti, sono un principiante autodidatta di arduino, e sto cercando di realizzare un piccolo progetto di idroponica, e mi trovo a programmare la sonda tds, mi sono ispirato a questa fonte qui Gravity__Analog_TDS_Sensor___Meter_For_Arduino_SKU__SEN0244-DFRobot

per cercare di capirci qualcosa in più l’ho italianizzato, ma nonostante ciò tanti punti ancora mi rimangono oscuri :slight_smile: ed eccovi un riassunto di tutto quello che non riesco a capire di queste righe, spero che riusciate ad aiutarmi

#define VREF 5.0

“I convertitori analogico-digitali (ADC) richiedono un ingresso di tensione di riferimento (V REF ) per funzionare correttamente. Gli ADC convertono gli ingressi analogici che possono variare da zero volt fino a un livello di tensione massimo chiamato tensione di riferimento. La tensione di riferimento determina il limite massimo di ciò che l'ADC può convertire ed è essenzialmente il parametro rispetto al quale viene misurata ogni proporzione e risultato. Pertanto, nella scelta di una tensione di riferimento (V REF ) il livello di uscita della tensione e la precisione iniziale sono la prima preoccupazione.”

Se ho capito bene ogni qual volta che a Arduino si collega un sensore analogico bisogna indicare la tensione massima di riferimento, in questo caso 5V, quindi ogni volta che inserirò la sonda nell’acqua ad Arduino arriverà un’onda tonda che varia da 0 a 5 v il quale lui la trasformerà in una onda quadra sempre nel solito range.

Adesso le domande

Qual è la tensione massima che posso dichiarare?

può capitare di avere due convertitori che abbiano due tensioni di riferimento differenti?

E in questo caso come ci comportiamo?

int Array_ValoreAnalogico[SCOUNT];    // memorizzare il valore analogico nell'array, letto da ADC
int Array_ValoreAnalogico_Temp[SCOUNT];

In queste righe dichiariamo due array, una che si chiama Array_ValoreAnalogico e l’altra Array_ValoreAnalogico_Temp, e tra le parentesi quadre è indicato la grandezza di queste array, e in questo caso è indicata dalla variabile SCOUNT.

Però ho provato leggendo e rileggendo il codice a capire quanto vale la variabile SCOUNT, ma non ci sono riuscito, potete aiutarmi a capire anche questo?

int posizione_array = 0,copyIndex = 0;
float averageVoltage = 0,tdsValue = 0,temperature = 25;

in queste righe dichiariamo una serie di variabili con il valore di 0 tranne temperature che vale 25

    Serial.begin(115200);

Leggendo e guardando tutorial ho capito che con Serial.begin si dichiara la velocità con cui Arduino dovrà trasmettere dati, ma quasi sempre ho trovato indicato 9600 mentre questa volta si trova una velocità molto più alta, come mai?

Altra domanda, visto il codice d’esempio da cui sono partito che scrive i dati sulla seriale, mentre io li scrivo sul display, questa riga la potrei omettere?

static unsigned long punto_di_campionamento = millis();

In questa riga dichiariamo una variabile dal nome punto_di_campionamento, e gli assegnamo il valore di millis, che è il tempo trascorso dall’accensione di Arduino

Con static si indica una variabile che viene usata in tutta la funzione

mentre con unsigned si indica che la variabile può indicare solo numeri positivi

[color=#859900]  if(millis()-punto_di_campionamento > 40U)     //ogni 40 millisecondi, leggere il valore analogico dall'ADC[/color]
[color=#859900]   {[/color]
[color=#859900]     punto_di_campionamento = millis();[/color]
[color=#859900]     Array_ValoreAnalogico[posizione_array] = analogRead(Sensore_TDS);    //leggere il valore analogico e memorizzarlo nel buffer[/color]
[color=#859900]     posizione_array++;[/color]
[color=#859900]     if(posizione_array == SCOUNT) [/color]
[color=#859900]         posizione_array = 0;[/color]
[color=#859900]   }[/color]

Con questo if creo una condizione dove ogni 40 millisecondi memorizzo un dato dal sensore tds, ogni volta che questa condizione è vera, memorizzo il valore nella array Array_ValoreAnalogico, nella posizione indicata dalla variabile posizione_array, che di conseguenza la stessa variabile viene aumentata di uno. Quando posizione_array equivale al valore di SCOUNT posizione_array torna a 0

Su queste righe le domande sono

Cosa indica quella U dopo 40

static unsigned long punto_temporale = millis();
if(millis()-punto_temporale > 800U)//ogni 800 millisecondi
   {
      punto_temporale = millis();
      for(copyIndex=0;copyIndex<SCOUNT;copyIndex++)
        Array_ValoreAnalogico_Temp[copyIndex]= Array_ValoreAnalogico[copyIndex];
      averageVoltage = getMedianNum(Array_ValoreAnalogico_Temp,SCOUNT) * (float)VREF / 1024.0; // leggere il valore analogico più stabile dall'algoritmo di filtraggio mediano e convertirlo in valore di tensione
      float compensationCoefficient=1.0+0.02*(temperature-25.0);    //formula di compensazione della temperatura: fFinalResult (25 ^ C) = fFinalResult (corrente) / (1.0 + 0.02 * (fTP-25.0));
      float compensationVolatge=averageVoltage/compensationCoefficient;  //temperature compensation
      tdsValue=(133.42*compensationVolatge*compensationVolatge*compensationVolatge - 255.86*compensationVolatge*compensationVolatge + 857.39*compensationVolatge)*0.5; //convert voltage value to tds value
      lcd.home();
      lcd.print("TDS Value= ");
      lcd.print(tdsValue,0);
      lcd.println("ppm");
   }
}

A questo punto del codice vado un po’ più a intuito, ho capito che tramite un’altra condizione che avviene ogni 800 millisecondi attiviamo un ciclo in cui viene inserito altri dati in alcune array, e vengono fatti una serie di calcoli dove il risultato finale è il tdsvalue (vi giuro sono andato a cercare su internet ma non c’ho capito molto di più) e lo stampo sul display

Adesso veniamo alla parte per me più incomprensibile

int getMedianNum(int bArray[], int iFilterLen) 
{
      int bTab[iFilterLen];
      for (byte i = 0; i<iFilterLen; i++)
      bTab[i] = bArray[i];
      int i, j, bTemp;
      for (j = 0; j < iFilterLen - 1; j++) 
      {
      for (i = 0; i < iFilterLen - j - 1; i++) 
          {
        if (bTab[i] > bTab[i + 1]) 
            {
        bTemp = bTab[i];
            bTab[i] = bTab[i + 1];
        bTab[i + 1] = bTemp;
         }
      }
      }
      if ((iFilterLen & 1) > 0)
    bTemp = bTab[(iFilterLen - 1) / 2];
      else
    bTemp = (bTab[iFilterLen / 2] + bTab[iFilterLen / 2 - 1]) / 2;
      return bTemp;
   
}

Alla fine di tutto il codice, addirittura dopo il loop mi trovo tutta queste serie di calcoli, mi sapete dire che funzione abbiano?

In passato mi è capitato di scrivere qualcosa dopo il loop, ma andava dichiarata un nuovo void, in questo caso non è stato fatto niente di tutto ciò ... come mai?

Vi sono molto grato se mi aiutate a capire tutta questa roba, sia per la realizzazione del mio progetto sia per la mia crescita nel mondo di Arduino, vi ringrazio ancora tantissimo

Ciao Piperino,
ti premetto che sono anch'io un autodidatta e che non me ne intendo tantissimo ma a questa domanda mi sento abbastanza sicuro di risponderti:

"I convertitori analogico-digitali (ADC) richiedono un ingresso di tensione di riferimento (V REF ) per funzionare correttamente. .......[/quote]
allora, arduino di solito basa il suo riferimento di conversione sui 5V, tensione di funzionamento e tensione massima che può supportare; se vuoi modificare la tensione di rifermento puoi fare in due modi: il primo è utilizzare una tensione di riferimento esterna, generata per esempio da un potenziometro, tramite pin Aref; oppure utilizzare le tensioni di rifermento che ti predispone arduino.
Detto questo devi utilizzare il comando analogRefernce, che va messo nel setup se non erro, la cui sintassi è
* *analogReference(type);* *
e al posto di type inserisci DEFAULT, INTENAL (no Arduino Mega), INTERNAL1V1 (solo Arduino Mega), INTERNAL2V56 (solo Arduino Mega), EXTERNAL. In cui default è la tensione di 5V (o 3.3 per le schede a 3.3V), internal in cui imposta la tensione a 1,1V, e internal1v1 e inetrnal2v56 rispettivamente a 1,1 e 2,56 V ma solo in Arduino Mega, e infine external che come detto prima utilizzi una tensione di riferimento esterna. Puoi chiarire meglio questo comando andando su l'IDE di Arduino > Aiuto > Guida di Riferimento.
Perciò qui dipende che scheda Arduino utilizzi: siccome la sonda del tuo progetto ha un uscita analogica fino a 2.3V se utilizzassi un Arduino mega ti consiglio di impostare la tensione su 2.56v ma nel caso di un UNO puoi utilizzare la tensione esterna.
rispondendo alla seconda domanda: se si possono avere due tensioni di riferimento diversi la risposta é sì ma solo se almeno una di queste è rispetto una tensione "interna" (5 o 1.1V, in arduino uno) poichè il pin aref è uno solo.
nel codice dovrai fare una cosa del genere:
* *void loop() { analogReference(INTERNAL); analogRead(A1); analogReference(DEFAULT); analogRead(A2); }* *

Ciao.
Per la U leggi qui

In pratica sta per unsigned.

Invece questa
int getMedianNum(int bArray[], int iFilterLen)
È la dichiarazione di una funzione che accetta 2 parametri e restituisce un int.
L'ho guardata un po' di corsa, ma mi pare faccia un ordinamento degli elementi dell'array e poi calcola una media di alcuni valori.
Quando vedi scritto void significa che quella funzione non restituisce nessun valore.

>enrico03: Quando si quota un post, NON è necessario riportarlo (inutilmente) tutto; bastano poche righe per far capire di cosa si parla ed a cosa ci si riferisce, inoltre, se si risponde al post immediatamente precedente, normalmente NON è necessario alcun "quote" dato che è sottinteso. :slight_smile:

Gli utenti da device "mobile" (piccoli schermi) ringrazieranno per la cortesia :wink:

Guglielmo

P.S.: Ho troncato io il "quote" del tuo post sopra :wink:

/***************************************************
 DFRobot Gravity: Analog TDS Sensor / Meter For Arduino
 <https://www.dfrobot.com/wiki/index.php/Gravity:_Analog_TDS_Sensor_/_Meter_For_Arduino_SKU:_SEN0244>

 Created 2017-8-22
 By Jason <jason.ling@dfrobot.com@dfrobot.com>

 GNU Lesser General Public License.
 See <http://www.gnu.org/licenses/> for details.
 All above must be included in any redistribution

 /***********Notice and Trouble shooting***************
 1. This code is tested on Arduino Uno and Leonardo with Arduino IDE 1.0.5 r2 and 1.8.2.
 2. More details, please click this link: <https://www.dfrobot.com/wiki/index.php/Gravity:_Analog_TDS_Sensor_/_Meter_For_Arduino_SKU:_SEN0244>
 ****************************************************/

#define TdsSensorPin A1
#define VREF 5.0      // analog reference voltage(Volt) of the ADC
#define SCOUNT  30           // sum of sample point
int analogBuffer[SCOUNT];    // store the analog value in the array, read from ADC
int analogBufferTemp[SCOUNT];
int analogBufferIndex = 0,copyIndex = 0;
float averageVoltage = 0,tdsValue = 0,temperature = 25;

void setup()
{
    Serial.begin(115200);
    pinMode(TdsSensorPin,INPUT);
}

void loop()
{
   static unsigned long analogSampleTimepoint = millis();
   if(millis()-analogSampleTimepoint > 40U)     //every 40 milliseconds,read the analog value from the ADC
   {
     analogSampleTimepoint = millis();
     analogBuffer[analogBufferIndex] = analogRead(TdsSensorPin);    //read the analog value and store into the buffer
     analogBufferIndex++;
     if(analogBufferIndex == SCOUNT) 
         analogBufferIndex = 0;
   }   
   static unsigned long printTimepoint = millis();
   if(millis()-printTimepoint > 800U)
   {
      printTimepoint = millis();
      for(copyIndex=0;copyIndex<SCOUNT;copyIndex++)
        analogBufferTemp[copyIndex]= analogBuffer[copyIndex];
      averageVoltage = getMedianNum(analogBufferTemp,SCOUNT) * (float)VREF / 1024.0; // read the analog value more stable by the median filtering algorithm, and convert to voltage value
      float compensationCoefficient=1.0+0.02*(temperature-25.0);    //temperature compensation formula: fFinalResult(25^C) = fFinalResult(current)/(1.0+0.02*(fTP-25.0));
      float compensationVolatge=averageVoltage/compensationCoefficient;  //temperature compensation
      tdsValue=(133.42*compensationVolatge*compensationVolatge*compensationVolatge - 255.86*compensationVolatge*compensationVolatge + 857.39*compensationVolatge)*0.5; //convert voltage value to tds value
      //Serial.print("voltage:");
      //Serial.print(averageVoltage,2);
      //Serial.print("V   ");
      Serial.print("TDS Value:");
      Serial.print(tdsValue,0);
      Serial.println("ppm");
   }
}
int getMedianNum(int bArray[], int iFilterLen) 
{
      int bTab[iFilterLen];
      for (byte i = 0; i<iFilterLen; i++)
      bTab[i] = bArray[i];
      int i, j, bTemp;
      for (j = 0; j < iFilterLen - 1; j++) 
      {
      for (i = 0; i < iFilterLen - j - 1; i++) 
          {
        if (bTab[i] > bTab[i + 1]) 
            {
        bTemp = bTab[i];
            bTab[i] = bTab[i + 1];
        bTab[i + 1] = bTemp;
         }
      }
      }
      if ((iFilterLen & 1) > 0)
    bTemp = bTab[(iFilterLen - 1) / 2];
      else
    bTemp = (bTab[iFilterLen / 2] + bTab[iFilterLen / 2 - 1]) / 2;
      return bTemp;
}

Ho riportato il codice della pagina che hai linkato, così è più semplice da analizzare senza dover andare di la ogni volta.

Il valore di SCOUNT viene definito all'inizio con una #define
#define SCOUNT 30 // sum of sample point
quindi SCOUNT vale 30. Occhio che non è una variabile, ma una "costante". Per dettagli sulla #define puoi guardare qua

Il Serial.begin() inizializza la seriale. La velocità puoi darla tu in base anche a quello che c'è dall'altra parte. Se usi la seriale per comunicare col pc e dell'altra parte c'è il monitor seriale dell'ide devi solo stare attento che la velocità impostata nello sketch sia uguale a quella impostata nel monitor seriale (ma te ne accorgi se sono diverse perché vedi caratteri strani).
Se nel tuo sketch non usi mai la seriale puoi evitare anche quella riga.

La static serve per dichiarare una variabile all'interno di una funzione (e quindi visibile sollo dentro quella funzione) che però mantiene il proprio valore anche quando esci dalla funzione. E quindi ti ritrovi quel valore quando rientri nella funzione.
Senza la static la variabile viene creata quando entri e distrutta quando esci dalla funzione.

A proposito del tuo sketch... sarebbe meglio che tu lo postassi, così vediamo cosa stai usando e non cosa immaginiamo che tu stia usando.

Mamma mia quanta roba da studiare, non so se avrò il tempo per studiarle tutte, grazie a tutti per le risposte.

Andiamo in ordine

enrico03:

analogReference(type);

Andando a cercare istruzioni su analogReference mi sono imbattuto in [questo ](http://"http://http://www.istitutobartolo.it/didattica/arduino/Arduino TMP36.pdf")PDF e seguendo quelle istruzioni ho collegato il pin di 3.3V al pin Aref e nel setup ho inserito la seguente scritta

analogReference(INTERNAL2V56);

Va bene cosi?
Andiamo avanti

fratt:
Quando vedi scritto void significa che quella funzione non restituisce nessun valore.

Quindi dopo il loop posso dichiarare una funzione (esmpio Void Pippo) se ad arduino voglio fargli compier una azione, tipo far girare un motorino oppure prelevare un valore con la mia sonda tds.
Mentre se dopo il loop voglio fare solo dei calcoli basta che dichiari una variabile ed esegua i calcoli di cui ho bisogno

fratt:
A proposito del tuo sketch... sarebbe meglio che tu lo postassi, così vediamo cosa stai usando e non cosa immaginiamo che tu stia usando.

eccovi il mio sketch

 #include <Arduino.h>

#include <LiquidCrystal_I2C.h>// dichiarazione libreria lcd
LiquidCrystal_I2C lcd(0x27,20,4);// inizializzazione display lcd
#define Sensore_TDS A1 //Definisco a quale pin analogico ho attaccato il sensore tds
#define VREF 5.0      // Tensione di riferimento utilizzata per l'ingresso analogico
#define SCOUNT  30           // somma del punto campione
int Array_ValoreAnalogico[SCOUNT];    // memorizzare il valore analogico nell'array, letto da ADC
int Array_ValoreAnalogico_Temp[SCOUNT];
int posizione_array = 0,copyIndex = 0;
float averageVoltage = 0,tdsValue = 0,temperature = 25;
int getMedianNum(int bArray[], int iFilterLen) ;
 


void setup() {

analogReference(INTERNAL2V56);
pinMode(Sensore_TDS,INPUT);
//Impostazione display
lcd.init(); 
lcd.backlight();
//*************************
}




void loop() { 
   
static unsigned long punto_di_campionamento = millis();
   if(millis()-punto_di_campionamento > 40U)     //ogni 40 millisecondi, leggere il valore analogico dall'ADC
   {
     punto_di_campionamento = millis();
     Array_ValoreAnalogico[posizione_array] = analogRead(Sensore_TDS);    //leggere il valore analogico e memorizzarlo nel buffer
     posizione_array++;
     if(posizione_array == SCOUNT) 
         posizione_array = 0;
   }   
   static unsigned long punto_temporale = millis();
   if(millis()-punto_temporale > 800U)//ogni 800 millisecondi
   {
      punto_temporale = millis();
      for(copyIndex=0;copyIndex<SCOUNT;copyIndex++)
        Array_ValoreAnalogico_Temp[copyIndex]= Array_ValoreAnalogico[copyIndex];
      averageVoltage = getMedianNum(Array_ValoreAnalogico_Temp,SCOUNT) * (float)VREF / 1024.0; // leggere il valore analogico più stabile dall'algoritmo di filtraggio mediano e convertirlo in valore di tensione
      float compensationCoefficient=1.0+0.02*(temperature-25.0);    //formula di compensazione della temperatura: fFinalResult (25 ^ C) = fFinalResult (corrente) / (1.0 + 0.02 * (fTP-25.0));
      float compensationVolatge=averageVoltage/compensationCoefficient;  //temperature compensation
      tdsValue=(133.42*compensationVolatge*compensationVolatge*compensationVolatge - 255.86*compensationVolatge*compensationVolatge + 857.39*compensationVolatge)*0.5; //convert voltage value to tds value
      lcd.home();
      lcd.print("TDS = ");
      lcd.print(tdsValue,0);
      lcd.println("ppm");
   }
}
int getMedianNum(int bArray[], int iFilterLen) 
{
      int bTab[iFilterLen];
      for (byte i = 0; i<iFilterLen; i++)
      bTab[i] = bArray[i];
      int i, j, bTemp;
      for (j = 0; j < iFilterLen - 1; j++) 
      {
      for (i = 0; i < iFilterLen - j - 1; i++) 
          {
        if (bTab[i] > bTab[i + 1]) 
            {
        bTemp = bTab[i];
            bTab[i] = bTab[i + 1];
        bTab[i + 1] = bTemp;
         }
      }
      }
      if ((iFilterLen & 1) > 0)
    bTemp = bTab[(iFilterLen - 1) / 2];
      else
    bTemp = (bTab[iFilterLen / 2] + bTab[iFilterLen / 2 - 1]) / 2;
      return bTemp;
   
}

Ho cancellato Serial.Begin, perche non uso la seriale, poi ho un'altra domanda che mi sono dimenticato di farvi ieri: Sul display do la frase "TDS =" e il valore del tds appaiono due caselle con 4 barre orizzontali ognuna, come mai questa cosa?
Visto che mi è stato chiesto vi dico anche che uso un arduino Mega
Grazie e buona domenica a tutti

Cambio un attimo argomento rimanendo con il solito codice
Per tenere la parte loop più in ordine avrei fatto questa modifica

#include <Arduino.h>
#include <LiquidCrystal_I2C.h>// dichiarazione libreria lcd
LiquidCrystal_I2C lcd(0x27,20,4);// inizializzazione display lcd

//dichiaro le funzioni
void tds();
//************************
#define Sensore_TDS A1 //Definisco a quale pin analogico ho attaccato il sensore tds
#define VREF 5.0      // Tensione di riferimento utilizzata per l'ingresso analogico
#define SCOUNT  30           // somma del punto campione
int Array_ValoreAnalogico[SCOUNT];    // memorizzare il valore analogico nell'array, letto da ADC
int Array_ValoreAnalogico_Temp[SCOUNT];
int posizione_array = 0,copyIndex = 0;
float averageVoltage = 0,tdsValue = 0,temperature = 25;
int getMedianNum(int bArray[], int iFilterLen) ;
 


void setup() {

analogReference(INTERNAL2V56);
pinMode(Sensore_TDS,INPUT);
//Impostazione display
lcd.init(); 
lcd.backlight();
//*************************
}




void loop() { 
  void tds(); 
}

void tds(){
static unsigned long punto_di_campionamento = millis();
   if(millis()-punto_di_campionamento > 100U)     //ogni 40 millisecondi, leggere il valore analogico dall'ADC
   {
     punto_di_campionamento = millis();
     Array_ValoreAnalogico[posizione_array] = analogRead(Sensore_TDS);    //leggere il valore analogico e memorizzarlo nel buffer
     posizione_array++;
     if(posizione_array == SCOUNT) 
         posizione_array = 0;
   }   
   static unsigned long punto_temporale = millis();
   if(millis()-punto_temporale > 800U)//ogni 800 millisecondi
   {
      punto_temporale = millis();
      for(copyIndex=0;copyIndex<SCOUNT;copyIndex++)
        Array_ValoreAnalogico_Temp[copyIndex]= Array_ValoreAnalogico[copyIndex];
      averageVoltage = getMedianNum(Array_ValoreAnalogico_Temp,SCOUNT) * (float)VREF / 1024.0; // leggere il valore analogico più stabile dall'algoritmo di filtraggio mediano e convertirlo in valore di tensione
      float compensationCoefficient=1.0+0.02*(temperature-25.0);    //formula di compensazione della temperatura: fFinalResult (25 ^ C) = fFinalResult (corrente) / (1.0 + 0.02 * (fTP-25.0));
      float compensationVolatge=averageVoltage/compensationCoefficient;  //temperature compensation
      tdsValue=(133.42*compensationVolatge*compensationVolatge*compensationVolatge - 255.86*compensationVolatge*compensationVolatge + 857.39*compensationVolatge)*0.5; //convert voltage value to tds value
      lcd.home();
      lcd.print("TDS= ");
      lcd.print(tdsValue,0);
      lcd.println("ppm");
   }
}
int getMedianNum(int bArray[], int iFilterLen) 
{
      int bTab[iFilterLen];
      for (byte i = 0; i<iFilterLen; i++)
      bTab[i] = bArray[i];
      int i, j, bTemp;
      for (j = 0; j < iFilterLen - 1; j++) 
      {
      for (i = 0; i < iFilterLen - j - 1; i++) 
          {
        if (bTab[i] > bTab[i + 1]) 
            {
        bTemp = bTab[i];
            bTab[i] = bTab[i + 1];
        bTab[i + 1] = bTemp;
         }
      }
      }
      if ((iFilterLen & 1) > 0)
    bTemp = bTab[(iFilterLen - 1) / 2];
      else
    bTemp = (bTab[iFilterLen / 2] + bTab[iFilterLen / 2 - 1]) / 2;
      return bTemp;
   
}

Ma purtroppo non mi appare più niente sul display ... Perché?
Grazie ancora

Ma purtroppo non mi appare più niente sul display ... Perché?

Perchè il tuo loop() è praticamente vuoto, non sta facendo niente. Se vuoi richiamare la tua funzione tds() non la far precedere da void, altrimenti diventa una dichiarazione. In pratica hai dichiarato dentro il loop una funzione locale (vuota, cioè priva del corpo) e basta. Non hai errori perchè tutto ciò è lecito dal punto di vista formale, ma abbastanza inutile...

Ciao, Ale.

Sulla questione analogReference non sono ferrato, meglio che aspetti qualcuno che ne capisce di più.

Piperino:
Quindi dopo il loop posso dichiarare una funzione (esmpio Void Pippo) se ad arduino voglio fargli compier una azione, tipo far girare un motorino oppure prelevare un valore con la mia sonda tds.
Mentre se dopo il loop voglio fare solo dei calcoli basta che dichiari una variabile ed esegua i calcoli di cui ho bisogno

Allora... qui c'entra poco Arduino, siamo proprio alle basi del C... forse conviene che cerchi un libro sul C e vedi se riesci a capirci qualcosa.
Cerco di fare un mega riassunto in 4 righe...
Una funzione è una porzione di codice che puoi richiamare da altre parti del codice.
Una funzione accetta dei parametri (da 0 a n) che sono quelli che definisci dentro le parentesi.
Una funzione restituisce un valore, che definisci indicandolo prima del nome della funzione.
Esempio:
int miaFunzione() {} è una funzione che non accetta nessun parametro e che restituisce un int
void altraFunzione(int a, char b) {} è una funzione che non restituisce nulla e accetta 2 parametri, il primo int, il secondo char.
Fuori dal loop() puoi sia dichiarare variabili che funzioni. Ad una variabile non "fai fare dei conti". Al limite una funzione fa dei conti al proprio interno...

Io a prescindere da tutta quella robaccia software (scherzo :D) avrei un dubbio diverso ... ma tu esattamente cosa ci vuoi misurare dell'acqua che usi ? ... perche' TDS e' una definizione piuttosto ampia ... :wink:

Etemenanki:
Io a prescindere da tutta quella robaccia software (scherzo :D) avrei un dubbio diverso ... ma tu esattamente cosa ci vuoi misurare dell'acqua che usi ? ... perche' TDS e' una definizione piuttosto ampia ... :wink:

Quando si dice che le domande fannfanno crescere, grazie Etemenanki.
Per l'idroponica mi ci vuole l' EC e cercando la sonda per misurare l'EC ricadevo sempre sulla sonda TDS e pensavo fosse la solita cosa, adesso che mi hai fatto questa domanda sono andato a cercare meglio e ho trovato questo.
EC è la misura di tutti gli ioni che conducono elettricità nella soluzione nutritiva. Maggiore sarà la quantità di ioni presenti nella soluzione nutritiva, maggiore sarà l'elettricità condotta da quella soluzione nutriente (aumento dell'EC).
La conducibilità elettrica (EC) della soluzione nutritiva è espressa in siemens per centimetro (s/cm), millisimens per centimetro (ms/cm) oppure microsimens per centimetro (µS/cm). La misura puo' essere effettuata con un misuratore di EC. Quando si aggiungono fertilizzanti all'acqua aumentano gli ioni con carica elettrica. Monitorare il valore EC è determinante, poichè, se la soluzione ha una conducibilità troppo alta, bisogna ridurre la quantità di fertilizzante somministrato o viceversa.
TDS e le p.p.m.
Per convenienza, le misure EC sono spesso convertite in TDS dagli strumenti di misura. TDS (Total Dissolved Solids) viene espressa in ppm (parts per millions).
La concentrazione di ciascun elemento che entra a far parte di una soluzione nutritiva si esprime in ppm (parti per milione) che rappresentano una parte di una sostanza (sale minerale) sciolta in un milione di parti di un'altra (l'acqua). In una soluzione nutritiva i grammi dei vari elementi che la compongono s'intenderanno diluiti sempre in mille litri d'acqua. Le unità di misura che si possono prendere in considerazione sono diverse ma, nelle soluzioni idroponiche, si preferisce il rapporto mg (milligrammi) / litro. Trovare una giusta proporzione, nel dosaggio dei fertilizzanti (sali minerali), è d'importanza fondamentale per ottenere una soluzione nutritiva equilibrata.
Come convertire il valore EC(µS/cm) in TDS(ppm)?
Moltiplicare EC(µS/cm) x 1000 e dividere 2 = TDS(ppm)
Esempio: se il tuo valore EC è 1.2µS/cm
1.2 x 1000 / 2 = 600ppm
Come convertire il valore TDS(ppm) in EC(µS/cm)?

Moltiplicare TDS(ppm) x 2 e dividere 1000
Esempio: se il tuo valore TDS è 700ppm
700 x 2 / 1000 = 1.4µS/cm

This topic was automatically closed 120 days after the last reply. New replies are no longer allowed.