Het grote Lidl wallbox voor thuisladen topic

[olympusdenk]

Ik heb zelf sinds rond de kerst (toen nog voor €399) en ook op forum gezocht naar ervaringen met de

Lidl ULTIMATE SPEED® Wallbox 11 kW

maar nog niet veel kunnen vinden. Deze heb ik zelf laten installeren en weet eerlijk gezegd nog niet wat ik er van moet vinden maar goed om even mijn ervaring hier neer te schrijven en mogelijk wat inzicht te winnen.

Achtergrond

Om te beginnen heb ik een Volvo V60 2.4 D6 AWD hybrid (2013) die tot 3,5 kwh volgens specificaties zou moeten kunnen laden. Bij de eerste Lidl wallbox die ik heb ontvangen heeft lokale electricien netjes vijf-aderige kabel naar meterkast doorgelegd en uitgebreid, vanwege de maandelijkse kosten ben ik nog bij één-fase aansluiting gebleven aangezien dit voor nu meer dan afdoende vermogen zou zijn voor deze hybrid.

Eén-fase aangesloten

De electricien had bedacht dat dit mogelijk zou zijn omdat wallbox zowel 1 / 3 fase ondersteunt, d.m.v. in de meterkast één van de drie fases maar aan te sluiten op de nieuwe groep, zodat de 3-fase bekabeling er wel alvast ligt en vijf-aderige kabel bemeten is op de toekomst.

Met als resultaat dat wel alle draden uit vijf-aderige kabel zijn aangesloten maar uiteindelijk maar één van de drie fases in de meterkast is aangesloten:


Waar beetje issues begonnen dat de electricien er niet uit kwam hoe het vermogen correct in te stellen, waar ik dus dan maar zelf vanuit de handleiding heb opgezocht dat we met de (pagina 15) konden begrensen op 16A / 4 kwh.

---

Eerste poging - succesvol op 9A / ~2kW

De wallbox was dus via de draaiknop hardwarematig gecapped tot 16A


Voor de eerste laadsessie van een half uur is (via het display) laadvermogen op 8A / 2 kwh gezet, dit verliep vlekkeloos alleen wat mij achteraf opviel is dat het voltage rond 198 / 211 volt slingerde tijdens laadsessie. Wel stukje vastgelegd op video (helaas niet slingerende voltage)

---

Tweede poging - wallbox stuk 16A / ~4kW

Na via het display het laadvermogen verhoogd te hebben ging het na luttle minuten eigenlijk al mis, waarbij de wallbox (ook na het verwijderen van de laadkabel uit de auto) in soort oneidinge bootloop terecht komt.

---

Derde poging - NIEUWE wallbox, stuk met 13A / ~3kW

De defecte wallbox is teruggestuurd en binnen dezelfde week nog had Lidl bevestigd dat de wallbox inderdaad defect was (geraakt), en was de nieuwe al binnen. Omdat de hybride eigenlijk maximaal 3,5kW aankan ditmaal laadpoging gedaan op 13A / 3kW met de wallbox weer in dezelfde bootloop als bij tweede poging.

---

Oorzaak bij hybride auto electra óf electra achter de wallbox / voltage. En vervolgstappen

Vanuit publieke laadsessie via Tap gaf wat inzicht in power consumptie, maar omdat deze grafiek rustig boven de 6kW uit lijkt te komen (max van auto zou 3,5kW zijn) durf ik qua betrouwbaar van deze grafiek niet zo stellig te zeggen.



De hybride auto heb ik inmiddels bij meerdere laadpalen in de buurt geprobeerd over periode van twee weken, allereerst een andere stad gezocht vanwege zelf zorg om lage voltage . Daarna binnen onze stad maar net 1km verderop bij winkelcentrum, en daarna binnen onze wijk.

Ik vermoed daarmee ook electra begrensd van andere wijken met kanaaltje want wat er gebeurde als volgt: het opladen bij parkeergarages, bij winkelcentrum buiten wijk verliep probleemloos 8,5 kWh volgeladen. Maar binnen onze wijk niet alleen de aangesloten laadpaal stuk ging (ANWB moest tepas komen om kabel komen om kabel los te halen) maar schoten ook alle drie overige Total palen in onze wijk op rood. De Volvo garage zegt wij zitten tot 8 weken vol De electricien neemt gelukkig voortouw om nu de Lidl wallbox als voorstel terug te sturen.

Hij biedt aan dat Lidl terugbetaling kan doen, vervolgens een vervanging kan met een Zappi / of mogelijk zelfs nog liever zijn voorkeur een ander "gerenoveerd" merk. Ik vraag mij sterk af wat handig is met vervolgstappen, en mogelijk komt dit meer Tweakers gedeeltelijk bekend voor qua ervaring / aanpak

• electra probleem, electricien heeft naast gekke voltage geen andere issues kunnen vinden. Maar voltage zou dit mogelijke dwarsboom oorzaak zijn hier. Gezien problemen van publieke laadpalen precies binnen deze wijk, of zou het kunnen dat voor mijn electricien dit onbekende edge-case is. Mogelijk zelf bij netbeheerder / wijktrafo ligt?
• publieke palen, mogelijk dat Total ook problemen op niveau van mijn woonwijk onvervindt. Neem aan dat ze hun palen ook goed werkend willen hebben, blijkbaar valt hele rits aan palen om bij issue met één van de palen
• kostenaspect, nog een rug extra aftikken terwijl mogelijk voltage issue is. Mogelijk dat ik nog een derde poging kan overwegen met nieuwe Lidl wallbox. Lost 'probleem' niet op, mogelijk wel een risico voor auto electra maar mogelijk werkt het ook gewoon stabiel op 2A limiet voor periode

[lithoijen]

Ik heb zelf de 22 kW variant van je lader. Deze heb ik begrenst op 16 ampere (11kW) en gebruik ik icm een ioniq 5 73kWh accu op een driefase aansluiting. Nooit problemen, werkt als een trein. Mijn broer heeft net als jij de 11kW variant die hij gebruikt voor zijn electrische MG (3 fase), ook probleemloos.

Ik monitor mijn netspanning, daarom weet ik dat een laadsessie nauwelijks impact heeft op de netspanning, niet bij de meter, ook niet bij de lader. Het feit dat bij jou de spanning zo laag is kan mijn inziens 2 redenen hebben:
- lage netspanning in de wijk: hiervoor zou je de netbeheerder kunnen benaderen meer dan een 10% afwijking is niet toegestaan, 200volt is dus te laag
- Ergens in het circuit is een te grote overgangsweerstand: een slecht contact zorgt voor een grote overgangsweerstand waardoor de spanning inzakt als er grotere vermogens worden gevraagd

Mijn gok zou oorzaak 2 zijn, hier moet je dan iets aan doen want dit is gevaarlijk, op de plek van de overgangsweerstand wordt de zaak heet wat kan leiden tot beschadigingen van componenten of zelfs brand. Deze slechte verbinding kan bijvoorbeeld zitten in de aansluiting van de kabel in de laadpaal, de kabel in de meterkast, maar kan ook zitten bij je hoofdschakelaar, slimme meter of zelfs bij de zekeringen van de netbeheerder. Zakt de spanning ook in op anderre groepen wanneer je veel stroom verbruikt? Dit kun je testen met een duspel/multimeter icm een waterkoker of electrische kachel. Alternatief is een infrarood camera lenen en daarmee je meterkastr bekijken als er wat vermogen wordt gevraagd.

overigens verklaart optie 2 niet de problemen bij andere laders in de wijk, dit wijst dan weer een beetje op optie 1, maar dan zou ik verwachten dat er veel meer klachten zijn (uitvallende pv omvormers, knipperende lampen, etc.). Kun je op verschillende tijden eens de netspanning uitlezen op je slimme meter (of nog beter deze structueel uitlezen)

[ Voor 10% gewijzigd door lithoijen op 07-03-2024 16:04 ]

[olympusdenk]

@lithoijen ik was van de week nog niet toegekomen aan reactie (in ieder geval hartstikke bedankt voor op topic in gaan) en dus bij deze reactie + kleine update.

lithoijen schreef op donderdag 7 maart 2024 @ 15:48:

Ik monitor mijn netspanning, daarom weet ik dat een laadsessie nauwelijks impact heeft op de netspanning, niet bij de meter, ook niet bij de lader. Het feit dat bij jou de spanning zo laag is kan mijn inziens 2 redenen hebben:
- lage netspanning in de wijk: hiervoor zou je de netbeheerder kunnen benaderen meer dan een 10% afwijking is niet toegestaan, 200volt is dus te laag
- Ergens in het circuit is een te grote overgangsweerstand: een slecht contact zorgt voor een grote overgangsweerstand waardoor de spanning inzakt als er grotere vermogens worden gevraagd

Erg nuttig blijkt aan hand van wat jij aangaf als intuitie toen ik even in de kruipruimte verder gekeken heb dat ik weldaar een lasdoos tegenkwam als 'verlengstuk', na navraag blijkt electricien nét kabel tekort gekomen en heeft laatste meter met andere vijf-aderige kabel afgemaakt.

Als update ik heb eerst met Liander via Whatsapp gesproken, zij hebben een meting uitgevoerd en geven aan 225v te meten en verder 'geen thuis'. Medewerker geeft aan dat enige oplossing is overstappen meer betalen per maand voor drie-fase, dat dit overkill is voor mijn hybride auto gaven ze als reactie dat één-fase officieel niet geschikt is voor elektrisch laden.

Omdat ik inmiddeles van Lidl een nieuwe wallbox al terug heb ga ik maandag nog even Liander via Whatsapp vragen (en anders daarna electricien) om van het voltage op de meterkast (+ nog met multimeter in huis) het voltage uit te lezen tijdens een actieve laadsessie.
Deze loopt inmiddels volgens de Wallbox zelf bij monitoren van een vijf-tal laadsessies qua uitvallen nu zonder problemen, maar wel op minimale vermogen 2A / 9kW~ met concreet voltage wat bij 2A op tot ongeveer ondergrens van 208v daalt:

[lithoijen]

@olympusdenk Heb je een slimme meter? Dan kun je daar meestal vrij makkelijk de spanning op aflezen en deze vergelijken met de spanning die je laadpaal aangeeft. Hier zou niet veel verschil in mogen zitten. Als de spanning bij de meter inderdaad de 225 volt is die Liander aangeeft en maar 208v bij de lader dan verlies je dus bijna 20v. 20v bij 9ampere is een vermogen van 180w. Dat is gevaarlijk veel als dit komt door een slechte verbinding ergens het tracé. Ik zou niet laden totdat je dat beter snapt, er is risico op brand. Laad in ieder geval niet als er niemand thuis is en zeker niet als iedereen slaapt!

Overigens kost een 3x25a huisaansluiting per maand niet meer dan de 1x40a die je nu hebt (is alleen niet handig als je auto op maar 1 fase laad.)

[ Voor 60% gewijzigd door lithoijen op 17-03-2024 11:50 ]

[olympusdenk]

Dat is een goeie! Ik heb even de slimme meter doorgescrold maar, ook even vergeleken met YouTube hoe je voltage uit zou moeten lezen maar mijn meter (Iskra AM550) geeft alleen op display tenminste op welke fase spanning staat, helaas mist voltage e.d.

Zonder twijfel zal ik eerst even multimeter erbij interne voltage bekijken, helemaal voordat de Wallbox gebruikt gaat worden

[Maarten69]

Ik heb zojuist de 22 kW versie aangeschaft die ben ik (voorlopig) van plan om op mijn bestaande 1 fase aansluiting aan te sluiten voor de (nog te leveren) Kia EV6 Light Edition.
Ik ga proberen updates hier te plaatsen met name mijn ervaring met aansturing via Modbus RS485.

[tedkroon]

Mijn vraag is hoe ik load balancing aansluit via de RS485 bus aan de Iskra M550 meter

[Maarten69]

@tedkroon Bij mijn weten kan dit niet direct. Er is nu een werkende methode die gebruikt maakt van een esp32 om de stroom te beperken: hier meer info
Zelf probeer ik het via een python script (Master/Slave) en een USB to RS485 adapter om later aan te sturen via Home Assistant.
Ik kan momenteel even niet verder zonder EV, maar post hier eventuele updates.

[ Voor 4% gewijzigd door Maarten69 op 10-04-2024 12:57 ]

[Maarten69]

Hij hangt nu:


Ik heb nu de RS485 adapter verbonden met de Wallbox op Net2-A en Net2-B.
Nu heb ik de potmeter op stand 1 (MASTER) gezet en test ik momenteel een python script.
Ik kan de stroom nu beperken van 32A tot 4 A

keep you updated!

[tedkroon]

Maarten, super bedankt! Wellicht kan je mij hiermee helpen om ook mijn Wallbox van lidl 11kW die ik inmiddels binnen heb, om hiermee te configureren. Natuurlijk wacht ik jouw bevindingen af uiteraard. De wallbox werkt op 3 fasen echter kan ik alleen nog niet testen omdat ik nog niet mijn ev heb die wordt 1e week van mei geleverd.


Ter info: https://github.com/evcc-io/evcc/discussions/5572

[ Voor 42% gewijzigd door tedkroon op 15-04-2024 10:29 ]

[tedkroon]

Ik heb mijn zonnepanelen op 2 fasen verdeeld en mijn vraag is of deze Wallbox op 2 fasen gaat werken indien ik 1 fase van de 3 los haal?

Lees net en daar sluit ik mij ook helemaal bij aan, dat de meter alle fasen het verbruik totaliseert en daarmee is mijn vraag al direct mee beantwoord dat het niets uitmaakt als de Wallbox van alle fasen zijn energie betrekt en op het moment gelijk de opbrengst nivelleert t.o.v. van het verbruik.

Het enige waar ik op moet letten dat ik ongeveer gelijk oplaadt aan energie die overeenkomt met de opbrengst van de zonnepanelen.

[ Voor 64% gewijzigd door tedkroon op 30-05-2024 16:05 ]

[Maarten69]

tedkroon schreef op vrijdag 12 april 2024 @ 18:16:
Maarten, super bedankt! Wellicht kan je mij hiermee helpen om ook mijn Wallbox van lidl 11kW die ik inmiddels binnen heb, om hiermee te configureren. Natuurlijk wacht ik jouw bevindingen af uiteraard. De wallbox werkt op 3 fasen echter kan ik alleen nog niet testen omdat ik nog niet mijn ev heb die wordt 1e week van mei geleverd.
[Afbeelding]

Ter info: https://github.com/evcc-io/evcc/discussions/5572

Ik ben wat verder gekomen hiermee.
Ik kan bevestigen dat ik hem aan kan sturen via een python script en (op 1 fase) ik kan regelen tussen 6 vermogens!
7380w, 3730w, 2740w, 1780w, 1550w en 1310w (31,5A , 15,5A, 11,5A, 7,4 A, 6,5A en 5,5 A)
Zou ook voor 3 fase aansluiting moeten werken, maar dat kan ik zelf niet testen.


De wallbox is met een 2-aderige kabel aangesloten op een USB RS485 dongle:

het werkt door het emuleren van andere clients (extra wallboxen) die zogenaamd hun vermogen verdelen over het aantal clients (load balancing).
Ik simuleer dit via een Python script door de master te vertellen dat client 2 ook 16 ampere nodig heeft en dan verdeeld hij het vermogen door 2 (32/2 is 16 A)

Ik wil mijn vorderingen best delen, maar het is nu nog maar een test scriptje.
Ik moet nu nog zelf de WANT_LOAD_B PER client instellen. Het script loopt nu ook continue wat ook niet nodig is.
Dit is mijn huidige testscript:

code:

from crc import Calculator, Crc16
import struct
import serial
import logging
import time

logger = logging.getLogger(__name__)

START_MSG_FRAME = bytes([0x5A,0xA5])
MSG_LENGTH_BYTES = 1 # third byte hold the message length without SOF and length byte himself
MODE_MASTER = False
MAX_CURRENT_A = 16
MODE_SLAVE_ID = 2
COM_PORT = "/dev/ttyUSB2" #pas dit aan naar jouw com poort. Onder windows kan dit bijvoorbeeld zijn COM3

def main():
    setup_logger()
    logger.info("Logger setup successful")
    setup_communication(master=MODE_MASTER)

def setup_logger():
    global logger
    logger.setLevel(logging.DEBUG)
    ch = logging.StreamHandler()
    # ch.setLevel(logging.DEBUG)
    # formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
    ch.setFormatter(formatter)
    logger.addHandler(ch)

def bytes_to_hexstring(bytes):
    return ' '.join(['0x{:02X}'.format(x) for x in bytes])

def calc_checksum_wb(data, with_crc=True):
    calculator = Calculator(Crc16.MODBUS)
    crc_expected = 0
    if with_crc:
        crc_expected = bytes(data[-2:])
        data = data[:-2]
    data = bytes(data)
    crc = calculator.checksum(data[-5:])
    crc_byte = struct.pack("<H", crc)
    # print(f"Check data {bytes_to_hexstring(data)} ({bytes_to_hexstring(crc_byte)}) -> {crc_expected == crc_byte}")
    return crc_byte

def setup_communication(master=True):
    with serial.Serial() as ser:
        ser.baudrate = 4800
        ser.port = COM_PORT
        ser.timeout = 1
        ser.open()
        # ser.write(b'hello')
        logger.info("Opened serial port")
        if master:
            handle_master_comm(ser)
        else:
            handle_client_comm(ser)

def handle_master_comm(ser: serial.Serial):
    logger.info("Start MASTER mode")
    allow_loading = True
    initial_current = 0
    initial_current = MAX_CURRENT_A
    allow_timeslot = 20
    while True:
        # TEST ONLY: change allowed current after a few seconds
        allow_timeslot -= 1
        if allow_timeslot <= 0:
            initial_current = 0
        # for i in range(2,10):
        for i in [MODE_SLAVE_ID]:
            logger.info(f"Send initial message to slave {i}")
            msg = START_MSG_FRAME + bytes([0x07, 0x00, i, 0x02, 0x01, initial_current])
            msg = msg + calc_checksum_wb(msg, False)
            ser.write(msg)
            logger.debug("-> send: " + bytes_to_hexstring(msg))
            time.sleep(0.05)
            if ser.in_waiting > 0:
                logger.debug("Serial port in readable state")
                response = ser.read(3)
                if (response[:2] == START_MSG_FRAME):
                    response += ser.read(response[2])
                    logger.debug("<- recv: " + bytes_to_hexstring(response))
                    if response[7] != 0:
                        logger.info(f"Slave wallbox {i} want to load with {response[7]}A - allow {initial_current}A")

        time.sleep(2)


def handle_client_comm(ser: serial.Serial):
    logger.info(f"Start SLAVE mode (id: {MODE_SLAVE_ID})")
    sof = False
    msg = b''
    load_count = 3 # simulate charging until Nth message from master arrived
    while True:
        c = ser.read()
        if not sof and len(c) > 0 and (c[0] == START_MSG_FRAME[0]):
            msg = c
        elif not sof and len(msg) == 1 and c[0] == START_MSG_FRAME[1]:
            msg += c
            sof = True
        elif sof:
            msg += c
        else:
            continue
        # Process msg
        if len(msg) == 10:
            sof = False
            if msg[-2:] != calc_checksum_wb(msg):
                #logger.warning("Checksum mismatch - ignore data")
                continue


            #logger.debug("<- recv: " + bytes_to_hexstring(msg))
            WANT_LOAD_B = 4 #if load_count > 0 else 0
            SLAVE = 2 # 1 = MASTER, 2 = THIS CLIENT, 3 = SLAVE3


            logger.info(f"****Max stroom voor slave id {msg[4]} is {msg[7]}A")


            if msg[5:7] == bytes([0x02,0x01]):
                logger.info(f"Max stroom voor slave id {msg[4]} is {msg[7]}A")
                msg = START_MSG_FRAME + bytes([0x07, 0x00, SLAVE, 0x02, 0x02, WANT_LOAD_B])
                msg = msg + calc_checksum_wb(msg, False)
                ser.write(msg)
                #-> send: " + bytes_to_hexstring(msg))

                WANT_LOAD_B = 4
                SLAVE = 3
                #logger.debug("WANT_LOAD_B = " + str(WANT_LOAD_B))
                msg = START_MSG_FRAME + bytes([0x07, 0x00, SLAVE, 0x02, 0x02, WANT_LOAD_B]) 
                msg = msg + calc_checksum_wb(msg, False)
                ser.write(msg)
                #logger.debug("-> send: " + bytes_to_hexstring(msg))

                WANT_LOAD_B = 4
                SLAVE = 4 # 1 = MASTER, 2 = THIS CLIENT, 3 = SLAVE3
                msg = START_MSG_FRAME + bytes([0x07, 0x00, SLAVE, 0x02, 0x02, WANT_LOAD_B]) 
                msg = msg + calc_checksum_wb(msg, False)
                ser.write(msg)
                #logger.debug("-> send: " + bytes_to_hexstring(msg))

                WANT_LOAD_B = 4
                SLAVE = 5 # 1 = MASTER, 2 = THIS CLIENT, 3 = SLAVE3
                msg = START_MSG_FRAME + bytes([0x07, 0x00, SLAVE, 0x02, 0x02, WANT_LOAD_B])
                msg = msg + calc_checksum_wb(msg, False)
                ser.write(msg)
                #logger.debug("-> send: " + bytes_to_hexstring(msg))

                WANT_LOAD_B = 4
                SLAVE = 6 # 1 = MASTER, 2 = THIS CLIENT, 3 = SLAVE3
                msg = START_MSG_FRAME + bytes([0x07, 0x00, SLAVE, 0x02, 0x02, WANT_LOAD_B])
                msg = msg + calc_checksum_wb(msg, False)
                ser.write(msg)
                #logger.debug("-> send: " + bytes_to_hexstring(msg))

                WANT_LOAD_B = 4
                SLAVE = 7 # 1 = MASTER, 2 = THIS CLIENT, 3 = SLAVE3
                msg = START_MSG_FRAME + bytes([0x07, 0x00, SLAVE, 0x02, 0x02, WANT_LOAD_B])
                msg = msg + calc_checksum_wb(msg, False)
                ser.write(msg)
                #logger.debug("-> send: " + bytes_to_hexstring(msg))

                WANT_LOAD_B = 4
                SLAVE = 8 # 1 = MASTER, 2 = THIS CLIENT, 3 = SLAVE3
                msg = START_MSG_FRAME + bytes([0x07, 0x00, SLAVE, 0x02, 0x02, WANT_LOAD_B])
                msg = msg + calc_checksum_wb(msg, False)
                ser.write(msg)
                #logger.debug("-> send: " + bytes_to_hexstring(msg))

                WANT_LOAD_B = 0
                SLAVE = 9 # 1 = MASTER, 2 = THIS CLIENT, 3 = SLAVE3
                msg = START_MSG_FRAME + bytes([0x07, 0x00, SLAVE, 0x02, 0x02, WANT_LOAD_B])
                msg = msg + calc_checksum_wb(msg, False)
                ser.write(msg)
                #logger.debug("-> send: " + bytes_to_hexstring(msg))
                
                #time.sleep(1)
            # elif msg[5:8] == bytes([0x02,0x01,0x00]):
            #     pass
            else:
                logger.critical(f"Got unknown message - SKIP")

            # Reset all
            msg = []


def test():
    slave_id = 0x02
    def cmsg(master=True, load=0):
        msg = START_MSG_FRAME + bytes([0x07, 0x00, slave_id, 0x02, (0x01 if master else 0x02), load])
        return msg + calc_checksum_wb(msg, False)

    msgs = [
        (True, 0, "Master initial scan"),
        (False, 0, "Wallbox without vehicle"),
        (True, 0, "Master next loop"),
        (False, 16, "Wallbox request 16A"),
        (True, 9, "Master allow 9A"),
        (False, 16, "Wallbox request 16A"),
        (True, 9, "Master allow 9A"),
        (False, 0, "Wallbox is ready"),
        (True, 0, "Master allow requested 0A"),
        (False, 0, "Wallbox same response"),
    ]
    for m in msgs:
        print(f"{m[2]:<26}{'>>' if m[0] else '<<'} {bytes_to_hexstring(cmsg(m[0], m[1]))}")

if __name__ == '__main__':
    main()

Ik meld mij binnenkort hier weer terug!

edit:
credits voor het python script gaan naar BAMMAB

[ Voor 6% gewijzigd door Maarten69 op 19-06-2024 10:19 ]

[tedkroon]

Super dat je goed op weg bent!!!
Deze script staat op een usb dongel opdat hij de Wallbox aanstuurt? Dat is mijn Ik heb vroeger basic programmeren gehad op de HTS maar mijn vaardigheden zijn beperkt tot het maken van een bat file. Wellicht kan mijn zoon of zwager mij helpen.
Het liefste zou ik al mijn zon energie direct in mijn auto willen laden. Kan dat met een Python script ?

Mijn Wallbox werkt prima op 3 fasen en is met mijn dochter's Tesla getest en laadt max. 10,8kwh. Helaas komt mijn Volvo ex30 pas medio juli. 3 maanden verlaat.

[Maarten69]

tedkroon schreef op donderdag 20 juni 2024 @ 17:19:
1]-Deze script staat op een usb dongel opdat hij de Wallbox aanstuurt?
2]-Het liefste zou ik al mijn zon energie direct in mijn auto willen laden. Kan dat met een Python script ?

1] De usb-dongle is aangesloten op een mini-pc (Intel-Nuc) waar Home Assistant op draait. Dit kan natuurlijk ook met een Raspberry Pi

2] Ja, ik heb nu onder AppDeamon in Home Assistant een Python script die dit aanstuurt.
Twee losse automations sturen het script dan aan:

en


Vereist is dus:
-computer/Raspberry Pi
-usb dongle of HAT voor RS485 communicatie
-Home Assistant met Addon AppDeamon
-Onderstaand python-scipt
-Twee helpers (input_boolean.loadbalancing + input_number.wallbox_power_setting) en twee automations.

In de UI ziet het er mij nu zo uit:

code:

import appdaemon.plugins.hass.hassapi as hass
from crc import Calculator, Crc16
import struct
import serial
import logging
import time

logger = logging.getLogger(__name__)

START_MSG_FRAME = bytes([0x5A, 0xA5])
MSG_LENGTH_BYTES = 1  # third byte holds the message length without SOF and length byte himself
MODE_MASTER = False
MAX_CURRENT_A = 16
MODE_SLAVE_ID = 2
COM_PORT = "/dev/ttyUSB2"

class wallbox(hass.Hass):

    def initialize(self):
        self.wallbox_power_setting = -1  # default value for the instance attribute wallbox_power_setting
        self.listen_state(self.wallbox_control, "input_number.wallbox_power_setting")

    def wallbox_control(self, entity, attribute, old, new, kwargs):
        load_balancing = self.get_state("input_boolean.loadbalancing")
        if load_balancing == "off":
            print("Automatic load balancing is disabled.")
            wallbox_power = float(self.get_state("sensor.kwh_meter_2_channel_power_b"))
            self.wallbox_power_setting = round(float(self.get_state("input_number.wallbox_power_setting")))
            #if float(wallbox_power) > 10:
            self.main()
        if load_balancing == "on":
            print("Automatic load balancing is enabled.")
            wallbox_power = float(self.get_state("sensor.kwh_meter_2_channel_power_b"))
            self.wallbox_power_setting = round(float(self.get_state("input_number.wallbox_power_setting")))
            #if float(wallbox_power) > 10:
            self.main()

    def main(self):
        setup_communication(master=MODE_MASTER, wallbox_power_setting=self.wallbox_power_setting)
        #print('wallbox_power_setting: ' + str(self.wallbox_power_setting))

def bytes_to_hexstring(bytes):
    return ' '.join(['0x{:02X}'.format(x) for x in bytes])

def calc_checksum_wb(data, with_crc=True):
    calculator = Calculator(Crc16.MODBUS)
    crc_expected = 0
    if with_crc:
        crc_expected = bytes(data[-2:])
        data = data[:-2]
    data = bytes(data)
    crc = calculator.checksum(data[-5:])
    crc_byte = struct.pack("<H", crc)
    return crc_byte

def setup_communication(master=True, wallbox_power_setting=-1):
    with serial.Serial() as ser:
        ser.baudrate = 4800
        ser.port = COM_PORT
        ser.timeout = 1
        ser.open()
        print("Opened serial port " + COM_PORT)
        handle_client_comm(ser)
        send_message(ser, wallbox_power_setting)

def send_message(ser: serial.Serial, wallbox_power_setting):

    def send(slave_id, want_load):
        message = START_MSG_FRAME + bytes([0x07, 0x00, slave_id, 0x02, 0x02, want_load])
        message += calc_checksum_wb(message, False)
        ser.write(message)

    #print('wallbox_power_setting = ' + str(wallbox_power_setting))    

    if wallbox_power_setting == 0:
        for slave_id in range(2, 10):
            want_load = 1 if slave_id < 9 else 0
            send(slave_id, want_load)
        print("Wallbox power setting: {}".format(wallbox_power_setting))
    elif wallbox_power_setting == 1:
        for slave_id in range(2, 10):
            want_load = 1 if slave_id < 7 else 0
            send(slave_id, want_load)
        print("Wallbox power setting: {}".format(wallbox_power_setting))
    elif wallbox_power_setting == 2:
        for slave_id in range(2, 10):
            want_load = 1 if slave_id < 5 else 0
            send(slave_id, want_load)
        print("Wallbox power setting: {}".format(wallbox_power_setting))
    elif wallbox_power_setting == 3:
        for slave_id in range(2, 10):
            want_load = 1 if slave_id < 4 else 0
            send(slave_id, want_load)
        print("Wallbox power setting: {}".format(wallbox_power_setting))
    elif wallbox_power_setting == 4:
        for slave_id in range(2, 10):
            want_load = 1 if slave_id < 3 else 0
            send(slave_id, want_load)
        print("Wallbox power setting: {}".format(wallbox_power_setting))
    elif wallbox_power_setting == 5:
        for slave_id in range(2, 10):
            want_load = 0
            send(slave_id, want_load)
        print("Wallbox power setting: {}".format(wallbox_power_setting))

    print("-> send data to serial port completed <-------")

def handle_client_comm(ser: serial.Serial):
    print(f"Start SLAVE mode (id: {MODE_SLAVE_ID})")
    sof = False
    msg = b''
    load_count = 3  # simulate charging until Nth message from master arrived
    while len(msg) < 10:
        c = ser.read()
        if not sof and len(c) > 0 and (c[0] == START_MSG_FRAME[0]):
            msg = c
        elif not sof and len(msg) == 1 and c[0] == START_MSG_FRAME[1]:
            msg += c
            sof = True
        elif sof:
            msg += c
        else:
            continue
        # Process msg
        if len(msg) == 10:
            sof = False
            if msg[-2:] != calc_checksum_wb(msg):
                print("Checksum mismatch - ignore data")
                continue
            print(f"Max STROOM voor slave id {msg[4]} is {msg[7]}A")

[ Voor 5% gewijzigd door Maarten69 op 21-06-2024 13:41 ]

[Maarten69]

Mocht iemand dit verder kunnen verbeteren door er een HA-integratie van te maken zou ik het erg waarderen. Dat gaat vooralsnog boven mijn pet

[tedkroon]

Ik vind al dat je mooi resultaat heb bereikt, proficiat!! En allemaal met de Lydl Wallbox, echt geweldig!

[Timo002]

Ik sta op het punt om zelf ook een Lidl wallBox 11kW te bestellen voor mijn plug-in hybride. Die laad maar maximaal met 3kW, ga dat dus makkelijk met 1 fase redden en kan ook zoveel mogelijk mijn eigen zonne-energie gebruiken.

Nu wil ik hem zelf installeren, ik heb wel enige elektrotechnische achtergrond, maar been geen installateur. Het lijkt me dat ik hiervoor een extra aardlekschakelaar met daarachter 1 groep moet plaatsen in mijn meterkast?

Daarnaast, deze wallbox is IP65. Daarmee zou die tegen regen moeten kunnen, maar op de pagina van de lidl staat dat hij het beste wel onder een carport moet hangen. Die mogelijkheid heb ik niet en hij zou vol op de weerkant komen te hangen. Zon, wind en regen. Gaat dat een probleem worden?

Ook ben ik erg benieuwd naar welke hardware er nodig is om de wallbox te koppelen aan HA. @Maarten69 Ik ben ook benieuwd hoe je load balacing uitgewerkt hebt

[Maarten69]

Beste @Timo002 hoe ik dat gedaan heb staat dacht ik duidelijk beschreven, maar wil je best verder helpen hiermee.
Ik heb de 22 kW versie op 1 fase. Je weet het nooit in de toekomst.
Ik heb 399 betaald bij lidl.nl

Hij hangt hier in de regen, kan geen kwaad denk ik. Vind het geheel degelijk gebouwd.

Aardlek:

[ Voor 39% gewijzigd door Maarten69 op 30-07-2024 16:50 ]

[Timo002]

@Maarten69 Ik heb hem aangeschaft, de 11kW versie. Ik heb maar een 1-fase 25A meterkast, dus krijg ik 16A automaat. Heb je hiervoor nog een aardlek zitten?
Zal nog even duren voordat hij helemaal functioneel is (vakantie zit ertussen). Maar zal de voortgang hier updaten

[Timo002]

Ik heb hem ontvangen, mis alleen de drie pasjes. Zitten die erin? Ik moet namelijk eerst nog een veiligheids torx kopen voordat ik hem los kan halen 🙈

[Maarten69]

@Timo002 meen dat deze in de doos zaten (bruin envelopje)

[erik57]

Hallo
Wij hebben zonet de 22kw wallbox geïnstalleerd volgens beschrijving.
Onze vraag is of display blijft branden of uitgaat? Ons display blijft n.m. aan.

[Maarten69]

Gaat na verloop van tijd uit, ook tijdens het laden. Denk na 5 of 10 minuten.
De groene ledrand blijft wel branden.

[ Voor 5% gewijzigd door Maarten69 op 07-08-2024 16:00 ]

[tedkroon]

Even een vraag: Werkt deze Wallbox ook op 2 fasen?

[Wokschotel]

Kickje. Voor mijn nieuwe VW PHEV wil ik een laadpaal/wallbox plaatsen. De Lidl wallbox 11kW is nu in de aanbieding en dat lijkt me een prima oplossing. Ik wil gebruik maken van de groep waarop nu alleen de wasmachine zit, ook omdat die op een fase zit in mijn 3x25A aansluiting waar niet veel andere zware gebruikers op zitten. Het idee is dan om mijn kelder (waar alle elektra doorheen loopt en waar ik makkelijk bij kan) een lasdoos te plaatsen in de kabel die nu naar de wasmachine loopt. In de lasdoos een aftakking naar een werkschakelaar en vanaf die werkschakelaar de kabel door een mantelbuis naar de laadpaal. Alhoewel ik maar 1 fase nodig heb, trek ik een 5x4 kabel (4mm ivm de lengte, ivm 25 meter afstand naar laadpaal). Mocht ik in de toekomst toch 3 fase laden nodig hebben, dan is een 5 aderige kabel van meterkast (dan wel met nieuwe 3-fase groep) naar lasdoos snel getrokken.

Als ik de laadpaal begrens op 2 of 3 kW kan er weinig fout gaan aan bovenstaande, of is er iemand die dat anders ziet? En daarnaast de vraag, als ik toch een kabel trek door de mantelbuis, welke kabel voor de RS485 adviseren jullie om dan mee te trekken?

[Maarten69]

Wokschotel schreef op zondag 24 november 2024 @ 06:54:
Als ik de laadpaal begrens op 2 of 3 kW kan er weinig fout gaan aan bovenstaande, of is er iemand die dat anders ziet? En daarnaast de vraag, als ik toch een kabel trek door de mantelbuis, welke kabel voor de RS485 adviseren jullie om dan mee te trekken?

Dat moet inderdaad prima lukken. Wil je helemaal zeker zijn zet je er een 16A zakeringsautomaat tussen.
ik heb 5x6mm2 gebruikt gezien de geringe meerprijs en gebruik ook maar 1 fase. (22kW variant).
Voor aansturen gebruik ik een 2 aderige kabel. Zal zo post updaten met foto's:

[ Voor 36% gewijzigd door Maarten69 op 24-11-2024 13:16 ]

[CptObvious12]

Maarten69 schreef op vrijdag 21 juni 2024 @ 13:19:
[...]

1] De usb-dongle is aangesloten op een mini-pc (Intel-Nuc) waar Home Assistant op draait. Dit kan natuurlijk ook met een Raspberry Pi

2] Ja, ik heb nu onder AppDeamon in Home Assistant een Python script die dit aanstuurt.
Twee losse automations sturen het script dan aan:
[Afbeelding]
en
[Afbeelding]

Vereist is dus:
-computer/Raspberry Pi
-usb dongle of HAT voor RS485 communicatie
-Home Assistant met Addon AppDeamon
-Onderstaand python-scipt
-Twee helpers (input_boolean.loadbalancing + input_number.wallbox_power_setting) en twee automations.

In de UI ziet het er mij nu zo uit:
[Afbeelding]

code:

import appdaemon.plugins.hass.hassapi as hass
from crc import Calculator, Crc16
import struct
import serial
import logging
import time

logger = logging.getLogger(__name__)

START_MSG_FRAME = bytes([0x5A, 0xA5])
MSG_LENGTH_BYTES = 1  # third byte holds the message length without SOF and length byte himself
MODE_MASTER = False
MAX_CURRENT_A = 16
MODE_SLAVE_ID = 2
COM_PORT = "/dev/ttyUSB2"

class wallbox(hass.Hass):

    def initialize(self):
        self.wallbox_power_setting = -1  # default value for the instance attribute wallbox_power_setting
        self.listen_state(self.wallbox_control, "input_number.wallbox_power_setting")

    def wallbox_control(self, entity, attribute, old, new, kwargs):
        load_balancing = self.get_state("input_boolean.loadbalancing")
        if load_balancing == "off":
            print("Automatic load balancing is disabled.")
            wallbox_power = float(self.get_state("sensor.kwh_meter_2_channel_power_b"))
            self.wallbox_power_setting = round(float(self.get_state("input_number.wallbox_power_setting")))
            #if float(wallbox_power) > 10:
            self.main()
        if load_balancing == "on":
            print("Automatic load balancing is enabled.")
            wallbox_power = float(self.get_state("sensor.kwh_meter_2_channel_power_b"))
            self.wallbox_power_setting = round(float(self.get_state("input_number.wallbox_power_setting")))
            #if float(wallbox_power) > 10:
            self.main()

    def main(self):
        setup_communication(master=MODE_MASTER, wallbox_power_setting=self.wallbox_power_setting)
        #print('wallbox_power_setting: ' + str(self.wallbox_power_setting))

def bytes_to_hexstring(bytes):
    return ' '.join(['0x{:02X}'.format(x) for x in bytes])

def calc_checksum_wb(data, with_crc=True):
    calculator = Calculator(Crc16.MODBUS)
    crc_expected = 0
    if with_crc:
        crc_expected = bytes(data[-2:])
        data = data[:-2]
    data = bytes(data)
    crc = calculator.checksum(data[-5:])
    crc_byte = struct.pack("<H", crc)
    return crc_byte

def setup_communication(master=True, wallbox_power_setting=-1):
    with serial.Serial() as ser:
        ser.baudrate = 4800
        ser.port = COM_PORT
        ser.timeout = 1
        ser.open()
        print("Opened serial port " + COM_PORT)
        handle_client_comm(ser)
        send_message(ser, wallbox_power_setting)

def send_message(ser: serial.Serial, wallbox_power_setting):

    def send(slave_id, want_load):
        message = START_MSG_FRAME + bytes([0x07, 0x00, slave_id, 0x02, 0x02, want_load])
        message += calc_checksum_wb(message, False)
        ser.write(message)

    #print('wallbox_power_setting = ' + str(wallbox_power_setting))    

    if wallbox_power_setting == 0:
        for slave_id in range(2, 10):
            want_load = 1 if slave_id < 9 else 0
            send(slave_id, want_load)
        print("Wallbox power setting: {}".format(wallbox_power_setting))
    elif wallbox_power_setting == 1:
        for slave_id in range(2, 10):
            want_load = 1 if slave_id < 7 else 0
            send(slave_id, want_load)
        print("Wallbox power setting: {}".format(wallbox_power_setting))
    elif wallbox_power_setting == 2:
        for slave_id in range(2, 10):
            want_load = 1 if slave_id < 5 else 0
            send(slave_id, want_load)
        print("Wallbox power setting: {}".format(wallbox_power_setting))
    elif wallbox_power_setting == 3:
        for slave_id in range(2, 10):
            want_load = 1 if slave_id < 4 else 0
            send(slave_id, want_load)
        print("Wallbox power setting: {}".format(wallbox_power_setting))
    elif wallbox_power_setting == 4:
        for slave_id in range(2, 10):
            want_load = 1 if slave_id < 3 else 0
            send(slave_id, want_load)
        print("Wallbox power setting: {}".format(wallbox_power_setting))
    elif wallbox_power_setting == 5:
        for slave_id in range(2, 10):
            want_load = 0
            send(slave_id, want_load)
        print("Wallbox power setting: {}".format(wallbox_power_setting))

    print("-> send data to serial port completed <-------")

def handle_client_comm(ser: serial.Serial):
    print(f"Start SLAVE mode (id: {MODE_SLAVE_ID})")
    sof = False
    msg = b''
    load_count = 3  # simulate charging until Nth message from master arrived
    while len(msg) < 10:
        c = ser.read()
        if not sof and len(c) > 0 and (c[0] == START_MSG_FRAME[0]):
            msg = c
        elif not sof and len(msg) == 1 and c[0] == START_MSG_FRAME[1]:
            msg += c
            sof = True
        elif sof:
            msg += c
        else:
            continue
        # Process msg
        if len(msg) == 10:
            sof = False
            if msg[-2:] != calc_checksum_wb(msg):
                print("Checksum mismatch - ignore data")
                continue
            print(f"Max STROOM voor slave id {msg[4]} is {msg[7]}A")

Ik ben mij aan het oriënteren op een laadpaal met load balancing. Zou jij voor de volledigheid de YAML code van de automations kunnen delen?

[Maarten69]

@CptObvious12 Natuurlijk:

code:

alias: Kia EV6 Laadstatus aanzetten
description: ""
triggers:
  - entity_id:
      - sensor.kwh_meter_2_channel_power_b
    trigger: state
conditions:
  - condition: numeric_state
    entity_id: sensor.kwh_meter_2_channel_power_b
    above: 500
actions:
  - target:
      entity_id: input_boolean.kiaev6_laadstatus
    data: {}
    action: input_boolean.turn_on
mode: single

code:

alias: Kia EV6 Laadstatus uitzetten
description: ""
triggers:
  - entity_id:
      - sensor.kwh_meter_2_channel_power_b
    trigger: state
conditions:
  - condition: numeric_state
    entity_id: sensor.kwh_meter_2_channel_power_b
    below: 500
actions:
  - target:
      entity_id:
        - input_boolean.kiaev6_laadstatus
    data: {}
    action: input_boolean.turn_off
mode: single

Maar het gaat met name om deze:

code:

alias: Wallbox power setting omhoog
description: ""
mode: single
triggers:
  - entity_id:
      - sensor.electricity_meter_energieproductie
    trigger: state
conditions:
  - condition: numeric_state
    entity_id: sensor.electricity_meter_energieproductie
    above: 1
  - condition: numeric_state
    entity_id: sensor.kwh_meter_2_channel_power_b
    above: 10
    enabled: true
  - condition: numeric_state
    entity_id: input_number.wallbox_power_setting
    below: 4
  - condition: state
    entity_id: input_boolean.loadbalancing
    state: "on"
actions:
  - metadata: {}
    data: {}
    target:
      entity_id: input_number.wallbox_power_setting
    action: input_number.increment

code:

alias: Wallbox power setting omlaag
description: ""
mode: single
triggers:
  - entity_id:
      - sensor.electricity_meter_energieproductie
      - sensor.electricity_meter_energieverbruik
    trigger: state
conditions:
  - condition: numeric_state
    entity_id: sensor.electricity_meter_energieproductie
    below: 0.1
  - condition: numeric_state
    entity_id: sensor.kwh_meter_2_channel_power_b
    above: 10
    enabled: true
  - condition: numeric_state
    entity_id: input_number.wallbox_power_setting
    above: 0
  - condition: state
    entity_id: input_boolean.loadbalancing
    state: "on"
actions:
  - target:
      entity_id:
        - input_number.wallbox_power_setting
    data: {}
    action: input_number.decrement

[annestweak]

Enthousiast geworden door jullie mooie oplossing, heb ik ook een Lidl-oplader besteld. Sinds enkele dagen hebben wij een elektrische auto, en aangezien we geen 3-fasenaansluiting hebben, lijkt jullie oplossing mij perfect. Alles mooi geïntegreerd in Home Assistant én met slim laden – precies waar we willen zijn!

[annestweak]

Oplader, modbus, grondkabel en automaat zijn binnen, met een beetje geluk kan ik het dit weekend installeren.
Ik houd jullie op de hoogte, en ik hoop jullie mij mocht ik vragen hebben ;-)

[inhumain]

Ik heb vorige week de kabels onder de oprit door gelegd en vandaag is de installateur de wallbox van lidl komen plaatsen. Helaas heb ik geen pasjes meegeleverd gekregen en kan ik de paal nu niet ontgrendelen... iemand enig idee hoe ik dit kan oplossen? Lidl wil de wallbox retour nemen en een nieuwe toesturen maar daarmee heb ik mijn installatie kosten nog niet terug...

[annestweak]

Zitten ze nog niet in de doos? Bij mij zat er een kleine bruine enveloppe in de doss waarin de pasjes zaten?

En qua vervanging dat is mooi aangeboden door Lidl maar daar heb je niets aan qua opnieuw installeren. Niemand in je de buurt die een beetje handig is? Als je doormidden van de zekering de stroom van het apparaat afhaalt en dan zelf losmaakt en foto’s maakt van hoe het zat. Kun je bijna niets verkeerd doen. Het zijn nl alleen de 5 draadjes die ook nog een gekleurd zijn, die je los moet halen en weer vast moet zetten.

[inhumain]

Helaas alles goed nagekeken met mijn installateur maar nergens een envelop of pasje mogen vinden

Ik hoop dat de pasjes van de nieuwe wallbox geaccepteerd worden door die er nu hangt. Anders zit er helaas niks anders op dan de wallbox te vervangen.

[olympusdenk]

inhumain schreef op vrijdag 20 december 2024 @ 13:47:
Ik heb vorige week de kabels onder de oprit door gelegd en vandaag is de installateur de wallbox van lidl komen plaatsen. Helaas heb ik geen pasjes meegeleverd gekrengen en kan ik de paal nu niet ontgrendelen... iemand enig idee hoe ik dit kan oplossen? Lidl wil de wallbox retour nemen en een nieuwe toesturen maar daarmee heb ik mijn installatie kosten nog niet terug...

Ik heb dit topic geopend vanwege defecte wallbox en heb mijn wallbox ook moeten omruilen maar dan omdat deze defect was.

Lidl doet er niet moeilijk over als je de muursteun niet retour stuurt, ik durf eerlijk te zeggen dat het demonteren van de wallbox en het opnieuw aansluiten goed zelf te doen was. De wallbox heeft aan de zijkanten aantal soort van torx schroeven zodra die los zijn kun je de wallbox laten rusten op een klein krukje of emmer. Dan is het zaak de achterkant de schroeven eruit te halen en even *edit* en niet vergeten: stroom van groep af, en foto van kabel aansluiting maken en met beleid de bescherming van de 5-aderige kabel eraf te halen, en dan opsturen maar

Bij retour ontvangst (zijn nu feestdagen maar ze zijn supersnel binnen week) kun je of de wallbox zelf weer aansluiten ik heb zelf ook de box ook aangesloten, is net lamp aan plafond verlichting aansluiten maar dan met 5 kabels op juiste plek. Of als je het spannend vindt even op werkspot (€40-60?) iemand vragen je handje vast te houden

Zo’n Bosch setje bij Gamma met 43 verschillende bitjes (€30.99) is wel een aanbeveling hierbij net zoals wat elektra afplak tape om de paar dagen dat de paal weg is de 5-aderige kabel af te plakken en dan ben je klaar . Ik kreeg toen ook een gloednieuwe meteen retour en moet zeggen nu met nieuwe auto (MG ZS 2019) werkt de Lidl wallbox als een trein

[annestweak]

Goedemorgen,

weten jullie toevallig welke maat torx-t (torx met gat erin) ik nodig heb om de oplader van de muurplaat los te maken?
en heb ik nog meer speciale torx-t nodig? plaatje op de zijkant?

bvd

[olympusdenk]

annestweak schreef op zaterdag 21 december 2024 @ 08:56:
Goedemorgen,

weten jullie toevallig welke maat torx-t (torx met gat erin) ik nodig heb om de oplader van de muurplaat los te maken?
en heb ik nog meer speciale torx-t nodig? plaatje op de zijkant?

bvd

Het is een soort torx met puntje erin, ik heb zelf deze sowieso altijd handig in huis te hebben en het benodigde bitje zit hier ook in https://www.gamma.nl/asso...n-dopsleutelset/p/B131441

[annestweak]

top, bedankt

[annestweak]

[annestweak]

Buitenunit hangt, nu in de warmte de rest van binnenuit aansluiten 👍🏻

[Foofur]

Ik ben nu zelf ook druk aan het testen met een script voor de modbus rs485. Alleen heb ik nog niet veel kunnen testen helaas, aangezien de vrouw de auto steeds mee heeft.
Ik gebruik nog geen Home Assistand maar enkel een los script die ik via een webpagina aanstuur.
Heeft iemand ook een mogelijkheid gevonden om het laden te pauzeren? (b.v. max beschikbaar naar 0)
De wallbox is aangesloten op 3 fasen. Dat is mooi voor het "snel" laden op 11Kw, maar voor het opmaken van de zonnestroom is dat niet heel handig. Zelfs de laagste setting (4Kw) is dan eigenlijk teveel.
Zou er ook een mogelijkheid zijn om te schakelen tussen 3 fase / 1 fase?

[annestweak]

[annestweak]

Gelukt👍🏻

[annestweak]

Volgende stap de usb hub en de homeassistant

[annestweak]

Nu bij de Lidl voor 249 via de app

[inhumain]

Ik heb gister mijn vervangende box binnen gehad vanuit Lidl. De pasjes werken echt alleen op de box met hetzelfde serie nummer als op het pasje zelf helaas. Dus de box vervangen en de andere retour gedaan, werkt prima nu!

[Jeromium]

Heeft iemand een idee waarom de 11kw wallbox die op drie fasen is aangesloten er maar eentje gebruikt?

[annestweak]

Werkte het voorheen wel goed over de 3 fasen?

[Jeromium]

Ik heb de 11kw lader vanmiddag opgehangen, ik heb een Dacia Spring uit 2024 aangesloten en gezien dat maar een van de drie fases in gebruik is.

De drie fases worden wel gedetecteerd denk ik omdat er een correct voltage wordt weergegeven.

[ASW1]

Jeromium schreef op zaterdag 28 december 2024 @ 17:06:
Ik heb de 11kw lader vanmiddag opgehangen, ik heb een Dacia Spring uit 2024 aangesloten en gezien dat maar een van de drie fases in gebruik is.

De drie fases worden wel gedetecteerd denk ik omdat er een correct voltage wordt weergegeven.

Dacia Spring kan toch maar op 1 fase laden?

[Jeromium]

Je hebt helemaal gelijk.. dat verklaart een hoop.
Bedankt voor de reacties

[annestweak]

Vraag ik lees dat je met app deamon script moet toevoegen, ik heb nog nooit met app deamon gewerkt.
Kun je laten zien hoe je dat gedaan hebt of hoe jou map eruit ziet.

[ Voor 75% gewijzigd door annestweak op 28-12-2024 21:39 ]

[markimarc]

Deze paal lijkt mij erg interessant!
Hebben jullie toevallig ervaring met het vervangen/verlengen van de laadkabel? De bijgeleverde 5 meter zal voor ons helaas niet voldoende zijn.

[Maarten69]

AppDaemon is een add-on voor Home Assistant.
Onder het tabblad configuratie (van AppDaemon) heb ik deze libs toegevoegd.

code:

system_packages:
  - libressl-dev
  - gcc
  - libcurl
python_packages:
  - selenium
  - beautifulsoup4
  - paho-mqtt
  - geopy
  - pyserial
  - crc
  - crc16
  - crcmod

Maar ze zijn zeker niet allemaal nodig, deze "selenium" zeker niet.

Als de plugin gestart is zou je onderstaande mappen moeten hebben:

code:

/usr/share/hassio/addon_configs/a0d7b954_appdaemon/apps/

Daarin heb ik 2 bestanden;

apps.yaml

code:

wallbox:
  module: wallbox
  class: wallbox
  description: wallbox control loading

en

wallbox.py

code:

import appdaemon.plugins.hass.hassapi as hass
from crc import Calculator, Crc16
import struct
import serial
import logging
import time

logger = logging.getLogger(__name__)

START_MSG_FRAME = bytes([0x5A, 0xA5])
MSG_LENGTH_BYTES = 1  # third byte holds the message length without SOF and length byte himself
MODE_MASTER = False
MAX_CURRENT_A = 16
MODE_SLAVE_ID = 2
COM_PORT = "/dev/ttyUSB2"

class wallbox(hass.Hass):

    def initialize(self):
        self.wallbox_power_setting = -1  # default value for the instance attribute wallbox_power_setting
        self.listen_state(self.wallbox_control, "input_number.wallbox_power_setting")

    def wallbox_control(self, entity, attribute, old, new, kwargs):
        load_balancing = self.get_state("input_boolean.loadbalancing")
        if load_balancing == "off":
            print("Automatic load balancing is disabled.")
            wallbox_power = float(self.get_state("sensor.kwh_meter_2_channel_power_b"))
            self.wallbox_power_setting = round(float(self.get_state("input_number.wallbox_power_setting")))
            #if float(wallbox_power) > 10:
            self.main()
        if load_balancing == "on":
            print("Automatic load balancing is enabled.")
            wallbox_power = float(self.get_state("sensor.kwh_meter_2_channel_power_b"))
            self.wallbox_power_setting = round(float(self.get_state("input_number.wallbox_power_setting")))
            #if float(wallbox_power) > 10:
            self.main()

    def main(self):
        setup_communication(master=MODE_MASTER, wallbox_power_setting=self.wallbox_power_setting)
        #print('wallbox_power_setting: ' + str(self.wallbox_power_setting))

def bytes_to_hexstring(bytes):
    return ' '.join(['0x{:02X}'.format(x) for x in bytes])

def calc_checksum_wb(data, with_crc=True):
    calculator = Calculator(Crc16.MODBUS)
    crc_expected = 0
    if with_crc:
        crc_expected = bytes(data[-2:])
        data = data[:-2]
    data = bytes(data)
    crc = calculator.checksum(data[-5:])
    crc_byte = struct.pack("<H", crc)
    return crc_byte

def setup_communication(master=True, wallbox_power_setting=-1):
    with serial.Serial() as ser:
        ser.baudrate = 4800
        ser.port = COM_PORT
        ser.timeout = 1
        ser.open()
        print("Opened serial port " + COM_PORT)
        handle_client_comm(ser)
        send_message(ser, wallbox_power_setting)

def send_message(ser: serial.Serial, wallbox_power_setting):

    def send(slave_id, want_load):
        message = START_MSG_FRAME + bytes([0x07, 0x00, slave_id, 0x02, 0x02, want_load])
        message += calc_checksum_wb(message, False)
        ser.write(message)

    #print('wallbox_power_setting = ' + str(wallbox_power_setting))    

    if wallbox_power_setting == 0:
        for slave_id in range(2, 10):
            want_load = 1 if slave_id < 9 else 0
            send(slave_id, want_load)
        print("Wallbox power setting: {}".format(wallbox_power_setting))
    elif wallbox_power_setting == 1:
        for slave_id in range(2, 10):
            want_load = 1 if slave_id < 7 else 0
            send(slave_id, want_load)
        print("Wallbox power setting: {}".format(wallbox_power_setting))
    elif wallbox_power_setting == 2:
        for slave_id in range(2, 10):
            want_load = 1 if slave_id < 5 else 0
            send(slave_id, want_load)
        print("Wallbox power setting: {}".format(wallbox_power_setting))
    elif wallbox_power_setting == 3:
        for slave_id in range(2, 10):
            want_load = 1 if slave_id < 4 else 0
            send(slave_id, want_load)
        print("Wallbox power setting: {}".format(wallbox_power_setting))
    elif wallbox_power_setting == 4:
        for slave_id in range(2, 10):
            want_load = 1 if slave_id < 3 else 0
            send(slave_id, want_load)
        print("Wallbox power setting: {}".format(wallbox_power_setting))
    elif wallbox_power_setting == 5:
        for slave_id in range(2, 10):
            want_load = 0
            send(slave_id, want_load)
        print("Wallbox power setting: {}".format(wallbox_power_setting))

    print("-> send data to serial port completed <-------")

def handle_client_comm(ser: serial.Serial):
    print(f"Start SLAVE mode (id: {MODE_SLAVE_ID})")
    sof = False
    msg = b''
    load_count = 3  # simulate charging until Nth message from master arrived
    while len(msg) < 10:
        c = ser.read()
        if not sof and len(c) > 0 and (c[0] == START_MSG_FRAME[0]):
            msg = c
        elif not sof and len(msg) == 1 and c[0] == START_MSG_FRAME[1]:
            msg += c
            sof = True
        elif sof:
            msg += c
        else:
            continue
        # Process msg
        if len(msg) == 10:
            sof = False
            if msg[-2:] != calc_checksum_wb(msg):
                print("Checksum mismatch - ignore data")
                continue
            print(f"Max STROOM voor slave id {msg[4]} is {msg[7]}A")

[Maarten69]

@annestweak Laat je weten of het gelukt is?

[annestweak]

@Maarten69 bedankt voor je reactie, ik blijf bij punt 1 en 2 al hangen.
Ik heb onder appdeamon een map aangemaakt met de naam configuratie, hierin een file libs en daarin jouw code. Het zal vast hilarisch zijn wat ik gedaan heb want dat werkt niet :-)
er start dus geen plugin.

De apps.yaml en de wallbox.py, die zijn wel gelukt, maar staan nog niet in de folder die de plugin genereert.

Kun je het eerste gedeelte mij duidelijk maken?

[Maarten69]

Nee geen bestand libs aanmaken, maar in tabblad configuratie dit toevoegen:




Ik neem aan dat je vooraf de plugin wel al geïnstalleerd en gestart hebt?

[ Voor 9% gewijzigd door Maarten69 op 29-12-2024 16:33 ]

[annestweak]

IK HEB NU DIT

[Maarten69]

Dat lijkt op Studio Code Server. Dan ziet het er zo goed uit. Draait de add-on AppDaemon? Kijk anders in het log tablad, daar zie je eventuele foutmeldingen.

[annestweak]

Bedankt @Maarten69 ik zie geen foutmeldingen
morgen ga ik verder proberen.

[arie2005]

Maarten,

Ik zie dat je de vermogens wil schakelen dmv van een script.
Ik wil alleen het laden starten op moment dat de dynamische energietarieven laag zijn.
Jij hebt Net2-A en Net2-B aangesloten maar als ik he laden wil schakelen op laagste energierprijzen moet ik dan ook deze aansluiingen gebruiken of de gateway aansluitingen gebruiken??
Ik ben benieuwd of je deze aansluitingen ook hebt geprobeerd? en of je hier ook mee kon communiceren?
Graag hoor ik van je,

[Maarten69]

@arie2005 Ik kreeg het niet anders voor elkaar, maar zou wel moeten kunnen zeggen ze ergens in onderstaande bronnen:

code:

https://github.com/evcc-io/evcc/discussions/5572
https://github.com/bammab/custom_components_for_esphome/tree/main/components/uswb
https://github.com/bammab/custom_components_for_esphome/issues/1
https://forum.openwb.de/viewtopic.php?t=7504

Succes en mocht jij er wel uitkomen, laat het hier weten aub.

[arie2005]

Bedankt @Maarten69.
Ik had inderdaad ook op deze forums wel het een en ander gelezen
zoals de snelheid van de rs485 : poort 4800 baud n81.
Ik heb nu getracht met modbus in de config.yaml een sessie op te zetten met home assistant.
Nadeel met modbus is dat je een entity aan moet maken alleen welke he??
Ik heb een dummy aangemaakt maar dan houdt het weer even op.

Hoe heb jij de sessie opgezet vanuit home assistant??
Kan je niet vanuit de terminal een sessie opzetten naar de wallbox?

[Maarten69]

arie2005 schreef op maandag 30 december 2024 @ 14:32:
Hoe heb jij de sessie opgezet vanuit home assistant??
Kan je niet vanuit de terminal een sessie opzetten naar de wallbox?

Via terminal zal best lukken.
Ik roep via het Python script de sessie op, zie mijn script hierboven.

[annestweak]

Update van mijn kant, eerst uiteraard de beste wensen voor jullie allemaal
Qua Wallbox lijkt alles goed te werken, de tesla wordt op 16amp met net geen 4kw opgeladen. (1fase)

[annestweak]

met hulp is de script iets aangepast en deze werkt ook.
dit is aangepast:

Configuratiebestand om parameters zoals seriële poort, baudrate, en slave-ID's eenvoudig aan te passen.

foutafhandeling toegevoegd zoals herverbinding bij seriële poortfouten.

logging toegevoegd om debugging te vergemakkelijken.

asynchrone functies (async def) voor betere prestaties in AppDaemon.

[annestweak]

import appdaemon.plugins.hass.hassapi as hass
from crc import Calculator, Crc16
import struct
import serial
import logging
import time

logger = logging.getLogger(__name__)

START_MSG_FRAME = bytes([0x5A, 0xA5])
MSG_LENGTH_BYTES = 1 # Third byte holds the message length without SOF and length byte itself
MODE_MASTER = False
MAX_CURRENT_A = 16
MODE_SLAVE_ID = 2
COM_PORT = "/dev/ttyUSB2"
BAUDRATE = 4800
TIMEOUT = 1

class Wallbox(hass.Hass):

def initialize(self):
self.wallbox_power_setting = -1 # Default value for the instance attribute
self.listen_state(self.wallbox_control, "input_number.wallbox_power_setting")

def wallbox_control(self, entity, attribute, old, new, kwargs):
load_balancing = self.get_state("input_boolean.loadbalancing")
wallbox_power = float(self.get_state("sensor.kwh_meter_2_channel_power_b"))
self.wallbox_power_setting = round(float(self.get_state("input_number.wallbox_power_setting")))

if load_balancing == "off":
logger.info("Automatic load balancing is disabled.")
elif load_balancing == "on":
logger.info("Automatic load balancing is enabled.")
else:
logger.warning("Unknown load balancing state: %s", load_balancing)

self.main()

def main(self):
try:
setup_communication(master=MODE_MASTER, wallbox_power_setting=self.wallbox_power_setting)
except Exception as e:
logger.error("Error during communication setup: %s", e)


def bytes_to_hexstring(bytes):
return ' '.join(['0x{:02X}'.format(x) for x in bytes])

def calc_checksum_wb(data, with_crc=True):
calculator = Calculator(Crc16.MODBUS)
crc_expected = 0
if with_crc:
crc_expected = bytes(data[-2:])
data = data[:-2]
data = bytes(data)
crc = calculator.checksum(data[-5:])
crc_byte = struct.pack("<H", crc)
return crc_byte

def setup_communication(master=True, wallbox_power_setting=-1):
try:
with serial.Serial() as ser:
ser.baudrate = BAUDRATE
ser.port = COM_PORT
ser.timeout = TIMEOUT
ser.open()
logger.info("Opened serial port %s", COM_PORT)
handle_client_comm(ser)
send_message(ser, wallbox_power_setting)
except serial.SerialException as e:
logger.error("Serial communication error: %s", e)
except Exception as e:
logger.error("Unexpected error: %s", e)

def send_message(ser: serial.Serial, wallbox_power_setting):

def send(slave_id, want_load):
message = START_MSG_FRAME + bytes([0x07, 0x00, slave_id, 0x02, 0x02, want_load])
message += calc_checksum_wb(message, False)
ser.write(message)

if wallbox_power_setting not in range(0, 6):
logger.error("Invalid wallbox_power_setting: %s", wallbox_power_setting)
return

load_limits = {0: 9, 1: 7, 2: 5, 3: 4, 4: 3, 5: 2}
limit = load_limits.get(wallbox_power_setting, 0)

for slave_id in range(2, 10):
want_load = 1 if slave_id < limit else 0
send(slave_id, want_load)

logger.info("Wallbox power setting: %s", wallbox_power_setting)

def handle_client_comm(ser: serial.Serial):
logger.info("Start SLAVE mode (id: %s)", MODE_SLAVE_ID)
sof = False
msg = b''

while len(msg) < 10:
c = ser.read()
if not sof and len(c) > 0 and (c[0] == START_MSG_FRAME[0]):
msg = c
elif not sof and len(msg) == 1 and c[0] == START_MSG_FRAME[1]:
msg += c
sof = True
elif sof:
msg += c
else:
continue

if len(msg) == 10:
sof = False
if msg[-2:] != calc_checksum_wb(msg):
logger.warning("Checksum mismatch - ignoring data")
continue
logger.info("Max STROOM voor slave id %s is %sA", msg[4], msg[7])

[Maarten69]

Mooi werk @annestweak
Werkt het naar behoren in Home Assistant?

[annestweak]

Maarten69 schreef op donderdag 2 januari 2025 @ 15:01:
Mooi werk @annestweak
Werkt het naar behoren in Home Assistant?

Ja ik denk het wel maar voor de zekerheid heb ik de auto gister volgeladen en dit buiten de regeling om. Ook heb ik nog niet een mooi Dashboard ervoor. En ik vraag mij af of dit ook te combineren is met het laagste stroom tarief. Er zijn zoveel opties daarvoor met dayahead prijzen, dat ik eerst moet uitzoeken wat voor ons de beste optie is. Wij hebben dynamisch contact via zonneplan.

[arie2005]

@Annestweak, beste wensen en lekker bezig daar.
Ik ben blij dat er meerdere mensen bezig zijn met de wallbox en home assistant.
Ik heb ook zonneplan met p1 meter en home assistant. Ik heb het config.yaml script en automation script gebruikt van pelicano (https://community.home-as...m-component/283435?page=9) en dat lijkt te werken. Ik heb nog geen goede communicatie met de wallbox maar automation stuurt mijn telefoon een berichtje als de tarieven laag zijn. Heb een mooi dag/ uren overzicht gebaseerd op de zonneplan current prices in mijn dashboard.
Ik krijg eerdaags een betrouwbare rs485 dongle binnen en daarmee ga ik verder experimenteren.

[arie2005]

Voor een mooi dashboard overzicht heb ik het script van eXisTa gebruikt:
type: custom:plotly-graph
title: Dynamische stroomprijs
hours_to_show: 18
time_offset: 12h
fn: |
$fn ({ hass, vars => {
vars.x = []; vars.y = []; vars.color = []; vars.hover = []
vars.min = {p: 999,t: null}; vars.max = {p:-999,t:null}
vars.ymin = 999; vars.ymax = -999
vars.unit_of_measurement = hass.states['sensor.zonneplan_current_electricity_tariff'].attributes.unit_of_measurement
vars.now = {t: Date.now(), p: parseFloat(hass.states['sensor.zonneplan_current_electricity_tariff'].state)}
vars.now.h = "<b>" + vars.now.p.toFixed(3) + "</b> " + vars.unit_of_measurement + " @now "
vars.avg = { p: 0, c: 0 }
hass.states['sensor.zonneplan_current_electricity_tariff']?.attributes?.forecast?.map(e => {
var t = new Date(e.datetime).getTime()+1800000
var p = e.electricity_price/10000000
vars.avg.p += p
vars.avg.c++
var c = e.tariff_group.replace("low", "#00a964").replace("normal", "#365651").replace("high","#ed5e18")
if (t>=Date.now()-1800000) {
if (p<vars.min.p) vars.min = {p,t,c}
if (p>vars.max.p) vars.max = {p,t,c}
}
if (p<vars.ymin) vars.ymin = p
if (p>vars.ymax) vars.ymax = p
vars.x.push(t)
vars.y.push(p)
vars.color.push(c)
vars.hover.push(String(new Date(t).getHours()).padStart(2,"0") + "-" +
String(new Date((new Date(t).getTime()+3600000)).getHours()).padStart(2,"0") + ": <b>" +
p.toFixed(3) + "</b> " + vars.unit_of_measurement)

vars.min.h = "<b>" + vars.min.p.toFixed(3) + "</b> " + vars.unit_of_measurement + " @ " + new Date(vars.min.t).getHours() + ":00"
vars.max.h = "<b>" + vars.max.p.toFixed(3) + "</b> " + vars.unit_of_measurement + " @ " + new Date(vars.max.t).getHours() + ":00"
vars.avg.p = vars.avg.p / vars.avg.c
vars.avg.h = "<b>" + vars.avg.p.toFixed(3) + "</b> " + vars.unit_of_measurement + " average"
// console.log(vars)
}
layout:
margin:
l: 20
r: 20
b: 40
yaxis:
fixedrange: false
tickformat: .2f
range: $fn ({vars}) => [ vars.ymin-0.02, vars.ymax+0.02 ]
showgrid: false
visible: false
showticklabels: true
showline: false
title: null
xaxis:
tickformat: '%H'
showgrid: false
visible: true
showticklabels: true
showline: false
dtick: 3600000
config:
displayModeBar: false
scrollZoom: false
entities:
- entity: ''
unit_of_measurement: $ex vars.unit_of_measurement
showlegend: false
x: $ex vars.x
'y': $ex vars.y
marker:
color: $ex vars.color
type: bar
hovertemplate: $ex vars.hover
- entity: ''
mode: markers
textposition: top
showlegend: true
name: $ex vars.min.h
hovertemplate: $ex vars.min.h
yaxis: y0
marker:
symbol: diamond
color: $ex vars.min.c
opacity: 0.7
x:
- $ex vars.min.t
'y':
- $ex vars.min.p
- entity: ''
mode: markers
textposition: top
showlegend: true
name: $ex vars.max.h
hovertemplate: $ex vars.max.h
yaxis: y0
marker:
symbol: diamond
color: $ex vars.max.c
opacity: 0.7
x:
- $ex vars.max.t
'y':
- $ex vars.max.p
- entity: ''
name: Now
hovertemplate: Now
yaxis: y9
showlegend: false
line:
width: 0.5
color: gray
opacity: 1
x: $ex [vars.now.t, vars.now.t]
'y':
- 0
- 1

[zteph]

Foofur schreef op zaterdag 21 december 2024 @ 16:59:
De wallbox is aangesloten op 3 fasen. Dat is mooi voor het "snel" laden op 11Kw, maar voor het opmaken van de zonnestroom is dat niet heel handig. Zelfs de laagste setting (4Kw) is dan eigenlijk teveel.
Zou er ook een mogelijkheid zijn om te schakelen tussen 3 fase / 1 fase?

Weet iemand dit? Ik zou het ook handig vinden om te schakelen tussen 1 en 3 fasen.

[annestweak]

zteph schreef op donderdag 2 januari 2025 @ 21:40:
[...]


Weet iemand dit? Ik zou het ook handig vinden om te schakelen tussen 1 en 3 fasen.

hier is dezelfde vraag gesteld:
Schakelen tussen 3 fase en 1 fase laden EV

[annestweak]

@arie2005 ik krijg het dashboard niet werkend
ploty pakt m niet

[Maarten69]

@annestweak en @arie2005 willen jullie de code van je vorige post in code tags zetten aub?

code:

</>

[ Voor 17% gewijzigd door Maarten69 op 03-01-2025 13:31 ]

[arie2005]

type: custom:plotly-graph
title: Dynamische stroomprijs
hours_to_show: 24
time_offset: 12h
fn: |
$fn ({ hass, vars => {
vars.x = []; vars.y = []; vars.color = []; vars.hover = []
vars.min = {p: 999,t: null}; vars.max = {p:-999,t:null}
vars.ymin = 999; vars.ymax = -999
vars.unit_of_measurement = hass.states['sensor.zonneplan_current_electricity_tariff'].attributes.unit_of_measurement
vars.now = {t: Date.now(), p: parseFloat(hass.states['sensor.zonneplan_current_electricity_tariff'].state)}
vars.now.h = "<b>" + vars.now.p.toFixed(3) + "</b> " + vars.unit_of_measurement + " @now "
vars.avg = { p: 0, c: 0 }
hass.states['sensor.zonneplan_current_electricity_tariff']?.attributes?.forecast?.map(e => {
var t = new Date(e.datetime).getTime()+1800000
var p = e.electricity_price/10000000
vars.avg.p += p
vars.avg.c++
var c = e.tariff_group.replace("low", "#00a964").replace("normal", "#365651").replace("high","#ed5e18")
if (t>=Date.now()-1800000) {
if (p<vars.min.p) vars.min = {p,t,c}
if (p>vars.max.p) vars.max = {p,t,c}
}
if (p<vars.ymin) vars.ymin = p
if (p>vars.ymax) vars.ymax = p
vars.x.push(t)
vars.y.push(p)
vars.color.push(c)
vars.hover.push(String(new Date(t).getHours()).padStart(2,"0") + "-" +
String(new Date((new Date(t).getTime()+3600000)).getHours()).padStart(2,"0") + ": <b>" +
p.toFixed(3) + "</b> " + vars.unit_of_measurement)

vars.min.h = "<b>" + vars.min.p.toFixed(3) + "</b> " + vars.unit_of_measurement + " @ " + new Date(vars.min.t).getHours() + ":00"
vars.max.h = "<b>" + vars.max.p.toFixed(3) + "</b> " + vars.unit_of_measurement + " @ " + new Date(vars.max.t).getHours() + ":00"
vars.avg.p = vars.avg.p / vars.avg.c
vars.avg.h = "<b>" + vars.avg.p.toFixed(3) + "</b> " + vars.unit_of_measurement + " average"
// console.log(vars)
}
layout:
margin:
l: 20
r: 20
b: 40
yaxis:
fixedrange: false
tickformat: .2f
range: $fn ({vars}) => [ vars.ymin-0.02, vars.ymax+0.02 ]
showgrid: false
visible: false
showticklabels: true
showline: false
title: null
xaxis:
tickformat: "%H"
showgrid: false
visible: true
showticklabels: true
showline: false
dtick: 3600000
config:
displayModeBar: false
scrollZoom: false
entities:
- entity: ""
unit_of_measurement: $ex vars.unit_of_measurement
showlegend: false
x: $ex vars.x
"y": $ex vars.y
marker:
color: $ex vars.color
type: bar
hovertemplate: $ex vars.hover
- entity: ""
mode: markers
textposition: top
showlegend: true
name: $ex vars.min.h
hovertemplate: $ex vars.min.h
yaxis: y0
marker:
symbol: diamond
color: $ex vars.min.c
opacity: 0.7
x:
- $ex vars.min.t
"y":
- $ex vars.min.p
- entity: ""
mode: markers
textposition: top
showlegend: true
name: $ex vars.max.h
hovertemplate: $ex vars.max.h
yaxis: y0
marker:
symbol: diamond
color: $ex vars.max.c
opacity: 0.7
x:
- $ex vars.max.t
"y":
- $ex vars.max.p
- entity: ""
name: Now
hovertemplate: Now
yaxis: y9
showlegend: false
line:
width: 0.5
color: gray
opacity: 1
x: $ex [vars.now.t, vars.now.t]
"y":
- 0
- 1

[arie2005]

Deze doet het bij mij, zie meteen met nieuwe invoer in dashboard

[arie2005]

in config.yaml:
Sensors:
goedkoopste_tarief:
friendly_name: "Goedkoopste Tarief"
value_template: >-
{% set now_time = now().isoformat() %}
{% set future_prices = state_attr('sensor.zonneplan_current_electricity_tariff', 'forecast') | selectattr('datetime', '>', now_time) | list %}
{% set min_future_price_obj = future_prices | min(attribute='electricity_price') %}

{% if min_future_price_obj is defined %}
{{ as_timestamp(min_future_price_obj.datetime) | timestamp_custom('%-H:%M') }}
{% else %}
Niet beschikbaar
{% endif %}
goedkoopste_tarief_prijs:
friendly_name: "Goedkoopste Tarief Prijs"
value_template: >-
{% set now_time = now().isoformat() %}
{% set future_prices = state_attr('sensor.zonneplan_current_electricity_tariff', 'forecast') | selectattr('datetime', '>', now_time) | list %}
{% set min_future_price_obj = future_prices | min(attribute='electricity_price') %}

{% if min_future_price_obj is defined %}
{{ min_future_price_obj.electricity_price / 10000000 }}
{% else %}
Niet beschikbaar
{% endif %}

[arie2005]

ik gebruik deze hacs intregration: https://github.com/fsaris/home-assistant-zonneplan-one

[arie2005]

alias: AutoLaden laagste prijs
description: ""
triggers:
- entity_id: sensor.zonneplan_current_electricity_tariff
trigger: state
conditions: []
actions:
- variables:
now_time: "{{ now().isoformat() }}"
future_prices: >-
{{ state_attr('sensor.zonneplan_current_electricity_tariff', 'forecast')
| selectattr('datetime', '>', now_time) | list }}
min_future_price: >-
{{ future_prices | map(attribute='electricity_price') | map('float') |
min }}
- choose:
- conditions:
- condition: template
value_template: >-
{{ states('sensor.zonneplan_current_electricity_tariff') | float
>= (min_future_price / 10000000) + 0.005 }}
sequence: []
- conditions:
- condition: template
value_template: >-
{{ states('sensor.zonneplan_current_electricity_tariff') | float
<= (min_future_price / 10000000) + 0.005 }}
sequence:
- action: notify.mobile_app_pixel_7_pro
metadata: {}
data:
message: auto laden ingeschakeld
mode: single

[arie2005]

ik heb meerdere intregraties geprobeerd, maar deze werkte redelijk snel , en hoewel geen communicatie met wallbox, krijg ik op de laagste prijs uurtjes wel de melding "autoladen" op mijn pixel

[Foofur]

zteph schreef op donderdag 2 januari 2025 @ 21:40:
[...]


Weet iemand dit? Ik zou het ook handig vinden om te schakelen tussen 1 en 3 fasen.

Ik zou niet weten hoe ik hem zou kunnen laten schakelen tussen 1 of 3 fasen.
Het laagste wat ik tot nu toe voor elkaar krijg is 6A per fase. Dus 3,6Kw ongeveer (gelezen vanaf het display)
Wel jammer, het had voor mij ook niet tijdens het laden gehoeven, maar 9/10x is langzaam laden met 1 fase ruim voldoende, maar soms is wat sneller "boosten" wel fijn.
Dan is de 1 fase variant beter, maar dan moet je auto dat wel weer aankunnen...

Weet iemand hoe de laadpaal omgaat als je gewoon 2 fasen los neemt terwijl de lader aan staat? (uiteraard niet aan het laden)

[Joukev]

arie2005 schreef op vrijdag 3 januari 2025 @ 16:37:
ik heb meerdere intregraties geprobeerd, maar deze werkte redelijk snel , en hoewel geen communicatie met wallbox, krijg ik op de laagste prijs uurtjes wel de melding "autoladen" op mijn pixel

Vraag over het maken van deze oplossing: Hoe is deze aangesloten op de p1 aansluiting (meting stroomverbruik- zoals dezehttps://www.sossolutions....er-kabel-p1-kabel-5-meter )? Of via cloud? Dan specifieke remote API nodig? Ben benieuwd.

[ Voor 10% gewijzigd door Joukev op 04-01-2025 15:14 ]

[arie2005]

Simpele p1 interface kabel ( Ali Express) en p1 meter van zonneplan op de slimme meter met splitter, de simpele p1 interface zit via een usb op mijn pc aangesloten.
Via hacs zonneplan integratie installeren.

[Foofur]

@Maarten69 Ik ben ook bezig om het vermogen te regelen van de lader.
Mijn lader is een 3 fase 11KW.
Momenteel gebruik ik een deel van je script en koppel ik steeds een slave erbij om het vermogen te verlagen. Dit werkt en geeft mij de opties 6A, 7,5A en 15,8A.
Door er steeds een "Want_load" bij te zetten. Dit werkt wel, maar ik heb nu best een gat tussen de 7,5 en de 15,8A. Hoe heb jij dit opgelost?

In je bericht schrijf je:
Ik wil mijn vorderingen best delen, maar het is nu nog maar een test scriptje.
Ik moet nu nog zelf de WANT_LOAD_B PER client instellen. Het script loopt nu ook continue wat ook niet nodig is.
Dit is mijn huidige testscript:

Hoe stel je die Want_load_B in? Want welke waarde ik hier ook opgeef, er is geen reactie.
Er is enkel een reactie op de want_load=1
P.S. ik ben een niet heel handig met scripting.

[annestweak]

Maarten69 schreef op vrijdag 3 januari 2025 @ 13:31:
@annestweak en @arie2005 willen jullie de code van je vorige post in code tags zetten aub?

code:

</>

ja hier komt ie, de wallbox control

code:

 import appdaemon.plugins.hass.hassapi as hass
from crc import Calculator, Crc16
import struct
import serial
import logging
import time

logger = logging.getLogger(__name__)

START_MSG_FRAME = bytes([0x5A, 0xA5])
MSG_LENGTH_BYTES = 1  # Third byte holds the message length without SOF and length byte itself
MODE_MASTER = False
MAX_CURRENT_A = 16
MODE_SLAVE_ID = 2
COM_PORT = "/dev/ttyUSB2"
BAUDRATE = 4800
TIMEOUT = 1

class Wallbox(hass.Hass):

    def initialize(self):
        self.wallbox_power_setting = -1  # Default value for the instance attribute
        self.listen_state(self.wallbox_control, "input_number.wallbox_power_setting")

    def wallbox_control(self, entity, attribute, old, new, kwargs):
        load_balancing = self.get_state("input_boolean.loadbalancing")
        wallbox_power = float(self.get_state("sensor.kwh_meter_2_channel_power_b"))
        self.wallbox_power_setting = round(float(self.get_state("input_number.wallbox_power_setting")))
        
        if load_balancing == "off":
            logger.info("Automatic load balancing is disabled.")
        elif load_balancing == "on":
            logger.info("Automatic load balancing is enabled.")
        else:
            logger.warning("Unknown load balancing state: %s", load_balancing)
        
        self.main()

    def main(self):
        try:
            setup_communication(master=MODE_MASTER, wallbox_power_setting=self.wallbox_power_setting)
        except Exception as e:
            logger.error("Error during communication setup: %s", e)


def bytes_to_hexstring(bytes):
    return ' '.join(['0x{:02X}'.format(x) for x in bytes])

def calc_checksum_wb(data, with_crc=True):
    calculator = Calculator(Crc16.MODBUS)
    crc_expected = 0
    if with_crc:
        crc_expected = bytes(data[-2:])
        data = data[:-2]
    data = bytes(data)
    crc = calculator.checksum(data[-5:])
    crc_byte = struct.pack("<H", crc)
    return crc_byte

def setup_communication(master=True, wallbox_power_setting=-1):
    try:
        with serial.Serial() as ser:
            ser.baudrate = BAUDRATE
            ser.port = COM_PORT
            ser.timeout = TIMEOUT
            ser.open()
            logger.info("Opened serial port %s", COM_PORT)
            handle_client_comm(ser)
            send_message(ser, wallbox_power_setting)
    except serial.SerialException as e:
        logger.error("Serial communication error: %s", e)
    except Exception as e:
        logger.error("Unexpected error: %s", e)

def send_message(ser: serial.Serial, wallbox_power_setting):

    def send(slave_id, want_load):
        message = START_MSG_FRAME + bytes([0x07, 0x00, slave_id, 0x02, 0x02, want_load])
        message += calc_checksum_wb(message, False)
        ser.write(message)

    if wallbox_power_setting not in range(0, 6):
        logger.error("Invalid wallbox_power_setting: %s", wallbox_power_setting)
        return

    load_limits = {0: 9, 1: 7, 2: 5, 3: 4, 4: 3, 5: 2}
    limit = load_limits.get(wallbox_power_setting, 0)
    
    for slave_id in range(2, 10):
        want_load = 1 if slave_id < limit else 0
        send(slave_id, want_load)

    logger.info("Wallbox power setting: %s", wallbox_power_setting)

def handle_client_comm(ser: serial.Serial):
    logger.info("Start SLAVE mode (id: %s)", MODE_SLAVE_ID)
    sof = False
    msg = b''

    while len(msg) < 10:
        c = ser.read()
        if not sof and len(c) > 0 and (c[0] == START_MSG_FRAME[0]):
            msg = c
        elif not sof and len(msg) == 1 and c[0] == START_MSG_FRAME[1]:
            msg += c
            sof = True
        elif sof:
            msg += c
        else:
            continue

        if len(msg) == 10:
            sof = False
            if msg[-2:] != calc_checksum_wb(msg):
                logger.warning("Checksum mismatch - ignoring data")
                continue
            logger.info("Max STROOM voor slave id %s is %sA", msg[4], msg[7])

[Maarten69]

Foofur schreef op zaterdag 4 januari 2025 @ 19:19:
@Maarten69 Ik ben ook bezig om het vermogen te regelen van de lader.
Mijn lader is een 3 fase 11KW.
Momenteel gebruik ik een deel van je script en koppel ik steeds een slave erbij om het vermogen te verlagen. Dit werkt en geeft mij de opties 6A, 7,5A en 15,8A.
Door er steeds een "Want_load" bij te zetten. Dit werkt wel, maar ik heb nu best een gat tussen de 7,5 en de 15,8A. Hoe heb jij dit opgelost?

[...]


Hoe stel je die Want_load_B in? Want welke waarde ik hier ook opgeef, er is geen reactie.
Er is enkel een reactie op de want_load=1
P.S. ik ben een niet heel handig met scripting.

Ik eigenlijk ook niet.
Tussen stap 4 (5)en 5 (6) heb ik ook een sprong van 3,6 kW naar 7,4 kW

[Joukev]

Op basis van het eerste idee (goedkope LIDL wallbox kunnen uitrusten met dynamic load balancing) kwam ik op de draadloze uitlezer van p1 https://www.zuidwijk.com/product/slimmelezer-plus/ (zonder externe voeding voor plm 20 eur).
Om het nog minimalistischer uit te voeren dacht ik: waarom niet direct vanuit die microcontroller een modbus aansluiting met simpele thresholds om de stroom te reguleren zoals hierboven al beschreven is? Bv door op deze slimme lezer een modbus interface https://hackatronic.com/m...e-interfacing-with-esp32/Dan helemaal geen PC/raspberry nodig… en eventueel wel aan te sturen/monitoren via HA….

Ben benieuwd of dit een valabele oplossing lijkt te zijn. Er is al een oplossing die passief op p1 werkt (benelux getest) zonder wifi maar zo te zien niet open sourced, zie https://smart-stuff.nl/product/p1-naar-modbus-dongle/

[olympusdenk]

Joukev schreef op zondag 5 januari 2025 @ 11:18:
Op basis van het eerste idee (goedkope LIDL wallbox kunnen uitrusten met dynamic load balancing) kwam ik op de draadloze uitlezer van p1 (zonder externe voeding voor plm 20 eur)

[…]

Dan helemaal geen PC/raspberry nodig… en eventueel wel aan te sturen/monitoren via HA….

Ben benieuwd of dit een valabele oplossing lijkt te zijn. Er is al een oplossing die passief op p1 werkt (benelux getest) zonder wifi maar zo te zien niet open sourced, zie https://smart-stuff.nl/product/p1-naar-modbus-dongle/

Afhankelijk hoe het de komende periode zal gaan met huizen zoeken zal ik ook mogelijk dan wat tijd gaan investeren in loadbalancen van de wallbox via modbus.

Als het geen probleem is dat de P1 meter op wifi werkt dan is uiteraard de HomeWizard een ideale om via de API uit te lezen HomeWizard Energy - De modulaire WiFi P1 meter

[Joukev]

olympusdenk schreef op zondag 5 januari 2025 @ 11:55:
[...]


Afhankelijk hoe het de komende periode zal gaan met huizen zoeken zal ik ook mogelijk dan wat tijd gaan investeren in loadbalancen van de wallbox via modbus.

Als het geen probleem is dat de P1 meter op wifi werkt dan is uiteraard de HomeWizard een ideale om via de API uit te lezen HomeWizard Energy - De modulaire WiFi P1 meter

Interessante optie! Ik zie wel een smartsocket.
Hoe werkt dat als interface naar modbus/wallbox? Toch een pc nodig?zou jammer zijn…

[olympusdenk]

Joukev schreef op zondag 5 januari 2025 @ 14:43:
[...]

Interessante optie! Ik zie wel een smartsocket.
Hoe werkt dat als interface naar modbus/wallbox? Toch een pc nodig?zou jammer zijn…

Je hebt geen PC nodig om de P1 meter uit te lezen die is gewoon direct via wifi bereikbaar. De home assistant zou dan direct met HomeWizard kunnen praten voor energieverbruik inzicht

[Joukev]

Joukev schreef op zondag 5 januari 2025 @ 14:43:
[...]

Interessante optie! Ik zie wel een smartsocket.
Hoe werkt dat als interface naar modbus/wallbox? Toch een pc nodig?zou jammer zijn…

Ik bedoel: de koppeling naar de Lidl laadpaal- hoe verloopt die dan?

[Foofur]

Weet iemand hoe ik het laden kan stoppen/pauzeren via de modbus?
Welk commando zou ik daarvoor moeten sturen?

[annestweak]

Foofur schreef op maandag 6 januari 2025 @ 19:20:
Weet iemand hoe ik het laden kan stoppen/pauzeren via de modbus?
Welk commando zou ik daarvoor moeten sturen?

op pagina 2 bij de post van @Maarten69 staan de aan en uit schakelingen vermeld

[Fasthook]

Vraagje, ik lees dat er 3 kaartjes worden meegeleverd.

Kan je zelf rfid kaartjes toevoegen?

Ik gebruik liever een druppel en wil bij verlies en vervangende rfid kunnen bestellen...

[annestweak]

Fasthook schreef op dinsdag 7 januari 2025 @ 06:58:
Vraagje, ik lees dat er 3 kaartjes worden meegeleverd.

Kan je zelf rfid kaartjes toevoegen?

Ik gebruik liever een druppel en wil bij verlies en vervangende rfid kunnen bestellen...

geen idee of dat kan, staat nergens beschreven in de beschrijving of dat mogelijk is

[Foofur]

Toevoegen denk ik niet, maar je kan de bestaande wel kopiëren naar een druppel. Ali heeft daar wel apparaatjes voor.

[Foofur]

annestweak schreef op maandag 6 januari 2025 @ 22:38:
[...]


op pagina 2 bij de post van @Maarten69 staan de aan en uit schakelingen vermeld

Dat zag ik inderdaad, maar ik begrijp dat niet. Ik gebruik zelf geen home assistant.
Er is geen reactie wanneer ik meer dan 3 slaves bijschakel. Hij blijft op minimaal 6A laden.

Hebben jullie de wallbox dan in slave draaien en het script als Master?

[Maarten69]

@Foofur als je doelt op de knoppen start en stop laden;
Ik gebruik hiervoor de API voor mijn Kia EV6. Ik krijg de wallbox zelf ook niet gestopt.

[Foofur]

Dat verklaart het. Die optie heb ik eigenlijk niet/slecht.
Ik zit te denken of het niet handiger is om de lader in slave te zetten. Zoals ik de berichten lees is het vermogen dan beter te regelen. Ook het stoppen van laden zou dan moeten kunnen werken.
Het nadeel is dan wel dat er minimaal elke 30sec berichten naar de lader moeten worden verstuurd en zonder de master werkt hij dus helemaal niet.

[Joukev]

Foofur schreef op woensdag 8 januari 2025 @ 08:34:
Ik zit te denken of het niet handiger is om de lader in slave te zetten. Zoals ik de berichten lees is het vermogen dan beter te regelen. Ook het stoppen van laden zou dan moeten kunnen werken.
Het nadeel is dan wel dat er minimaal elke 30sec berichten naar de lader moeten worden verstuurd en zonder de master werkt hij dus helemaal niet.

Bron? Ben benieuwd…