Alfen_manager.py

#!/home/pi/Programs/.venv/bin/python3.11

# https://github.com/nessnaj/alfen_eve_modbus_tcp/blob/master/example.py
import sys
import csv
import sqlite3
import argparse
import json
import requests
from datetime import datetime, timedelta, time
from time import ctime, sleep
import systemd.daemon
import threading
from apscheduler.schedulers.background import BackgroundScheduler

import alfen_eve_modbus_tcp

from config import READER_DATA_JSON, SETPOINTS_JSON, LP_VALUES_JSON, LP_MANAGER_CSV, URL_LAADPAAL, LOG_MAX_SIZE, MIN_AMP, MAX_AMP
from laadpaal import laadpaalData

from shared_store import set_key, get_key
from logger_setup import get_logger
logger = get_logger("LP_reader")

car_charger = alfen_eve_modbus_tcp.CarCharger(
    host=URL_LAADPAAL,
    port=502,
    timeout=1
)

# car_charger wordt gedeeld tussen changeAmp(), readLP() en check_laadpaal(),
# die elk in hun eigen thread draaien. Zonder lock kan de ene thread
# car_charger.disconnect() aanroepen (socket -> None) terwijl een andere
# thread nog midden in een .read()/.write() zit, met een race-condition-
# crash tot gevolg ('NoneType' object has no attribute 'recv').
car_charger_lock = threading.Lock()

def rotate_log(logfile):
    if logfile.exists() and logfile.stat().st_size > LOG_MAX_SIZE:
        logfile.replace(logfile.with_suffix(logfile.suffix + ".1"))

def write_csv (FILE, values):
   rotate_log(FILE)
   FIELDNAMES = list(values.keys())
   FILE.parent.mkdir(parents=True, exist_ok=True)
   with open(FILE, "a", newline="") as f:
      writer = csv.DictWriter(f, fieldnames = FIELDNAMES)
      writer.writerow(values)

def check_laadpaal():
    power = get_key("LP_reader", default={"laadpower": 0}, path=READER_DATA_JSON).get("laadpower", 0)  # Ophalen van laadpower
    if power > 0:
        with car_charger_lock:
            laadpaalData(car_charger) # Laadpaal data wegschrijven als laadpaal actief is

def watchdog_task() -> None:
    while True:
        systemd.daemon.notify("WATCHDOG=1")
        sleep(1)

def sessie(status, start):
    """Schrijft laadsessies start/stop naar CSV file."""
    try:
        date = datetime.now().strftime("%Y-%m-%d")
        hour = datetime.now().strftime("%H:%M:%S")
        if status == "start":
           values = {"date":date, "time":hour, "status":status, "counter":start}
           write_csv(LP_MANAGER_CSV, values)
        if status == "stop":
           end = car_charger.read('real_energy_delivered_sum')
           end = end['real_energy_delivered_sum']
           delivered = (end - start) / 1000
           values = {"date": date, "time":hour, "status":status, "counter":end, "kWh":delivered}
           write_csv(LP_MANAGER_CSV, values)
    except Exception as e:
        logger.error(f"VW Database update sessie mislukt {e}")


def changeAmp():
    laden = get_key("laadsessie", default={"laden": False}, path=READER_DATA_JSON).get("laden", False)
    while True:
        with car_charger_lock:
            try:
                car_charger.connect()
                # lees laadpower
                try:
                    state = car_charger.read("mode_3_state").get("mode_3_state")
                    state2 = alfen_eve_modbus_tcp.MODE_3_STATE_MAP[state]
                    laadpower = int(car_charger.read("real_power_sum").get('real_power_sum',0))
#                    laadpower = int(laadpower['real_power_sum'])
                    applied = car_charger.read("actual_applied_max_current").get("actual_applied_max_current", MIN_AMP)
#                    applied = applied["actual_applied_max_current"]
                    actSP = int(round(laadpower / 240 / 3, 2)+0.5)

                    if laadpower > 0 and laden == False:
                       logger.warning(f"start laadsessie: laadpower {laadpower} laden {laden}")
                       start = car_charger.read('real_energy_delivered_sum').get('real_energy_delivered_sum')
#                       start = start['real_energy_delivered_sum']
                       laden = True
                       set_key("laadsessie", {"start": start, "laden": laden}, path=READER_DATA_JSON)
                       sessie("start", start)
                    if int(laadpower) == 0 and laden == True:
                       logger.warning(f"stop laadsessie: laadpower {laadpower} laden {laden}")
                       laden = False
                       start = get_key("laadsessie", default={"start": 0}, path=READER_DATA_JSON).get("start", 0)
                       sessie("stop", start)
                       set_key("laadsessie", {"start": 0, "laden": laden}, path=READER_DATA_JSON)

                except Exception as error:
                    logger.error(f"schrijven LPlaadpower mislukt {error}")

                # lees nieuw SP
                try:
                    loadAmp = get_key("LPnew", path=SETPOINTS_JSON)["setpoint"]
                except Exception as error:
                    logger.error(f"lezen LPsetpoint setpoints.json mislukt {error}")
                    loadAmp = MIN_AMP

                # 3. Nachtperiode bepalen (00:00–06:00)
                now = datetime.now().time()
                nacht = now >= time(0,0) and now < time(6,0)
                try:
                # 4. Logica op basis van status
                   if state != "C2":    # Auto laadt NIET,  OCPP werkt hier niet → Modbus moet de baas zijn
                      car_charger.write("modbus_slave_max_current", MIN_AMP)
                      if state2 == "Connected" and loadAmp > 0:
                         requests.post(f"http://localhost:9001/set_current?amps={MIN_AMP}") # om laden na pauze weer op te starten
                         if applied != MIN_AMP:
                            logger.warning(f"{state} {state2} Auto laden opstarten, setting van {applied} naar nieuw ocpp {MIN_AMP}")
                   elif state == "C2":  # Auto laadt actief, Modbus moet op maximale bovengrens staan
                      car_charger.write("modbus_slave_max_current", MAX_AMP)
                      if nacht:          # Nacht → altijd max van LPsetpoint en 10A
                         loadAmp = max(loadAmp, 10)
                         if abs(loadAmp - applied) <= 1:
                            logger.info(f"'s nachts setting van {applied} naar nieuw ocpp {loadAmp}")
                            requests.post(f"http://localhost:9001/set_current?amps={loadAmp}")
                      else:              # Overdag → dynamische laadstroom via OCPP
                         if abs(loadAmp - applied) > 0.5:
                            logger.info(f"overdag setting van {applied} naar nieuw ocpp {loadAmp}")
                         status = requests.post(f"http://localhost:9001/set_current?amps={loadAmp}")
                         logger.info(f"geen verandering setting van {applied} naar nieuw ocpp {loadAmp}")
                except Exception as error:
                     logger.error(f"fout in nieuw stuk: {error}")

                set_key("LP_reader", {
                   "laadpower": laadpower,
                   "status": state2,
                   "maxcurrent": applied,
                   "LPsetpoint": loadAmp
                }, path=READER_DATA_JSON)
            except Exception as error:
                logger.error(f"fout in changeAmp: {error}")

            car_charger.disconnect()
        sleep(60)

def readLP():
    while True:
       laden = get_key("laadsessie", default={"laden": False}, path=READER_DATA_JSON).get("laden", False)
       while laden:
          with car_charger_lock:
             try:
                car_charger.connect()
                laadpower = car_charger.read("real_power_sum")
                laadpower = round(laadpower['real_power_sum'] / 1000, 2)
                laden = get_key("laadsessie", default={"laden": False}, path=READER_DATA_JSON).get("laden", False)
             except Exception as error:
                logger.error(f"fout in readLP: {error}")
             finally:
                car_charger.disconnect()  # geforceerd
          sleep(2)  # korte pauze

       with car_charger_lock:
          car_charger.disconnect()
       sleep(180)

def main():
    systemd.daemon.notify("READY=1")
    threading.Thread(target=watchdog_task, daemon=True).start()
    threading.Thread(target=changeAmp, daemon=True).start()
    threading.Thread(target=readLP, daemon=True).start()

    # start scheduler
    scheduler = BackgroundScheduler()
    scheduler.add_job(check_laadpaal, 'cron', minute='0,15,30,45')
    scheduler.start()

    # hoofdthread blijft leven
    while True:
        sleep(10)

if __name__ == "__main__":
   main()