Go Down

Topic: Controllo e gestione carichi casalinghi con sistema di priorità e tapparelle! (Read 18544 times) previous topic - next topic

Brunello

quello che volevo dirti e' che fino a che e' collegato all'USB, Arduino viene alimentato dall'USB ( se la tensione sul Vin <6.6V )

Al momento che scolleghi l'USB , con solo 5,08V sul Vin, probabilmente hai una tensione di poco superiore a 4V per alimentare Arduino
"C' è chi legge Guerra & Pace e non ci capisce un tubo vuoto; c'è chi legge l'etichetta delle patatine fritte e ci trova la spiegazione del mondo" (J.S. S. architetto napoletano)

5a2v0

riporto quanto leggo dalla pagina guida di YUN

Quote
There is no built in 5V regulator. If you power your Yún with more than 5V, you will likely damage it. If you are not powering the Yún from the micro-USB connection, you can apply power to the VIN and 5V pins on the board. If using the VIN pin, you cannot provide more than 5V, it will damage your board. It is recommended to power the Yún from the USB connection whenever possible.


http://arduino.cc/en/Guide/ArduinoYun

Brunello

"C' è chi legge Guerra & Pace e non ci capisce un tubo vuoto; c'è chi legge l'etichetta delle patatine fritte e ci trova la spiegazione del mondo" (J.S. S. architetto napoletano)

5a2v0

credo di aver sistemato  8) 8)
Dico credo perché ho fatto a distanza l'upload del nuovo sketch e attualmente il tutto è montato senza i sensori...

Visto che fare una sola (o una manciata: si ho provato anche a mettere 3 o 4 letture consecutive di ogni porta prima di leggere la seguente) letture a vuoto prima della lettura ritenuta affidabile non risolveva, ho provato in quest'altro modo:

Code: [Select]

//Lettura dati dei sensori e calcolo della corrente assorbita e dei consumi in watt
  sensorTotValue = 0;
  sensorCucinaValue = 0;
  sensorStanzeValue = 0;
  sensorBagniValue = 0;
  offsetValue = 0;
  //SENSORE BAGNI
  numeroCampionamenti = 0;
  inizioCampionamenti = millis() ;
  do
  {
    numeroCampionamenti++;
    sensorBagniValue += analogRead(sensorBagniPin);
  }
  //20 sono i millisecondi che verranno campionati per ogni sensore (tempo di ciclo della corrente elettrica alternata a 50 Hz utilizzata in Europa)
  while ((millis() - inizioCampionamenti) < 20);
  sensorBagniValue /= numeroCampionamenti;
  //SENSORE STANZE
  numeroCampionamenti = 0;
  inizioCampionamenti = millis() ;
  do
  {
    numeroCampionamenti++;
    sensorStanzeValue += analogRead(sensorStanzePin);
  }
  //20 sono i millisecondi che verranno campionati per ogni sensore (tempo di ciclo della corrente elettrica alternata a 50 Hz utilizzata in Europa)
  while ((millis() - inizioCampionamenti) < 20);
  sensorStanzeValue /= numeroCampionamenti;
  //SENSORE CUCINA
  numeroCampionamenti = 0;
  inizioCampionamenti = millis() ;
  do
  {
    numeroCampionamenti++;
    sensorCucinaValue += analogRead(sensorCucinaPin);
  }
  //20 sono i millisecondi che verranno campionati per ogni sensore (tempo di ciclo della corrente elettrica alternata a 50 Hz utilizzata in Europa)
  while ((millis() - inizioCampionamenti) < 20);
  sensorCucinaValue /= numeroCampionamenti;
  //SENSORE TOTALE
  numeroCampionamenti = 0;
  inizioCampionamenti = millis() ;
  do
  {
    numeroCampionamenti++;
    sensorTotValue += analogRead(sensorTotPin);
  }
  //20 sono i millisecondi che verranno campionati per ogni sensore (tempo di ciclo della corrente elettrica alternata a 50 Hz utilizzata in Europa)
  while ((millis() - inizioCampionamenti) < 20);
  sensorTotValue /= numeroCampionamenti;
  //OFFSET
  numeroCampionamenti = 0;
  inizioCampionamenti = millis() ;
  do
  {
    numeroCampionamenti++;
    //offsetValue è la lettura senza carico che poi sottraiamo alle letture dei sensori
    offsetValue += analogRead(offsetPin);
  }
  //20 sono i millisecondi che verranno campionati per ogni sensore
  while ((millis() - inizioCampionamenti) < 20);
  offsetValue /= numeroCampionamenti;
  sensorTotValue -= offsetValue;
  sensorCucinaValue -= offsetValue;
  sensorStanzeValue -= offsetValue;
  sensorBagniValue -= offsetValue;
  //Alcune differenze potrebbero avere valore negativo per cui noi consideriamo il valore assoluto
  sensorTotValue = abs(sensorTotValue);
  sensorCucinaValue = abs(sensorCucinaValue);
  sensorStanzeValue = abs(sensorStanzeValue);
  sensorBagniValue = abs(sensorBagniValue);
  //Per ottenere gli ampere reali moltiplichiamo la media di ampere letti nei 20ms per 0.166 che è il fattore di conversione calcolato con un carico noto
  ampereTot = sensorTotValue * fattoreConversione;
  ampereCucina = sensorCucinaValue * fattoreConversione;
  ampereStanze = sensorStanzeValue * fattoreConversione;
  ampereBagni = sensorBagniValue * fattoreConversione;
  //Infine moltiplichiamo gli ampere per la tensione stabilita per ottenere il consumo in Watt
  consumoTot = ampereTot * tensione;
  consumoCucina = ampereCucina * tensione;
  consumoStanze = ampereStanze * tensione;
  consumoBagni = ampereBagni * tensione;


e ho 0 watt in tutte e 4 le variabili:  consumoTot, consumoCucina, consumoStanze, consumoBagni.

Appena torno sul posto, provo a collegare i sensori per accertarmi che non ci siano errori  o altri problemi  :smiley-red:

5a2v0

Aggiornamento situazione:
ho collegato i sensori e provato a leggere i 4 valori .. non erano attendibili, avevo spesso 0 oppure 38 oppure 76 oppure maxxxx su quello del totale 114 !!

però seguono il consumo, infatti se accendo un utilizzatore in bagno (phon da circa 1800watt) il valore di quel sensore sale, il totale pure, gli altri no ---> OK!

Però ovviamente non riportano valori giusti... ho provato ad abbassare il tempo di campionamento per ogni sensore (su Uno campionavo in 20 ms sia l'unico sensore che l'offset)... ho messo 10ms (a testa)  e i sensori hanno iniziato a mostrare valori piu reali (2000watt per la cucina con forno acceso!) ma se aggiorno velocemente la pagina che mostra i valori, vedo che ho dei brevi intervalli che mostrano valori più bassi del normale.

esempio ancora con cucina con forno acceso:

2050 - 2100 - 2050 - 1200 - 2050 (sono dati di esempio eh !!)

come posso aggirare il nuovo problema ?

5a2v0

Ci tengo, mentre cerco ancora di risolvere il problema,  a pubblicare 4 fotine dell'app per android che è uscita fuori:


gateway74

perché hai utilizzato un contattore NO e non NC ?
Nella normale operatività sarebbe stato non alimentato (minor usura, minor consumo di corrente) 

pablos

perché hai utilizzato un contattore NO e non NC ?
Nella normale operatività sarebbe stato non alimentato (minor usura, minor consumo di corrente)
??... NO = contatto Normalmente Open e quindi non alimentato perciò minor consumo, tutti i contattori hanno i contatti NO e non sono deviati come i relay a bassa potenza, non esiste NO-C-NC nei contattori ... cosa vuoi dire?
L'esperienza è il tipo di insegnante più difficile ....
Prima ti fa l'esame e poi ti spiega la lezione.

gateway74



Quote
??... NO = contatto Normalmente Open e quindi non alimentato perciò minor consumo, tutti i contattori hanno i contatti NO e non sono deviati come i relay a bassa potenza, non esiste NO-C-NC nei contattori ... cosa vuoi dire?
NO non vuol dire non alimentato.. vuol dire che senza tensione il suo contatto è aperto.

esistono contattori NC cioè nella normalità chiudono il circuito e quindi senza essere alimentati.
quando sono eccitati aprono il circuito.

Nell'impianto di casa considerando la normalità, tutti i circuiti devono essere alimentati, quindi mi chiedevo: perchè utilizzare un contattore NO e  tenerlo alimentato per farlo diventare NC?

ecco un esempio


5a2v0

Scusa se rispondo solo adesso, ma avrò perso la notifica della discussione...Ho usato dei contattori "da eccitare" solo e soltanto perché nella mia città avevano solo questi...i normalmente chiusi li trovavo solo online e mi sarebbero costati il triplo...

Sono comunque in piena possibilità di "se li trovo al giusto prezzo" sostituire i contattori e collegarli diversamente alla scheda relè che uso per pilotarli.

5a2v0

Nuovo post per aggiornamento importante... oggi con qualche minuto di tempo libero ho preso ArduinoUNO e ho fatto delle prove per cercare di capire meglio il problema delle letture un po sfalsate e se possibile risolverlo..

Con il seguente sketch, che mantiene degli aspetti simili allo sketch utilizzato nel progetto vero e proprio anche se qui praticamente inutili (vedi il ciclo while che li serve per effettuare un TOT di letture e poi fare la media dei valori)
Code: [Select]
void setup() {
  Serial.begin(9600);
  pinMode(A0, INPUT);
  pinMode(A1, INPUT);
}

void loop() {
  unsigned long prev = millis();
  long a = 0;
  long b = 0;
  while (millis() - prev <= 80) {
    a = analogRead(A0);
    b = analogRead(A1);
  }
  Serial.println(b);
}



avendo un cavetto che collega il pin dei 5v (o dei 3,3 o altra tensione) con A0 e un cavetto che collega A1 a GND, il valore stampato su seriale NON E' sempre 0 !! Perchè l'adc rimane influenzato dalla lettura precedente di A0 dove aveva appunto una certa tensione...nel caso dei 5v a me riportava ogni tanto qualche 1 o qualche 2 ma ho provato ad aggiungere altri valori su altre porte e leggere anche quelle per rendere quanto piu simile il tutto al mio caso ed effettivamente il tutto peggiora portando la lettura di A1 (ricordo essere collegato verso massa) a valori come 7 o 8 ecc..

Nel mio progetto, l'adc deve leggere: offset (tensione in uscita da un partitore di tensione) poi 4 porte analogiche diverse dove la tensione sarà quella dell'offset +o- quella del sensore... il tutto viene fatto un tot di volte entro un tot di millisecondi e poi viene fatta la media dei valori assoluti...in pratica dei valori anche di 7 o 8 letti al posto di uno zero, creano quel consumo fantasma che in realtà non c'è !!

Sempre su UNO ho provato allora quest'altro sketch:

Code: [Select]
void setup() {
  Serial.begin(9600);
  pinMode(A0, INPUT);
  pinMode(A1, INPUT);
  pinMode(A2, INPUT);
}

void loop() {
  unsigned long prev = millis();
  long a = 0;
  long b = 0;
  long c = 0;
  while (millis() - prev <= 80) {
    c = analogRead(A2);
    a = analogRead(A0);
    c = analogRead(A2);
    b = analogRead(A1);
  }
  Serial.println(b);
}


dove A2 è collegato a massa e la sua lettura non serve a null'altro che a far "scaricare" il condensatore sample&hold dell'adc cosi da leggere poi il valore "pulito" di A1... infatti provando mi legge sempre 0 fisso qualunque voltaggio io abbia su A0 !!!

Nel mio progetto attualmente ho in uso solo 5 delle 6 porte analogiche per cui ho pensato che al posto di:


Code: [Select]
do
  {
    numeroCampionamenti++;
    //offsetValue è la lettura senza carico quindi lo sottraiamo alle letture dei sensori
    offsetValue = analogRead(offsetPin);
    sensorStanzeValue = analogRead(sensorStanzePin);   
    sensorStanzeValue -= offsetValue;
    sensorBagniValue = analogRead(sensorBagniPin);
    sensorBagniValue -= offsetValue;
    sensorCucinaValue = analogRead(sensorCucinaPin);
    sensorCucinaValue -= offsetValue;
    sensorTotValue = analogRead(sensorTotPin);
    sensorTotValue -= offsetValue;
    //Alcune letture potrebbero avere valore negativo per cui noi consideriamo il valore assoluto
    ampereTot += abs(sensorTotValue);
    ampereCucina += abs(sensorCucinaValue);
    ampereStanze += abs(sensorStanzeValue);
    ampereBagni += abs(sensorBagniValue);
  }
  //20 sono i millisecondi che verranno campionati per ogni pin-analogico/sensore (tempo di ciclo della corrente elettrica alternata a 50 Hz utilizzata in Europa)
  while ((millis() - inizioCampionamenti) < 100);


dovrei collegare il pin analogico non utilizzato a GND e fare

Code: [Select]

do
  {
    numeroCampionamenti++;
    //offsetValue è la lettura senza carico quindi lo sottraiamo alle letture dei sensori
    int cleaner = analogRead(inutilizzato);
    offsetValue = analogRead(offsetPin);
    int cleaner = analogRead(inutilizzato);
    sensorStanzeValue = analogRead(sensorStanzePin);   
    sensorStanzeValue -= offsetValue;
    int cleaner = analogRead(inutilizzato);
    sensorBagniValue = analogRead(sensorBagniPin);
    sensorBagniValue -= offsetValue;
    int cleaner = analogRead(inutilizzato);
    sensorCucinaValue = analogRead(sensorCucinaPin);
    sensorCucinaValue -= offsetValue;
    int cleaner = analogRead(inutilizzato);
    sensorTotValue = analogRead(sensorTotPin);
    sensorTotValue -= offsetValue;
    //Alcune letture potrebbero avere valore negativo per cui noi consideriamo il valore assoluto
    ampereTot += abs(sensorTotValue);
    ampereCucina += abs(sensorCucinaValue);
    ampereStanze += abs(sensorStanzeValue);
    ampereBagni += abs(sensorBagniValue);
  }
  //20 sono i millisecondi che verranno campionati per ogni pin-analogico/sensore (tempo di ciclo della corrente elettrica alternata a 50 Hz utilizzata in Europa)
  while ((millis() - inizioCampionamenti) < 120);

5a2v0

Desideravo aggiornare il topic inserendo anche il codice utilizzato negli Arduino mini che controllano le tapparelle visto che il mio progetto e la mia app hanno inglobato anche questo aspetto della casa.

Code: [Select]
#include <SPI.h>
#include <Ethernet.h>
#include <EEPROM.h>
//Configuro MAC Address, IP e porta
//TEST
byte mac[6] = { 0x90, 0xA2, 0xDA, 0xAC, 0xCB, 0x49 };
IPAddress ip(192, 168, 1, 254);
//SINGOLA NANO-1
//byte mac[6] = { 0x90, 0xA2, 0xDA, 0x5F, 0x18, 0x3C };
//IPAddress ip(192, 168, 1, 5);
//SOGGIORNO NANO-2
//byte mac[6] = { 0x90, 0xA2, 0xDA, 0x29, 0x2F, 0xDE };
//IPAddress ip(192, 168, 1, 6);
//MATRIMONIALE NANO-3
//byte mac[6] = { 0x90, 0xA2, 0xDA, 0xCC, 0x04, 0xF2 };
//IPAddress ip(192, 168, 1, 7);
IPAddress dnServer(192, 168, 1, 1);
IPAddress gateway(192, 168, 1, 1);
IPAddress subnet(255, 255, 255, 0);
EthernetServer server(80);
//Variabile per memorizzare ed analizzare le richieste http
String readString;
//Variabili in cui verrà memorizzato il valore leto dal potenziometro a seguito di una calibrazione
//Inizialmente il valore assegnato è puramente teorico.
//Il nome della variabile indica la percentuale d'apertura della tapparella
int _100_ = 1023;
int _75_ =  768;
int _50_ =  512;
int _25_ =  256;
int _5_ =  50;
int _0_ =  0;
//#define tollerance 3
byte tollerance = 0;
byte state = 0;
//Limite di tempo in millisecondi prima di interrompere una richiesta http per timeout
unsigned int timeout = 30000;
unsigned long previous_timeout = 0;
boolean error = false;
//Dichiaro i pin dei relè e del potenziometro che legge lo stato della serranda
#define rele_up 6
#define rele_down 7
#define potenziometro A7
#define potenziometro_vcc 9
//Dichiaro il pin usato per il reset manuale della shield ethernet
#define res_eth 8


void setup() {
  //Serial.begin(9600);
  //Reset manuale della scheda di rete per poter aggiornare lo sketch senza scollegare la shield
  pinMode(res_eth, OUTPUT);
  digitalWrite(res_eth, LOW);
  delay(100);
  pinMode(res_eth, INPUT);
  //Avvio la connessione di rete ed il webserver
  Ethernet.begin(mac, ip, dnServer, gateway, subnet);
  server.begin();
  //Dichiaro i pin digitali a cui sono collegati i relè che comandano la salita (2) e la discesa (3) della tapparella e l'alimentazione del potenziometro
  pinMode(rele_up, OUTPUT);
  pinMode(rele_down, OUTPUT);
  pinMode(potenziometro_vcc, OUTPUT);
  digitalWrite(rele_up, LOW);
  digitalWrite(rele_down, LOW);
  digitalWrite(potenziometro_vcc, HIGH);
  //Leggo dalla eprom i valori registrati in fase di calibrazione e li riconverto nel corrispondente valore di tipo INT con range da 0 a 1023 per un più rapido confronto in fase di controllo della serranda
  _0_ =  map(EEPROM.read(0), 0, 255, 0, 1023);
  _5_ =  map(EEPROM.read(1), 0, 255, 0, 1023);
  _25_ =  map(EEPROM.read(2), 0, 255, 0, 1023);
  _50_ =  map(EEPROM.read(3), 0, 255, 0, 1023);
  _75_ =  map(EEPROM.read(4), 0, 255, 0, 1023);
  _100_ = map(EEPROM.read(5), 0, 255, 0, 1023);
  tollerance = EEPROM.read(6);
  Serial.print(tollerance);
}



5a2v0

void loop separato per raggiungimento limite caratteri:

Code: [Select]
void loop() {
  //Imposto il server in ascolto di eventuali client
  EthernetClient client = server.available();
  if (client) {
    //Una richiesta http termina con una linea vuota, uso la variabile per identificare il termine di una richiesta
    boolean currentLineIsBlank = true;
    while (client.connected()) {
      if (client.available()) {
        char c = client.read();
        //Leggo la richiesta http un carattere alla volta per analizzare la URL richiesta
        if (readString.length() < 100) {
          readString += c;
        }
        //Ricevendo una riga vuota, la richiesta http è terminata e possiamo mandare la risposta
        if (c == '\n' && currentLineIsBlank) {
          //100% rappresenta l'apertura totale, per cui alzo la tapparella
          if (readString.indexOf("index.php?p=100%") > 0) {
            previous_timeout = millis();
            while (analogRead(potenziometro) <= (_100_ - tollerance)) {
              if (millis() - previous_timeout >= timeout) {
                error = true;
                break;
              }
              digitalWrite(rele_up, HIGH);
              digitalWrite(rele_down, LOW);
            }
            digitalWrite(rele_up, LOW);
            if (error == false) state = 100;
          }
          //75% rappresenta l'apertura per oltre metà della tapparella, verifico la posizione attuale e decido se alzare o abbassare
          else if (readString.indexOf("index.php?p=75%") > 0) {
            previous_timeout = millis();
            if (analogRead(potenziometro) <= (_75_ - tollerance)) {
              while (analogRead(potenziometro) <= (_75_ - tollerance)) {
                if (millis() - previous_timeout > timeout) {
                  error = true;
                  break;
                }
                digitalWrite(rele_up, HIGH);
                digitalWrite(rele_down, LOW);
              }
              digitalWrite(rele_up, LOW);
            }
            else if (analogRead(potenziometro) >= (_75_ + tollerance)) {
              while (analogRead(potenziometro) >= (_75_ + tollerance)) {
                if (millis() - previous_timeout > timeout) {
                  error = true;
                  break;
                }
                digitalWrite(rele_up, LOW);
                digitalWrite(rele_down, HIGH);
              }
              digitalWrite(rele_down, LOW);
            }
            if (error == false) state = 75;
          }
          //50% rappresenta l'apertura a metà della tapparella, verifico la posizione attuale e decido se alzare o abbassare
          else if (readString.indexOf("index.php?p=50%") > 0) {
            previous_timeout = millis();
            if (analogRead(potenziometro) <= (_50_ - tollerance)) {
              while (analogRead(potenziometro) <= (_50_ - tollerance)) {
                if (millis() - previous_timeout > timeout) {
                  error = true;
                  break;
                }
                digitalWrite(rele_up, HIGH);
                digitalWrite(rele_down, LOW);
              }
              digitalWrite(rele_up, LOW);
            }
            else if (analogRead(potenziometro) >= (_50_ + tollerance)) {
              while (analogRead(potenziometro) >= (_50_ + tollerance)) {
                if (millis() - previous_timeout > timeout) {
                  error = true;
                  break;
                }
                digitalWrite(rele_up, LOW);
                digitalWrite(rele_down, HIGH);
              }
              digitalWrite(rele_down, LOW);
            }
            if (error == false) state = 50;
          }
          //25% rappresenta l'apertura per meno della metà della tapparella, verifico la posizione attuale e decido se alzare o abbassare
          else if (readString.indexOf("index.php?p=25%") > 0) {
            previous_timeout = millis();
            if (analogRead(potenziometro) <= (_25_ - tollerance)) {
              while (analogRead(potenziometro) <= (_25_ - tollerance)) {
                if (millis() - previous_timeout > timeout) {
                  error = true;
                  break;
                }
                digitalWrite(rele_up, HIGH);
                digitalWrite(rele_down, LOW);
              }
              digitalWrite(rele_up, LOW);
            }
            else if (analogRead(potenziometro) >= (_25_ + tollerance)) {
              while (analogRead(potenziometro) >= (_25_ + tollerance)) {
                if (millis() - previous_timeout > timeout) {
                  error = true;
                  break;
                }
                digitalWrite(rele_up, LOW);
                digitalWrite(rele_down, HIGH);
              }
              digitalWrite(rele_down, LOW);
            }
            if (error == false) state = 25;
          }
          //5% rappresenta la chiusura della tapparella con i fori ancora visibili, verifico la posizione attuale e decido se alzare o abbassare
          else if (readString.indexOf("index.php?p=5%") > 0) {
            previous_timeout = millis();
            if (analogRead(potenziometro) <= (_5_ - tollerance)) {
              while (analogRead(potenziometro) <= (_5_ - tollerance)) {
                if (millis() - previous_timeout > timeout) {
                  error = true;
                  break;
                }
                digitalWrite(rele_up, HIGH);
                digitalWrite(rele_down, LOW);
              }
              digitalWrite(rele_up, LOW);
            }
            else if (analogRead(potenziometro) >= (_5_ + tollerance)) {
              while (analogRead(potenziometro) >= (_5_ + tollerance)) {
                if (millis() - previous_timeout > timeout) {
                  error = true;
                  break;
                }
                digitalWrite(rele_up, LOW);
                digitalWrite(rele_down, HIGH);
              }
              digitalWrite(rele_down, LOW);
            }
            if (error == false) state = 5;
          }
          //0% rappresenta la chiusura totale, per cui abbasso la tapparella
          else if (readString.indexOf("index.php?p=0%") > 0) {
            previous_timeout = millis();
            while (analogRead(potenziometro) >= (_0_ + tollerance)) {
              if (millis() - previous_timeout > timeout) {
                error = true;
                break;
              }
              digitalWrite(rele_up, LOW);
              digitalWrite(rele_down, HIGH);
            }
            digitalWrite(rele_down, LOW);
            if (error == false) state = 0;
          }
          //Check è il comando per leggere lo stato della serranda
          //Leggo il valore del potenziometro e lo rapporto ai valori min/max registrati nella eprom
          //Stabilisco la percentuale alla quale si avvicina di più l'attuale posizione
          else if (readString.indexOf("check.php") > 0) {
            state = map(analogRead(potenziometro), _0_, _100_, 0, 100);
            if (state <= 14) state = 0;
            else if ((state >= 15) && (state <= 34)) state = 5;
            else if ((state >= 35) && (state <= 64)) state = 25;
            else if ((state >= 65) && (state <= 84)) state = 50;
            else if ((state >= 85) && (state <= 94)) state = 75;
            else if (state >= 95) state = 100;
          }

........... continua



5a2v0

Code: [Select]
          //Set è il comando per memorizzare in eprom il valore del potenziometro corrispondente alla percentuale di apertura
          else if (readString.indexOf("set.php?p=100%") > 0) {
            _100_ = analogRead(potenziometro);
            state = map(_100_, 0, 1023, 0, 255);
            EEPROM.write(5, state);
            state = 100;
          }
          else if (readString.indexOf("set.php?p=75%") > 0) {
            _75_ = analogRead(potenziometro);
            state = map(_75_, 0, 1023, 0, 255);
            EEPROM.write(4, state);
            state = 75;
          }
          else if (readString.indexOf("set.php?p=50%") > 0) {
            _50_ = analogRead(potenziometro);
            state = map(_50_, 0, 1023, 0, 255);
            EEPROM.write(3, state);
            state = 50;
          }
          else if (readString.indexOf("set.php?p=25%") > 0) {
            _25_ = analogRead(potenziometro);
            state = map(_25_, 0, 1023, 0, 255);
            EEPROM.write(2, state);
            state = 25;
          }
          else if (readString.indexOf("set.php?p=5%") > 0) {
            _5_ = analogRead(potenziometro);
            state = map(_5_, 0, 1023, 0, 255);
            EEPROM.write(1, state);
            state = 5;
          }
          else if (readString.indexOf("set.php?p=0%") > 0) {
            _0_ = analogRead(potenziometro);
            state = map(_0_, 0, 1023, 0, 255);
            EEPROM.write(0, state);
            state = 0;
          }
          else if (readString.indexOf("set.php?tollerance=") > 0) {
            tollerance = readString.indexOf("=");
            String temp = "";
            temp += (char)readString.charAt(tollerance + 1);
            tollerance = temp.toInt();
            EEPROM.write(6, tollerance);
            //Serial.print(tollerance);
            state = tollerance;
          }
          //Se non è stato trovata nessuna stringa compatibile con i comandi riconosciuti, genera un errore
          else error = true;
          //Genera l'output considerando eventuali errori altrimenti fornendo lo stato della serranda dopo un movimento o per un semplice controllo
          if (error == false) client.println("HTTP/1.0 200 OK");
          else client.println("HTTP/1.0 404 Not Found");
          client.println("Content-Type: text/html");
          client.println("Connection: close");
          client.println();
          client.println("<!DOCTYPE HTML>");
          client.println("<html>");
          if (error == false) client.println(state);
          client.println("</html>");
          break;
        }
        //Controllo se ho ricevuto una riga vuota per inviare poi la risposta
        if (c == '\n') {
          currentLineIsBlank = true;
        }
        else if (c != '\r') {
          currentLineIsBlank = false;
        }
      }
    }
    //Attendi per la fine della trasmissione dei dati e chiudi la connessione
    delay(1);
    client.stop();
    //Pulisci la variabili per le prossime letture
    readString = "";
    error = false;
  }
  //Debug tramite seriale
  //state = map(analogRead(potenziometro), _0_, _100_, 0, 100);
  //Serial.println(state);
}

Go Up
 


Please enter a valid email to subscribe

Confirm your email address

We need to confirm your email address.
To complete the subscription, please click the link in the email we just sent you.

Thank you for subscribing!

Arduino
via Egeo 16
Torino, 10131
Italy