Ethernet shield v2 (SD) + sito web + dati arduino (I/O + variabili di processo)

Ciao a tutti,

ho realizzato una semplice applicazione per la termostatazione delle tubazioni dell'acqua fredda della mia caldaia quando sono in vacanza d'inverno, in modo tale da non far congelare il circuito dell'acqua (sanitaria+riscaldamento) avendo la caldaia nel sotto tetto.

ho già sviluppato l'applicazione che prevede:
n°4 sensori di temperatura LM35

  • temperatura acqua fredda ingresso caldaia
  • temperatura acqua fredda uscita caldaia
  • temperatura valvola acqua/gas
  • temperatura ambiente

n°3 uscite digitali per comando relè (complete di circuito di pilotaggio)

  • comando cavo scaldante ingresso acqua fredda
  • comando cavo scaldante uscita acqua fredda
  • comando cavo scaldante valvola acqua/gas

ho effettuato tutte le prove per l'accensione/spegnimento/esclusione dei cavi scaldanti con relativo debug su serialmonitor (come si fa di solito), fi qui non ho avuto grossi problemi....

ho sviluppato il sito web con dreamweaver cs3 e l'ho caricato su scheda sd (ethernet shield v2 con micro SD), ho implementato l'esempio tinywebserver.fileupload con relative modifiche per MAC address ed indirizzo IP, ho testato l'upload tramite il comando curl e tutto funziona correttamente, arduino mi risponde con la pagina web presente in SD di cui allego il link: boscomortara.dynalias.net/index.htm ed una immagine statica della stessa:

Uploaded with ImageShack.us

ora viene il bello:
come faccio ad effettuare un link in lettura/scrittura sulle variabili presenti in arduino, quelle con cui ho effettuato il debug da serial monitor?

ho effettuato alcune ricerche per utilizzare i metodi GET e POST dei form (ogni pulsante invia dati è parte di un form contenente due variabili: setpoint start e setpoint stop)

sarebbe possibile che all'apertura della pagina web arduino si comportasse in questo modo:

  • recupero variabili da arduino -> aggiornamento contenuto statico pagina web -> visualizzazione pagina web "modificata" con i valori attuali (non m'importa se è statica, riaggiornando la pagina si avranno i nuovi valori istantanei presenti in arduino)

  • ad ogni click sul corrispondente pulsante "invia dati" -> arduino prenda in carico i nuovi dati provenienti dal form corrispondente ed aggiorni le variabili di start e stop memorizzate in precedenza.

allego il codice di esempio che ho utilizzato per la visualizzazione delle pagine web caricando le stesse da/verso uSD:

// -*- c++ -*-
//
// Copyright 2010 Ovidiu Predescu <ovidiu@gmail.com>
// Date: June 2010
//

#include <SPI.h>
#include <Ethernet.h>
#include <Flash.h>
#include <SdFat.h>
#include <SdFatUtil.h>
#include <TinyWebServer.h>

boolean file_handler(TinyWebServer& web_server);
boolean index_handler(TinyWebServer& web_server);

TinyWebServer::PathHandler handlers[] = {
  // Work around Arduino's IDE preprocessor bug in handling /* inside
  // strings.
  //
  // `put_handler' is defined in TinyWebServer
  {"/", TinyWebServer::GET, &index_handler },
  {"/upload/" "*", TinyWebServer::PUT, &TinyWebPutHandler::put_handler },
  {"/" "*", TinyWebServer::GET, &file_handler },
  {NULL},
};

const char* headers[] = {
  "Content-Length",
  NULL
};

TinyWebServer web = TinyWebServer(handlers, headers);

boolean has_filesystem = true;
Sd2Card card;
SdVolume volume;
SdFile root;
SdFile file;

static uint8_t mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

// Don't forget to modify the IP to an available one on your home network
byte ip[] = { 192, 168, 1, 112 };

void send_file_name(TinyWebServer& web_server, const char* filename) {
  if (!filename) {
    web_server.send_error_code(404);
    web_server << F("Could not parse URL");
  } else {
    TinyWebServer::MimeType mime_type
      = TinyWebServer::get_mime_type_from_filename(filename);
    web_server.send_error_code(200);
    web_server.send_content_type(mime_type);
    web_server.end_headers();
    if (file.open(&root, filename, O_READ)) {
      Serial << F("Read file "); Serial.println(filename);
      web_server.send_file(file);
      file.close();
    } else {
      web_server << F("Could not find file: ") << filename << "\n";
    }
  }
}

boolean file_handler(TinyWebServer& web_server) {
  char* filename = TinyWebServer::get_file_from_path(web_server.get_path());
  send_file_name(web_server, filename);
  free(filename);
  return true;
}

boolean index_handler(TinyWebServer& web_server) {
  send_file_name(web_server, "INDEX.HTM");
  return true;
}

void file_uploader_handler(TinyWebServer& web_server,
			   TinyWebPutHandler::PutAction action,
			   char* buffer, int size) {
  static uint32_t start_time;
  static uint32_t total_size;

  switch (action) {
  case TinyWebPutHandler::START:
    start_time = millis();
    total_size = 0;
    if (!file.isOpen()) {
      // File is not opened, create it. First obtain the desired name
      // from the request path.
      char* fname = web_server.get_file_from_path(web_server.get_path());
      if (fname) {
	Serial << F("Creating ") << fname << "\n";
	file.open(&root, fname, O_CREAT | O_WRITE | O_TRUNC);
	free(fname);
      }
    }
    break;

  case TinyWebPutHandler::WRITE:
    if (file.isOpen()) {
      file.write(buffer, size);
      total_size += size;
    }
    break;

  case TinyWebPutHandler::END:
    file.sync();
    Serial << F("Wrote ") << file.fileSize() << F(" bytes in ")
	   << millis() - start_time << F(" millis (received ")
           << total_size << F(" bytes)\n");
    file.close();
  }
}

void setup() {
  Serial.begin(115200);
  Serial << F("Free RAM: ") << FreeRam() << "\n";

  // initialize the SD card
  Serial << F("Setting up SD card...\n");
  pinMode(10, OUTPUT); // set the SS pin as an output (necessary!)
  digitalWrite(10, HIGH); // but turn off the W5100 chip!
  if (!card.init(SPI_FULL_SPEED, 4)) {
    Serial << F("card failed\n");
    has_filesystem = false;
  }
  // initialize a FAT volume
  if (!volume.init(&card)) {
    Serial << F("vol.init failed!\n");
    has_filesystem = false;
  }
  if (!root.openRoot(&volume)) {
    Serial << F("openRoot failed");
    has_filesystem = false;
  }

  if (has_filesystem) {
    // Assign our function to `upload_handler_fn'.
    TinyWebPutHandler::put_handler_fn = file_uploader_handler;
  }

  Serial << F("Setting up the Ethernet card...\n");
  Ethernet.begin(mac, ip);

  // Start the web server.
  Serial << F("Web server starting...\n");
  web.begin();

  Serial << F("Ready to accept HTTP requests.\n");
}

void loop() {
  if (has_filesystem) {
    web.process();
  }
}

aiuto!!!!

sono ad un passo dalla fine :stuck_out_tongue:

grazie a tutti :smiley:

saluti
Kattivik76

Ciao,
il progetto è bello, graficamente curato; bravo.

Puoi usare la eeprom di arduino (o una eeprom esterna, o la stessa sd) per salvare i parametri che tu passi, i modo da preservarli anche da eventuali riavvi.

Per visualizzare poi i dati letti dai sensori arduino, secondo me le soluzioni sono:

  • o passi tali parametri nella chiamata alla INDEX.HTML, e nella stesso file INDEX.HTML implementi qualche funzioncina js che faccia il parsing di tale URL; i dati così ottenuti vanno scritti poi negli opportuni campi;
  • o usi la ricerca in alto a dx, e trovi qualcuno che ha avuto le tue stesse esigenze (e ha risolto :P):
    http://arduino.cc/forum/index.php?topic=54797.0

Scusa mi daresti l'espressione per calcolare la temperatura tramite sensore lm35dz che ho visto che hai usato nel tuo progetto?

ciao,

ecco un'ottimo tutorial riguardo gli lm75/76
http://www.ladyada.net/learn/sensors/tmp36.html

saluti
kattivik76

Grazie per la risposta,

potresti farmi un'esempio pratico di lettura variabili da arduino e scrittura variabili su arduino?

esempio, in arduino ho una variabile float denominata start01 -> come la inserisco nella mia pagina web residente su uSD?

grazie,
saluti

Kattivik76

Qualche tempo fa ho messo insieme le due librerie webduino e tinywebserver in modo che Arduino, al momento della lettura della pagina dalla uSD, possa inserire dei valori in posizioni opportune. E' un sistema un po' "grezzo" : nel punto della pagina dove voglio inserire il valore metto un marcatore tipo @A oppure @B oppure @C ..... Quando arduino carica la pagina dalla SD cerca questi marcatori e li sostituisce con il dato opportuno. Se vai a questo post http://arduino.cc/forum/index.php/topic,54797.0.html trovi la discussione con la libreria che ho modificato, dovrebbe anche esserci un esempio. Prova a dare un'occhiata, se ti sembra che possa essere utile chiedi pure, ho altri esempi che ti posso uploadare.
Penso comunque che ci siano altri sistemi tipo quello che ha usato l'autore di tinywebserver, purtoppo non sono molto esperto nell'interazione tra pagine - client - webserver per cui ho preferito fare a modo mio. :slight_smile:

@Gianni
:smiley: è proprio il thread che ho indicato qualche post fa!

grazie,

ho visto che si utilizza jquery.js, penso sia una funzione standard e quindi non va modificata giusto?

domani in ufficio, avrò sicuramente modo di caricare sul mio arduino la tua demo e vedrò di capirci qualcosa :smiley:
altrimenti chiederò, chiederò, chiederò....

grazie ancora a tutti

p.s.: sarò presente entrambi i giorni di arduino camp a milano :smiley:

saluti
Kattivik76

ciao,

be che dire, è semplicemente quello che volevo realizzare,

ho caricato la tua demo con un paio di modifiche (indirizzo ip, define marker aumentati fino a 12)...
con la mia pagina index.htm e la funzione jquery.js...

e con mia sorpresa mi sono trovato i dati modificati all'interno della mia pagina index :smiley:

veramente facile...

funziona correttamente con IE ma con google crhome l'invio dei form ha un esito random :smiley: a volte inviano i dati, a volte no... bho! :smiley:

oggi provo a completare il codice utilizzando le mie variabili analog+digital+register... e vediamo cosa riesco a fare :smiley:

grazie davvero della dritta :smiley:
saluti
kattivik76

Grazie alle vostre dritte, ho terminato l'applicazione per la gestione antigelo caldaia :smiley:

ecco il sito completato, residente su uSD:

Uploaded with ImageShack.us

il codice è stato sviluppato in due file .pde:
1- gestione webserver + replacestring + scheduled thread@60 secondi (lettura canali analogici d'ingresso e gestione output digitali)
2- gestione logica start/stop cavi scaldanti + funzioni varie

allego il progetto completo e funzionante

grazie a tutti :smiley:

saluti
kattivik76

Caldaia_Elio.rar (609 KB)

Bravo kattivik76!
Adesso so di esagerare, ma sarebbe bello avere invece dell'immagine statica una gif animata, con i flussi che si muovono...
Magari con il dato della temperatura a fianco reale...

Buongiorno :smiley:

Ho provato a far girare il programma ma mi manca:

#include <WebServerSD.h>

Dove lo trovo?

Grazie per la pazienza, Valerio.

ciao,

eccolo:

http://code.google.com/p/webduino/downloads/list

Ciao kattivik76,
sto leggendo da un paio di giorni il codice dei tuoi sketch e devo dire che è molto ben fatto.
Penso che con una get sia più semplice in quanto i valori sono tutti nell'url.
Guarda che il file WebServerSD.h è un po infossato nel sito e i motori di ricerca non lo trovano, se lo cerchi con google non esce niente.
Magari dagli più visibilità visto che è un componente molto importante.
Grazie.

Alberto

lupusimprobus:
Buongiorno :smiley:

Ho provato a far girare il programma ma mi manca:

#include <WebServerSD.h>

Dove lo trovo?

Grazie per la pazienza, Valerio.

:slight_smile: se hai bisogno chiedimi pure anche in PM, trovi tutto sul nostro google.site: https://sites.google.com/site/circuitiarduino/home/antigelo-caldaia
compreso le nuove modifiche per la memorizzazione e la lettura dei dati di setpoint sulla eeprom interna di ArduinoUno.

a breve, se riesco a risolvere alcuni problemi di comunicazione tra le mie sinapsi, farò un upgrade della pagina web, utilizzerò, credo, funzioni Ajax e snellirò gli sketch per recuperare memoria...

url dettaglio sketch: https://sites.google.com/site/circuitiarduino/home/antigelo-caldaia/sketch

p.s.: sono contento di aver rivisto il mio vecchio post in prima pagina :wink:

p.p.s.: url del server web ArduinoUno in fase di test: http://home-galliate.dyndns.org:81/
saluti
kattivik76

ciao a tutti,

ecco il link di test sulla nuova versione della pagina grafica per la visualizzazione dello stato della caldaia, è solo una pagina di test, ma vi assicuro molto interessante

http://home-galliate.dyndns.org:81/

l'aggiornamento delle variabili avviene tramite json+ajax, ogni 500ms :slight_smile:

a breve l'upgrade della pagina completa :smiley:

saluti
kattivik76

Ciao,
guarda che da quando ti ho mandato l'esempio ho fatto degli aggiornamenti al codice per gestire meglio il reload della pagina e altri problemi, vedi il post http://arduino.cc/forum/index.php/topic,76032.60.html
Forse è meglio dividere i valori dei sensori per 1023, non 1024 in quanto il primo valore è zero.
Refrech it!

Alberto

Ciao a tutti,

nuovo aggiornamento sullo stato dell'attività di sviluppo antigelo caldaia:

url: http://home-galliate.dyndns.org:81/

i dati vengono aggiornato ogni 5 secondi, le misure reali sono "temperatura esterna" e "temperatura ambiente", vengono gestite tutte le chiamate GET, POST, PUT (upload file in uSD arduino) mediante curl.exe

ho implementato un piccolo datalogger su uSD, i dati vengono memorizzati in un file .csv ogni ora, downloadabile direttamente da: http://home-galliate.dyndns.org:81/logger00.csv

ho implementato un trend storico in javascript (al momento presenta ancora dati di esempio) dove, mediante script ancora da realizzare, andrò a leggere il file logger00.csv per il recupero degli ultimi dati riferiti alle 24 ore precedenti.

saluti
kattivik76

Ciao a tutti,

ecco i nuovi sviluppi del sistema antigelo caldaia, archiviata la gestione del webserverSD con ajax e json, ho utilizzato l'ethernet shield per la realizzazione di una connessione fullduplex con il server pachube www.pachube.com ed ho utilizzato il sistema web di www.altervista.com.

questo è il link del sito: http://homegalliate.altervista.org/

antigelo caldaia udpate:

  • Sostituite le sonde di temperatura analogiche LM35 con dallas 1wird DS18B20 (digitali)
  • Gestione invio e ricezione dati via pachube
  • Gestione accesso al sistema antigelo caldaia mediante PHP+MySQL
  • Gestione crittografia utente con sistema MD5 per la creazione della sessione di accesso
  • Aggiornamento setpoint start-stop mediante form (invio dati a feed pachube) e successivamente letti da arduinoUno
  • Abilitazione/Disabilitazione logica di gestione cavi scaldanti mediante form (invio dati a feed pachube) e successivamente letti da arduinoUno

i dati da arduino a feeds pachube vengono inviati ogni minuto
i dati da feeds pachube ad arduino vengono richiesti ogni 10sec (setpoint,enable)

nella pagina web di gestione antigelo caldaia trovano posto tutti gli indicatori di temperatura, un grafico zoomabile della temperatura esterna (app pachube), un grafico delle ultime 24ore (temperatura ambiente), tutti i setpoint impostabili, lo stato delle uscite relè (attualmente linkate allo stato di ENABLE per testare le funzioni javascript verso pachube).

:wink:
saluti
kattivik76

Bravo kattivik76!

questo è il link del sito: http://homegalliate.altervista.org/

hai un'utenza di test? O dobbiamo accontentarci della pagina di login? :smiley: