Oplossingen · hoofdstuk 30Datalogging en communicatie

Getest:

# sht31_bytes.py - zes bytes van de SHT31 omrekenen en controleren
def crc8(data):
    """CRC-8 zoals in de datasheet: veelterm 0x31, beginwaarde 0xFF."""
    crc = 0xFF
    for b in data:
        crc ^= b
        for _ in range(8):
            if crc & 0x80:
                crc = ((crc << 1) ^ 0x31) & 0xFF
            else:
                crc = (crc << 1) & 0xFF
    return crc


print("test:", hex(crc8([0xBE, 0xEF])), "(datasheet: 0x92)")
for b in ([0x64, 0x29, 0x59, 0x9C, 0xED, 0xF5], [0x64, 0x3C, 0x2B, 0x9C, 0x6A, 0x18]):
    ruw_t = b[0] * 256 + b[1]
    ruw_rv = b[3] * 256 + b[4]
    goed = crc8(b[0:2]) == b[2] and crc8(b[3:5]) == b[5]
    print(f"T = {-45 + 175 * ruw_t / 65535:.2f} °C, RV = {100 * ruw_rv / 65535:.1f} %, CRC {'in orde' if goed else 'FOUT'}"
          f" (berekend {crc8(b[0:2]):02X} en {crc8(b[3:5]):02X})")

test: 0x92 (datasheet: 0x92)
T = 23.47 °C, RV = 61.3 %, CRC in orde (berekend 59 en F5)
T = 23.52 °C, RV = 61.1 %, CRC FOUT (berekend EF en 18)

In de tweede meting klopt de CRC van de temperatuur niet: de sensor stuurde 0x2B, maar uit 0x64 0x3C volgt 0xEF. Er is onderweg een bit omgevallen (0x38 werd 0x3C).

# verwerk.py - een regel van de seriële poort omzetten, zonder dat een rare regel het programma laat crashen
KOP = ["tijd_s", "temperatuur_C", "vocht_pct", "licht_ruw"]


def verwerk(regel, kop=KOP):
    """Een woordenboek met getallen (None voor een lege cel), of None als de regel niet bruikbaar is."""
    regel = regel.strip()
    if regel == "" or regel.startswith("#"):
        return None
    velden = regel.split(",")
    if len(velden) != len(kop):
        return None
    uit = {}
    for naam, tekst in zip(kop, velden):
        if tekst == "" or tekst.lower() == "nan":
            uit[naam] = None
            continue
        try:
            uit[naam] = float(tekst)
        except ValueError:                       # bv. '482x' of '23 5'
            return None
    return uit


testregels = ["2,23.50,64.0,477", "4,23,61,63.8,478", "# SD-kaart klaar", "6,nan,63.6,479",
              "8,,,480", "10,23.9", "12,24.01,63.0,482x", ""]
for r in testregels:
    print(f"{r!r:24} -> {verwerk(r)}")

Uitvoer:

'2,23.50,64.0,477'       -> {'tijd_s': 2.0, 'temperatuur_C': 23.5, 'vocht_pct': 64.0, 'licht_ruw': 477.0}
'4,23,61,63.8,478'       -> None
'# SD-kaart klaar'       -> None
'6,nan,63.6,479'         -> {'tijd_s': 6.0, 'temperatuur_C': None, 'vocht_pct': 63.6, 'licht_ruw': 479.0}
'8,,,480'                -> {'tijd_s': 8.0, 'temperatuur_C': None, 'vocht_pct': None, 'licht_ruw': 480.0}
'10,23.9'                -> None
'12,24.01,63.0,482x'     -> None
''                       -> None

try/except vangt de ValueError van float() op: een regel met rommel wordt overgeslagen in plaats van het programma te stoppen.

# per_blok.py - de minuten van de logger samenvatten in blokken van 3 uur (het formaat van hoofdstuk 28)
import csv

from logboek import lees_week, opschonen

rijen = lees_week()
opschonen(rijen)
blokken = {}                                     # begin van het blok -> de regels van dat blok
for r in rijen:
    t = r["tijd"]
    begin = t.replace(hour=t.hour - t.hour % 3, minute=0)
    if begin not in blokken:
        blokken[begin] = []
    blokken[begin].append(r)

with open("klimaatmodule_oktober.csv", "w", newline="", encoding="utf-8") as bestand:
    schrijver = csv.writer(bestand)
    schrijver.writerow(["tijdstip", "temperatuur_C", "vocht_pct", "verbruik_Wh", "zon_Wh"])
    for begin in sorted(blokken):
        rs = blokken[begin]
        t = [r["T"] for r in rs if r["T"] is not None]
        rv = [r["RV"] for r in rs if r["RV"] is not None]
        genoeg = len(t) >= 90                    # minstens de helft van de 180 minuten geldig
        rij = [begin.strftime("%Y-%m-%d %H:%M"),
               f"{sum(t) / len(t):.1f}" if genoeg else "",
               f"{sum(rv) / len(rv):.0f}" if genoeg else "",
               round(sum(r["verbruik"] for r in rs)),
               round(sum(r["zon"] for r in rs))]
        schrijver.writerow(rij)
        if begin.day == 14:                      # woensdag tonen
            print(rij, len(rs), "minuten")
print("blokken:", len(blokken))

Uitvoer:

['2026-10-14 00:00', '18.0', '84', 22, 0] 180 minuten
['2026-10-14 03:00', '18.0', '84', 22, 0] 180 minuten
['2026-10-14 06:00', '19.4', '82', 545, 78] 180 minuten
['2026-10-14 09:00', '19.4', '82', 272, 464] 180 minuten
['2026-10-14 12:00', '20.3', '80', 219, 547] 180 minuten
['2026-10-14 15:00', '20.3', '80', 475, 183] 180 minuten
['2026-10-14 18:00', '19.4', '82', 570, 0] 180 minuten
['2026-10-14 21:00', '18.0', '84', 22, 0] 180 minuten
blokken: 56

# per_uur.py - de temperatuur van woensdag 14 oktober per uur
from logboek import lees_week, opschonen

rijen = lees_week(14, 14)                        # alleen woensdag
opschonen(rijen)
uren = {}                                        # uur -> geldige temperaturen
for r in rijen:
    if r["T"] is not None:
        uur = r["tijd"].hour
        if uur not in uren:
            uren[uur] = []
        uren[uur].append(r["T"])
for uur in range(10, 15):
    t = uren[uur]
    print(f"{uur:02d}:00  {sum(t) / len(t):5.2f} °C  ({len(t)} minuten)")

Uitvoer:

10:00  19.41 °C  (60 minuten)
11:00  19.76 °C  (48 minuten)
12:00  20.07 °C  (60 minuten)
13:00  20.39 °C  (60 minuten)
14:00  20.57 °C  (60 minuten)

Getest tegen de simulatie van logger.ino met een stilgevallen klok:

# klok_zetten.py - de klok van de logger zetten op de tijd van de computer, in wintertijd (UTC+1)
import time
from datetime import datetime, timedelta, timezone

import serial

WINTERTIJD = timezone(timedelta(hours=1))        # het hele jaar: nooit een uur dubbel of kwijt
poort = serial.Serial("COM3", 115200, timeout=2)
time.sleep(2)                                    # het openen van de poort herstart de Mega: even wachten
nu = datetime.now(WINTERTIJD)
opdracht = nu.strftime("T%Y-%m-%d %H:%M:%S")
poort.write((opdracht + "\n").encode("ascii"))
print("verstuurd:", opdracht)
for _ in range(6):                               # de logger antwoordt met een regel die met # begint
    antwoord = poort.readline().decode("utf-8", errors="replace").strip()
    if antwoord.startswith("#"):
        print("logger:", antwoord)
poort.close()

verstuurd: T2026-10-11 20:00:00
logger: # de klok heeft stilgestaan: stuur T jjjj-mm-dd uu:mm:ss
logger: # SD-kaart klaar
logger: # klok gezet

De Mega herstart bij het openen van de poort en stuurt eerst zijn meldingen; daarna komt het antwoord op de opdracht.