In the previous article we looked at how to rationally charge EVs if you have the option to install your home own charger (EVSE). But if you can install your home charger, chances are you can install a rooftop solar system too. And once you have that, a home storage battery is the logical next step.

These two investments finally let you take matters into your own hands and, combined with a heat-pump, effectively decarbonize the majority of your energy use. You will still be dependent on the grid, but instead of being dependent all the time, your dependence shrinks to 3-4 months a year, depending on the sizing and where you live. 🥳

But let’s stick to EV charging for now:

The Basic Concept

The best way to explain this is to pretend you are a farmer 😃 Your rooftop solar is a bit like a farm in that it’s dependent on the weather. When the sun is shining, your solar plant is producing kilowatts of power. When it’s heavily overcast, rainy, or at night, you get next to no production. So when you see the sun shining brightly, charge your car!

This brings all kinds of advantages:

• The solar energy is effectively free, except for installation costs. You should recover the installation costs in 6-7 years.
• Any energy you charge from your solar system is carbon neutral, expect for the carbon debt of the installation (I don’t like greenwashing, but this happens only once as well and with rational use, it is negligible in comparison to the avoided emissions).
• You are actively contributing to your grid stability. Not only will you be a smaller burden on your grid in general, but with some automation, you can actively act as a good citizen and act to reduce grid load in peak times. Why push power into the grid if you can charge your car instead? Why charge your car with grid power at night if you could have taken advantage of the sun during the day?

The Setup

The base for this article are a solar system with storage and a controllable car charger (EVSE), connected to a Home Assistant system. I’m going to describe a solution with a hybrid inverter, but solutions with a separate power-wall will be similar, depending on the way your power-wall is controlled.

The charging logic will implemented using a Python script in AppDaemon, the rest are normal integrations, automations and entities in Home Assistant.

The Charging Strategy

There are several things to take care of here:

• We need to supervise the total current of the installation to prevent overloads. If you have a 3x 20A home installation, you need to take care not to exceed 20A on any of the phases at any time, regardless of the resulting grid current including solar.

• We need to prepare separate options at least for green charging and low-cost charging.

  • Green charging will only turn on when you have an excess of energy available and only charge the excess energy without taking any from the grid.
  • Low-cost charging will charge the car when the energy prices are low using all the available power.
  • You could also add an “express” mode which will give you all available power at any time while still ensuring you don’t blow any fuses.

• We want to monitor the following at all times:

  • The phase currents. If any one of them is above the installation limit, we need to reduce charging current of the EVSE.
  • The storage battery charge level. Our strategy will depend on it.
  • The power coming from/going into the storage battery. This will help us set the EVSE charging power in the green mode.
  • The power coming from/going into the grid. This will help us avoid the grid utilization penalties.
  • Status of car connection to the EVSE. This is one of the inputs when deciding whether to turn on charging.
  • The grid utilization time-slots and limits. This is again helping us to avoid the grid utilization penalties.
  • Information about consumed energy at the EVSE. This is just to know how much charge was delivered to the car.

Limiting Currents

This is the simplest part of it all.

1. We set a current limit, 15A in my case due to limits of the inverter. I could actually go up to 20A, but there are other things to think about outside this scope…

2. We check the phase currents of the installation every minute.

   The interval is important: Too fast and the EVSE does not have the time to respond to current changes. Too slow and we run the risk of blowing a fuse. Fuses work relatively slowly, so you should have about 10 minutes before anything bad happens. But it’s better to do it as fast as your car can follow. You see, when the car charger sets the current, it basically tells your car what the maximum current it can take from the EVSE. The on-board charger of the car (OBC) will then honor this limit with a certain delay depending on the manufacturer. But one minute should be ok for most cars.

3. If any of the phase currents is above the limit, we:

   1. Calculate the excess current. E.g. if we set the limit to 15A and the biggest phase current is 18A, the excess is 3A.
   2. Then we check the EVSE set curent (e.g. 10A) and subtract the excess (3A) to get the needed current setting (7A).
   3. Most cars can only charge with a minimum of 6A. So if the new current setting is lower than that, we need to turn off the EVSE for a while (e.g. 5 minutes). This will give the fuses some time to cool down.
   4. If limit is over minimum, we set the new current limit (7A) on the EVSE.

4. Conversely, if all the phase currents are well below the limit (more than a tolerance we set, normally just the setting resolution, i.e. 1A), we do the above steps in the other direction, increasing the EVSE current limit as needed or turning it on if we had to turn it off previously.

5. Rinse and repeat forever.

This process needs to have an absolute top priority, because it is the only part that can cause problems with our installation. Any strategy we implement will be using it.

Example Code

def currentControl(self, limit):    
    headroom = limit + CURRENT_TOLERANCE - INSTALLATION_MAXIMUM
    if headroom < 0:
      #Current too high, calculate wanted charging current to compensate
      wanted_current = int(self.set_current + int(headroom))
      if wanted_current >= MIN_CHARGE_CURRENT:
        self.setEVSE(wanted_current)
      elif not self.powerOff:
        # Turn off to cool off if no headroom
        self.powerOff = True
    elif headroom > CURRENT_TOLERANCE:
      #Current too low, calculate wanted charging current to compensate
      wanted_current = int(self.set_current + headroom)
      self.setEVSE(wanted_current)

This function will be called every minute, regardless of the chosen charging mode, as long as charging is active.

Green Charging

Now that the current limiting is out of the way, we can start thinking about green charging.

The first thing to consider is whether the storage battery is at least partially charged. It will act as our buffer when setting the charging power, taking or receiving any power we will not be able to fully compensate by setting the charger current. The storage battery voltage is not an exact measurement of charge level, but close enough. So I simply decided on the lower storage battery voltage limit to enable green charging, corresponding to about 20% of it’s capacity. I also set a hysteresis so the charging does not turn on/off repeatedly when we are near the limit. And the charging power near the limit is minimal to avoid spikes.

Next we must take care of proper turning on and off of the car charger. We do this by looking at the car connection status of the charger (in my case 1 means nothing is connected, 2 means connected but not charging, 3 means connected and charging). If the car is connected, but not charging, we should turn on the charger. If the car is not corrected, we should turn it off.

Most importantly, we need to look at the power being charged to the storage battery. This is effectively the excess solar power available and we should charge the car with it. The approach I took is simple, but works well: If the excess power exceeds a certain value (1A of charging current, i.e. 690W + losses), increase the charging current by 1A. If the excess power drops below zero (i.e. we are draining the storage battery), decrease the charging current by 1A. This approach is really simple, but it also helps to smooth out spikes that happen in the solar system due to e.g. clouds shifting quickly.

If you were careful, you might wonder how this works together with the current limiting. For simplicity I decided to adapt the current limiting function to take two values, the current control maximum and the charging logic maximum resulting from excess power.

Finally, I think it’s useful to try to speed up the charging when the sun is plentiful. So if the storage battery is more than half-full, I simply charge with full power until it gets down to half-full. This makes the charging faster.

Example Code

def doGreenCharge(self):
    # Set current to minimum at start of charge, only start if voltage high
    # enough, only start if enough headroom
    if self.battery_voltage > (LOW_BATTERY_LIMIT + VOLTAGE_HYSTERESIS):
      if (self.vehicle_state == 2) and ((MAX_INVERTER_CURRENT - self.highest_inverter_current) >= MIN_CHARGE_CURRENT):
        if (self.set_current == 0) or (self.set_current > MIN_CHARGE_CURRENT):
          self.setEVSE(MIN_CHARGE_CURRENT)
    # If the battery if full enough, charge
    if (self.battery_voltage > LOW_BATTERY_LIMIT) and (self.vehicle_state == 3):
      # Do the excess power control
      if (self.battery_power<-800) and (self.greenCurrent>MIN_CHARGE_CURRENT):
        if (self.battery_voltage < (LOW_BATTERY_LIMIT + VOLTAGE_HYSTERESIS)):
          self.greenCurrent=MIN_CHARGE_CURRENT
        else:
          self.greenCurrent=self.greenCurrent-1
      elif (self.battery_power>800) and (self.greenCurrent<MAX_INVERTER_CURRENT):
        if (self.battery_voltage < (LOW_BATTERY_LIMIT + VOLTAGE_HYSTERESIS)):
          self.greenCurrent=MIN_CHARGE_CURRENT
        else:
          self.greenCurrent=self.greenCurrent+1
      # Do full power with full storage battery
      elif (self.battery_voltage > HIGH_BATTERY_LIMIT):
        self.greenCurrent=MAX_CHARGE_CURRENT
      self.currentControl(MAX_INVERTER_CURRENT, self.greenCurrent)
def currentControl(self, limit, preference):    
    headroom = limit + CURRENT_TOLERANCE - MAX_INVERTER_CURRENT
    if headroom < 0:
      #Current too high, calculate wanted charging current to compensate
      wanted_current = int(self.set_current + int(headroom))
      if wanted_current >= MIN_CHARGE_CURRENT:
        if wanted_current > preference:
          self.setEVSE(preference)
        else:
          self.setEVSE(wanted_current)
      elif not self.powerOff:
        # Turn off to cool off if no headroom
        self.powerOff = True
    elif headroom > CURRENT_TOLERANCE:
      #Current too low, calculate wanted charging current to compensate
      wanted_current = int(self.set_current + headroom)
      if wanted_current > preference:
        self.setEVSE(preference)
      else:
        self.setEVSE(wanted_current)

Called every minute, calls adapted currentControl function to control the charge current

Results

Let’s look at a typical mostly sunny day using green charging:

It was a sunny day and I decided to charge up the car in green mode at around 12:20:

• You can see how the charging power ramps up quickly due to there being so much solar power available at around 12:30, around 8kW.
• The power stays almost constant until around 13:20, when another large load (the oven) turns on. This in turn causes the charging power to drop to about 3.5kW due to current limiting until the oven is done. During this time, the system is unable to take all available power (the oven only works on one phase), so the storage battery gets charged up a bit.
• At around 13:40 the oven thermostat turns off and the charging power ramps up again. There is another cycle of the oven thermostat with power reducing again due to current control. The oven is finally turned off at about 13:50.
• After 14:00 the solar power begins to slowly drop as the afternoon begins. It is clear to see how the system reduces charging power accordingly until about 16:00. There are some short current spikes, but current control takes quick care of them.
• At 16:30 the solar power finally drops to a value below minimal charging power and we can finally see a clear trend in the storage battery voltage. The minimal charging power is maintained until the shutoff limit is reached at about 18:15 when the charging shuts off for the day.

This was in late October, so I was able to charge only 11.6kWh that day (my personal best was 39,6kWh, almost 2/3 of my Kona), but this is still enough charge to do two errands. It was free in all important aspects—I didn’t have to pay anything, it caused no carbon emissions and the power control prevented unnecessary cycling of the storage battery. It is a win-win-win 😀 If I needed more charge that day, I could still simply turn on the cheap charging option and charge to full at night. But it turns out that with my driving, the green option is all I need from about March to about October.

What If You Don’t Have Storage?

This same approach would still work if you didn’t have a storage battery in your solar system. Instead of looking at the storage battery charging power you would have to look at grid power, but all the rest would be the same.

The only difference is that you would be using the grid as your battery. This means you are not worried about wear on the battery, but you can still be a good citizen and reduce your usage during the maximum grid load times. Sadly, the old-style net-metering with constant energy price does not give you any financial incentive to do that, but I’m assuming this will change soon.

Conclusion

This was a short description of the principles of EV charging control in a smart home installation with solar, storage battery, and a car charger. As you can see, home automation is an interesting way to reduce your carbon footprint, save energy (costs), and reduce grid load.

To keep thing simple, I did not discuss the grid utilization limit handling here. If there is interest, I’ll write a separate article about that.

The code examples are only snippets and intended as an illustration of principle. If you are interested in details, add a comment below and let’s discuss!

If you found this article useful, you can buy me a beer here.

Charging an EV can be really straightforward—have a charger (EVSE) installed, plug the car in and wait until the battery is full. But there is a lot more to it than that—the technical constraints, the varying costs, the desire for sustainability all play a role.

Technical Constraints

Grid Connection Capacity

Many European single-family houses will have a hard limit on on grid connection capacity. For my own home this amounts to 230V, 3-phase, 20A per phase, i.e. 13.8kVA. Plug in any more than that and the distribution fuse blows, leaving you in the dark with an expensive addition to your next electrical bill.

The usual car chargers (EVSE) for family homes in Europe will have a 3x 16A (11kW) charging capacity. This is enough to charge a car at home, but it’s not much more than the grid connection capacity of my house. So if the charger is dumb and I try to charge my car while baking some cookies, the combined current on one phase will shoot to 16A (charger) + 8A (oven) = 24 A and I’m going to end up in the dark, with an empty battery and no cookies 🫠

Solutions

Buy More Capacity

The old way of solving this would be to install bigger distribution fuses, but this is not an optimal solution and it will be expensive:

• Your monthly capacity cost will be bigger.
• You might have to rewire a part of your house wiring for bigger current.
• Depending on the utilization of the transformer in your neighborhood, you might not get the extra capacity even if you are willing to pay for it.
• You will be paying for mostly unused capacity.

Use a Smart Charger

A much better solution is to simply look at the current you are taking from the grid and take action when it exceeds the limit.

You can do this manually to some extent, you just need to be the nagging presence that scolds anyone who even thinks about turning on any big load while you charge your car. This should also immensely improve your relationships! 🤪

A much better solution is to automate this. It’s called “dynamic charging” and most modern home charging stations are able to do it at least to some extent. It works like this: You have a current meter installed on the main electrical connection to your home and a mechanism of some sort regularly checks the load. If the load exceeds your limit, this mechanism (a smart home automation or a function of the charger itself) commands to charger to temporarily reduce the charging current until everything is back to normal. Your car will charge a bit slower sometimes, but you get to eat your cookies, stay warm and keep the lights on. 😃

These days, you can buy an off the shelf home car charger with dynamic charging support and there are a lot of models available. But if you are interested in DIY solutions, I wrote an article about building one yourself.

Varying Costs

Time-Based Energy Costs

Depending on where you live, the cost of electric energy will vary through the day. Where I live, daytime electrical energy is about 50% more expensive, so charging your car will be much cheaper at night and on weekends here.

Grid Utilization Costs

Depending on where you live, you might have time-slot based grid utilization costs charged extra. We just got these added to our system and they can make a major difference, a couple hundred Euro or more per year.

It works like this: you choose a connection capacity for each time slot and pay an upfront fixed cost for that. The busy time-slots (during office hours and daytime in winter) are really expensive per kilowatt, so it makes sense to book just enough capacity during the expensive time-slots and all the available capacity during the cheap ones. But there is a catch: if you don’t book enough capacity, you will pay a couple of Euros for each 15 minutes you have exceeded it. It will add up quickly!

At first glance, this boils down to the same thing as varying energy costs—charging from grid on off-peak times is cheaper. But this cost basically forces you to really think about your energy use. If you book low capacity during expensive time-slots, you can save hundreds of Euro per year, but if you then blow through those limits, you will pay much more in penalties.

Solution

Both of these issues can be taken care of manually by being careful about when you decide to charge your car. Of course, having a bit of automation can help a lot, especially with the grid utilization costs and the varying capacities in individual time slots.

A good automated solution will automatically limit the charging power to the capacity limits of the individual time-slots and give you an option to allow or disallow daytime charging. Most cars also have built-in charge schedulers that can help you charge them when the energy is cheaper.

Sustainability

If you care about the climate emergency, you care about carbon intensity of the electric energy you use. In an ideal world, this would have been taken care of by the utilities for you, but we are still a long way from that.

Of course, many utilities are happy to sell you an “All Renewables” package for your electricity bill, where you pay a little extra so the energy is bought from renewable sources. I support this wholeheartedly, because it gives the energy producers the right incentives to build more renewables. On the other hand, we have to be realistic and acknowledge that you are always consuming electric energy with the average carbon intensity your grid is producing at any given time. There is no way to select for less-carbon intensive electrons, unfortunately 😞

This means you must think about the energy mix in your area and this is something your utility is compelled by law to report transparently. You should get a diagram showing the percentages of energy that come from coal, natural gas, nuclear, solar, hydro, wind etc with all your electricity bills.

But keep in mind, this mix is an average and the actual values vary:

• Depending on time of day: If you have a big nuclear backbone, like my country does, you will be consuming mostly nuclear at night, which is low carbon. If you don’t, the cheaper night-time energy will probably have a much bigger carbon footprint, coming from coal and natural gas. But some countries have a lot of hydro…
• Depending on the weather: If your country has a lot of solar, daytime electricity will be almost carbon free unless the weather is bad. A rainy day can cut solar production by 80% or more.
• Then there are the seasons: Hydroelectric plants produce much more energy when the water is plentiful, e.g. in spring and fall. Solar is less plentiful in winter and the opposite holds for wind power.

The good thing is, you don’t really have to work all of this out yourself. There are services that will give you a good estimate of current carbon intensity in your area, like Electricity Maps, which also has an API and there is even a Home Assistant integration for it.

Solution

You can do a lot here if you just behave rationally. Find the data and act accordingly. But there is also the potential to automate things using the publicly available services like Electricity Maps mentioned above.

Conclusion

EVs have the potential to strongly reduce your carbon footprint and cost per kilometer driven, if you use them rationally. But this is not trivial and there are many factors to consider.

If you want to do EV-charging right, you need to think at least about:

• Dynamic charging
• Time-based energy costs
• Grid utilization costs
• The energy mix in your area
• The variations of the energy mix because of time of day, weather and seasons

Keep in mind that you can still think about your energy mix even if you are not able to charge at home. You will, of course, make sure to keep yourself mobile first, but once you take care of that, you can start thinking about other things like carbon intensity.

To keep this article somewhat manageable, I did not discuss other very important factors, like your driving habits, choosing an efficient car and, most importantly, alternative mobility solutions. But let’s face it, these are way more important than any charging strategy and the one thing you should think about at the very beginning. Our dependence on cars is toxic to us and the planet, so the best car is still the one that never got built.

The Second Conclusion

You may have noticed I did not mention rooftop solar or home energy storage. This is intentional, for two reasons: Most people do not have rooftop solar systems. And of those that do, only few have storage. I wanted to focus on a regular home owner buying their first EV, trying to help them understand the potential and behave rationally, both in terms of costs and environmental concerns.

But rooftop solar, especially combined with storage, opens a whole new dimension of options. I explored these in the next article, EV Charging With Rooftop Solar and Storage.

If you found this article useful, you can buy me a beer here.

If you’ve been reading my DIY EV Charging Point Basics post, you probably wonder how all the options mentioned might be distilled into a practical DIY project. This post describes a charging point I actually built. I will explain why and how I made the individual choices, list an actual BOM, describe how everything is connected and even give you the configuration files I used in the first version.

Design Objectives

Some Background

I built this charging point for a neighbor friend who recently, after some deliberation, decided to start driving an EV in the best possible way for “beginners”: He bought a used short-range EV he uses as the “second car” to drive to work and do errands (he has a big family, so there are many errands to take care of). This saves him a ton of gas money and the objectively better driving experience is simply the icing on the cake.

Until now, he was using the charging cable he got with the car, but this was slow (only half the available charging power) and he had no handy sockets to plug it in, forcing him to use an extension cord. So we talked and I offered to help him build a proper Type 2 charging point, enabling him to use the full charging power and avoid dealing with the “cable salad”, while having everything properly prepared for the next EV that is sure to come in time. We sat down, talked and decided what to build.

Parameters

• He does not have a smart home solution, so the solution had to be standalone.
• We decided it would be best if we installed it on the outside wall of his house, next to his driveway.
• To keep the charging point visually clean, we would use a socket, not a cable.
• Although his present car only has a one-phase internal charger, we decided to build a full three-phase charging point, since the difference in costs is minimal and we wanted to keep everything future-proof.
• With 3x 20A distribution fuses, dynamic current control was a must.
• He needs minimal access control, a switch in the house was enough.
• There should be some easy way to charge only at night, when energy is cheaper. But there should also be an option to charge at any time to top up the car when needed.

Design Choices

After the parameters were set, it was relatively easy to decide on the final solution:

• I decided to use the SimpleEVSE controller to take care of the SAE J1772 standard signalling and control since I had good experience using it in the past.
• I would use a ESPHome controller, connected to the WiFi to control the EVSE controller (current and time control, monitoring).
• The charging point would have it’s own weatherproof switchboard on the outside wall, containing the fuse, relay, EVSE controller and the ESPHome controller. The socket would be built right next to it.
• He had some space left in an auxiliary switchboard inside the house, so we would put the RCD switch there, so it can also serve as an access control switch to turn off the whole charging point when needed.
• We would install a cheap smart electricity meter in the main switchboard to measure the currents on distribution fuses. Since this switchboard is on the other side of the house and wiring an extra data transfer cable to the charging point would be a problem, I decided to read it using a separate ESPHome controller connected to the home WiFi network.

The Actual Build

In our case, the system is housed in two small boxes, but if your installation allows, you could connect the energy counter directly to the charge control ESPHome controller, saving yourself one extra ESPHome controller and getting better reliability.

BOM:

Current Supervisor:

• Wiring box as your situation requires
• An energy meter with Modbus interface, e.g. this one or this one
• RS485 to 3.3V converter, e.g. this
• ESP8266 or ESP32 module, e.g. this
• A 5V power supply

Charge Control Unit:

• Wiring box
• RS485 to 3.3V converter, e.g. this
• ESP8266 or ESP32 module, e.g. this
• 12V to 5V DC-DC converter, e.g. this
• EVSE DIN controller, buy it here, the have many other parts for this project too
• 4-pole contactor, like this one
• A RCD, type B, like this one
• A MCB (fuse), 16A B-type in our case
• A 4P T2 surge protecting device (SPD), like this one
• A type 2 socket, like this one

Build Instructions

Use the schematic as your guide. Be careful about proper grounding, correct wire and component sizing, weatherproofing, wiring screw torques etc. DIN-rails are your friend.

You should have enough experience with electric projects to be able to build and customize this from the data I provided. If you don’t, it’s likely you are not able to build it safely on your own, so talk to people who understand it better.

Example Code for the Two ESPHome Controllers

Current Supervisor:

esphome:
  name: stevec

esp8266:
  board: d1_mini
  
# Disable logging to be able to use Modbus
logger:
  baud_rate: 0

ota:

wifi:
  networks:
 —ssid: "ssid"
    password: "pass"

web_server:
  port: 80

uart:
  id: mod_bus
  tx_pin: GPIO1
  rx_pin: GPIO3
  baud_rate: 9600
  stop_bits: 1
  parity: even

modbus:
  id: modbus_stevec
  send_wait_time: 200ms
  flow_control_pin: GPIO5

modbus_controller:
 —id: stevec
    address: 24
    modbus_id: modbus_stevec
    update_interval: 5s
    setup_priority: -10

sensor:
  #Template sensor
 —platform: template #Max phase current, will be written by lambda
    name: "TokMax"
    id: tokmax

  #Readouts of individual phase currents from the smart meter
 —platform: modbus_controller
    modbus_controller_id: stevec
    id: tokr
    name: "TokR"
    address: 0x0008
    unit_of_measurement: "A"
    register_type: "read"
    value_type: FP32
    accuracy_decimals: 1
    filters:
     —sliding_window_moving_average:
          window_size: 6

 —platform: modbus_controller
    modbus_controller_id: stevec
    id: toks
    name: "TokS"
    address: 0x000A
    unit_of_measurement: "A"
    register_type: "read"
    value_type: FP32
    accuracy_decimals: 1
    filters:
     —sliding_window_moving_average:
          window_size: 6

 —platform: modbus_controller
    modbus_controller_id: stevec
    id: tokt
    name: "TokT"
    address: 0x000C
    unit_of_measurement: "A"
    register_type: "read"
    value_type: FP32
    accuracy_decimals: 1
    filters:
     —sliding_window_moving_average:
          window_size: 6


time:
 —platform: sntp
    id: sntp_time
    on_time:
      # Every 10 seconds do readout of max phase current
     —seconds: /10
        then:
         —lambda: |-
              id(tokmax).publish_state((id(tokr).state > id(toks).state) ? ((id(tokr).state > id(tokt).state) ? id(tokr).state : id(tokt).state) : ((id(toks).state > id(tokt).state) ? id(toks).state : id(tokt).state));              

This is simple: We talk to the Modbus electricity meter every 10 seconds to get the three currents. We do a moving average to keep track of fast current changes. The result (largest average current) is available over HTTP API.

Charge Controller:

esphome:
  name: evse

esp8266:
  board: d1_mini

# Disable logging to be able to use Modbus
logger:
  baud_rate: 0

ota:

http_request:
  useragent: esphome/ESP8266
  timeout: 10s
  esp8266_disable_ssl_support: yes #to prevent OTA filing
  id: http_request_data

wifi:
  networks:
 —ssid: "ssid"
    password: "pass"

web_server:
  port: 80

uart:
  id: mod_bus
  tx_pin: GPIO1
  rx_pin: GPIO3
  baud_rate: 9600

modbus:
  id: modbus_evse

modbus_controller:
 —id: evse
    address: 0x01
    modbus_id: modbus_evse
    update_interval: 30s
    setup_priority: -10

sensor:
 —platform: template #Max phase current, will be written by lambda
    name: "TokMax"
    id: tokmax

  #EVSE sensors
 —platform: modbus_controller
    modbus_controller_id: evse
    id: set_charge_current
    register_type: holding
    address: 1000
    value_type: U_WORD
    name: Set Charge Current
    unit_of_measurement: A
    device_class: current
    state_class: measurement
    accuracy_decimals: 0

 —platform: modbus_controller
    modbus_controller_id: evse
    id: vehicle_state
    register_type: holding
    address: 1002
    value_type: U_WORD
    name: Vehicle State
    accuracy_decimals: 0

 —platform: modbus_controller
    modbus_controller_id: evse
    id: ctrl_bits
    register_type: holding
    address: 1004
    value_type: U_WORD
    name: Control Bits
    entity_category: diagnostic
    disabled_by_default: true

 —platform: modbus_controller
    modbus_controller_id: evse
    id: evse_state
    register_type: holding
    address: 1006
    value_type: U_WORD
    name: EVSE State
    accuracy_decimals: 0

#Manual current setting slider
number:
 —platform: modbus_controller
    modbus_controller_id: evse
    id: set_charge_current_input
    address: 1000
    value_type: U_WORD
    name: Set Charge Current (Input)
    unit_of_measurement: A
    min_value: 0
    max_value: 16
    step: 1
    use_write_multiple: True
    write_lambda: |-
      if (x > 0 && x < 6) {
        return 6;
      }
      return x;      

#Switch for turning EVSE on or off. Note the negated function: switch on = EVSE off!
switch:
 —platform: modbus_controller
    modbus_controller_id: evse
    id: disable_charging
    name: Disable Charging
    use_write_multiple: True
    register_type: holding
    address: 2005
    bitmask: 16384

#Template binary sensor for enabling/disabling the whole EVSE system, used for time scheduling to reduce electricity costs
 —platform: template
    name: Enable
    id: enable
    restore_state: true
    optimistic: true
    turn_on_action:
     —switch.turn_off: disable_charging
    turn_off_action:
     —switch.turn_on: disable_charging

#Readouts and automation
time:
 —platform: sntp
    id: sntp_time
    on_time:
      # Every 30 seconds do readout of max phase current
     —seconds: /30
        then:
         —http_request.get:
              url: http://stevec.local/sensor/tokmax
              headers:
                Content-Type: application/json
              verify_ssl: false
              on_response:
                then:
                 —lambda: |-
                      json::parse_json(id(http_request_data).get_string(), [](JsonObject root) {
                        id(tokmax).publish_state(root["value"]);
                      });                      
      # Every 5 minutes do current control
     —seconds: 0
        minutes: /2
        then:
         —lambda: |-
              //Current limits of system
              const float max_phase_current=20, max_charge_current=16, min_charge_current=6;
              //Only do current control if EVSE is ON
              if (!id(disable_charging).state) {
                //Only do current control if max phase current is too high or charge current setting is reduced (plus offset to prevent corrections under 1A, which have no effect)
                if ((id(tokmax).state > (max_phase_current + 0.5))||(id(set_charge_current).state < max_charge_current)) {
                  //If max phase current is too high (plus offset)
                  if (id(tokmax).state > (max_phase_current + 0.5)) {
                    //If current is low enough to limit properly
                    if (id(tokmax).state < (max_phase_current + id(set_charge_current).state—min_charge_current)) {
                      //Reduce current setting by exactly the excess current
                      auto call = id(set_charge_current_input).make_call();
                      call.set_value(id(set_charge_current).state—(id(tokmax).state-max_phase_current));
                      call.perform();
                    } else {
                      //Turn off EVSE to cool everything off
                      id(disable_charging).turn_on();
                    }
                  } else if (id(set_charge_current).state < max_charge_current) {
                    //Increase current setting by exactly the unused current capacity
                    if ((id(set_charge_current).state—(id(tokmax).state-max_phase_current)) < max_charge_current) {
                      auto call = id(set_charge_current_input).make_call();
                      call.set_value(int (id(set_charge_current).state—(id(tokmax).state-max_phase_current)));
                      call.perform();
                    } else {
                      //Or set maximum charge current
                      auto call = id(set_charge_current_input).make_call();
                      call.set_value(max_charge_current);
                      call.perform();
                    }
                  }
                }
              }              

      # Every 15 minutes turn EVSE back on
     —seconds: 0
        minutes: /15
        then:
         —if:
              condition:
                lambda: |-
                  return id(enable).state;                  
              then:
               —switch.turn_off: disable_charging

This is the main functionality. We set up the Modbus communication with the EVSE controller and prepare the necessary variables to control it. My neighbor did not want to have the whole Home Assistant setup, so the control works via a slider in the inbuilt web server.

The control principle is simple – if the average max current exceeds the permitted maximum, the charging current is set to a lover value. E.g. with 20A limit, if the actual phase current is 22A and the set charging current is 16A, the charging current is reduced by 22-20 = 2A, e.g. to 14A. If there is headroom (a big load has disconnected), the charging current is set higher in the same way. This repeats every 5 minutes.

In extreme cases, where the charging current would have to be reduced under 6A (minimum for the EVSE standard), the charging point is turned off until the next 15 minute interval. This should cool off the fuses enough. Keep in mind that normal fuses should hold a significant overload for tens of minutes (standard requirement is: blow in less than one hour for 45% overload, over one hour for 13% overload).

All that is left is a simple option to turn the whole thing on or off via a switch in the web server or an API call.

Final Notes

This was intended as an illustration of how to build a safe EV charging point with dynamic current control. There are literally thousands of ways how you could go about achieving this, but the general outline will always be the same:

Measure current coming into your home, compare to limit, set charging current, repeat. Turn off EVSE for 15 minutes, if load is too damn high 😉

This could be thought of as trivial, but there is an important point here: if you buy a ready-made charging point, it needs to dynamically control the charging current! If you buy a “dumb” charging point, you are going to be paying for blown fuses at least some of the time and extra power capacity all the time.

If you found this article useful, you can buy me a beer here.

Why DIY an EV-charging Point?

• It’s fun to build things yourself 🎉
• You can save some money 💰
• You have so much freedom: how it looks, how it works, it’s almost entirely up to you 🤓

Disclaimer

Unless you know how to DIY some serious electrical installations on your own AND have done that before, DO NOT start building a charging point. A short list of things that could go wrong: fire, electrocution, blown mains fuses, blown built-in car charger…

Adults with electrical engineering background only!

What To Build?

Just a Charging Cable

It’s hard to make a reliable current limiting solution this way, so it’s probably not worth the extra effort – just buy a standard one.

But it can be a worthwhile option if you need to repair a dead charging cable. Just buy a SimpleEVSE controller, a 2-pole relay, and a power supply and put it in the old charging cable casing. Please don’t forget to put a Type A RCD on the supply side cable to keep it safe – you never know what’s behind a socket you did not install yourself.

A Full-blown Type 2 Charging Point

This is where all the options are: current limiting, automation, access control, visual design, cable v. socket, integration, automation…

Options

Current Limiting

I think it’s not an option, actually. Either:

• You risk blowing the distribution fuses every time you forget you are charging a car and you turn on an electric oven or another large load for more than a few minutes.

Or:

• You pay through the nose for bigger distribution fuses.

  Where I live, the standard option is 230V, 3x 20A. Most EVs now have 3x 16A or larger built-in charger. This gives you 4 amps of headroom. Any significant appliance like an oven, washing machine, vacuum, cooking plate, microwave, etc. puts you in the danger zone. So, if you want to be sure, you need at least 35A fuses. This is costly for several reasons:

  • First of all, bigger fuses directly increase your electric bill even before you use any extra power. In EU, the difference will be on the order of several hundred euros per year.

  • You will have to pay for the change and take care of the paperwork.

  • Your existing house connection likely does not have big enough cabling so you need to upgrade this as well.

  • Your local transformer station could already be loaded to the limit and you can’t even get the extra capacity even if you are willing to pay for it.

The downside to current limiting is a slightly more complicated installation and charging will sometimes take a little longer when you have big loads turned on in your house.

Cable or Socket?

My preference is clear: use a socket.

Pros: It looks cleaner (no “elephant trunk” on your wall), it’s easier to weatherproof, and every EV owner owns a Type 2 charging cable.

Cons: You have to take the cable out of your car before you plug it in. But when you come home, you usually have to take groceries etc. out of the car anyway, so it’s not a big deal.

Access Control

I think most people reading this own a house and are thinking about building a charging point of their own in their own driveway or garage. If this is the case, you don’t need access control unless you live in a really rowdy neighborhood. Let’s face it, most people will not park a car in a driveway belonging to someone else, much less hook up a charging cable unless they REALLY need it. Even if they do, this will cost you a few euros at most. If you are in this situation, you can probably afford a few euros – we should look out for each other, when we can.

Nevertheless, if you need access control, it’s quite easy to arrange and you have several options:

• The standard solution seems to be RFID. This is an easy option to implement, you just need a RFID reader:
  • Most RFID-readers have the option to simply hard wire an output to the device you want to control. In this case, any EVSE controller should have an input pin to control. Just program your reader, connect the output to the controller and you are done.
  • You could use the SimpleEVSE-Wifi solution – a simple ESP8266 board you can connect your RC522 RFID-Reader to. It takes care of access control and many other things as well.
• You could control the charging station via your Home Assistant system. A simple switch there can turn your charging point on or off, but you can also do so much more – time control, control according to your photovoltaic plant production, the possibilities are endless.
• Just wire a simple key-controlled switch, hooked to the enable input of your EVSE controller. Install a switch inside your home and connect it to your EVSE controller. It could even be just your RCD switch. Turn on when needed.

What Hardware To Use

Electrical Components

Any charging point needs these at a minimum:

• An RCD protection switch, type B.

  This is expensive, but important! A regular RCD (type AC) could fail to protect you in case your car charger fails in a way that makes the fault current non-sinusoidal (e.g. leakage on only one leg of the rectifier). A type B RCD is a more expensive, but it will reliably trip for DC fault currents as well, which are unlikely, but possible in case of catastrophic damage of the built-in charger in the EV. It is also required by the relevant standard (IEC 60364-7-722:2018). Current capacity should be equal to or larger to your fuse rating. Trigger current should be according to your country standard (30mA for me).

• A fuse.

  A regular installation fuse with the same nominal current you want the charging point to have, type A or B (no need for starting current protection).

• A relay.

  A relay (or a contactor) that breaks all the phases AND the neutral. E.g. for a 3-phase charging point you need a 4-pole relay. Nominal relay current should be at least 120% of the nominal fuse current. (E.g. for a 16A charging point, use at least a 20A relay.)

• A surge protection device.

  An over-voltage protection device, type 2, 2-pole for 1-phase and 4-pole for 3-phase charging points. If your car is not protected from lightning (e.g. away from the building, no roof, etc.), use T1+T2.

• An enclosure.

  It’s best to put all of these in an enclosure with a DIN rail. If the enclosure is exposed to the elements, it needs at least an IP55 rating. Some people prefer to put their RCD switch inside the house, so they have an easy way to turn off the entire charging point there as a kind of access control.

• Cable or socket.

  Also expensive, but you don’t want to skimp here, since it is subject to wear. I usually put it next to the enclosure and build an extra sturdy bracket for it – it takes some force to plug and unplug the Type 2 cable.

The EVSE Controller

You could implement everything using a simple ESP8266 board and some peripherals. But unless this is something you dream about doing, I would very much recommend you go modular: Buy a proven EVSE controller to do all the SAE J1772 standard signalling and control (pilot signal, current control, relay control, enable/disable).

A good option is the Simple EVSE open source project. You can build it yourself or buy a built module at GWL. I built three chargers using their kit already and can recommend them (they have sockets, cables, relays, etc. too). But there are other options too: OpenEVSE, DehneEVSE, smartWB, and others.

You could also buy a ready-made charging point – you can now buy them at hardware stores. But you will a) overpay for the components you get and b) lose a lot of flexibility. Always go open-source when you can, it will save you trouble in the long run (when the supplier decides to stop supporting it).

The Charging Point Controller

The EVSE controller will take care of the signalling and turning the relay on or off. But what about current control, access control, automation, supervision, energy metering, cost counting etc.? This is where it gets interesting. You have many options:

No Extra Controller

If you don’t want any of the above options, just build a dumb charging point. You need a RCD, fuse, EVSE controller, relay and a socket/cable. It will work, but read about the options to understand why this may not be a good idea.

Ready Made Integrated Solution

Some solutions, like OpenEVSE and smartWB, already take care of some of these options. In essence, they contain both the EVSE controller and the charging point controller. But in my opinion the extra cost is not worth it now that we have ESPHome to play with. Just read their githubs and send these awesome guys some beer money via the donation link, they deserve it.

Simple EVSE-WiFi

A simple ESP8266-based solution with an in-built web server for the Simple EVSE charging controller that will take care of:

• Default functions:
  • Turning the charging point on or off
  • Setting the charging current
  • Charge logging
  • Control of the SimpleEVSE charging controller registers
  • HTTP API for automation
• Optional functions:
  • With added RC522 RFID-Reader:
    • Authentication
    • User management
  • With an added S0 or ModBus energy meter:
    • Measuring charging power
    • Metering charged energy (included in log)

You will need to control the current via the API if you want current limiting. This is easily achievable e.g. in Home Assistant, where you probably already have a smart energy meter integrated. Use the REST service integration.

ESPHome

A truly versatile solution that works with an ESP8266 or ESP32 board. It is extremely convenient, you simply program your ESP board via USB once and then you can change the configuration any time using OTA via WiFi. You simply change the YAML file and run the upload program.

The magic of ESPHome is it can work standalone very well, but it is also EXTREMELY easy to integrate into Home Assistant. Whatever hardware you choose to integrate into your charging point (energy meter, sensors, RFID, display, buzzers, LEDs, etc.), you simply add to the YAML configuration file using provided integrations. You can then link these directly using automations within ESPHome or indirectly in Home Assistant.

Conclusion

These are some of the options and things you need to know if you want to build a homebrew EV charging point. In the next post, I present an example solution using ESPHome that includes current limiting and works standalone.

If you found this article useful, you can buy me a beer here.