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

[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:

[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 ]

[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 ]

[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]

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 ]

[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]

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 ]

[annestweak]

[annestweak]

[Jeromium]

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

[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

[arie2005]

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

[Maarten69]

@annestweak en @Foofur Ik denk dat jullie inmiddels meer weten van de wallbox en scripts dan ik. Denk niet dat ik jullie verder kan helpen hiermee.
Ik kan wel vertellen dat ik met de 22kW uitvoering op de laagste stand (6A) prima kan laden.

[ Voor 22% gewijzigd door Maarten69 op 08-01-2025 21:43 ]

[Michel1973]

Ik ben wel een beetje vastgelopen. Krijg nu zoveel foutmeldingen dat het beter is dat ik alles opnieuw installeer. Wel wat wijzer geworden, maar c64 ervaring is toch niet toereikend om dit te doorgronden.
Ik heb wel een leuk regenhoesje gekocht voor 5 euro. Past precies, dus voor de geïnteresseerden:

[Michel1973]

annestweak schreef op donderdag 23 januari 2025 @ 21:16:
Waar loop je op vast @Michel1973 ?

Ik heb een pi4 die ik met home assist bestuur. (Ik kende dat nog helemaal niet dus was wel even wennen, mijn kennis is beperkt tot een knappe excel en wat basic uit een grijs verleden)
Ik ben nu wel zover dat ik live de meter zie (L1-L3), en dat ik bv een melding krijg als er 1 boven de 5kw komt. Mijn doel is overigens gewoon een beveiliging in te bouwen dat bij laden de stoppen er niet uitvliegen als iemand een ei gaat bakken, dus integreren met zonneplan etc hoeft van mij niet.
Ik heb de box op master staan en via die route probeer ik dus dat script, maar ik heb het idee dat mijn mappenstructuur etc niet meer klopt. Ik begrijp ook niet wat dat deamon etc doet dus kan ook niet etc doorgronden wat er gebeurt. Het zou fantastisch zijn als je gewoon bij automatisering kan kiezen welk vermogen je naar de box moet sturen en daar je voorwaarden aan hangt maar zo simpel is het helaas niet. Hier zie je iig mijn lijst foutmeldingen waardoor ik door de bomen het bos kwijt ben geraakt..(ik moet wel zeggen dat ik er ook wel lol aan beleef eea uit te zoeken, maar het is taaie kost)..

[Michel1973]

Het gaat om bovenstaande meldingen. Met dan het script van configuration en automation waar het volgens mij fout gaat..

[ Voor 5% gewijzigd door Michel1973 op 24-01-2025 19:23 ]

[Michel1973]

Dank voor je reactie,
Ik heb appdeamon wel geïnstalleerd, maar ik heb geen idee hoe dat werkt. Ik weet niet of het mogelijk is of je me dat kunt uitleggen of dat ik eerst een halve studie moet doen.. het is in ieder geval niet iets wat ik intuïtief invul zeg maar. Dat met die helpers en automations kwam ik nog net uit, maar de rest is toch wel specialistisch heb ik het idee.

[stenvl]

Dag allen,

Hopelijk kan iemand mij vooruit helpen. Ik probeerde de Wallbox te koppelen aan Home Assistant om mijn wallbox op afstand aan te kunnen sturen. Ik zeg het alvast, veel ChatGPT gebruikt en helaas beperkte kennis zelf

Ik kocht een Elfin EW11 om de wallbox over Wifi verbinding informatie te laten sturen naar mijn Home Assistant (draaiend op een Raspberry Pi).



Ik heb binnen de wallbox:
A verbonden met NET1-485A
+ verbonden met 5V DC stroom
- verbonden met COM
B verbonden met NET1-485B

(ik heb tevens ook de NET2 en Gateway poorten uitgeprobeerd)

De EW11 heb ik online ingesteld met de volgende instellingen. Deze instellingen heb vooral van deze forum afgespiekt:



Ik heb mijn draaiknop 41 in de Wallbox gedraaid naar getal 2 (="Slave 1").

In home Assistant heb ik de volgende code toegevoegd aan configuration.yaml


In mijn Home Assistant dashboard staat de waarde van "Wallbox Inow" echter steeds op 'niet Beschikbaar'. In het Elfin Dashboard zie ik dat er wel bytes verzonden worden, maar dat de wallbox geen data terugstuurt.

❌ Mijn vraag is, wat doe ik verkeerd? ❌

[Foofur]

Ik heb eindelijk mijn lader weer terug. En ik ben ook direct weer bezig gegaan.
ik heb door wat omwegen wel een leuke functionaliteit erbij gekregen.
1 - starten/stoppen met laden
2 - uitgesteld laden
3 - slim starten/laden met overstroom panelen

Momenteel heb ik een flow in node red omdat het teveel werd voor een los python script:



het staat nog heel erg in de kinderschoenen, maar het doel is om de flow aan te sturen via mqtt / http aanroepen.


nu nog heel rommelig, maar daar moet ik nog mee aan de gang.

Het starten/stoppen met laden heb ik werkend door een foefje uit te halen met de 0A instelling.

Ik vond het heel jammer dat ik de lader niet kon laten stoppen met laden. Nu had ik eerst het idee om een modbus relais te koppelen tussen de noodstop knop aan de zijkant. Dat zou kunnen werken maar het nadeel daarvan was dat de kaart autorisatie dan verloren gaat. dwz na stoppen moet je hem opnieuw vrijgeven met de kaart. Het zou kunnen werken, maar dan moet de lader op altijd vrijgeven staan.

Dus bleef ik verder zoeken. Ik vond het ook vreemd dat je wel een maximaal "net" vermogen kan instellen, maar indien er veel slaves zijn ga je hier gewoon overheen. Dan zou dus de net zekering er uit kunnen klappen. Na wat proberen blijkt het dat de fabrikant hier wel aan heeft gedacht.
Wanneer je namelijk een auto aansluit vraagt de slave aan de master dat hij wil laden met xx aantal Ampere. afhankelijk wat er beschikbaar is geeft de master aan alle slaves een evenredig aantal Ampere om te laden. Wanneer echter iedereen op het laagste van 6A zit gebeurt er iets vreemds bij de eerstvolgende slave die ook nog wil gaan laden.
Deze laatste slave doet een verzoek, maar krijgt antwoord 0Ampere. Die slave blijft dus keurig op het witte "gereed" scherm staan wachten tot de master weer een hoeveelheid Ampere beschikbaar stelt.
Na autorisatie met de kaart locked de lader en auto de kabel en zelfs na vele uren blijft hij keurig staan wachten op het verlossende bericht van de master.

Hoe heb ik dit nu geïmplementeerd in de flow:
In normale stand stuurt de flow continu de laatst geladen waarde naar de wallbox (b.v. 6 of 8A)
Hierdoor valt de lader niet op error 20
Als ik nu gebruik wil gaan maken van uitgesteld laden of ik wil het laden stoppen, dan doe ik het volgende:
Ik stop ongeveer 10sec (kan mogelijk nog korter) met berichten sturen. Alleen als er een auto is aangesloten zal de lader op error 20 vallen. Bij geen auto blijft hij op het normale scherm staan (die time out is langer)
Na deze 10sec stuur ik continu een bericht met 0Ampere. De lader komt nu weer in zijn normale scherm te staan. (Als er geen auto was aangesloten had je het op de lader error 20 nooit gezien).
De laadsessie is nu gestopt en kan ik hervatten wanneer ik wil door gewoon weer een b.v. 6A te sturen.
De laadsessie is enkel weer te stoppen door de lader kort op error 20 te laten vallen.
Bij uitgesteld laden stel ik de datum/tijd in via mqtt/http of op het dashboard. Vervolgens koppel ik de auto aan geef ik de laadpaal vrij en de laadsessie zal pas starten wanneer ik dat wil.
Als de auto al aangekoppeld was bij het instellen van de datum/tijd wordt de laadsessie gestopt en hervat op het ingestelde tijdstip.

[ Voor 85% gewijzigd door Foofur op 27-05-2025 11:52 ]

[Foofur]

Aller eerst, ik ben geen programmeur en wat ik doe doe ik samen met ChatGPT. Wees dus mild met commentaar over de manier hoe dingen verwerkt worden in de flow.
Dit is de 2e versie met al flink afgeslankte code omdat ik in de eerste opzet helemaal gek werd van de race condities.

Wat hebben we:

- Starten / stoppen van het laden
- Handmatig bepalen van de laadstroom
- Variabel laden aan de hand van de P1 meter (zoveel mogelijk zonnestroom gebruiken)
- Uitgesteld laden
- Laden tot target SoC
- Laden met garantie tot target Soc op een ingestelde tijd. (evt gecombineerd met uitgesteld/variabel en gratis laden)
- "Gratis" Laden, dwz indien mogelijk zoveel mogelijk zonnestroom "dumpen" in de auto accu.
- losse waardes kunnen uitgelezen en gestuurd worden via MQTT
- Een overzichtelijk dashbord



Uitleg bij de verschillende functies:

- Handmatige stop
Deze heeft de hoogste prioriteit en zal het laden stoppen.
Het stoppen van het laadproces doe ik door de communicatie met de wallbox te stoppen. Helaas is de wallbox niet consistent met het op error 20 vallen. (de ene keer na 13sec, de volgende keer na 14sec etc). Dit vang ik op door het laden te stoppen in 3 fases. De eerste fase wordt de communicatie gestopt voor 12sec. Na 12sec wordt er 0A gestuurd. Deze 0A wordt 10sec lang gestuurd. wanneer de chargingPower NIET zakt wordt er wederom naar fase 1 geschakeld en wordt er dit keer 12sec en 200ms gewacht. Dit loopt op net zo lang tot de chargingPower wel zakt. Als de chargingPower laag genoeg is gaat de box naar fase 3 en dat is continu 0A sturen.

Slim Laden:
Indien uit kun je met de slider het aantal ampere bepalen waarmee geladen wordt.
Indien aan geeef je met de slider het laagste aantal ampere aan waarmee geladen wordt. Maar indien er meer of minder powerReturned is zal de logica de laadstroom verhogen/verlagen. Maar nooit lager dan de instelling van de slider.

Gratis Laden:
Gratis laden kan de overige instellingen behalve de handmatige stop overschrijven. Wanneeer de gemiddelde powerReturned (15min) hoog genoeg is zal deze functie het laden toestaan. Ongeacht of uitgesteld laden actief is of target_Soc al bereikt is.

Uitgesteld Laden:
je kan hier een datum / tijd ingeven wanneer hij mag beginnen meet laden.

Doel SoC laden:
Indien actief en een datum/tijd is ingevoerd zal de logica gaan laden zodat het target gehaald gaat worden op de ingestelde tijd. Hier is extra logica aan toegevoegd om zoveel mogelijk zonnestroom te gebruiken.
De functie rrekent continu of de huidige stroom voldoende is en grijpt in als de stroom verhoogt of zelfs verlaagt kan worden om target te halen.
Bijvoorbeeld: je hebt s'avonds voor je rit minimaal 80% nodig. en je hebt ingesteld dat hij s'ochtends mag beginnen om zoveel mogelijk zonnestroom te pakken.
De ochtend had eerst veel zon, dus hij probeert zoveel mogelijk zon alvast te pakken (stuurt hoog ampere). Vervolgens wordt het bewolkt dus de laadstroom zakt in tot het laaagste niveau om target wel te kunnen halen. In de middag is er weer even zon dus wordt er weer maximaal geladen. Helaas moest je tussendoor even weg, dus de SoC is gezakt en de eerdere berekende laadstroom instelling is niet meer voldoende. De override zal inschakelen om target alsnog te halen. Indien target niet gehaald kan worden is dat zichtbaar op het dashbord.


Voor een goede werking zijn de volgende extra gegevens minimaal nodig:

- powerUsed & powerReturned van de DSMR P1 meter. Ik heb eventueel een losse parser bijgevoegd
- Huidige Soc van de auto. Deze moet het liefst regelmatig worden geupdated. Gebruik eventueel een berekende Soc
- chargingPower als nummer in Watt
Deze externe data moet je voeden in de flow.

Ik heb zelf een IP connectie naar een waveshare verbonden met de Wallbox in Slave mode.

https://1drv.ms/t/c/7e57e...Hy8tnS7zvJ4bJiUg?e=LJRxbG

Deze code kun je importeren in Node Red.
Daarna kun je je P1 meter voeden via de input nodes en de TCP node moet je aanpassen naar het IP van je Waveshare.
Ik heb het niet getest met een USB verbinding. Ik heb wel getest met een USB naar TCP omzetting. Dit werkte "redelijk". Maar had toch wel last van wegvallende verbindingen.

[akgdrg]

thanks, i have a powermeter from huawei and also the inverter is from huawei. and both are alreday intergrated in ha. the rs485 adapter is still on the way. but thanks for the infos.
the datepicker and the dashboard seems to be installed, but how to switch to the ui like you posted?
this is the current view of my flow:

[akgdrg]

thanks. I imported these nodes and changed the sensor names to mine. i also modified the "combine node" because i have one sensor value and if the value is negative it means i am consuming power from grid and if the value is positive i am producing power and export it to grid.






In debugoutput the mesaage with the values seems now to be correct

But what to do with the combined message with the payload? where to connect the output of the combination node to? I now connected it to the "beepal ladstrom". is this correct?

[ Voor 25% gewijzigd door akgdrg op 26-06-2025 11:55 ]