Air Quality Meter Esp32 Oled+Sgp302

[Vitoch]

Monitor qualità dell’aria
con utilizzo della scheda wifi kit 32 Oled 128x64 della Heltec Automation e SGP30 Co2 sensore CO2

trattato nella rivista di Settembre 2022 di Elettronica In

Seguendo le specifiche riportare nell'articolo, utilizzando l'iDE Thonny non riesco ad installare la libreria adafruit_sgp30

Come riporta l'articolo la libreria è scaricabile da https://github.com/alexmrqt/micropython-sgp30

Al momento dell'installazione del pacchetto, attraverso Thonny mi segnala il seguente errore

Error Command '['C:\\Users\\maggi\\AppData\\Local\\pipkin\\cache\\workspaces\\8b697ae7ca0b92f6fbc17bcea577a836\\Scripts\\python.exe', '-I', '-m', 'pip', '--no-color', '--disable-pip-version-check', '--trusted-host', '127.0.0.1', 'install', '--no-compile', '--use-pep517', '--upgrade-strategy', 'only-if-needed', 'install', 'C:/Users/maggi/Downloads/micropython-sgp30-master.zip', '--index-url', 'http://127.0.0.1:36628']' returned non-zero exit status 1.
Esiste una libreria funzionante?
Grazie per la vostra disponibilità

[ffich]

ciao,
non capisco di preciso cosa hai cercato di fare con lo zip file, ma alla fine si tratta semplicemente di avere il file .py nella memoria del dispositivo, e quindi nell'ordine bisogna:

1. scaricare il master branch da github (lo zip che hai menzionato nel post)

2. estrarlo e prendere il file adafruit_sgp30.py

3. aprire il file con thonny e poi cliccare sull'icona di salvataggio (oppure su file-> save as...)

4. a questo punto thonny ti permette di salvare il file su PC o sul dispositivo micropyhton (che deve essere collegato), tramite una finestrella di dialogo. Seleziona l'opzione "Micropython Device" e salva il file esattamente con lo stesso nome e estensione .py

Fammi sapere se hai problemi.

ciao
F.

[Vitoch]

Erroneamente cercavo di installare la libreria da Strumenti gestione pacchetti installando il file zip scaricato.
Negli ultimi giorni ho verificato quello che mi hai suggerito ovvero salvare il file di libreria *.py direttamente sulla board, e il procedimento è corretto e il tutto funziona.

Una seconda problematica ho riscontrato.
Nel file boot.py ho inserito il comando import main.py in modo tale che quando è alimentata la board entra in funzione.
Con il file main.py in esecuzione eventuali modifiche al programma non mi sono più permesse, perchè mi compare il messaggio di errore
" Device is busy -- can't perform this action now. Please wait or cancel current work and try again"
C'è una soluzione per stoppare tramite Thonny l'esecuzione di main.py?
Ho provato a selezionare da Esegui ---- Interrompi l'esecuzione
senza aver effetto
Grazie per l'aiuto

[ffich]

Ciao,
Prova premendo ripetutamente il pulsante stop (anche diverse volte). Se non si ferma devi cancellare la memoria, ri-flashare uPython e ricopiare I files.

Non importare main.py in boot.py, ti basta copiare main.py nella root. uPython esegue automaticamente main.py se lo trova nella root.

Ciao
F.

[Vitoch]

Al momento ho cancellato la memoria, ri-flashato uPython e ricopiato I files è la soluzione che meglio funziona.
Proverò a impostare il main.py come mi hai suggerito
Grazie

[Vitoch]

Problemi risolti posto il codice funzionante

# --------------------------------------------------------------------------------
# - DEPENDENCIES
# --------------------------------------------------------------------------------
import time
from machine import Pin, SoftI2C, I2C
import ssd1306
import adafruit_sgp30

# --------------------------------------------------------------------------------
# - CONST
# --------------------------------------------------------------------------------
CO2_LINE = 20
TVOC_LINE = 40
DEBUG = False

# --------------------------------------------------------------------------------
# - USER TH DEFAULT VALUES
# --------------------------------------------------------------------------------
co2eq_th = 2500
hysteresis = 200

# --------------------------------------------------------------------------------
# - TIMING CONST
# --------------------------------------------------------------------------------
SAMPLING_TIME_S = 1
SENS_INIT_DELAY_S = 15

# 3600
ONE_HOUR_S = 3600
# 43200
TWELVE_HOURS_S = 43200

# --------------------------------------------------------------------------------
# - GLOBALS
# --------------------------------------------------------------------------------
has_baseline = False
baseline_time = 0

# --------------------------------------------------------------------------------
# - SERVICE FUNCTIONS
# --------------------------------------------------------------------------------
def user_message(text):
if DEBUG == True:
print(text)
oled.fill(0)
oled.text(text, 0, 0)
oled.show()

def oled_data(co2eq, tvoc):
oled.fill(0)
oled.text('CO2 Sensor - Ein', 0, 0)
oled.text('CO2: ', 0, CO2_LINE)
oled.text(str(co2eq) + ' ppm',45, CO2_LINE)
oled.text('TVOC: ', 0, TVOC_LINE)
oled.text(str(tvoc) + ' ppb', 45, TVOC_LINE)
oled.show()

def get_sensor_baseline():
global has_baseline

try:
# Retrieve previously stored baselines, if any (helps the compensation algorithm).
f_co2 = open('co2eq_baseline.txt', 'r')
f_tvoc = open('tvoc_baseline.txt', 'r')
co2_baseline = int(f_co2.read())
tvoc_baseline = int(f_tvoc.read())
# Use them to calibrate the sensor
sgp30.set_iaq_baseline(co2_baseline, tvoc_baseline)
f_co2.close()
f_tvoc.close()
has_baseline = True
user_message('Baseline Set')
except:
user_message('No baseline')

time.sleep(2)

def update_sensor_baseline():
global has_baseline
global baseline_time

# Baselines should be saved after 12 hour the first time then every hour, according to the doc
if (has_baseline and (time.time() - baseline_time >= (ONE_HOUR_S/SAMPLING_TIME_S))) \
or ((not has_baseline) and (time.time() - baseline_time >= (TWELVE_HOURS_S/SAMPLING_TIME_S))):

baseline_time = time.time()

try:
f_co2 = open('co2eq_baseline.txt', 'w')
f_tvoc = open('tvoc_baseline.txt', 'w')
bl_co2, bl_tvoc = sgp30.get_iaq_baseline()
f_co2.write(str(bl_co2))
f_tvoc.write(str(bl_tvoc))
f_co2.close()
f_tvoc.close()
has_baseline = True
user_message('Baseline Set')
except:
user_message('No baseline')

time.sleep(2)

def get_user_threshold():
global co2eq_th
global hysteresis

try:
# Get the Threshold fro CO2
f_co2_th = open('co2eq_th.txt', 'r')
f_hysteresis = open('hist_th.txt', 'r')
co2eq_th = int(f_co2_th.read())
hysteresis = int(f_hysteresis.read())
f_co2_th.close()
f_hysteresis.close()
user_message('User Th set')
except:
user_message('No user Th')

time.sleep(2)

# --------------------------------------------------------------------------------
# - SYSTEM INIT
# --------------------------------------------------------------------------------

# LEDs
led_green = Pin(2, Pin.OUT)
led_red = Pin(17, Pin.OUT)
led_green.on()
led_red.off()

# Initialize I2C buses
d_i2c = I2C(scl=Pin(15), sda=Pin(4), freq=100000) #Oled Display
s_i2c = SoftI2C(scl=Pin(18), sda=Pin(19), freq=100000) #Sensore SGP30

# OLED enable pin
oled_sts = Pin(16, Pin.OUT)
oled_sts.on()

# OLED initialization
oled_width = 128
oled_height = 64
oled = ssd1306.SSD1306_I2C(oled_width, oled_height, d_i2c)

# Air quality sensor init
sgp30=adafruit_sgp30.Adafruit_SGP30(s_i2c)

# Initialize SGP-30 internal drift compensation algorithm.
sgp30.iaq_init()

# Wait 15 seconds for the SGP30 to properly initialize
user_message('Sensor Init...')
time.sleep(SENS_INIT_DELAY_S)

# User threshold for LEDs indication
get_user_threshold()

# Sensor Calibration
get_sensor_baseline()

# Store the time at which last baseline has been saved
baseline_time = time.time()

# --------------------------------------------------------------------------------
# - MAIN LOOP
# --------------------------------------------------------------------------------
while True:
# Get CO2 and TVOC data
co2eq, tvoc = sgp30.iaq_measure()

if DEBUG == True:
# Print values on REPL
print('co2eq = ' + str(co2eq) + ' ppm \t tvoc = ' + str(tvoc) + ' ppb')

# Print values on Display
oled_data(co2eq, tvoc)

# Manage LEDs
if (co2eq > co2eq_th):
led_green.off()
led_red.on()
elif (co2eq < (co2eq_th - hysteresis)):
led_green.on()
led_red.off()

# Update sensor baseline
update_sensor_baseline()

# Wait for the new sampling time
time.sleep(SAMPLING_TIME_S)