Controllare la temperatura di un acquario a distanza - Metodo Economico

Tenere d’occhio le temperature è estremamente importante quando si allevano urodeli, in quanto sono particolarmente sensibili alle alte temperature ed essere in grado di controllare rapidamente le temperature in remoto è non solo incredibilmente facile grazie all’IoT, ma diminuirá alcune delle preoccupazioni principali del lasciare gli animali per un lungo periodo di tempo per le vacanze.

Nell’articolo Come controllare la temperatura di terrari a distanza abbiamo esplorato come usare un Raspberry Pi e un sensore BME280 per monitorare la temperatura, umiditá e pressione atmosferica della stanza dove teniamo i nostri animali. Usare un Raspberry Pi per questo tipo di progetto ha il vantaggio di essere molto semplice, e puó essere ampliato ad avere multipli sensori e funzioni che lo rendono ideale per il monitoraggio di Rack System con piú acquari/terrari, ma lo svantaggio é il costo. Benché economico, il costo di un Raspberry Pi inizia dai 15€ insú, al cui bisogna aggiunger il costo di una Micro SD e sensori, il che a seconda dal setup puó portare il costo di un sensore sopra i 25€.

In questo tutorial esploreremo un’ alternativa al Raspberry Pi che sebben piú limitata é molto piú economica e ci permetterá di monitorare un acquario/terrario con un costo di circa €5 usando un microschip ESP8266 e un sensore impermeabile DS18B20, e registrare la temperatura ad intervalli regolari su Google Sheet.

Cos'é l' ESP8266:

L’ ESP8266 é un microchip con Wi-Fi integrato prodotto dall’azienda Espressif Systems che é diventato molto popolare dato il basso costo e la compatibilitá con l’ Arduino IDE che ci permette di programmarlo come se fosse un Arduino con Wi-Fi integrato. Data la popolaritá di questo chip, varie compagnie hanno prodotto moduli che contengono questo chip che ci semplifica di molto la vita dato che questi moduli contengono tutti i componenti necessari per connettere il chip ad un PC e programmarlo come un Arduino. 

Nel mio caso ho usato un Wemos D1 Mini che contiene il chip ESP8266-12F, ma il tutorial dovrebbe essere compatibile con ogni modulo che contiene un ESP8266.

Materiali:

Ecco la lista dei materiali di cui avrai bisogno. Ho incluso i nostri link Affiliati di Amazon per semplicitá, ma ognuno di questi materiali puó essere trovato anche a meno su eBay, Aliexpress o negozi specializzati in elettronica, quindi controlla in giro per trovare i prezzi migliori.

  • Componenti minimi necessari:
    • Wemos D1 Mini (€1/5): Questo puó essere trovato sotto i €2 su Aliexpress o sui €5 su Amazon.
    • DS18B20 (€1/2): Come sopra, il prezzo puó variare considerevolmente da dove l’acquistate. IMPORTANTE: Prendete la versione impermeabile per essere usata in acquari e terrari umidi.
    • 4.7kOhm Resistore (€0.10): il sensore DS18B20 necessita di una resistore a 4.7kOhm. Questi sono molto economici e a volte sono inclusi nel prezzo dei sensori.
    • Alimentatore (€5): Avrai bisogno di un cavetto microUSB e un alimentatore. Se non hai un caricatore per telefono in piú, dovrai comprarne uno. Volendo questa board puó essere alimentata anche da batteria o pannelli solari.

Connessione:

Connetti il DS18B20, Resistore e Wemos D1 Mini come nello schema in basso. Da tener presente, il resistore deve collegare il Pin con 3.3V e il pin Dati.

Wemos D1 Sketch

Configurazione Arduino IDE:

Iniziamo col configurare l’Arduino IDE in modo che riconosca il nostro Wemos D1.

  1. Scarica l’Arduino IDE qui: https://www.arduino.cc/en/main/software
  2. Vai in File > Preferences
  3. incolla http://arduino.esp8266.com/stable/package_esp8266com_index.json in Additional Boards Manager URLs e Premi OK
  4. Vai in Tools > Boards: > Boards Manager…
  5. Cerca il Modulo esp8266 (dovrebbe essere all fine) e clicca su Install
  6. Torna in Tools > Boards: e seleziona la tua board. Nel mio caso ho selezionato LOLIN(WEMOS) D1 R2 & mini

Una volta che abbiamo configurato il Wemos D1 possiamo occuparci di installare le librerie di cui abbiamo bisogno (alcune di queste librerie potrebberero essere giá installate).

  1. Vai in Sketch > Include Library > Manage Libraries
  2. Installa DallasTemperature
  3. Installa OneWire
  4. Installa HTTPSRedirect manualmente
Per installare HTTPSRedirect manualmente:
  1. Scarica questa repository sul tuo PC
  2. Sposta la cartella HTTPSRedirect nella cartella contenente le Librerie di Arduino IDE. Solitamente si trova Documenti > Arduino > Libreries

Configurare Google Sheet:

Le letture del sensore verranno registrate a intervalli periodici in un Google Sheet. Questo ci permetterá di usare Google Sheet sia come database per l’archiviazione dei dati e sia come una Dashboard interattiva per la lettura.

  1. Iniziamo col creare un nuovo Google Sheet e cambiamo l’impostazione da Privato andando in Condividi > Ottieni Link e impostiamo “Chiunque abbia il link puó modificare”
  2. Cambia il nome del foglio in cui vuoi salvare le temperature, ad esempio Temperature

Creazione di un Google App Script:

Quando il Wemos D1 completerá una lettura del sensore, questá verrá mandata ad un Google App Script che poi registrerá la lettura nel Google Sheet.

Per configurare questo piccolo pezzo di Javascript avremo bisogno di:

  • ID del Google Sheet
  • Nome del foglio in cui vogliamo inserire le letture
Per creare lo script, clicca su Tools > Script. Una nuova pagina si aprirá. Scegliete un nome per lo script e incollate Questo codice con le opportune modifiche nelle prime due linee del codice. 

 

var SS = SpreadsheetApp.openById('~~Sheet ID~~');    //Inserisci l'ID del tuo Google Sheet
var sheet = SS.getSheetByName('~~Sheet Name~~');      // Inserisci il nome del foglio in cui vuoi registrare le temperature
var str = "";

function doPost(e) {

  var parsedData;
  var result = {};
  
  try { 
    parsedData = JSON.parse(e.postData.contents);
  } 
  catch(f){
    return ContentService.createTextOutput("Error in parsing request body: " + f.message);
  }
   
  if (parsedData !== undefined){
    
    var flag = parsedData.format;
    
    if (flag === undefined){
      flag = 0;
    }
    var dateTime = new Date();
    sheet.appendRow([dateTime,parsedData]);

}
}

Una volta fatte le modifiche, clicca su Publish > Deploy as Web App e nella sezione Who has access to the app: seleziona Anyone, even anonymous e clicca OK.

A questo punto lo script sará pubblicato come una Web App, e dovresti vedere un link nel formato script.google.com. Salva questo link che ne avremo bisogno dopo.

Programma il Wemos D1 Mini:

Questo é l’ultimo passaggio. Per completare la programmazione del Wemos D1 abbiamo bisogno di:

  • Google Apps Script ID
  • Nome del tuo Wi-Fi
  • Password del tuo Wi-Fi 

Puoi trovare l’ID nel link della Web App che abbiamo appena creato (https://script.google.com/macros/s/~~~Google Apps Script~~~/exec)

 
#include "TickTwo.h"
#include "ESP8266WiFi.h"
#include "HTTPSRedirect.h"
#include "DebugMacros.h"
#include "OneWire.h"
#include "DallasTemperature.h"

// Data wire is plugged into port D2 on the ESP8266
#define ONE_WIRE_BUS D2

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);


float m = 30; // intervall in minutes
float in = m * 60000;
void push();
TickTwo timer(push, in );

float t;
String sheetTemp = "";

const char* ssid = "WiFi Name"; //WiFi Name
const char* password = "WiFi Password"; //WiFi Password
const char* deviceName = "Device name"; //Device name

const char* host = "script.google.com";
const char *GScriptId = "scipt ID"; //scipt ID
const int httpsPort = 443;
const char* fingerprint = "";

// Write to Google Spreadsheet
String url = String("/macros/s/") + GScriptId + "/exec?";

String payload = "";

HTTPSRedirect* client = nullptr;

void setup() {
  Serial.begin(115200);
  timer.start();
  sensors.begin();
  Serial.println(in);
  Serial.flush();

  Serial.println();
  Serial.print("Connecting to wifi: ");
  Serial.println(ssid);
  Serial.flush();
  WiFi.mode(WIFI_STA);
  WiFi.hostname(deviceName);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());

  client = new HTTPSRedirect(httpsPort);
  client->setInsecure();
  client->setPrintResponseBody(true);
  client->setContentTypeHeader("application/json");

  Serial.print("Connecting to ");
  Serial.println(host);

  bool flag = false;
  for (int i = 0; i < 5; i++) {
    int retval = client->connect(host, httpsPort);
    if (retval == 1) {
      flag = true;
      break;
    }
    else
      Serial.println("Connection failed. Retrying...");
  }

  if (!flag) {
    Serial.print("Could not connect to server: ");
    Serial.println(host);
    Serial.println("Exiting...");
    return;
  }

  delete client;
  client = nullptr;

}

void loop() {
  timer.update();
}

void push() {
  Serial.println("Start of Push Function");

  Serial.print("Requesting temperatures...");
  sensors.requestTemperatures(); // Send the command to get temperatures
  Serial.println("DONE");
  float t = sensors.getTempCByIndex(0);
  if (t != DEVICE_DISCONNECTED_C)
  {
    Serial.print("Temperature for the device is: ");
    Serial.println(t);
  }
  else
  {
    Serial.println("Error: Could not read temperature data");
  }
  sheetTemp = String(t);

  payload = sheetTemp;

  static int error_count = 0;
  static int connect_count = 0;
  const unsigned int MAX_CONNECT = 20;
  static bool flag = false;

  if (!flag) {
    client = new HTTPSRedirect(httpsPort);
    client->setInsecure();
    flag = true;
    client->setPrintResponseBody(true);
    client->setContentTypeHeader("application/json");
  }


  if (client != nullptr) {
    if (!client->connected()) {
      client->connect(host, httpsPort);
    }
  }
  else {
    DPRINTLN("Error creating client object!");
    error_count = 5;
  }

  if (connect_count > MAX_CONNECT) {
    connect_count = 0;
    flag = false;
    delete client;
  }

  if (client->POST(url, host, payload, false)) {
    Serial.println("Uploading temperature to Google Sheet");
  }
  else {
    ++error_count;
    DPRINT("Error-count while connecting: ");
    DPRINTLN(error_count);
  }

  if (error_count > 3) {
    Serial.println("Halting processor...");
    delete client;
    client = nullptr;
    Serial.flush();
  }
  delete client;
  client = nullptr;
  flag = false;
  Serial.println("End of Push Function");
}

Formattazione dei dati:

Wemos Dashboard
Esempio di come i dati possono essere mostrati in Google Sheet.

La lettura del sensore sono inviate al foglio di lavoro che hai selezionato, con ogni lettura inserita alla prima linea vuota e disponibile, il che significa che possiamo usare Row 1 per descrivere i valori di ogni colonna.

Il vantaggio di usare Google Sheets é che oltre ad essere gratuito, ci permette di manipolare questi dati molto facilmente e creare un’interfaccia facilmente leggibile da smartphone.

Questo é un esempio del mio setup, che mi permette di vedere temperature Minime, Massime e Medie per vari periodo di tempo, un grafico della temperatura e una sezione contenenti le ultime 3 osservazioni fatte.

Sull'Autore...

Josh Coppola
Josh Coppola

Josh Coppola, nato nel 1991 a Salerno, fin da subito sviluppa una passione per animali e la natura in generale, con un interesse particolare verso anfibi e rettili. Si trasferisce a Londra dopo il liceo per conseguire un BSc in Business Studies alla Cass Business School, dovendo rinunciare all’allevamento di animali per 10 anni.

Nel 2017 riprende l’allevamento di caudata, per poi interessarsi anche alla fotografia ma con pessimi risultati.

“Come obiettivo vorrei concentrarmi sulla riproduzione in cattività di specie rare e poco diffuse in terraristica, così da poterle diffondere ed evitare che scompaiono dall’hobby per sempre.”