[LaPa1]

MoGreen



Premessa: ho deciso di pubblicare il progetto, che è abbastanza lungo da descrivere, a puntate, non potrei fare altrimenti, me ne scuso in anticipo. Cercherò di descrivere il progetto passo passo, il più dettagliatamente possibile, in modo che anche chi non ha dimestichezza possa seguirlo.



Che cos'è MoGreen: è una strumentazione basata su Raspberry Pi connessa a 4 sensori, ad un modulo Cam e che comanda l'accenzione di un faretto led che serve, se c'è necessità, ad illuminare la scena per le riprese. Il linguaggio usato è Python e i vari script sono lanciati da Crontab.



Cosa fa MoGreen: rileva dati ambientali, fa foto e filmati delle piante invia il tutto su web e conserva, dati, foto e filmati anche in locale.



A cosa serve MoGreen:

• Il rilievo dei dati può essere utile per verificare se le condizioni ambientali coincidono o meno con quelli ottimali per la crescita delle piante.
  
• Modificare le condizioni di crescita: la serra, a differenza della coltivazione in pieno campo, consente di modificare molti parametri ambientali che influenzano la crescita delle piante pertanto un monitoraggio continuo può essere utile per correggere le condizioni in tempo reale. MoGreen non comanda attuatori e quindi non è utilizzabile per automatizzare la serra.
  
• Tenere sotto controllo altri organismi viventi presenti in serra: in serra non ci sono solamente le piante coltivate ma anche molti altri esseri viventi. Alcuni di questi possono ostacolare la crescita (parassiti) delle piante altri (ausiliari) invece l’agevolano. Il monitoraggio può aiutarci a capire se l’ambiente, in un determinato periodo, può agevolare un parassita od ostacolare un ausiliario e viceversa. Capire questo può aiutarci a prendere delle decisioni favorevoli alle piante. Ci sono molti modelli matematici di crescita, sia di specie coltivate che di parassiti che di ausiliari che partendo da dati ambientali ci rivelano il tasso di crescita dei vari organismi che vivono in serra, MoGreen rende facilmente utilizzabili tali modelli. Anche questo può aiutarci a prendere decisioni per migliorare lo sviluppo e/o la produttività delle piante coltivate.
  
• Il monitoraggio visivo, nato quasi per caso in questo progetto, può darci conferma o meno delle scelte di conduzione della coltivazione, è un sistema ulteriore di monitoraggio. In una prova di collaudo sono riuscito a catturare il progresso dell’attacco di un parassita, il filmato fornisce le esatte condizioni ambientali e il momento esatto in cui è avvenuto. Lo stesso dicasi se si vuole individuare con precisione la data in cui c’è stata una determinata fase di crescita delle piante (ad esempio l’inizio della fioritura) o i giorni che intercorrono tra 2 fasi (ad esempio inizio fioritura ed inizio raccolta) quando ci sono determinate condizioni ambientali che vengono nel frattempo rilevate in continuo.
  
• Verifica e studio ex post: i dati e filmati sono conservati in memoria locale possono essere utili per lo ripercorrere sotto vari aspetti la stagione di crescita e prendere decisioni per le stagioni successive.
  

A chi può interessare:

• Tecnici in ambito agricolo che forniscono consulenza alle aziende agricole per il miglioramento della redditività e della sostenibilità ambientale delle colture.
  
• Studenti degli istituti tecnici o professionali o università ad indirizzo agrario che hanno la possibilità di istallare MoGreen in una serra per fare un’esperienza applicativa di quanto hanno studiato.
  
• Agricoltori che conducono colture in serra.
  
• Chiunque abbia una serra per la coltivazione di piante anche a scopo non professionale.
  

Punti di forza:

• Estrema duttilità degli output che sono generati su GoogleSheet: chi sa usare i fogli elettronici può elaborare nel modo più svariato i dati rilevati, esistono molti modelli che simulano la crescita a partire dalle condizioni ambientali rilevate, sia delle piante che di altri organismi viventi che popolano la serra.
  
• Dati disponibili su web in tempo reale
  
• Output multimediale consente una verifica in tempo reale dell'andamento delle colture in serra
  
• BackUp dei dati in automatico
  
• Collaudato in situazione reale
  

Punti deboli

• sono un principiante: errori o script migliorabili.
  
• I sensori avrebbero bisogno di una calibrazione iniziale ma non saprei come farla.
  

I rilievi:

• I parametri rilevati: temperatura, umidità relativa, luce, umidità del suolo a 10 e 20 Cm. di profondità ogni 15 minuti.
  
• Rilievi fotografici: ogni 30 minuti viene scattata una foto alle piante nel visibile. Le foto vengono scattate anche al buio con l’ausilio di una lampada che illumina il soggetto quando la luce scende al di sotto di un valore soglia. Sulla foto vengono sovrascritti i dati rilevati al momento dello scatto.
  
• Video in timelapse: 2 volte a settimana le foto scattate vengono utilizzate per produrre in automatico un video timelapse delle piante nei precedenti 3 o 4 giorni.
  

Output:

• 1) in una cartella Excell salvata in locale sono riportati tutti i dati rilevati
  
• 2) gli stessi dati vengono inviati in tempo reale in un foglio condiviso GoogleSheet visibili pertanto in rete
  
• 3) le foto vengono salvate in locale in una memoria USB collegata al Raspberry.
  
• 4) le foto vengono inviate in tempo reale su spazio web. Sulla foto come già menzionato sono riportati data ora e tutti i rilievi di cui sopra. In effetti la foto sostituisce un display, di cui MoGreen non è dotato, che riporta oltre alla riproduzione fotografica delle piante gli ultimi dati rilevati. A differenza di un display in prossimità dell’attrezzatura foto e dati sono visibili anche da remoto.
  
• 5) i video prodotti, analogamente alle foto, vengono salvati in locale ed inviati in tempo reale su spazio web.
  
• 6) possono essere impostati allarmi per l’umidità del suolo che vengono inviati via eMail.
  
• 7) elaborazione dei dati rilevati:   
  
• il software fa le medie orarie e le inserisce in un foglio di Excell “ultime 48 ore”
  
• Dalle medie dei dati orari vengono elaborati i dati giornalieri, che vengono inseriti in altri fogli: “ultimaSettimana”, “ultime2settimane”, “ultimoMese”.
  
• I dati elaborati vengono poi copiati dalla cartella Excell a quella GoogleSheet in modo da essere disponibili in rete.
  
• Ho sfruttato l’estrema duttilità dei fogli elettronici per fare della cartella Google una vera e propria interfaccia utente o cruscotto. Ci sono dei fogli da cui si possono impostare alcuni parametri richiesti da MoGreen, e ho aggiunto i grafici dei rilievi e delle loro medie che si aggiornano in tempo reale.
  
• In un foglio vengono inseriti in automatico gli indirizzi dei timelapse che vengono via via prodotti.
  

Esempi di elaborazione



Se si ha dimestichezza con i fogli elettronici, si possono aggiungere nella cartella Google infiniti altri fogli riportanti elaborazioni che usano come input i dati rilevati e le loro medie e forniscono indicazioni descritte precedentemente o altro ancora. A titolo d’esempio in un foglio possono essere riportati nello stesso grafico le temperature ottimali per la pianta durante le ore della giornata (che variano in funzione della luce) e le temperature realmente rilevate. La differenza tra le due curve sul grafico fornisce con immediatezza la possibilità di miglioramento regolando meglio il sistema di riscaldamento o l’apertura delle finestre della serra.













Lista della spesa:



Materiali e prezzo in Euro

• Raspberry pi 3 mod B   35
  
• Alimentatore ufficiale Raspberry   12
  
• Raspberry Pi camera module V2   11
  
• Raspberry Camera Flex Cable da 1 metro 7
  
• microSD da 32 Giga  12
  
• Supporto orientabile per Raspberry Pi camera module
  (ho adattato un stativo per cellulare)   8
  
• 1 relay   4
  
• una porzione di millefori   1
  
• una resistenza da 1000 ohm   1
  
• un sensore BME 280   12
  
• un sensore VEML 7700   8
  
• due sensori SoilWatch10 di Pino-tech   40
  
• un Regolatore di Tensione Step Down Modulo di Alimentazione
  4.75V-12V a 3.3V 800mA   1
  
• un extender LTC 4311   10
  
• un convertitore analogico digitale ADS 1115   15
  
• Cavo Ethernet Cat5e   10
  
• Un faretto LED 220 V.    25
  
• Una scatola di derivazione da esterno   10
  
• Un router wifi portatile con SIM (tipo saponetta) con alimentatore.   60
  
• Una ciabatta con interruttore con 4 o 5 prese   10
  
• Nastro adesivo da elettricista   1
  
• Fascette stringifilo   1
  
• Memoria USB da 16 o 32 GB   10
  
  

Collegamenti di MoGreen





Per aiutare una piccola legenda:

rosso =  5v.

arancione = 3.3 v.

nero = GND

porpora = segnale del GPIO 6 per relay

blu = SDA della I2C

giallo = SCL della I2C

grigio = segnale del sensore della bagnatura del suolo 1

rosa = segnale del sensore della bagnatura del suolo 2



I sensori sono collegati con Cavo Ethernet Cat5e, per suggerimenti su come collegarli vedi:

https://forum.raspberryitaly.com/showthr...036&page=4  e

https://forum.raspberryitaly.com/showthr...036&page=5



Alcuni dettagli:

Collegamento Raspbery-stepdown-extender:



Collegamento LTC4211  2 sensori I2C



Collegamento ADS111 con 2 sensori analogici di bagnatura del suolo



Collegamento relay



Schema collegamenti





Link ad ingrandimenti di alcune immagini dello schema

Dettaglio RPI-relay-farettoLed

Dettaglio stepDown-extender

Dettaglio extender-BME280-VEML7700

Dettaglio ADS1115-2SoilWatch

Suggerimenti, messi in atto, di Riccardo Lisci del Dipartimento di Scienze e Tecnologie Agrarie dell'Università di Firenze: 

1) eliminare 2 resistenze presenti nell'ADC1115

metto i link alle immagini del dettaglio

Dettaglio ADS1115 integro

Dettaglio delle resistenze da eliminare

Dettaglio ADS1115 con le 2 resistenze eliminate

2) su ADS1115 collegare con ponticello ADDR e GND.

Ippogrifo, che ringrazio per le correzioni ai collegamenti, suggerisce di prendere anche il 3.3 v del relay dallo step-down.

_________________________________________________________________



Preparazione del raspberry:

Abilitare la telecamera

Modificare il clock della porta I2C https://www.raspberrypi-spy.co.uk/2018/0...bus-speed/ a 30000 Hz

Assegnare un indirizzo statico al Rapberry Pi

Installare Anydesk https://forum.raspberryitaly.com/showthr...p?tid=7014

per collegarsi al Raspberry Pi da remoto. (in alternativa si può fare lo stesso pi connect).

Gli script Python che seguono agiscono su file in specifiche posizioni con nomi e struttura specifiche che riporto di seguito queste si possono variare adattando lo script alle proprie esigenze:

Le posizioni e nomi delle directory utilizzate

/home/pi/plant+out/store.xlsx

/home/pi/plant+out/PlantToWeb/

/home/pi/plant+out/plantout1logger-**********.json (Service Account Credentials)

/media/pi/indirizzoMemoriaUSB/FotoDiPiante

/home/pi/plant+out/errori/



_________________________________________________________________________



nome del file excell da usare come data logger: store.xslx

nomi dei Fogli di store.xlsx

Sheet1

ultime48ore

ultimaSettimana

ultime2settimane

ultimoMese

datiOrari

datiGiornalieri

videoInLocale

videoSuWeb

___________________________________________



Creare un account google scegliendo un indirizzo eMail per attivare un servizio GoogleSheet API su Google Cloud Platform.

Ciò serve per aggiornare in automatico il foglio Google con i dati rilevati. In pratica i dati conservati in locale su file store,xslx vengono copiati su foglioGoogle.



Vedi 

https://docs.google.com/spreadsheets/d/1...id=0#gid=0

________________________________________________



Abilitare MoGreen ad inviare i dati all’applicazione “Fogli” di Google.



Questa parte è abbastanza complessa, almeno per me, e cercherò di dare ulteriori dettagli.

“Fogli” di Google mette a disposizione dei fogli elettronici a cui si può accedere on-line.

Tali fogli elettronici, generalmente, sono visibili da chi possiede il link. Il proprietario può decidere chi può editarlo.

L'idea, si trovano in rete altri esempi simili, è quella di usare questo sistema come data logger di MoGreen. E' necessario fare in modo che il codice Python, che gira su MoGreen, sia in grado di inviare i dati rilevati al Foglio Google specifico al cui interno questi vengono scritti e conservati. Per fare questo si rende necessaria una procedura su Google Cloud Plataform i cui passaggi cercherò di elencare di seguito.



Creare un progetto

1) andare su https://console.cloud.google.com

2) accedi con un account google ( o creane uno apposito)

3) crea un nuovo progetto o utilizzane uno creato in passato

4) scegliere come servizio GoogleSheet API

5) Compilare “Schermata di consenso Oauth”

a) Tipo di User: “esterno”

b) nella schermata di riepilogo appare il nome del progetto assegnato e l’ indirizzo eMail dell’account

6) credenziali:

Creare account di servizio

1. dettagli dell’account di servizio
   
2. nome dell’account di servizio (lo inserisce in automatico = al nome del progetto)
   
   2. ID account di servizio (lo assegna il sistema non si può cambiare)
      
   3. descrizione (possiamo aggiungerlo noi)
      
   4. clicca su crea sulla sezione “dettagli account di servizio” per creare l’account di servizio
      
3. Sezione “concedi a questo account di servizio l’accesso al progetto”
   
   2. Scegli “editor”, accede all’applicazione fogli e può scrivere i dati
      
   3. clicca “continua”
      
   4. clicca “fine”
      
      Creare credenziali
      
4. spuntare “account di servizio” email e l’eMail assegnata dal sistema (e’ la mail che da Google Fogli dobbiamo autorizzare con editor col tasto “condividi”)
   
5. spuntare “mostra delega a livello di dominio”
   
6. spuntare “abilita delega su tutto il dominio G-Suite
   
7. clicca su salva
   
8. Vai alla sezione “chiavi” nel menu in alto
   
   2. Clicca su “aggiungi chiave”
      
   3. e poi su “crea nuova chiave”
      
   4. Nella finestra di dialogo “crea nuova chiave per NOMEPROGETTO” clicca sul bottone di opzione “JSON”
      
   5. clicca su crea
      
   6. il sistema crea un file con estenzione JSON e ci chiede dove salvarlo
      

ATTENZIONE: andare sul foglioGoogle utilizzato come data logger e condividere l’eMail di account di servizio come “editor” per permettere all’applicazione Python di scrivere nel foglio.



In sintesi lo scopo è ottenere:

1. una eMail di account di servizio che è la mail che bisogna autorizzare con il tasto “Condividi” di GoogleFogli;
   
2. un file .json (chiave o credenziali ) di cui lo script di Python si serve per accedere al GoogleFoglio e scrivere i dati.
   

I passaggi su Google Cloud Plataform  sono descritti in questa presentazione .

________________________________________________



Nomi dei fogli su Fogli di Google, analogamente ai fogli di store.xslx anche i fogli di googleFogli (RpiPlantOut1Logger) devono essere:

Sheet1

ultime48ore

ultimaSettimana

ultime2settimane

ultimoMese

datiOrari

datiGiornalieri

video

ImpostazioniPlant+Out



nei primi 7 fogli sia in locale che su GoogleFogli le intestazioni delle colonne saranno le seguenti:

colonna 1: Data ora 

colonna 2:Temperatura dell'aria

colonna 3:Umidità Relativa

colonna 4: Luce

colonna 5: Bagnatura del suolo superficiale.

colonna 6: Lasciare vuoto

Colonna 7: Bagnatura del suolo profonda.

Colonna 18: lasciare vuota



Su googleFogli si possono aggiungere grafici, che si aggiornano in automatico, o ulteriori fogli per elaborare i dati mediante modelli.

Aprire un sito web per inviare le foto e i filmati: io ho scelto uno spazio web gratuito con Altervista per inviare le foto, esempio: http://rpiplant.altervista.org/ultima.jpg

e i filmati, esempio: http://www.rpiplant.altervista.org/movie..._03e16.mp4

Fare un abbonamento dati di almeno 5 GB al mese sulla SIM che va inserita nel modem.

Inserire password del WiFi del modem su Raspberry Pi per permettere la connessione.

_____________________________________________________________



Codice





Il codice è suddiviso in 4 parti.

I primi 3 codici riguardano il rilievo dei sensori e la scrittura dei rilievi nel foglio Excell (che si chiama store.xlsx)

Il quarto codice esegue tutte le altre elaborazioni dei rilievi effettuati.

I rilievi e le elaborazioni vengono effettuati ogni 15 minuti.

Al fine di distanziare sufficientemente i rilievi tra loro e dalle elaboarazioni in realtà i rilievi e le elaborazioni sono distanziati di qualche minuto:

1) Il rilievo della temperatura e umidità relativa viene effettuato 3 minuti prima dello scorrare dei 15 minuti: a 12, 27, 42, 57.

2) Il rilievo della luce viene effettuato 2 minuti prima dello scorrare dei 15 minuti: a 13, 28, 43, 59

3) Il rilievo della bagnatura del suolo alle 2 profondità viene effettuato 1 minuto prima dello scorrare dei 15 minuti: a 14, 29, 44, 59.

4) Tutte le altre funzioni ed elaborazioni dei dati vengono effettuate ogni 15 minuti: 15, 30, 45, 0

I 4 script vengono lanciati da crontab

per eseguire i codici relativi al rilievo dei sensori e alla scrittura su Excell è necessario installare le seguenti librerie:

1) smbus

2) openpyxl

Primo script esegue:

rilievo della temperatura ed umidità relativa

scrittura dei 2 dati in store.xlsx

scrittura della data e dell'ora del rilievo in store.xslx

Codice:

# -*- coding: utf-8 -*-























#lettura e scrittura BME280 come primo lettore e anche della data















#qui inserisco il codice di lettura del sensore, per le prove a casa scrivo già dei valori rilevati







import smbus







import time







# nel caso bus.close() non sia sufficiene ad evitare i conflitti provare con del smbus alla fine di lettura e







# import smbus prima della lettura del successivo







from ctypes import c_short







#from ctypes import c_byte







#from ctypes import c_ubyte







DEVICE = 0x76 # Default device I2C address























bus = smbus.SMBus(1) # Rev 2 Pi, Pi 2 & Pi 3 uses bus 1







                    # Rev 1 Pi uses bus 0















def getShort(data, index):







  # return two bytes from data as a signed 16-bit value







    return c_short((data[index+1] << 8) + data[index]).value















def getUShort(data, index):







  # return two bytes from data as an unsigned 16-bit value







    return (data[index+1] << 8) + data[index]















def getChar(data,index):







  # return one byte from data as a signed char







    result = data[index]







    if result > 127:







        result -= 256







    return result















def getUChar(data,index):







  # return one byte from data as an unsigned char







    result =  data[index] & 0xFF







    return result















def readBME280ID(addr=DEVICE):







  # Chip ID Register Address







    REG_ID    = 0xD0







    (chip_id, chip_version) = bus.read_i2c_block_data(addr, REG_ID, 2)







    return (chip_id, chip_version)















def readBME280All(addr=DEVICE):







    # Register Addresses







    REG_DATA = 0xF7







    REG_CONTROL = 0xF4







    REG_CONFIG  = 0xF5















    REG_CONTROL_HUM = 0xF2







    REG_HUM_MSB = 0xFD







    REG_HUM_LSB = 0xFE















  # Oversample setting - page 27







    OVERSAMPLE_TEMP = 2







    OVERSAMPLE_PRES = 2







    MODE = 1















  # Oversample setting for humidity register - page 26







    OVERSAMPLE_HUM = 2







    bus.write_byte_data(addr, REG_CONTROL_HUM, OVERSAMPLE_HUM)















    control = OVERSAMPLE_TEMP<<5 | OVERSAMPLE_PRES<<2 | MODE







    bus.write_byte_data(addr, REG_CONTROL, control)















  # Read blocks of calibration data from EEPROM







  # See Page 22 data sheet







    cal1 = bus.read_i2c_block_data(addr, 0x88, 24)







    cal2 = bus.read_i2c_block_data(addr, 0xA1, 1)







    cal3 = bus.read_i2c_block_data(addr, 0xE1, 7)















  # Convert byte data to word values







    dig_T1 = getUShort(cal1, 0)







    dig_T2 = getShort(cal1, 2)







    dig_T3 = getShort(cal1, 4)















    dig_P1 = getUShort(cal1, 6)







    dig_P2 = getShort(cal1, 8)







    dig_P3 = getShort(cal1, 10)







    dig_P4 = getShort(cal1, 12)







    dig_P5 = getShort(cal1, 14)







    dig_P6 = getShort(cal1, 16)







    dig_P7 = getShort(cal1, 18)







    dig_P8 = getShort(cal1, 20)







    dig_P9 = getShort(cal1, 22)















    dig_H1 = getUChar(cal2, 0)







    dig_H2 = getShort(cal3, 0)







    dig_H3 = getUChar(cal3, 2)















    dig_H4 = getChar(cal3, 3)







    dig_H4 = (dig_H4 << 24) >> 20







    dig_H4 = dig_H4 | (getChar(cal3, 4) & 0x0F)















    dig_H5 = getChar(cal3, 5)







    dig_H5 = (dig_H5 << 24) >> 20







    dig_H5 = dig_H5 | (getUChar(cal3, 4) >> 4 & 0x0F)















    dig_H6 = getChar(cal3, 6)















  # Wait in ms (Datasheet Appendix B: Measurement time and current calculation)







    wait_time = 1.25 + (2.3 * OVERSAMPLE_TEMP) + ((2.3 * OVERSAMPLE_PRES) + 0.575) + ((2.3 * OVERSAMPLE_HUM)+0.575)







    time.sleep(wait_time/1000)  # Wait the required time 















  # Read temperature/pressure/humidity







    data = bus.read_i2c_block_data(addr, REG_DATA, 8)







    pres_raw = (data[0] << 12) | (data[1] << 4) | (data[2] >> 4)







    temp_raw = (data[3] << 12) | (data[4] << 4) | (data[5] >> 4)







    hum_raw = (data[6] << 8) | data[7]















  #Refine temperature







    var1 = ((((temp_raw>>3)-(dig_T1<<1)))*(dig_T2)) >> 11







    var2 = (((((temp_raw>>4) - (dig_T1)) * ((temp_raw>>4) - (dig_T1))) >> 12) * (dig_T3)) >> 14







    t_fine = var1+var2







    temperature = float(((t_fine * 5) + 128) >> 8);















  # Refine pressure and adjust for temperature







    var1 = t_fine / 2.0 - 64000.0







    var2 = var1 * var1 * dig_P6 / 32768.0







    var2 = var2 + var1 * dig_P5 * 2.0







    var2 = var2 / 4.0 + dig_P4 * 65536.0







    var1 = (dig_P3 * var1 * var1 / 524288.0 + dig_P2 * var1) / 524288.0







    var1 = (1.0 + var1 / 32768.0) * dig_P1







    if var1 == 0:







        pressure=0







    else:







        pressure = 1048576.0 - pres_raw







        pressure = ((pressure - var2 / 4096.0) * 6250.0) / var1







        var1 = dig_P9 * pressure * pressure / 2147483648.0







        var2 = pressure * dig_P8 / 32768.0







        pressure = pressure + (var1 + var2 + dig_P7) / 16.0















  # Refine humidity







    humidity = t_fine - 76800.0







    humidity = (hum_raw - (dig_H4 * 64.0 + dig_H5 / 16384.0 * humidity)) * (dig_H2 / 65536.0 * (1.0 + dig_H6 / 67108864.0 * humidity * (1.0 + dig_H3 / 67108864.0 * humidity)))







    humidity = humidity * (1.0 - dig_H1 * humidity / 524288.0)







    if humidity > 100:







        humidity = 100







    elif humidity < 0:







        humidity = 0















    return temperature/100.0,pressure/100.0,humidity















def main():















    (chip_id, chip_version) = readBME280ID()







    print ("Chip ID    :", chip_id)







    print ("Version    :", chip_version)















    temperature,pressure,humidity = readBME280All()







    pressure=round(pressure,2)







    humidity=round(humidity,2)















    print ("Temperature : ", temperature, "C")







    print ("Pressure : ", pressure, "hPa")







    print ("Humidity : ", humidity, "%")















if __name__=="__main__":







    main()







temperature,pressure,humidity = readBME280All()







#print (temperature)















#chiamo la temperatura dell'aria taria







taria=temperature















print (taria)















#time.sleep(1)























#chiamo l'umidità dell'aria RH







RH=round(humidity,2)







print (RH)







bus.close()







del smbus























#importo tutti i moduli per la scrittura







import openpyxl







#importo la libreria per scrivere su excell: la dat va i colonna A, taria in colonna B, RH in colonna C















from datetime import datetime, timedelta























now=datetime.now()







ora=now.strftime('%d/%m/%Y %H:%M:%S')







print("l'ora attuale è ", ora," ma a questa devo aggiungere 3 minuti")







#a questa ora dovrei aggiungere 3 minuti







#ritrasformo ora in oggetto date time per aggiungere 3 minuti







ora=datetime.strptime(ora,'%d/%m/%Y %H:%M:%S')#trasformo in oggetto datetime







#print(ora)







oraPiu3=ora+timedelta(minutes=3)#aggiungo 3 minuti







print(oraPiu3)







oraPiu3=oraPiu3.strftime('%d/%m/%Y %H:%M:%S')#trasformo in str in formato italiano







print("l'ora da scrivere nel foglio è ", oraPiu3)























#wb=openpyxl.load_workbook("/home/pi/plant+out/store.xlsx", data_only=True)







#per le prove a casa store è in questa posizione







wb=openpyxl.load_workbook("/home/pi/plant+out/store.xlsx", data_only=True)







ws=wb["Sheet1"]







#conta il numero di righe già scritte per scrivere i dati nella riga giusta







nr=ws.max_row







print ("la riga di scrittura di ws di store è ",nr)







#scrivo la data nella casellina giusta







lista=[oraPiu3,taria,RH]







print(lista)







ws.append(lista)







wb.save('/home/pi/plant+out/store.xlsx')







print("ho scritto la data e ora, la temperatura e l'umidità relativa in store \n , ho salvato store.xlsx, ora deimporto la libreria openpyxl")







del openpyxl







print("termino il programma")







#bus.close()







#del smbus

Il codice che segue serve per rilevare la luce con il sensore VEML7700, ho impostato lo script per rilevare fino a 120 000 Lux a scapito della precisione del rilievo ma all'aperto in estate è possibile avere dei valori maggiore di 100 000 lux. Dopo il rilievo il codice scrive il valore in store.xlsx.

Lo script si chiama "rilievoLuceEScritturaSuStore.py" ed utilizza le 2 librerie viste precedentemente

Codice:

import smbus



bus = smbus.SMBus(1)







addr = 0x10







#Write registers



als_conf_0 = 0x00



als_WH = 0x01



als_WL = 0x02



pow_sav = 0x03







#Read registers



als = 0x04



white = 0x05



interrupt = 0x06











# These settings will provide the max range for the sensor (0-120Klx)



# but at the lowest precision:



#              LSB  MSB



confValues = [0x00, 0x13] # 1/8 gain, 25ms IT (Integration Time)



#Reference data sheet Table 1 for configuration settings







interrupt_high = [0x00, 0x00] # Clear values



#Reference data sheet Table 2 for High Threshold







interrupt_low = [0x00, 0x00] # Clear values



#Reference data sheet Table 3 for Low Threshold







power_save_mode = [0x00, 0x00] # Clear values



#Reference data sheet Table 4 for Power Saving Modes







bus.write_i2c_block_data(addr, als_conf_0, confValues)



bus.write_i2c_block_data(addr, als_WH, interrupt_high)



bus.write_i2c_block_data(addr, als_WL, interrupt_low)



bus.write_i2c_block_data(addr, pow_sav, power_save_mode)















word = bus.read_word_data(addr,als)



gain = 1.8432 #Gain for 1/8 gain & 25ms IT



#Reference www.vishay.com/docs/84323/designingveml7700.pdf



# 'Calculating the LUX Level'



print(word)



val = word * gain



valcorr = (6.0135E-13*val**4)-(9.392E-9*val**3)+(8.1488E-5*val**2)+(1.0023E00*val)



valcorr = round(valcorr,1) #Round corrected value for presentation



val = round(val,1) #Round value for presentation



print(val)



print(valcorr)



diff=valcorr-val



if val>100:



    val=valcorr



else:



    val=val



print ("il valore di lumminosità è ",str(val), " per valori > di 100 è stata applicata la formula di correzione")



print ("tale valore in float è ", float(val))



print ("la differenza del rilievo applicando la formula di correzione è ", diff)



lux=val



print ("ora dovrei aver definito il valore rilevato di luce lux che è ", lux)



bus.close()



print("Il valore di luce rilevata è ", lux)



del smbus



#importo tutti i moduli per la scrittura



import openpyxl



#importo la libreria per scrivere su excell: la dat va i colonna A, taria in colonna B, RH in colonna C















#wb=openpyxl.load_workbook("/home/pi/plant+out/store.xlsx", data_only=True)



#per le prove a casa store è in questa posizione



wb=openpyxl.load_workbook("/home/pi/plant+out/store.xlsx", data_only=True)



ws=wb["Sheet1"]



#conta il numero di righe già scritte per scrivere i dati nella riga giusta



nr=ws.max_row



print ("la riga di scrittura di ws di store è ",nr)







#scrivo la data nella casellina giusta



ws.cell(row=nr, column=4).value=lux



wb.save('/home/pi/plant+out/store.xlsx')



print("ho scritto il valore rilevato di luce in store \n , ho salvato store.xlsx, ora deimporto la libreria openpyxl")



del openpyxl



print("termino il programma")



#bus.close()



#del smbus

Segue il codice relativo al rilievo dei 2 sensori di umidità del suolo. Attenzione il codice contiene anche la scrittura in store.xslx di 2 temperature del suolo fittizie e deriva dal fatto che i sensori provati precedentemente misuravano anche la temperatura. Ho lasciato le colonne relative a questi rilievi perché conto in futuro di aggiungere altri sensori per quei rilievi.

Le righe relative ai rilievi fittizi sono facilmente identificabili ed eliminabili.

l sensori di bagnatura del suolo sono analogici e i rilievi vengono effettuati mediante il convertitore ADS1115, pertanto lo script legge i valori dall'ADS1115

Guido Luttemberg mi ha fornito lo script per la lettura di ADS1115, io ho adattato lo script al rilievo SoilWtch10.

Per la lettura è necessaria la libreria smbus.

Codice:

'''



@author: pasquale delli paoli, guido lutterbach



@contact: pasqualedellipaoli@libero.it



@version: 1.0



@licence: Public Domain







'''



 



import time, smbus



   



# ADS1115 + hardware constants



I2C_BUS = 1



DEVICE_ADDRESS = 0x48



POINTER_CONVERSION = 0x0



POINTER_CONFIGURATION = 0x1



POINTER_LOW_THRESHOLD = 0x2



POINTER_HIGH_THRESHOLD = 0x3



   



RESET_ADDRESS = 0b0000000



RESET_COMMAND = 0b00000110



   



# Open I2C device



BUS = smbus.SMBus(I2C_BUS)



BUS.open(I2C_BUS)



       



def swap2Bytes(c):



    '''Revert Byte order for Words (2 Bytes, 16 Bit).'''



    return (c>>8 |c<<8)&0xFFFF



   



def prepareLEconf(BEconf):



    '''Prepare LittleEndian Byte pattern from BigEndian configuration string, with separators.'''



    c = int(BEconf.replace('-',''), base=2)



    return swap2Bytes(c)



   



def LEtoBE(c):



    '''Little Endian to BigEndian conversion for signed 2Byte integers (2 complement).'''



    c = swap2Bytes(c)



    if(c >= 2**15):



        c= c-2**16



    return c



   



def BEtoLE(c):



    '''BigEndian to LittleEndian conversion for signed 2 Byte integers (2 complement).'''



    if(c < 0):



        c= 2**16 + c



    return swap2Bytes(c)



   



def resetChip():



    BUS.write_byte(RESET_ADDRESS, RESET_COMMAND)



    return







# read A0 and A1 once



resetChip()



# compare with configuration settings from ADS115 datasheet



# start single conversion - AIN2/GND - 4.096V - single shot - 8SPS - X



# - X - X - disable comparator



confA0 = prepareLEconf('1-100-001-1-100-0-0-0-11')



confA1 = prepareLEconf('1-101-001-1-100-0-0-0-11')



BUS.write_word_data(DEVICE_ADDRESS, POINTER_CONFIGURATION, confA0)



# long enough to be safe that data acquisition (conversion) has completed



# may be calculated from data rate + some extra time for safety.



# check accuracy in any case.



time.sleep(0.5)



value_raw = BUS.read_word_data(DEVICE_ADDRESS, POINTER_CONVERSION)



value = LEtoBE(value_raw)



#print("A0:", value)



A0Volt=value*(4.096/32767)



print('il valore di bagnatura del suolo in sensore 1 in volt è ',A0Volt)



BS1 = 2.8432*A0Volt**3 - 9.1993*A0Volt**2 + 20.2553*A0Volt - 4.1882



bs1=round(BS1,2)



#print("il contenuto idrico in  volume del suolo del sensore 1 è ", BS1)



BUS.write_word_data(DEVICE_ADDRESS, POINTER_CONFIGURATION, confA1)



# long enough to be safe that data acquisition (conversion) has completed



# may be calculated from data rate + some extra time for safety.



# check accuracy in any case.



time.sleep(0.5)



value_raw = BUS.read_word_data(DEVICE_ADDRESS, POINTER_CONVERSION)



value = LEtoBE(value_raw)



#print("A1:",value)



A1Volt=value*(4.096/32767)



print('il valore di bagnatura del suolo in sensore 2 in volt è ',A1Volt)



BS2 = 2.8432*A1Volt**3 - 9.1993*A1Volt**2 + 20.2553*A1Volt - 4.1882



bs2=round(BS2,2)



#bs1, bs2 = readA0A1()



print('il valore di bagnatura del suolo in sensore 1 in % in volume è ',bs1)



print('il valore di bagnatura del suolo in sensore 2 in % in volume è ',bs2)



# Close I2C device



BUS.close()



print (bs1)



print(bs2)



ts1=20



ts2=18



print("la temperatura fittizia del suolo superficiale è ", ts1)



print("la temperatura fittizia del suolo profonda è ", ts2)



del smbus



#importo tutti i moduli per la scrittura



import openpyxl



#importo la libreria per scrivere su excell: la dat va i colonna A, taria in colonna B, RH in colonna C



#wb=openpyxl.load_workbook("/home/pi/plant+out/store.xlsx", data_only=True)



#per le prove a casa store è in questa posizione



wb=openpyxl.load_workbook("/home/pi/plant+out/store.xlsx", data_only=True)



ws=wb["Sheet1"]



#conta il numero di righe già scritte per scrivere i dati nella riga giusta



nr=ws.max_row



print ("la riga di scrittura di ws di store è ",nr)







#scrivo BS1 e BS2 nelle caselline giuste.



ws.cell(row=nr, column=5).value=bs1



ws.cell(row=nr, column=7).value=bs2



ws.cell(row=nr, column=6).value=ts1



ws.cell(row=nr, column=8).value=ts2







wb.save('/home/pi/plant+out/store.xlsx')



print("ho scritto i valori rilevati di bagnatura e temperatura fittizia suolo in store \n , ho salvato store.xlsx, ora deimporto la libreria openpyxl")



del openpyxl



print("termino il programma")



#bus.close()



#del smbus

Siamo alle battute finali: di seguito lo script che elabora i dati raccolti inserisce le elaboarazioni nel foglio elettronico “store” e ricopia il tutto su gSheet in modo che sia visibile da web. Lo script lancia le funzioni che scattano le foto e poi queste vengono conservate in una directory in una memoria usb e lanciate su web. Le foto ogni 3 o 4 giorni vengono montate in un timelapse. Anche questo viene poi salvato su memoria usb e inviato su web.

Conosco solo le basi di Python quindi con quelle ho dovuto fare anche cose che probabilmente non erano alla mia portata. Ci sono sicuramente delle ridondanze, delle cose cose che non seguono sempre una logica lineare, il tutto è ottimizzabile tuttavia funziona. Un vantaggio potrebbe essere che un principiante può sicuramente seguirne la logica.

Nella prima parte dello script ci sono le funzioni. In una seconda parte dello script ci sono le condizioni di momento del giorno e connessione attiva per lanciare le funzioni della prima parte. Nella terza parte vengono lanciate le funzioni nei momenti opportuni.  Il file si chiama moGreen e viene lanciato dal crontab una volta ogni 15 minuti.





Per districarmi tra le 21 funzioni ho usato questa tabella che penso possa essere utile.







Lo script lo collego con il link che segue perchè ha molte righe



Script per elaboarazioni dati rilevati foto e filmati



Montaggio

Per facilitare il montaggio i 4 sensori non sono collegati direttamente alla millefori ma li ho collegati a questa mediante connettori quadripolari maschio/femmina.

Pertanto nella scatola di derivazione, oltre al Raspberry Pi,  è alloggiata la millefori a cui sono saldati i componenti, assicurati entrambi alla parete della scatola, opportunamente forata, mediante stringifili.

Dai fori della scatola usciranno:

1) i quattro connettori quadripolari

2) Il connettore piatto del modulo cam

3) l’ingresso e l’uscita di un polo della 220 che collega il relay all’interno della scatola al faretto led esterno. 

4) il cavetto che collega il trasformatore del Raspberry al Raspberry stesso

E’ ovvio che MoGreen può essere montata solamente in serre dotate di corrente elettrica. In serre riscaldate e/o anche con un minimo di automatismi per aperture finestre pompe, fertilizzatori etc. etc. in genere arriva la corrente elettrica.

Solitamente i quadri elettrici sono posizionati in prossimità delle pareti esterne dove non ci sono piante. Le condizioni di temperatura e umidità sono molto influenzate dalla distanza dalle pareti.

Sarà dunque necessaria una prolunga, posizionata sulle strutture alte della serra, che colleghi il quadro elettrico a MoGreen.

Posizionare MoGreen al centro della serra in genere comporta un cavo molto lungo. Consiglierei una posizione intermedia anche per avere una rappresentazione di condizioni intermedie.

MoGreen va montato con la coltura già trapiantata.

Io ho montato il sistema ad uno dei pali metallici verticali che reggono le capriate delle serre legando la scatola, opportunamente forata, con stringifili. Sullo stesso palo ho posizionato una ciabatta con interruttore e almeno 4 prese (1 trasformatore del Raspberry Pi, 2 trasformatore del modem,  3 faretto led, 4 computer durante l'installazione e le verifiche)  e il modem wireless con stringifili o nastro adesivo.

Per posizionare i 2 SoilWatch è necessario fare una buca nel terreno di diametro di poco maggiore della lunghezza del sensore. Profonda almeno 30 Cm. I sensori vanno posti orizzontalmente in una zona intermedia tra un gocciolatore e l’altro e dove ci sono alte probabilità che si sviluppino radici. Per non rovinare i SoilWatch evitare d’inserirli direttamente nel terreno. introdurre al loro posto una lama di metallo più o meno delle stesse dimensioni del sensore e poi una volta estratta, nella fessura praticata dalla lama, inserire il sensore.

Ricoprire la buca con il terreno e chiudere il buco della pacciamatura, in genere è presente, con un telo di plastica.

Il sensore BME280 l’ho inserito in un un tubo di cartone (la parte interna di rotolo tipo Scottex) su cui ho praticato delle aperture orizzontali. Il sensore l’ho posizionato sospeso con dei fili al centro del tubo in modo che non tocchi le pareti. Il tutto l’ho fissato in prossimità del fusto di una pianta. 

Il VEML7700 va messo più in alto possibile assicurandosi che non capiti in una zona completamente ombreggiata da qualche struttura portante della serra. Durante il giorno sicuramente qualche struttura metallica metterà in ombra il sensore momentaneamente in quanto il sole si sposta nel corso della giornata.

A questo punto collegare i sensori, il modem e il faretto led alla ciabatta accendere l’interruttore di quest’ultima.

Io impiego circa 2 ore per arrivare a questo punto del montaggio e sarebbe opportuno che in quel momento si fosse all’imbrunire in quanto resta da fissare e orientare al palo sia la telecamera che il faretto led. Per questa operazione mi sono aiutato con un computer collegato via WLAN/VNC al Raspberry.  Sul  desktop di quest'ultimo ci sono i comandi da lanciare per accendere la lampada e scattare una foto che viene salvata sul medesimo Desktop. L’orientamento della telecamera e faretto  va fatto per tentativi successivi guardando le foto scattate ad ogni tentativo.

Una volta terminato il montaggio lasciate MoGreen fare il suo lavoro.



Ringraziamenti

L’intera comunità di Raspberryitaly ma in particolare Ippogrifo e Zzed

Nuzzopippo e Senbee del forum.ubuntu-it.org

Riccardo Lisci

Guido Lutterbach di smartyPie

Piotr Trembecki

Hakimi Wanyusof

Pasquini Pierpaolo e Ridulfo Santa Società Semplice Società Agricola

Meini Alessandro, Luciano, e Mirko Società Semplice Società Agricola

[ippogrifo]

Bel progetto, dopo diverso tempo di prove e test lo hai terminato con soddisfazione (immagino). Seguirò sicuramente le prossime puntate...

[LaPa1]

Bel progetto, dopo diverso tempo di prove e test lo hai terminato con soddisfazione (immagino). Seguirò sicuramente le prossime puntate...

Ti ringrazio  

Delle "diverse prove" ne sai qualcosa

[Zzed]

Il progetto ha un grande valore perché, a differenza della stragrande maggioranza dei tutorial e guide che si trovano in rete, è frutto di una esperienza reale sul campo di anni.
È la dimostrazione tangibile che quello che tutto funziona sulla scrivania, a volte, sul campo, può presentare diversi problemi, dovuti alle tante variabili ambientali e di progetto che si aggiungono nel calare nella realtà un progetto elettronico/informatico.
Grazie per condividerlo con la Community!
Attendiamo le prossime puntate!

[LaPa1]

Grazie
Confermo quanto detto da Zzed, altri magari sono più smaliziati e prevedono molte cose prima di provarle, ma nel mio caso avevo tutto montato in casa su piante in vaso e una volta completato il progetto l'ho provato per settimane: tutto scorreva liscio. Montato in serra non funzionava per più di qualche ora. I problemi erano molteplici nelle condizioni operative. C'ho messo un bel po' a superarli con l'aiuto di questa comunità e di altri ancora.
Ovviamente il collaudo continuerà, lo rimonterò in serra a fine inverno, ma il più è fatto.
A presto
LaPa

[LaPa1]

.... Ho aggiornato la lista della spesa con i prezzi: il tutto poco più di 300 Euro.

[LaPa1]

Ho inserito i collegamenti!

[LaPa1]

Sono andato un po' avanti

[LaPa1]

ho iniziato ad inserire il codice

[ippogrifo]

Ciao,
è veramente un bel progetto e mi complimento con te, anche per averlo condiviso. Chi ha necessità di monitorare situazioni simili non avrà altro da fare che seguire le tue indicazioni.