[LaPa1]

Premessa
Le Phanaelopsis sono le orchidee più comuni: quelle che un po’ tutto l’anno si trovano nei supermercati. Quando le compriamo hanno solitamente un aspetto vigoroso con foglie di un verde intenso, fiori, boccioli e radici verdi ed argentee fuori e dentro il vaso. Può capitare che dopo qualche tempo che le abbiamo portate a casa perdano un po’ di smalto.
Le piante si nutrono di luce, posizionarle correttamente in casa significa dare loro un pasto giornaliero misero o sufficiente a seconda della luce che ricevono. Nel caso delle orchidee soffrono anche se la luce è troppo intensa.
Un altro fattore che crea difficoltà per la comprensione della giusta luce da fornire alle piante è che i nostri occhi si adeguano moltissimo all’intensità di luce che c’è in un ambiente pertanto un luogo illuminato insufficientemente per le piante lo percepiamo molto illuminato per la capacità di adattamento dei nostri occhi e viceversa quando siamo esposti a luce molto intensa non la percepiamo come tale.
Infine, una ulteriore complicazione, è che la luce in una determinata posizione della nostra casa cambia durante il giorno e cambia durante le stagioni. Per questo motivo si è prevista una funziona che registra per 24 ore quello che succede. Non è escluso che in seguito ai rilievi con MOrLight si decida di posizionare le piante in un ambiente in inverno e di spostarle in un altro in estate, oppure di dotarsi di una grow lamp per aiutare la pianta in una determinata posizione della casa.
MOrLight mi è stato richiesto da un amico che coltiva orchidee a casa per passione. 
Però un po' di Phanaelopsis nel frattempo le ho comprate anche io 

Il progetto:
MorLight è un luxometro con alimentazione a batteria, basato sul microcontrollore Raspberry Pi Pico, un sensore VEML7700, e un display LCD 1602.

Le funzioni sono 2:
a) misura istantanea della luminosità ambiente in Lux mostrata su display insieme a giudizio “emesso” dalla pianta: buio, triste, felice, molto felice, oh no troppo! (la pianta generalmente viene dall’Olanda ma parla in inglese   ).
b) monitoraggio in continuo per 24 ore della luce in un determinato ambiente, registrazione dei dati e restituzione come media in lux e durata di esposizione nelle diverse fasce d’idoneità di luce: notte, buio, triste felice, molto felice, oh no troppo! I risultati possono essere richiesti in qualsiasi momento fino al prossimo ciclo di registrazione di 24 ore premendo il tasto rosso.

La lista della spesa.
Raspberry Pi Pico 1
Display LDC 1602 con adattatore I2C
DC-DC Step Down 5-16V a 1.25V/1.5V/1.8V/2.5V/3.3V/5V 3A
Scatola portabatteria per 4 stilo AA size con interruttore
Un pulsante senza scatto
porzione di millefori
fili per connessioni
Scatola per elettronica con coperchio trasparente da adattare al progetto o in alternativa un case 3D stampato ad hoc.

Connessioni
Il portabatterie è collegato allo step-down per avere 5 v. per alimentare il display e il Pico su pin 39
il sensore invece è alimentato dall’uscita a 3,3 v. del Pico su pin 36.
Il ground da pin 33
SDA del sensore e del display da pin 31
SCL del sensore e del display da pin 32
Il pulsante che attiva parte del codice è su pin 17 (GP13)



modifica hardware
Per lo step-down saldare il ponticello in corrispondenza dei 5 V.
l’adattatore I2C del display ha un led rosso: io l’ho eliminato con la punta di un taglierino per limitare i consumi soprattutto durante la registrazione di 24 ore.

Interprete: Circuitpython

struttura CIRCUITPY/
├── code.py
 |____luce.txt
   └── lib/
. 
librerie
dove reperirle: da https://circuitpython.org/libraries scaricare l’ultima versione Bundle.
Da questa scegliere le seguenti directory:
1) adafruit_bus_device
2) adafruit_mcp230xx
3) adafruit_register
4) il file “adafruit_veml7700.py”
5) la directory lcd.
Nella directory lcd accertarsi che ci siano i seguenti 4 file:
“i2c_pcf8574_interface.py”, 
"__init__.py",  
"lcd.py", 
"lcd_api.py"
ed inserire tutto nella directory “lib”

Copiare nella directory principale un file vuoto "luce.txt"

code.py

Codice:

"""
#importo le librerie per il Pico
import time
import busio
import board
import digitalio
import microcontroller
import adafruit_veml7700
i2c = busio.I2C(board.GP1, board.GP0)
veml7700 = adafruit_veml7700.VEML7700(i2c)
from lcd.lcd import LCD
from lcd.i2c_pcf8574_interface import I2CPCF8574Interface
import math
SDA=board.GP0
SCL=board.GP1
#i2c=busio.I2C(SCL,SDA)
lcd = LCD(I2CPCF8574Interface(i2c, 0x27), num_rows=2, num_cols=16)
#attiva l'illuminazione del display
lcd.set_backlight(True)
button = digitalio.DigitalInOut(board.GP13)
button.switch_to_input(pull=digitalio.Pull.DOWN)



lcd.clear()

def rilievoLuceNoLCD():
    ADC=0
    lux=0
    veml7700.light_gain = veml7700.ALS_GAIN_1_8
    veml7700.light_integration_time = veml7700.ALS_100MS
    time.sleep(1)#tempo di stabilizzazione del sensore dopo l'impostazione di IT e GAIN
    #lettura in counts finalizzata al settaggio
    ADC=veml7700.light
    #print("valori in ADC con il primo rilievo con settaggio 100ms e GAIN 1/8 = ", ADC)
    #imposto una prima condizione sulle soglie indicate da Anderson
    if ADC>1000 and ADC<40657 or ADC == 40657:# corrisponde ad un valore in lux da 537 a 21857 senza CF
        #print("ADC tra 1000 e 40657 lascio le impostazioni IT=100 e GAIN=1/8 e poi rilevo con veml7700.lux")
        #print("valori di ADC in cnt ", ADC)
        time.sleep(0.2)
        _ = veml7700.lux#la prima lettura la perdo per evitare valori incongruenti
        time.sleep(0.2)
        lux = veml7700.lux
        #imposto la condizione per applicazione eventuale della formula di correzione
        if lux > 1000:
            #print("luce senza applicare la formula di correzione = ", lux)
            lux= 6.0135e-13 * lux**4 - 9.3924e-9 * lux**3 + 8.1488e-5 * lux**2 + 1.0023 * lux
            #print ("il valore di lux è > 1000 e va applicata la formula di correzione")
            #print("il valore di lux con la formula di correzione = ", lux)
            lux=round(lux)
        else:
            lux=round(lux)
            #print("valori di ADC in cnt ", ADC)
            #print("il valore di lux è tra 0 e 1000 non va applicata la formula di correzione", lux)
    elif ADC<1000 or ADC==1000:
    #per valori bassi, inferiori a 537 lx, si cambiano le impostazioni di IT e GAIN
        #print("valori di ADC in cnt ", ADC)
        #print("impostazioni IT=800 e GAIN=2 e poi rilevo con veml7700.lux")
        veml7700.light_gain = veml7700.ALS_GAIN_2
        veml7700.light_integration_time = veml7700.ALS_800MS
        time.sleep(1)#tempo di stabilizzazione del sensore dopo l'impostazione di IT e GAIN   
        _ = veml7700.lux#la prima lettura la perdo per evitare valori incongruenti
        time.sleep(1)
        lux=veml7700.lux
        #si deve verificare se maggiore di 1000 lx. o meno in quanto con il cambio d'impostazioni
        #non so se il valore in lux si alza sopra i 1000 lux.
        #print("il valore di luce con impostazioni IT 800 e GAIN 2 è lux", lux)
        #non  è possibile usare la formula di correzione in quanto questa è valida solo
        #per GAIN 1/4 o 1/8.
        #inoltre è molto improbabile, visto il primo rilievo in ADC per il setting
        #che i lux siano > di 1000
        lux=round(lux)
        #print("valori di ADC in cnt ", ADC)         
    elif ADC>40657:
        #con impostazioni IT 100 e GAIN 1/8 siamo oltre i 100Kl. se applichiamo al CF.
        #cambiamo impostazioni a IT 25 e GAIN 1/8
        print("il rilievo per il settaggio è molto alto provo le impostazioni IT=25 GAIN=1/8")
        veml7700.light_gain = veml7700.ALS_GAIN_1_8
        veml7700.light_integration_time = veml7700.ALS_100MS
        time.sleep(1)#tempo di stabilizzazione del sensore dopo l'impostazione di IT e GAIN
        ADC=veml7700.light
        #print("con le impostazioni IT=25 GAIN=1/8 ADC = ", ADC)
        time.sleep(0.2)
        _ = veml7700.lux#la prima lettura la perdo per evitare valori incongruenti
        time.sleep(0.2)
        lux = veml7700.lux
        #se i lux sono inferiori di 21857 lx.
        if lux < 21857:
            #devo sicuramente applicare la formula di correzione però per scrupolo pongo lo stesso
            #la condizione
                if lux > 1000:
                    #print("luce senza applicare la formula di correzione = ", lux)
                    lux= 6.0135e-13 * lux**4 - 9.3924e-9 * lux**3 + 8.1488e-5 * lux**2 + 1.0023 * lux
                    #print ("il valore di lux è maggiore di 1000 e va applicata la formula di correzione")
                    #print("il valore di lux con la formula di correzione = ", lux)
                    lux=round(lux)
                else:
                    lux=round(lux)
                    #print("valori di ADC in cnt ", ADC)
                    #print("il valore di lux è tra 0 e 1000 non va applicata la formula di correzione")
        else:
            #risultati superiori o 0 a 100000
            #per risultati > 100 kl. il sensore non rileva il valore correttamente o non so come
            #segue calcolo solo per capire a che valore arriverebbe am non mando a display
            lux= 6.0135e-13 * lux**4 - 9.3924e-9 * lux**3 + 8.1488e-5 * lux**2 + 1.0023 * lux
            print("lettura lux impostazioni IT 25 e GAIN 1/8 + CF = valore maggiore di 100000 lux = ", lux)
            lux=100000
            #print("quindi scrivo sul display ",lux, "or more")
    #print(lux)
    return lux
    #ripristino i settaggi iniziali
    veml7700.light_gain = veml7700.ALS_GAIN_1_8
    veml7700.light_integration_time = veml7700.ALS_100MS
   


def rilievoLuce():
    #scrittura su display dei risultati dopo avere applicato tutte le condizioni
    #le librerie di Dan Halbert
    #il codice è tratto dal video https://www.youtube.com/watch?v=2xWTxLE6dO0
    #pongo delle condizioni per dare un giudizio, concordate con S. Landi, che verrà mostrato su display
    #in seconda riga
    #importo le librerie del display
    lux=rilievoLuceNoLCD()
    lcd.clear()
    smile=(0x00,0x00,0x0A,0x00,0x00,0x11,0x0E,0x00)
    cuore=(0x00,0x00,0x0A,0x15,0x11,0x11,0x0A,0x04)
    sad=(0x00,0x00,0x0A,0x00,0x00,0x0E,0x11,0x00)
    ohNo=(0x15,0x15,0x15,0x00,0x0A,0x00,0x0E,0x11)
    dark=(0x00,0x0A,0x00,0x04,0x00,0x08,0x04,0x02)
    lcd.create_char(1,smile)
    lcd.create_char(2,cuore)
    lcd.create_char(3,sad)
    lcd.create_char(4,ohNo)
    lcd.create_char(5,dark)
   
    if lux >10000 and lux < 15000 or lux==15000:
        lux=str(lux)
        print("scriverò nel display ",lux,"Very happy")
        lcd.set_cursor_pos(0, 0)
        lcd.print("light="+lux+" lux")
        lcd.set_cursor_pos(1, 2)
        lcd.print("Very happy")
        lcd.set_cursor_pos(1, 1)
        lcd.write(2)
        lcd.set_cursor_pos(1, 12)
        lcd.write(2)
    elif lux > 1750 and lux < 5000 or lux==5000:
        lux=str(lux)
        print("scriverò nel display ",lux,"poor light")
        lcd.set_cursor_pos(0, 0)
        lcd.print("light="+lux+" lux")
        lcd.set_cursor_pos(1, 2)
        lcd.print("poor light")
        lcd.set_cursor_pos(1, 1)
        lcd.write(3)
        lcd.set_cursor_pos(1, 12)
        lcd.write(3)
    elif lux > 5000 and lux < 10000 or lux==10000:
        lux=str(lux)
        print("scriverò nel display ",lux,"Happy")
        lcd.set_cursor_pos(0, 0)
        lcd.print("light="+lux+" lux")
        lcd.set_cursor_pos(1, 2)
        lcd.print("Happy")
        lcd.set_cursor_pos(1, 0)
        lcd.write(1)
        lcd.set_cursor_pos(1, 8)
        lcd.write(1)
    elif lux < 1750 or lux==1750:
        lux=str(lux)
        print("scriverò nel display ",lux,"dark")
        lcd.set_cursor_pos(0, 0)
        lcd.print("light="+lux+" lux")
        lcd.set_cursor_pos(1, 6)
        lcd.print("dark")
        lcd.set_cursor_pos(1, 2)
        lcd.write(5)
        lcd.set_cursor_pos(1, 13)
        lcd.write(5)
    elif lux > 15000 and lux < 100000:
        lux=str(lux)
        print("scriverò nel display ",lux,"oh no-too much")
        lcd.set_cursor_pos(0, 0)
        lcd.print("light="+lux+" lux")
        lcd.set_cursor_pos(1, 1)
        lcd.print("Oh no-too much")
        lcd.set_cursor_pos(1, 0)
        lcd.write(4)
        lcd.set_cursor_pos(1, 15)
        lcd.write(4)
    elif lux == 100000:
        print("scriverò nel display = > 100000 oh no-too much")
        lcd.set_cursor_pos(0, 0)
        lcd.print("light=>100000lux")
        lcd.set_cursor_pos(1, 1)
        lcd.print("Oh no-too much")
        lcd.set_cursor_pos(1, 0)
        lcd.write(4)
        lcd.set_cursor_pos(1, 15)
        lcd.write(4)     
    #ripristino i settaggi iniziali
    veml7700.light_gain = veml7700.ALS_GAIN_1_8
    veml7700.light_integration_time = veml7700.ALS_100MS
    time.sleep(5)
    lcd.clear()
    print()

def scriviRisultatiRegistrazione():     
    lcd.clear()
    lcd.set_backlight(True)
    lcd.set_cursor_pos(0, 0)
    lcd.print("rec results to ")
    lcd.set_cursor_pos(1, 0)
    lcd.print("write down")
    time.sleep(10)
   
    print ("avvio il programma di lettura e giudizio di luce")
    print("........")
    print("sto eseguendo il programma di lettura e analisi del file luce.txt")
    print("........") 
    time.sleep(3)
 
    print("")
    f = open("luce.txt", "r")
    riga=1
    riga = f.readline()
    night=0
    dark=0
    poorLight=0
    happy=0
    veryHappy=0
    ohNoTooMuch=0
    listaNight=[]
    listaDark=[]
    listaPoorLight=[]
    listaHappy=[]
    listaVeryHappy=[]
    listaTooMuch=[]
    while riga != "":
        #print(riga)
        #print(type(riga))
        riga=int(riga)
        #print(type(riga))
        #print(riga)
        if riga <150 or riga == 150:
            night=night+1
            listaNight.append(riga)
        elif riga >150 and riga<1750 or riga==1750:
            dark=dark+1
            listaDark.append(riga)
        elif riga>1750 and riga<5000 or riga==5000:
            poorLight=poorLight+1
            listaPoorLight.append(riga)
        elif riga>5000 and riga<10000 or riga==10000:
            happy=happy+1
            listaHappy.append(riga)
        elif riga>10000 and riga<15000 or riga==15000:
            veryHappy=veryHappy+1
            listaVeryHappy.append(riga)
        else:
            ohNoTooMuch=ohNoTooMuch+1
            listaTooMuch.append(riga)
        #print(riga)
        #print(" ")
        riga = f.readline()     
    f.close()
    print("........")
    print("ho finito di leggere il file luce.txt:")
   
    print("........")
    print("dall'analisi dei dati rilevati risultano:")
    print("........")
    time.sleep(3)
    print("........")
    time.sleep(3)
    minutiNight=night*15
    minutiDark=dark*15
    minutiPoorLight=poorLight*15
    minutiHappy=happy*15
    minutiveryHappy=veryHappy*15
    minutiTooMuch=ohNoTooMuch*15
   
   
    oreNight=minutiNight/60
    oreDark=minutiDark/60
    orePoorLight=minutiPoorLight/60
    oreHappy=minutiHappy/60
    oreVeryHappy=minutiveryHappy/60
    oreTooMuch=minutiTooMuch/60
   
    oremNight=math.floor(oreNight)
    oremDark=math.floor(oreDark)
    oremPoorLight=math.floor(orePoorLight)
    oremHappy=math.floor(oreHappy)
    oremVeryHappy=math.floor(oreVeryHappy)
    oremTooMuch=math.floor(oreTooMuch)
   
    minHNight=(oreNight-oremNight)*60
    minHDark=(oreDark-oremDark)*60
    minHPoorLight=(orePoorLight-oremPoorLight)*60
    minHHappy=(oreHappy-oremHappy)*60
    minHVeryHappy=(oreVeryHappy-oremVeryHappy)*60
    minHTooMuch=(oreTooMuch-oremTooMuch)*60
    #tolgo il decimale ai minuti
    minHNight=round(minHNight, )
    minHDark=round(minHDark, )
    minHPoorLight=round(minHPoorLight, )
    minHHappy=round(minHHappy, )
    minHVeryHappy=round(minHVeryHappy, )
    minHTooMuch=round(minHTooMuch, )
    print("ore night", oremNight," e ",minHNight," minuti")
    print("ore dark", oremDark," e ",minHDark," minuti")
    print("ore poor light", oremPoorLight," e ",minHPoorLight," minuti")
    print("ore Happy", oremHappy," e ",minHHappy," minuti")
    print("ore very happy", oremVeryHappy," e ",minHVeryHappy," minuti")
    print("ore oh no too much ", oremTooMuch," e ",minHTooMuch," minuti")
    print("........")
   
   
    time.sleep(10)
    if night>0:
        mediaNight=sum(listaNight)/len(listaNight)
        mediaNight=round(mediaNight,)
    else:
        mediaNight="no"
    print("la media dei valori rilevati durante le ore di notte sono lux ",mediaNight)
    mediaNight=str(mediaNight)
    lcd.clear()
    lcd.set_cursor_pos(0, 0)
    lcd.print("night="+mediaNight+" lx")
    if dark>0:
        mediaDark=sum(listaDark)/len(listaDark)
        mediaDark=round(mediaDark,)
    else:
        mediaDark="no"
    print("la media dei valori rilevati durante le ore di dark sono lux ",mediaDark)
    mediaDark=str(mediaDark)
    print("scrivo nel display le medie")
    lcd.set_cursor_pos(1, 0)
    lcd.print("dark="+mediaDark+" lx")
    time.sleep(10)
   
    if poorLight>0:
        mediaPoorLight=sum(listaPoorLight)/len(listaPoorLight)
        mediaPoorLight=round(mediaPoorLight,)
    else:
        mediaPoorLight="nessuna"
    print("la media dei valori rilevati durante le ore di poor lux sono lux ",mediaPoorLight)
    mediaPoorLight=str(mediaPoorLight)
    lcd.clear()
    lcd.set_cursor_pos(0, 0)
    lcd.print("poorLight="+mediaPoorLight+" l")
    if happy>0:
        mediaHappy=sum(listaHappy)/len(listaHappy)
        mediaHappy=round(mediaHappy,)
    else:
        mediaHappy="no"
    print("la media dei valori rilevati durante le ore di Happy sono lux ")
    mediaHappy=str(mediaHappy)
    lcd.set_cursor_pos(1, 0)
    lcd.print("happy="+mediaHappy+" lx")
    time.sleep(10)
   
    if veryHappy>0:
        mediaVeryHappy=round(sum(listaVeryHappy)/len(listaVeryHappy),)
    else:
        mediaVeryHappy="no"
    print("la media dei valori rilevati durante le ore very happy sono lux ",mediaVeryHappy)
    if ohNoTooMuch>0:
        mediaTooMuch=round(sum(listaTooMuch)/len(listaTooMuch),)
    else:
        mediaTooMuch="no"
    print("la media dei valori rilevati durante le ore di oh no too much sono lux ",mediaTooMuch)
    lcd.clear()
    lcd.set_cursor_pos(0, 0)
    mediaVeryHappy=str(mediaVeryHappy)
    lcd.print("veryHappy=")
    lcd.set_cursor_pos(1, 0)
    lcd.print(mediaVeryHappy+" lx")
    time.sleep(10)
    lcd.clear()
    lcd.set_cursor_pos(0, 0)
    mediaTooMuch=str(mediaTooMuch)
    lcd.print("tooMuch=")
    lcd.set_cursor_pos(1, 0)
    lcd.print(mediaTooMuch+" lx")
    time.sleep(10)
    print("scrivo nel display ore e minuti di ogni fascia ")
    oremNight=str(oremNight)
    minHNight=str(minHNight)
    oremDark=str(oremDark)
    minHDark=str(minHDark)
    oremPoorLight=str(oremPoorLight)
    minHPoorLight=str(minHPoorLight)
    oremHappy=str(oremHappy)
    minHHappy=str(minHHappy)
    oremVeryHappy=str(oremVeryHappy)
    minHVeryHappy=str(minHVeryHappy)
    oremTooMuch=str(oremTooMuch)
    minHTooMuch=str(minHTooMuch)
    """
    Esempio di scrittura in LCD
    night 15h30'
    """
    lcd.clear()
    lcd.set_cursor_pos(0, 0)
    lcd.print("night "+oremNight+"h"+minHNight+"'")
    lcd.set_cursor_pos(1, 0)
    lcd.print("dark "+oremDark+"h"+minHDark+"'")
    time.sleep(10)
   
    lcd.clear()
    lcd.set_cursor_pos(0, 0)
    lcd.print("poorLight "+oremPoorLight+"h"+minHPoorLight+"'")
    lcd.set_cursor_pos(1, 0)
    lcd.print("happy "+oremHappy+"h"+minHHappy+"'")
    time.sleep(10)
   
    lcd.clear()
    lcd.set_cursor_pos(0, 0)
    lcd.print("veryHappy "+oremVeryHappy+"h"+minHVeryHappy+"'")
    lcd.set_cursor_pos(1, 0)
    lcd.print("tooMuch "+oremTooMuch+"h"+minHTooMuch+"'")
    time.sleep(10)
    lcd.clear()
    lcd.set_cursor_pos(0, 0)
    lcd.print("switch off")
    lcd.set_cursor_pos(1, 0)
    lcd.print("MOrLight")
    time.sleep(60)
    lcd.clear()
    import sys
    from sys import exit
    sys.exit()

#C O D I C E

for i in range(30): #cambia in 100?
    if button.value==False:
        rilievoLuce()       
    else:
        scriviRisultatiRegistrazione()

#avvia il ciclo 24ore
lcd.clear()
lcd.set_cursor_pos(0,0)
lcd.print("in30secNoDisplay")
lcd.set_cursor_pos(1,0)
lcd.print("rec24 h starting")
#cacello i contenuti del file scritti nel ciclo precedente
time.sleep(30)
lcd.clear()
lcd.set_backlight(False)

fileLuce=open('luce.txt', 'w')
fileLuce.close()
# Frequenze per un light sleep
NORMAL_FREQ = 125_000_000    # 125 MHz
SLEEP_FREQ = 18_000_000      # 18 MHz (puoi scendere a 6 MHz?)
for e in range (96):
    microcontroller.cpu.frequency = NORMAL_FREQ
    with open("/luce.txt", "a") as datalog:
        lux=rilievoLuceNoLCD()
        datalog.write(f"{lux:.0f}\n") # dovrebbe scriverle senza decimali e andando a capo
        datalog.flush()#questo comando salva il file ogni rilievo non solo alla fine, utile!
        print("ho scritto i lux rilevati: ", lux, " nel file luce.txt", ) 
        #ma io vedo le righe scritte solo nel file luce solo se riavvio il Pico
        datalog.close()#forse così leggo il contenuto di luce.txt anche senza riavviare circuitpy: non funziona
        microcontroller.cpu.frequency = SLEEP_FREQ
        time.sleep(900)
microcontroller.cpu.frequency = SLEEP_FREQ
print("terminato il ciclo di rilievi delle 24 ore per vedere tutti i dati nel file luce.txt riavviare MOrLight")

La foto che segue mostra l'immagine dell'oggetto completo con case stampato in 3D




Breve approfondimento
Ho scelto come sensore il VEML7700 per il costo contenuto, perché lo avevo già usato e perché ho trovato in rete dei lavori scientifici relativi al confronto tra diversi sensori di luce low-cost che mostravano una buona performance del VEML7700 sopratutto per intensità di luce al di sotto dei 50000 lux. Per il nostri scopi va bene perché oltre 16000 lux la luce è troppo intensa per le Phanaelopsis. Una restituzione precisa oltre quel valore non è importante.
Come molti di voi sapranno la luce è energia elettromagnetica che a seconda della frequenza o lunghezza d’onda diventa luce visibile, infrarosso, ultravioletto etc. etc. Il VEML7700 rileva l’intensità della luce nelle frequenze del visibile, le piante in realtà assorbono di più alcune frequenze particolari: la Radiazione Fotosinteticamente Attiva (PAR). Questa va da lunghezze d’onda tra i 400 e 700 nanometri (nm) con picchi di assorbimento in luce nel rosso profondo 660-665 nm e nel blu 430-465 nm. Per uso non professionale questa approssimazione o limite del sensore è accettabile. Il discorso cambierebbe se volessimo utilizzare MOrLight in un vivaio che coltiva Phanaelopsis per ricavarne reddito per il quale lo strumento non è stato pensato e costruito.


Ringraziamenti


Istruzioni