As an 48-year-old guy from a STEM background who tries to do the minimal-lying-to-yourself thing, I’ve always been curious about the whole faith-spirituality-devotion-religion-deeper-truth thing. It appears to be important; for one thing, it’s supposed to help you live longer; then there is the fact that over half of the world population seems to take it very seriously. So how do people seem to approach this?

It seems like there are three main directions:

• The organized religion, which, let’s face it, does not give us much space to think on our own AND it usually pushes us to think of people outside our group as the Other.
• The New Age thinking, which is more accepting of otherness, at least on some fronts, but is suffused with magical thinking and requires us to leave our reason at the door too.
• Accepting that there is no deeper meaning and we are simply individuals left to fend for ourselves; in other words, nihilism. It looks reasonable, but it is both deeply unsatisfying and lonely. It is also a betrayal of a fundamental truth: we are both social beings and a part of nature. Alienating yourself from the whole living planet, including the 8 billion other humans out there, appears to be the surest possible way to get mentally ill. Only far-right politicians and Amazon-like corporations could ever profit from that.

It looks like there is no good way out of this one, is there? You can drink the Kool-Aid and enjoy the community, along with the taste of biting your tongue every so often; some people let go of their individuality entirely. Most of us know people who have done one or the other. Or you can rely on your reason to guide you but basically be on your own forever.

Fortunately, like any good dichotomy, this one is false too. But first, let’s define some words and talk about why faith is relevant for rational people.

What is Faith?

When talking about things, it’s good to try to define them at least a bit. There are no bulletproof definitions, but thinking about the meanings of words is usually helpful. This discussion revolves mainly around three things: beliefs, faith, and religion. Let’s try to define these at least a little:

Very briefly, beliefs are what we think is true. Some beliefs are very down-to-earth, everyday things, like believing that brushing teeth is good for you. These are mostly easy to prove or disprove rationally, and they shape our everyday decisions. But some beliefs are unprovable, based on gut feelings or compelling stories. Some are placed in our cradle as we learn to talk and be human, like beliefs of organized religions and national identities. Some are marketed to us skillfully enough to make them our own; brands are a good example. And, every so often, there is no other way but to go with our gut feeling; for example, when we need to decide whether we should trust someone.

Some beliefs become important enough to take a special place in our minds. For example, if you decided to trust that particular person and it worked well for a long time, this belief grows into something more. It becomes faith, a default, something you no longer think about; there is no more need for proof; it’s simply the truth. Many people see faith as something connected to organized religion, but it is both deeper and simpler than that—it is a belief that sat in our mind, unchallenged and compelling, for long enough to become unassailable. An example would be the faith that every human being has intrinsic value, shared among humanists, for example, but other believers as well.

When you have faith in several things at once and start connecting them, seeing in them a deeper combined truth (a system, if you will), this is religion. Again, most people see this term through the lens of organized religion, but it can be entirely secular too, like the Humanist Manifesto. You could say non-organized religion is spirituality.

Why Faith Can Be Good for You

Faith, as we’ve seen, can be (there are meaningful exceptions) associated with positive life outcomes like better mental and physical health, as well as a longer life. But why?

From what I’ve read and thought about this, most of the positive effects of faith seem to come from two sources: social inclusion and decreased uncertainty. These sources are clearly intentionally addressed by most organized religions: they will ask you to attend religious services and to be charitable, both of which can be a real celebration of community; they will give you a mostly clear set of rules to follow, eliminating much of the uncertainty we face; and they will define clear devotional practices like prayer, fasting, or pilgrimages, often bringing a helpful routine into your life.

It is precisely the concept of devotional practices that interests me the most here, but we will come back to that later.

At this point it should be helpful to mention the concept of fast and slow thinking, as defined by Kahneman, among others. I will oversimplify: we use two mechanisms to think. Most of the time, we use intuitive, fast thinking. Some call it “the gut instinct”; Kahneman calls it System 1. But every so often the intuitive answer is not good enough, and we have to take the time to deliberate the question rationally; he calls this System 2. To me, this connects beautifully with beliefs and faith:

When faced with a situation about which we have an existing belief or even faith, System 1 fires immediately, and the answer is instantly available. There is no need to waste any time or think any longer; you can just deal with it. In the same situation with no strong beliefs, there will be no strong System 1 response, and we have to start thinking.

Now imagine a really difficult situation, maybe a traffic accident, a bereavement, or a relationship coming to an end. When faced with difficult choices and bad feelings, some people will be primed with relevant beliefs or faith, and some will not. For people primed in this way, these situations trigger the System 1 response; the response will be fast and usually fortified by emotion; they will probably deal with it faster. Others will be forced to fall back on System 2 and think long and hard about what is happening and how to respond. This may cause them to react too late and will definitely deepen the impact of the situation on them.

So, beliefs and faith can have a really positive effect on your life, BUT, and this is a ten-ton rocket-powered “but” on steroids, ONLY if your beliefs and faith are good for you. If you are primed by homophobic teachings of some religion, you will react terribly around gay people, causing pain for them and ostracism for you (hopefully). If you believe that vaccines cause autism, you will likely expose your children to easily preventable diseases. If you believe you are not good enough as a human being, it will be really difficult to have healthy relationships.

Examination is the only cure for harmful beliefs. By thinking about what we did wrong in a situation or being prompted to reexamine things in a conversation, we open the door to change. Of course, changing beliefs is far from easy, but still a picnic compared to changing our faith. So how to do it?

About Empowerment

In The Sovereignty of Good, Iris Murdoch gives us this gem:

… if we consider what the work of attention is like, how continuously it goes on, and how imperceptibly it builds up structures of value round about us, we shall not be surprised that at crucial moments of choice most of the business of choosing is already over. This does not imply that we are not free, certainly not. But it implies that the exercise of our freedom is a small piecemeal business which goes on all the time and not a grandiose leaping about unimpeded at important moments.

I understand it as a brilliant clarification of the age-old maxim “You are what you do.”

As we go about our lives, we do things all the time. We cook dinner for our family, we get up in the morning for work, and we go to the gym or the church or the supermarket. Each time you do something, this becomes easier—doing it shapes you just a little and makes that same act easier to do tomorrow.

But this process is not inherently positive. If you devote a little time every day to help your neighbors, it will become a habit, and everybody involved will be happier for it. If you try to exercise regularly, it will get easier each time, and you will probably be much healthier—but some people will, over time, overdo it to the point of injuries. If you spend hours each day scrolling hateful content on social media, it will become an effortless thing to spout hate at others, even harm them. We are what we do.

So if we want to have better beliefs and steer our lives more intentionally, we have to work on it.

But how?

In some cases, it’s pretty straightforward: If you wanted to get in shape, most people would join a gym and mark it on their calendar. If you hope to be a programmer, you have to dig into the books and start programming; it will take a while, but you can get there with enough practice. And you need to do a LOT of writing to be a decent writer.

Then there are the hard problems: How to live authentically? How to be a better partner? How to escape a feeling of loneliness?

So we start to think about it: What does it mean to be a better partner?

Is it better cooking, better communication, better sex, or doing more of the everyday chores? Probably all of it.

So our thinking deepens: Chores are easy, but how can I be a better cook? Trying some new recipes and cooking more often would surely help. And reading a good book about partner communication should definitely help in that area, as well as setting aside some time to just talk. Better sex requires good communication, and it can’t hurt to read about techniques and positions either.

But is that all? Can we become better partners by just making a to-do list and ticking things off until we get there?

I think most people will agree that it is a good start, but it’s certainly missing something. And here we can borrow from organized religion:

Devotional Practices

Organized religions have well-defined devotional practices: prayers, worship, contemplation, fasting, pilgrimages, and offerings. Most of these have some things in common: you are supposed to do them regularly, they cost something—at least some time, but often overcoming some physical discomfort or making a material sacrifice too—and they are devoted to the object of faith. This is a remarkably consistent pattern for many religions all over the world; it must mean something.

It is a well-known rule that we value things more if they cost us something. So this part is clear—the cost of these practices gives them value in our minds.

Doing things regularly makes sense too—repetition or routine makes whatever we are doing into a habit, an automatic thing; we are what we do.

Devotion is the odd one out—it’s not something a non-religious person is used to in our everyday lives. What does it mean to devote a practice to something? For me, this means thinking about the what and the why while we are doing it and doing it like we mean it, knowing it’s worth the effort because we thought about it well and decided to do it.

A religious person can recite certain words at a certain time while in a certain position, but that is not yet enough. Add devotion, and you get a prayer. Thinking about who or what you are praying to—imagining it—makes that something a little more tangible. Do it a few thousand times, and your religious faith will become a part of you.

But how is this useful for a non-religious person?

Consider our previous example, wanting to be a better partner and deciding to work on it: How do you do it with devotion?

Every day, as you start cooking, possibly a bit tired and bored, you could first try to remind yourself that you are doing this intentionally—you decided to be a better cook. You could then try to imagine your partner or children enjoying their meal. You could attempt to make this particular meal just a little special. If nothing else, you should have more fun doing it.

Then, when it’s time to just talk—maybe when the children go to bed—try to remind yourself that you want your relationship to thrive. You decided to make it work. You are both tired and probably a bit cranky, but remember, pushing yourself just a little makes the time you have together more significant.

And in the end, being a better lover is about deciding to be there and attempting to feel the other person as well as yourself. It’s deciding to do what feels right for both of you, imagining the ecstasy, and then making it happen together; this has to be one of the purest forms of devotion there is.

And then another day comes, and you have to do it all again.

Effort, repetition, and devotion are a way to build our rational choices into what we are. We start by thinking about what we want and then use these three principles to embed these choices into our automatic thinking mechanisms. This helps us make the right choices faster and to feel confident as it happens. Thus we reshape ourselves and make it easier for us to be and do better. We take the rational choices and turn them into faith.

But it’s worth addressing failure too. Deciding to empower yourself means a lot of work; you have to do it over and over again. There will be setbacks, even outright failures, but that’s ok; it happens to everyone. The only thing that helps is to rest for a while, think for a bit, and then try some more.

Conclusion

For me, empowerment is the ability to think about, decide to do, and then do the thousands of little things that need doing, intentionally and with devotion.

Of course, this is not at all trivial; it takes time and effort; occasional failure is a certainty. But you decided to do it, so you might as well keep at it. It will certainly get easier with time and eventually become a part of you. It will be a spring of faith in yourself, the people you are doing it with, and what you are striving for. It will make you resilient and give you meaning and connection.

It is the only thing any kind of meaningful freedom could ever grow from.

Acknowledgment

This is a heavily condensed essay, intended to convey a quite complex concept that took some time to think through. And what got me on this path was the excellent Philosophise This! podcast, specifically episodes 211 through 223—I cannot recommend it enough!

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

Introduction

Being a maker means having to measure things all the time. Usually, the things we measure are relatively straightforward — temperatures, voltages, currents, humidities. Usually, all you need is an off-the shelf sensor and an analog pin or an I2C bus on your microcontroller, a couple of lines of code, maybe a tutorial, and you are done.

But air velocity is different; there are few off-the shelf sensors that a maker would readily use:

• Suppose you wanted to measure the airspeed of your model airplane? Or maybe you wanted to build a simple protection controller to automatically close your motorized awning when it gets windy? You could maybe use a 3D-printed propeller-type sensor, but these are fragile (trust me, I tried a lot), and moving parts are something to be avoided in any project.

• Or maybe you are building something to do with ventilation and you need to measure air flow. While you might find an off-the-shelf sensor for air flow used for air-conditioning, I found these to be quite expensive and not particularly flexible.

Luckily, there is a maker-friendly answer to all these—Pitot tubes. If you never heard of them, I’m pretty sure you at least saw them before: it’s the pointy thing on the nose of most airplanes.

How Does It Work?

To put it simply, a Pitot tube (named after the inventor) is a tube that we insert into the flow of air with the opening pointing into the flow. The air pushes into the opening, producing a measurable pressure change. If we measure this change and know the density and physical properties of the gas, we can calculate the velocity of the flow of air. You can find a nice graphical explanation here.

How Do We Measure the Pressure Difference?

In conditions you are likely to encounter as a maker (roughly room temperature, roughly sea-level pressure, velocities not exceeding 100m/s), Pitot tubes produce rather small pressure differences (tens of millibars/hectopascals at most). Sensors for such low differential pressures with any kind of resolution/accuracy were rather expensive until the advent of MEMS-sensors, but the situation has changed dramatically since then.

You can now buy a Sensirion SDP differential pressure sensor with a pressure range of 125 or 500 Pa, I2C bus connection, some limited intelligence like averaging, and a couple of milliamps of power consumption for ~25€. This sensor, a couple of thin connection hoses to connect to the Pitot tube, and a very basic microcontroller are all you need.

How to Build a Practical Pitot Tube

If you clicked the explainer and the Wikipedia article above, you already know a Pitot tube is basically a stick with two holes or ports, one facing the airflow and one facing to the side. These ports are then connected to the differential pressure sensor by channels of some sort. You could simply point the two hoses coming from your sensor in the right directions, and it would already sort of work.

Of course, if you want any kind of accuracy, there are some things to consider:

• Positioning matters — you need to make sure the rest of your setup is not influencing the air velocity at the point of measurement. Imagine a car with a Pitot tube on the roof — the airflow along the hood, windshield, and roof will be quite different from the free airflow one meter higher or maybe one meter in front of the car. This is why jets have these tubes sticking forward on the nose — it’s the only place where the airflow hasn’t changed much yet.
• Direction matters — if the tube is not pointed straight into the airflow, you will have cosine losses, but you will also be adding pressure on the reference (side) port. Both will play havoc with your accuracy.
• Temperature matters — the calculation of air velocity depends on gas density and temperature. Gas density is again dependent on temperature and absolute pressure. So, depending on your application, you need to measure the temperature of the air near the tube. If you will be flying an airplane model, you should measure the absolute pressure as well.

An Example Design for 3D-Printing

Let me explain the above points using my first Pitot tube design:

As you can see, it is a simple pointed stick with one port on the pointed end and one on the side. At the back, there are two nipples to connect the sensor hoses.

It’s best explained by showing you the section view:

Here, you can see the two channels connecting the ports to the nipples. The chamfers are there to keep the bridging to a minimum. The nipples are a long way away from the ports to avoid any influence on the air velocity, e.g. when holding it.

3D-printing is a fantastic way to make Pitot tubes; you can make the necessary channels and everything in one easily printed piece.

The Actual Measurement

Once you have the Pitot tube connected to the differential pressure sensor, the next step is calculating the actual air velocity.

The Assumptions

I’m assuming ~2–5% accuracy with good repeatability, and a refresh rate in the order of a second or so is enough for your needs here. If you need more, it’s time for a deep dive, sorry. 😅

BTW, did you know: 5% is the difference between a measurement and an indication. Once you go above 5% accuracy, you are measuring things.

Of course, we are talking about volumetric air flow here. But in most practical cases, multiplying the mass air flow by the fixed air density value in your working conditions should give you a useful value.

The Algorithm

It involves several steps:

1. The pressure signal can be a bit noisy. E.g. with the Sensirion SDP810 sensor, the sampling rate can be up to ~2 kHz, which covers even a part of the audio spectrum and is sure to be noisy. A good antidote to noise is averaging, but the good news is, the sensor can do averaging already. It does full averaging for 25 ms and then exponential smoothing after that. As long as you aren’t worried about noise with frequencies under about 40 Hz, this is good enough. If you need to go even lower, read the average every 25 ms and do exponential smoothing yourself. Here is a good primer. It’s really simple to code and covers the majority of »we need to filter noisy input data« use cases, so you need it in your toolbox in any case.

2. You need temperature info. Temperature influences both the Mach velocity and gas density, both factors in the calculation. The Sensirion sensors include a temperature readout, so as long as the sensor is somewhat close to the Pitot tube, this should suffice. If not, add an DS18B20 sensor close to the sensing port of the Pitot tube.

3. You need absolute static (environment) pressure info. If you will never leave ground, assuming the pressure to be 1013hPa (mbar) is good enough, unless you live above about 500m of elevation. If you do, take the value from here. If you are flying a (model) airplane, you will need to have an absolute air pressure sensor on board too.

4. Once you have all this data, the formula to use is (C++, Arduino): v=(a0+((t)*css))*sqrt(5*(pow((fabs(p)/p0*k)+1,0.2857)-1));, where:

   • a0 is the speed of sound in m/s,
   • t is the temperature of the air at the input port,
   • css is the temperature coefficient of the speed of sound (at given absolute pressure, 0.606 at sea level; this is a non-linear relationship, but the value given should be good enough for atmospheric pressures given our assumptions),
   • p is the measured pressure difference (Pa),
   • p0 is the absolute pressure (Pa).
   • k is the Pitot tube coefficient, basically the measure of how much your measuring setup is influencing the airflow around the measuring ports. The good news is: If you positioned the Pitot tube well ahead of the rest of the hardware and did a reasonable job at directing and designing the Pitot tube, you can just say there should not be more than 2% of random influences, and you can set k = 0.98. Or you could take your setup for a ride in the car and calibrate it or at least check your assumptions. But keep in mind — getting the accuracy above 2% will involve some serious work.

The result is given in m/s.

Don’t forget the conversion factors! E.g., with the SDP810, divide the raw pressure value by 240 and the raw temperature value by 200 to get Pascals and °C.

The Hidden Bonus — No Calibration Required

If you look at the above formula, there is only one calibration coefficient, and it is one that we can at least partially omit. So if you built the system well, and you need only a reasonable accuracy (a few percent), no calibration is needed. This is a major advantage compared to other types of sensors, like Venturi or fan-type, etc.

What About the Flow Rate?

Model airplanes are cool and all, but I think the average maker will be more interested in measuring air flows, e.g. for ventilation, air conditioning, burner control, carburetors, etc.

Some examples:

• If you are building a ventilation system with heat recuperation, you need the ingoing and outgoing airflows to be about equal, or you are wasting heat that could be recuperated.

• If you are doing air conditioning, it’s good to have some idea about how clogged your filters are. If a clean filter gives you 100 m3/h of flow at a certain fan power level, a measurement of only 80 m3/h over a certain time means it’s time to clean or replace the filter.

• Burners and carburetors have one job: keeping the ratio of mass flow of air to mass flow of fuel constant. Modern fuel injection systems use a MAF sensor to do this, and this should be the first thing you try, but if that is not an option, measure the air flow at least.

So How Can I Measure Airflow Using a Pitot Tube?

How to Calculate the Flow Rate?

Once you have the air velocity, calculating the flow is easy: the air flow is simply the product of the average air velocity and the cross-section area of the flow channel. A duct with 1 m2 of area and 1 m/s of average air velocity will thus have exactly 1 m3/s of air flow.

Surely There Is a Catch?

Note the italicized averages above. Airflow velocity inside a duct is not constant across the whole area. At the edges (near the walls of the duct), it will be slower due to air friction with the duct walls. The average velocity is thus the highest in the center of the duct and slowest at the walls. The place where we measure it clearly matters — putting the Pitot tube in the center will give values that are too high, and putting it near the walls will result in values that are too low. So how do we account for this?

One way is to use an engineering approximation — at a certain airspeed and a certain temperature, the average airspeed will be the measured airspeed in the center times a certain coefficient that you would get from engineering tables. But this is not very accurate, both because your airspeeds and temperatures vary and because there are other factors at play — maybe your duct is not straight or there is more roughness (dust) on the bottom than on the top of the duct. Maybe your duct is weird in some other way? Wouldn’t it be nice if we could measure the average air velocity directly?

The Averaging Pitot Tube

It turns out that we can do that, at least mostly. The answer is the averaging Pitot tube. It sounds complicated, but it is simply a normal Pitot tube with several input and reference ports. These ports are connected to a larger cavity (one for the inputs and one for the reference), so the air pressure in the cavity is roughly the average of all the air pressures at individual ports.

Again, it’s easiest to explain with a couple of pictures. The averaging Pitot tube is installed to span the whole width of a duct:

It has several ports over the whole width, which are connected by a large averaging chamber, which gives us an average over the individual port pressures and thus an average pressure difference:

Some designs use a cross shape to average over the height AND width of the channel.

The pressures at the output nipples should roughly correspond to the average air velocity. We can calculate it using the formula in the previous section and then simply multiply with the (known) duct area, giving us the air flow.

Still, this is not a cure-all. You should have reasonably laminar flow in the duct to achieve any accuracy. In practice, this means you should try to put the tube at the end of a long straight duct, and avoid things that cause turbulence, like elbows.

A Practical Example of a Measurement System

To help you see how to put all of this together, I set up a Github repository with the STEP files for the two Pitot tubes and the code for an Arduino based measuring device I built.

From these humble beginnings, I went on to build a balanced-flow ventilation system for my home. It still works after several years. 🥳

Here is the testing setup I used for it. Note the measuring gear (averaging Pitot tube, hoses, and the measuring device) on the leftmost side of the duct. And on the right there are the 3D-printed impellers I was testing:

Let me know if you are interested in this in the comments.

Introduction

Last fall I came across an interesting article in Hackaday, where Arne van Itersen made an interesting solar power display with an analog gauge and an e-paper screen.

It immediately grabbed my attention because it solves the biggest problem with e-paper displays—they need a few seconds to refresh, making them unsuitable for displaying continuously changing data like solar power. A simple analog needle takes care of that problem but is limited to displaying one thing only. But if you put the needle in front of an e-paper screen, you get continuous power information from the needle. You can then use the e-paper display for displaying things that only change every few minutes, like storage battery level, daily production, and system operation mode.

But using an analog dial from a multimeter seemed a bit fiddly to me, and I thought about how to improve on that. Using a small servo instead would be better, because I could use needles of any size. Controlling the servos is quite simple too, I needed the ESP32 to control the e-paper display anyway. It took a weekend to put together a simple prototype for a one gauge display, which I used for my DIY EV-charger.

The thing worked like a charm and got me thinking about how to improve it. I was thinking about updating my solar system display for a while now, and this seemed like a good solution.

Thinking About The Design

One needle wasn’t going to cut it this time—I wanted one for solar power, one for power coming from the grid, and one for the power going into the house. After thinking about it for a while, I decided to put the grid and house power servos on the left and right side of the display. The solar servo would be on the bottom. This provides some spatial logic too—power flows from the grid (left) or solar (bottom) to the house (right). I guess putting the solar need on top could also work, but that didn’t look right to me for some reason.

I wanted to put the display outside, where it would be exposed to the elements, so it needed a weatherproof housing. So I had to think a bit on how to make a housing that would be both weatherproof and easy to assemble. It’s easy to build a two part shell, but how to design it in a way you can assemble and then disassemble it easily while keeping it watertight? I decided to approach it differently. I designed a mounting plate for the servos and the e-paper display first and gave it a flange on the sides and on the bottom. Then I designed a one-piece housing with a window and a simple top cover. This housing had simple guides to hold the flanges of the mounting plate. The window can be closed using some acrylic glued with silicone to make it weatherproof. The top cover is designed to have rainproof downslopes and only needs a drop of superglue on each side to keep it in place. This makes the assembly and testing really simple, you can do everything with the mounting plate alone.

The Software

I’m used to Arduino, so this is what I used. E-paper in Arduino is IMO best used with the GxEPD2 library, which includes the Adafruit GFX functions, the servos are controlled using the Servo library, data exchange is done using Adafruit MQTT, and network connectivity uses WiFi.

The program is subscribed to several MQTT topics, containing the values for grid power, house power, solar power, solar production, battery level, and system mode. Each of these topics is linked to a callback function that triggers on topic updates. The callback functions for grid, house and solar power all move the respective servo needles. The callbacks for battery level and solar production only update the relevant global variables. Screen refresh is only directly triggered by a system mode topic change or every 10 minutes, but this updates the display with the latest data stored in the globals.

Startup makes a full sweep of all the needles, serving as a kind of servo calibration check, then starts the main loop. The main loop is really short and only keeps the MQTT connection alive and resets the whole thing if Wi-Fi drops.

Getting the Data To the Topics

The one remaining job on the software side was to get the data from my solar system to the MQTT topics. The solar system is connected to my Home Assistant installation, so it was really easy to set up some automations that publish the relevant data to MQTT topics when the relevant sensor states change. I used state changes for triggers and the MQTT Publish service to send the data to the MQTT topic. I already had a MQTT broker set up for my other projects, so I just used that one.

Build

Once I was satisfied with the results, it was plain sailing:

• 3D-print the enclosure using ABS
• Cut the acrylic to size and glue it to the enclosure using some silicone glue
• Drill a hole for the power cable on the appropriate spot, then use some mounting glue to fix the enclosure to the wall
• Connect the power and insert the mounting plate in the housing.

You can find all the relevant code and files on Github

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

Part 2: The Hardware you Need to Control a Distributed Heating System Through Meter-thick Walls You are Not Allowed to Drill

In part 1 of this series we talked about how to retrofit a temperature control system into an 800-years-old heritage-protected monastery without drilling and running new cables. The solution turned out to be the LoRa (Long Range) radio transmission technology that trades transmission speed for extreme transmission range, enabling us to wirelessly talk to stations behind several thick walls over 100 meters away.

The Constraints

• No changes to the heritage protected building were allowed.
• Retrofit budget was limited, ruling out changes to existing cabling.
• It needed to be retrofitted to existing underfloor heating piping and valves.
• It needed remote per-room temperature control.

The Hardware Structure

Let’s refresh our memory and look at the proposed system structure:

The Hardware Parts

Note: I listed all the hardware parts I used with links to the manufacturer web pages. These are just for your information and I’m not earning any income through these.

Temperature Control Stations

Most of the rooms of the monastery have a large central table containing the electrical installation, and underfloor heating piping with valves, but some had only a small cubicle. I was going to have to install the control stations for these rooms there.

The designer chose to build these tables and cubicles from thick iron plate with laser/plasma cut decorations on the sides. It looks wonderful and they are extremely durable, but it meant I could not hide the entire control station inside — the iron plates were effectively a Faraday cage and prevented any radio communication inside. This meant I had to use control stations made from two parts — the radio communication part on the outside wall, and the power supply box with relays on the inside.

After fruitlessly searching for a suitable off-the-shelf product I decided to build these myself from individual modules:

The Wireless Station

The wireless station was the heart of the station, containing:

1. A Seeeduino XIAO motherboard, providing connectivity for everything else and a small OLED display for installation and diagnostic purposes, and holding:
2. A Seeeduino XIAO microcontroller board, the heart of the control station. It controls the relays and the display, reads the data from the temperature/humidity sensor, and handles the communication with the LoRa board.
3. A Grove LoRa-E5 transceiver board, handling all the wireless tasks.
4. A Grove AHT20 I2C board used to sense the humidity and temperature.
5. The LoRa antenna for the transceiver board. The transceiver actually has it’s own little antenna, but that was not enough, so I used a proper antenna, screwed to an SMA connector with a pigtail cable and an I-PEX connector for the transceiver board.
6. The wiring block.

I had to design a housing for it as well, which I 3D-printed out of flame retardant PETG. It has some holes for the sensors and the diagnostic display. Given that it was installed in a public space, I designed it to be extra sturdy and it also features a holder making it harder to unscrew or break off the antenna.

This was mounted on the outside of the iron tables and connected, using a 6-wire cable, to the power supply and relays board inside.

The Power Supply and Relays board

The wireless station, being publicly accessible, was strictly low-voltage (5V powered) for safety and it needed a power supply and relays to control the 230VAC underfloor heating control valves, so I needed to put all the high-voltage parts on a separate board, safely installed inside the table. It contains:

• A generic 4-relay board with built-in logic-level relay drivers
• A generic 5-watt 230VAC to 5VDC safety switching power supply, powering all the electronics.
• A fuse
• The low-voltage wiring block (above, for the 6-wire cable coming from the wireless station)
• The high-voltage wiring block (below, used to connect the station to 230VAC power and to wire the 230VAC valve actuators)

This board is safely tucked inside the table/cubicle and contains some components that get warm, so I designed a lighter housing. The cover has ventilation holes for cooling, but provides touch protection.

Wireless temperature sensors

After some research, I decided to use an off-the-shelf component, the RAK WisNode Sense Home (RAK7204), for the remaining wireless temperature, humidity and air quality sensors.

These wireless sensors are an elegant solution, running for anywhere from one to several years (depending on signal quality) on one included lithium primary battery. They also feature an automotive air quality sensor, giving us an additional data to monitor, e.g. for ventilation.

I glued some strong permanent magnets on their backs and simply stuck them to a less visible/reachable metal part in the room I wanted to monitor.

The monastery has quite a few rooms and corridors, so I installed 11 of these in all the places not covered with the control stations.

The LoRa Gateway

As explained in the part 1 of this series, using a public LoRa network was not an option for several reasons. This required installing a LoRa Gateway.

After some research, I again went for a solution from RAK, the WisGate Edge Lite (RAK7268). It has since been superseded, but the product on the link is mostly the same.

It only needs network and power. I found that the easiest way to interface with it was using the built-in MQTT server, but we will cover that in the software part of the series.

I installed it in a high place to get the best possible coverage and connected it to the same network switch the application server running Home Assistant was connected to.

The Home Assistant Server

The Home Assistant Server is running on a Raspberry Pi 4 SBC. For storage I used an SSD though an USB-SATA interface cable that allows me to store several years worth of data and backups. It is connected to the same switch as the LoRa Gateway.

Conclusion

In part 1 of this series I described this solution in a general way, but this part is my attempt to clarify by showing you the hardware I used.

As you can see, the off-the-shelf parts are all pretty low-cost components, easy to buy and install. The harder part was to select and integrate the custom wireless control stations, but I was forced to do this due to not finding the right component off the shelf. Still, using the rich plethora of modules available, it is not a big deal to assemble an usable system.

The wireless station design was heavily influenced by the fact it is a one-off project. I took proper care of electrical safety and reliability, but with less than 10 stations built, I did not have to think too much about the manufacturability of it.

The system still runs three years later with the original hardware and has turned out to be very reliable. The only maintenance needed is to replace the wireless sensor batteries as they wear out. In the three years so far, I only had to replace 5 batteries, making this a minimal, once-a-year effort.

The system needs some minimal software maintenance as well, but we will talk about that in part 3.

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

Part 1: How to control a distributed heating system through meter-thick walls you are not allowed to drill?

A couple of years ago a friend had a problem: He is in charge of an 800-year-old monastery building now used as a conference center and an event venue. This majestic building was thoroughly renovated about 10 years ago, but the otherwise excellent new heat-pump-based underfloor heating system was missing the provisions for temperature control in individual rooms. Heating all the rooms all the time was wasteful and there was no way to set the temperature higher (e.g. in the conference hall) or lower (for custodial or temporarily unused spaces). Fortunately, the system already included the necessary underfloor heating loop valves, we just needed to find a way to control them.

The building spans about 100 meters with a square footprint and has very thick walls (meter or more). It is of course heritage protected as well, so drilling for new cabling was out of the question. We also really did not want to change the existing cabling; the long cable runs would be both expensive and time-consuming. We had to go wireless.

But there was a big problem: Wireless communication over more than 100 meters of distance and through meter-thick walls is too much for most of the known technologies, like WiFi, Zigbee, Bluetooth, etc. There is also the issue of licensing. What to do?

LoRa

The solution was to use LoRa (Long Range) technology. It is a low-cost, long-range wireless communication technology that uses frequency bands from 400 to 900MHz. The LoRa protocol is much slower (kilobits instead of megabytes) than e.g. WiFi, but this is offset by the fact that it will work over distances of several kilometers in the open. Or, in our case, over 100 meters and through several thick walls. It also does not require a radio license (but you do have to check for legal limits in your area like permissible frequency bands, transmit powers, and duty cycles).

Timing

LoRa transfers data at low speeds, between 0.3 to 50 kbits/s. This is not enough to visit websites, control a robot, or listen to music, but plenty for a heating control system that needs at least several minutes to respond to changing inputs. This is why LoRa is used for monitoring and control of remote systems like weather stations, reservoirs, and even satellites. There are many systems out there that only need to send or receive a few tens of bytes every few minutes or hours.

Complexity

The LoRa protocol is complex to implement from the ground up, but you can buy off-the-shelf gateways and sensor stations, e.g. from RAK. If you want to build custom systems, there are comprehensive software stacks and hardware modules available for all major micro-controller families, e.g. from Seeed. All this makes it possible to build a basic prototype quite quickly.

An IoT Solution or a Closed System?

LoRa is a popular IoT solution and there are internet-connected public LoRa networks all over the world, many requiring a low-cost subscription. This makes it a great solution for mobile stations, e.g. location monitoring for machinery etc., or smaller systems where you don’t want to set up a gateway yourself.

In our case, we had to install a LoRa gateway because of the difficult environment (a public network was available, but the signal would not reach the inside stations). We also have over 20 stations, so the gateway was not a big expense. And there is the issue of control system safety and reliability, both easier to achieve using own gateway.

Control System

System structure

So what does the structure of the whole system look like?

Application Server

The application server is the heart of the whole system. It runs on a Raspberry Pi, runs Home Assistant, and is connected to the MQTT server in the LoRa gateway.

Home Assistant

Home Assistant is an open-source home automation platform that runs on Python. It provides many different components, including a web-based front end with authentication and integrations for climate control, MQTT, backups, data logging, and more. It provides a GUI for our whole system.

Connection To the Sensors and Control Stations

The LoRa gateway makes it possible to talk to all the LoRa sensors and control stations using MQTT. Each underfloor heating valve is represented as an MQTT switch in Home Assistant, while the temperature/humidity/air quality sensors are represented as MQTT sensors. The actual temperature control is done using Home Assistant’s Climate integration as simple thermostats reading the MQTT temperature sensors and controlling the MQTT switches for underfloor heating valves.

Data Logging

The system includes temperature, humidity, and air quality sensors. Their values are all logged inside the Home Assistant system and stored in a database.

Conclusion

This article is an outline of the control system solution and I will be going into more detail in the following articles, where I will be talking about the control station design, the LoRa gateway config, and the Home Assistant config.

LoRa turns out to be an excellent solution for retrofitting monitoring and control into existing distributed systems, giving us the option to avoid expensive cabling and making it easier to respect the heritage protection rules.

Home Assistant was designed for home automation by enthusiasts but grew into a lovely solution for diverse automation needs, including small and medium-sized HVAC and related systems. It needs some attention as the ecosystem grows and changes, but one update a year with maybe some config updates doesn’t take a lot of time. It gives you a gorgeously looking GUI and all the features you need for control and data logging.

One of the larger challenges of decarbonization is the legacy systems. These will often use energy inefficiently (heating everything all the time is an excellent example) and lack things like temperature control, which is important for comfort. Sometimes, it makes sense to rebuild them completely, e.g. to replace fossil-fuel-based systems, but some legacy systems really only need some additional control. In these cases, using LoRa can be a comparatively simple and extremely low-cost solution with incredible ROI.

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

When researching the e-paper displays for the art project described here, I bought a Waveshare ECP 600x488 7-color E-paper Display (just a normal link, I’m not making any money with this), but ended up never using it. I really try to avoid stuff piling up in my drawers, so I decided to use an old (vintage: 2011 😀) Raspberry Pi 1B I had lying around too and build a simple photo frame.

Using Raspberry Pi To Control the E-paper Display

First, set up a headless Pi using Raspberry Pi OS Lite.

Next, you have to wire the display to the Pi header. The Waveshare Wiki instructions are pretty good and the setup should work out of the box for most people.

I had to make a few changes for my setup, because I wanted to use my old Raspberry Pi 1B to keep it from the e-waste bin. But it has different GPIO pins, so I ended up using the SPI pins on the Pi 1 and GPIO0, GPIO2, and GPIO3 for the DC, RST, and BUSY signals. This required a change in the /RaspberryPi_JetsonNano/python/lib/waveshare_epd/epdconfig.py file. Under # Pin definition I changed the defs this way:

 # Pin definition
    RST_PIN  = "WPI2"
    DC_PIN   = "WPI0"
    CS_PIN   = "WPI10"
    BUSY_PIN = "WPI3"
    PWR_PIN  = "WPI1"
    MOSI_PIN = "WPI12"
    SCLK_PIN = "WPI14"

This enabled the Waveshare e-paper library to work with my old Pi. If you will be using a newer Pi (2 or higher, with the 40-pin header), you don’t need to do this.

Now just run the /RaspberryPi_JetsonNano/python/examples/epd_5in65f_test.py file to see if everything works.

Preparing the Image Files for Display

The 7-color e-paper display works differently than the normal LCD displays. Instead of every pixel having an RGB value, each pixel can only display one of the seven available colors: black, white, green, blue, violet, yellow, and red. Then there is the fixed 600x488 pixel resolution. Finally, the Waveshare library is written to accept bitmap (*.bmp) files only.

Color Conversion

The 7 color limitation means we have to do a color conversion to be able to display the pictures on this display. Selecting simply the nearest color for each pixel will give pretty underwhelming results, so we need a better method, called Floyd-Steinberg dithering. This is a very good explanation of it.

You could code this yourself, but there is a lovely program called ImageMagick that will take care of this for us. But first we need an file that contains only the colors we need. Luckily, the Waveshare library comes with example pictures and you only need this one: RaspberryPi_JetsonNano/python/pic/5in65_n0.bmp, just copy it to the folder you will be using.

Select the Files

This is a pretty obvious first step—collect all the pictures you want displayed on your photo frame. In my case, I did a keyword search in my Google Photo account and simply exported all the results to a temporary directory. Then I did a quick scroll through to delete some photos I did not want to include. Since I was dealing with about 7000 photos, “quick” was a relative term, but it only took a couple of hours.

Do the Conversion

First install ImageMagick (I used winget install ImageMagick.Q16-HDRI on my windows PC). Next, run the following command-line command (replace the folder name accordingly):

magick *.jpg -resize 600x488 -dither FloydSteinberg -define dither:diffusion-amount=85% -remap "folder/your/color/definition/file/is/in/5in65_n0.bmp" BMP3:images.bmp

This opens all the JPEG files in your folder, resizes them to max 600x488 pixels (leaving the unused space blank, so the aspect ratio stays correct), applies the Floyd-Steinberg dithering using the specified file, and, finally, saves them as bitmap files using the given filename, to which the sequence number of the file is appended.

Of course, there are many other ways of doing this, but this worked for me.

Doing the Conversion in Batches

ImageMagick is a very powerful program, but once you convert more than about 1000 pics at once, it will create a crazy amount of temporary files and the conversion itself will take a LONG time. So it’s best to limit the conversion to batches of about 500-2000 files. This depends on your computer: 2000 pics took almost an hour on my rather new and quite powerful computer, producing over hundred GBs of temporary files in the process.

I think the best way is to copy all the image files to a folder called todo first. Then you copy the first batch of, say, 1000 files to your working folder. You then run the conversion, wait until it completes, and then copy everything but the resulting BMP files to the done folder. Then copy the next 1000 files, run the conversion again, but add “_1” to the result filename. Repeat, incrementing the suffix, until the todo folder is empty.

Congratulations, you now have a large pile of bitmap files suitable for displaying on the 7 color e-paper display 😀 All you have to do now is copy it to a folder of your choice on the Raspberry Pi.

The Python Code

The code to display the files we just prepared is quite trivial, I simply copied the /RaspberryPi_JetsonNano/python/examples/epd_5in65f_test.py demo code and removed all the unnecessary parts. Then I added the code to be able to display bitmaps that don’t fill the whole screen. Finally, I added random selection to keep the files from repeating too quickly. The code uses Pillow and you should take care to use proper file handling or you will have problems.

import sys
import os
import random
import logging
import time
from PIL import Image
import traceback
# Imports the Waveshare library
libdir = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), 'lib')
if os.path.exists(libdir):
    sys.path.append(libdir)
from waveshare_epd import epd5in65f

# Let's keep the log short and only collect warnings. Use levels "INFO" or "DEBUG" for setup.
logging.basicConfig(level=logging.WARN)

try:
    logging.info("Random files")
    
    # Initialize the display driver
    epd = epd5in65f.EPD()
    logging.info("init")

    #The forever loop
    while True:
        logging.info("read bmp file")
        image_folder="/the/folder/with/the/bitmaps/"
        #Randomly select the file from the folder
        random_file=random.choice(os.listdir(image_folder))
        logging.info("Chosen file: " + image_folder + random_file)

        #This is important: if you don't use proper file handling using "with",
        #the file stays open and displaying the next file will fail
        with Image.open(image_folder + random_file).convert('RGBA') as bitmap:
            #First set up a white background
            Himage = Image.new('RGB', (epd.width, epd.height), 0xffffff)
            #Get image dimensions from the bitmap file
            width, height = bitmap.size
            #Paste the image on the middle of the white background
            Himage.paste(bitmap, (int((600-width)/2), int((488-height)/2), int((600-width)/2)+width, int((488-height)/2+height)))
        #Initialize the display
        epd.init()    
        #Display the bitmap on background
        epd.display(epd.getbuffer(Himage))
        #Turn off the display internals and wait 10 minutes before you show the next pic
        logging.info("Goto Sleep...")
        epd.sleep()
        time.sleep(600)
    
except Exception as e:
    logging.info(e)
    
except KeyboardInterrupt:    
    logging.info("ctrl + c:")
    epd5in65f.epdconfig.module_exit(cleanup=True)
    exit()

Insert the image path as needed, then run and check if it works.

Set Up the Pi To Run Unattended

If everything works as intended, set up the Pi to auto-run the code on startup using this handy guide. I like the SYSTEMD method best.

Once everything works well after you reboot the Pi, don’t forget to turn on the Overlay File System to prevent SD card corruption if the power goes out unexpectedly.

Putting Everything Together

You now have an e-paper display showing beautiful pictures next to a Raspberry Pi. But it’s not a digital photo frame yet, it needs some kind of a housing first. I decided to use a simple 3D-printed VESA 75 mm case for my Pi and then designed a simple stand to hold everything together.

Conclusion

The first thing anybody will probably ask is: Why? Why use a strange display with a rather low resolution and only 7 colors to display your family photos? Without even keeping it low-power?

The answer is a bit complicated, but I can explain it best like this:

• Constraints spur creativity.
• It’s not about the resolution or color fidelity, it’s about the pictures.
• The grainy dithered images have a nice rough and timeless vintage feel to them. They give a new quality to the images I saw many times before.
• The slow tempo of changing images does not demand your attention. It is a decor item, not another gadget to waste time with.

And I got to rescue an 13-year old Raspberry Pi from the drawer in the process 😄

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

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.

So What do I Mean by Topology?

Topology can be inexpertly defined as the science of how things are connected.

The basic concept of our smart home installation (what is connected to what and where to put the controller(s)) turns out to be immensely important in terms of costs, flexibility, complexity, and, consequently, reliability.

A Modern Home

To help explain the concept I prepared a simple schematic of a small modern home. It only has 5 residential rooms, a machine room and some external installations. Most homes will tend to be bigger (e.g. a room for the kids, etc.) and more complicated (e.g. separate fuses for outlets, solar systems, dimmable lights, etc.), but it’s a good starting point for our discussion.

The schematic shows the equipment of our model home, divided into seven units: five residential rooms, one machine room and the outside equipment.

Each unit contains the minimum equipment it needs, e.g. lights, switches, sensors, actuators, etc.

At the top the units are marked with the wiring requirements. E.g. 24/5/4 means a unit needs 24 wires in total (power, control and I/O), 5 of those will need control (relays), and 4 are general I/O (digital inputs, outputs, and field busses).

The Approaches to Smart Home Automation

The “One Large PLC” Approach

Years ago, smart homes were really expensive and so rich people hired contractors used to industrial automation to build them. Our model home may look complicated, but it’s about on par with a medium-sized machine in a factory. These were traditionally built around one big PLC in a central cubicle and everything was wired from there.

This seems like a pretty straightforward way of doing things, but it has some serious drawbacks:

Wiring Length and Cost

Every. Single. Wire. Has to be routed from the machine room with the giant PLC cubicle to the switch, sensor, or load that needs to be connected to it. This means a lot of cable: 2.2km for our simple example, but more like 8-10km for a medium size smart home with all the bells and whistles.

But wire is pretty cheap compared to the whole house, right? Not really: You need to route it throughout the house using cable conduits. In a brick-built European home, this means A LOT of carving of spaces for conduits and holes into the walls, which is expensive. These conduits also need to be quite large. The wires themselves also become a noticeable expense once you go beyond a kilometer or two.

Complexity

Programming PLCs is not trivial and this is not a small installation. If you don’t have extensive experience, this approach way will take a professional programmer and their time is expensive. You will also need to rehire them for changes to the system. This effectively means you ceded control to your smart home to somebody else. You also lost one of it’s main advantages—the ability to easily reconfigure it.

Reliability

Industrial PLCs are really reliable, so it’s unlikely that the control system itself will break. It’s much more likely that a relay will fail. Depending on your PLC this can mean you have to replace the whole PLC or just an output module. The option to replace individual relays is rare.

The main problem with replacement of the PLC is not the cost, but the fact that you will need to rewire everything and program the PLC. This both takes time and is possibly something you will not be able to do yourself, see “Complexity” above. And maybe, in 10 years, your PLC model will not be available anymore and you are looking at a complete redesign of the PLC cubicle. The same goes if you decide to do a major reconfiguration (e.g. increase the number of outputs).

Reconfigurability

Say you wanted to change the way you use a room or do a renovation, maybe add an extension to the house? You will most likely have to replace (Reliability), rewire, and reprogram (Complexity) the PLC, and find a good way to integrate the new wiring with the existing system. All of this is non-trivial.

The Distributed Approach

Looking at the drawbacks of the “One Large PLC” approach, we can see that most of them stem from one basic feature: centralization. Everything is done in one place and this is inefficient (most centralized systems are). So how can we approach this in a better way?

The answer is to use several small controllers instead of the one big PLC and put them close to where we need them, typically in a small control cubicle in the room it controls. This way we only need to route an Ethernet (or other control bus) cable, and power wiring to the controllers. The individual devices are then wired directly to the local controllers, which is much simpler and shorter.

Wiring Length and Cost

Let’s compare the wiring here with the “One Big PLC” scenario:

• The total wiring length comes out to about 1.5km, which is about a third less than with the centralized approach (I count the ethernet cables as single wires, nobody would ever run individual twisted pairs separately in a conduit).
• You can reuse the Ethernet cables for the network infrastructure you are going to need anyway (for computers, NAS, home cinema etc.)
• The cable conduits to the local controllers can be much smaller.
• You don’t need the big PLC and cubicle in the machine room any more (I put the main controller, a Raspberry Pi 4 SBC, inside the Ethernet switch cubicle I needed anyway), but you do need several smaller controllers with mini installation cubicles, one in each room.

All in all, you should be looking at about a 50% reduction in wiring costs.

Connecting the main controller and local controllers is trivial, they just need power and networking.

The bulk of the wiring work is needed at the local controllers. You still need to connect each switch, sensor and load directly to the local controller, but the cable runs are much shorter now, so at least wiring is less labor intensive and you can afford to be more lax when tagging the individual wires and cables.

With local cubicles, you get the additional benefit of having the option to do RCDs and other protections at the room level. This means that most faults will not trip the whole house, only the room affected. Lightning protectors will work better this way too, the wiring resistance between the primary and the secondary suppressor will help reduce the voltage spikes.

Complexity

The programming gets easier here. You can use “smart” (i.e. with some internal logic) or “dumb” (simple Modbus or MQTT relay/input boxes). Depending on the approach you take, you need to program either several small and simple controllers and/or implement some or all of the logic in your main smart home controller (e.g. Home Assistant).

If something fails, you deal with one room/block at the time and so the troubleshooting is much easier: Is it the local controller, programming, wiring or one of the devices? You go from hundreds to tens of potential sources of errors, especially on the code side.

Reliability

Both “smart” and “dumb” local controllers, as well as Linux SBCs are really reliable, as are Ethernet switches. And if something does break, they are all really cheap to replace. And if you use “dumb” local controllers, replacing them simply means wiring them into the cubicle and configuring the new local controller address, a trivial repair.

Reconfigurability

I already listed some important benefits of the distributed approach, but they pale in comparison to the improved reconfigurability:

• Want to build an annex or furnish an attic? Just run some Ethernet and power to the new room and add a local controller—the rest of the system stays exactly the same.
• Want to add some new hard-wired equipment (e.g. home cinema with motorized screen, new lighting, ceiling fans, etc.) to an existing the room? If you have enough inputs/outputs on the local controller, it’s simply a matter of wiring. If you run out of these, replacing the existing controller is much simpler that with a centralized PLC. But the simplest option of all is most often just to add an additional local controller, possibly in the same cubicle, if there is enough space, or near the new equipment.

The flexibility of this approach is simply incredible.

Conclusion

Building a smart home is not a trivial matter, but you can make choices that make it significantly easier, cheaper, and more useable. Thinking about architecture/topology first will save you a lot of money and frustration in the long run. If you have a contractor, make sure you are on the same page on this!

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

When you decide to build or extensively renovate your home, you will need to do a LOT of planning. This series of posts will give you some insights on how to begin to plan your smart home installation.

The Old Way of Doing Things

Our homes weren’t smart until about 10, maybe 15 years ago (for some rare enthusiasts like me).

The old way was to run two circuits of power wiring on separate fuses to each room, one for lamps, the other for outlets. Then you would have the lamps directly hard-wired to the switches and the switches to the power circuit (using wires in cable conduits inside the walls). The outlets would be directly wired to the other power circuit.

For large loads (washing machine, oven, water heater) you would have a separate fuse and power circuit, again directly hard-wired to the corresponding outlet.

All the fuses and a RCD were collected in a main distribution box somewhere near the entrance of the house.

Pros

• Simple to install
• Minimal length of wiring, minimal costs

Cons

• Very hard to make any changes after installation, everything is hard-wired
• Very hard to automate
• Very hard to log useful data

What Is a Smart Home Then?

For me, the defining feature of a smart home installation is the fact that hard-wiring of functions is, to the extent this is sensible, replaced with software and automation elements.

Instead of wiring a switch directly to the lamp the old way, the switch is wired to a controller digital input and the lamp is wired to the controller relay output. When we press the switch, the controller software senses this and switches the relay, turning the lamp on or off.

At first glance, this seems like a really roundabout way of doing things, but it opens all kinds of possibilities:

• You can turn the lamp off automatically once the presence sensor is inactive for a while to save energy.
• You can turn the lamp on automatically when someone enters the room, but only if the illumination sensor shows it’s dark in there.
• If you are deaf, you can set the lights to blink three times if somebody rings at the door.
• You can turn things (e.g. heat) on or off remotely, so you come home from a long trip to a warm home.
• You can reuse the same sensors for different purposes, e.g. presence sensors can be used for alarms, energy saving functions and comfort.

The possibilities are really endless and can help you save money and energy, have more comfort, be safer, etc.

What Are the Main Features of a Well Designed Smart Home System?

Reconfigurability

We all know how we try to make plans and then life happens.

You want to use a different switch for a certain lamp? With a good smart home system, all you need to do is change a line of a YAML file. Adding many features often entails simply installing and configuring a plugin. A well designed system also allows easy hardware upgrades and system extensions (e.g. adding a room) due to it’s modular and distributed nature.

Reliability

Things break. A smart home will have many more parts than a traditional installations and you are certain to have a failure every now and then. It is important the system is built as resiliently as possible.

I cannot overstate the importance of good backup, which is the backbone of reliability in any software-controlled system. It is the difference between an utter catastrophe and an inconvenient chore once something breaks or you are hacked. Make at least daily backups of any relevant files locally (you need a NAS anyway) and invest in a good well-encrypted online backup service to backup at least the important files from there. I found IDrive to work on any Linux SBC and the pricing is reasonable.

Modularity is an important part of reliability—a set of several smaller subsystems will be more reliable, less complex, and easier to troubleshoot than an equivalent big system. There is also an added benefit that most of the overall system will continue to work despite a part being down.

Another important part is wiring. Wireless connectivity can be really helpful where wiring things is impractical, but you should wire everything else. This gives you several advantages:

• No need for batteries. Batteries wear out and this is bad for two reasons: First there are the natural resources being wasted and secondly, a lot of e-waste comes from devices that are simply thrown away instead of replacing the battery (if that is even possible).
• Wireless works most of the time. Wired works all the time.
• Some devices need to be responsive: When you press a button, the lamp should light up in less than a second or you will think there is a problem. Wireless loses packets all the time and you will get weird delays/issues when you least expect them.

Sustainability

Sustainability has several dimensions:

Sustainable Use of Materials

Choosing the right system topology can substantially reduce the amount of work and materials needed. This will also have knock-on effects on reliability and reconfigurability.

Sustainable Choice of Platforms

To put it very simply: If you are building a system that needs to work for a couple of decades, you must actively avoid any closed source products!

15 or 20 years later, that fancy PLC will not be available to buy if you need to replace it. Even more, the programming software for it will likely not work on the future OS (Windows 17?). And since it’s all closed source, you can’t port or hack it. All the expensive gear and precious natural resources will go to waste and you will have to start almost from scratch.

Bought a cloud-enabled app-controlled EV charger? Read about Juicebox and imagine being locked out of your smart home because somebody ran their company into the ground and simply turned off the cloud computers.

What will work forever? Open source software (Linux, Home Assistant and a lot more), open hardware (any Linux SBC or PC, Modbus or MQTT relay/input boxes, etc.) and open industrial communication protocols/standards (Modbus, RS232, RS485, Ethernet, MQTT, and a lot more). If something breaks, these are cookie-cutter modules—even if the one you want to replace is not available anymore, just buy a similar one and reconfigure (RaspberryPi 12 is sure to happen someday).

Sustainable Use of Energy

As you are planning your home, remember that efficiency pays for itself quickly. Buy better performing machines, but don’t pay extra for gimmicks:

• Better home insulation will be more expensive, but then you need a smaller and cheaper heat pump, air conditioning, etc., so it should pay for itself.
• A heat pump does not need a fancy app to control it, just a Modbus interface for your system and the best COP you can afford.
• Invest in ventilation with heat recuperation. Or live with mold. Forget about apps, choose the model with efficient motors and some kind of communication interface. An integrated CO2/VOC sensor is a plus, so you only run it when needed.
• Buy an EV charger that will be locally controllable (i.e. it has a control interface) by your smart-home system so you can charge efficiently. Or build one yourself.
• Some EVs will consume 12kWh/100km, some will consume 25. Buy what you need, but not more. Same size cars from different manufacturers can have very different consumption. Why am I including your car in this article about smart homes? It will be a major consumer of energy, but also has the potential for a LOT of optimization, from smart charging control to V2G. Most important: For the love of Earth, don’t replace it until it stops working or you really need a different one. Buying a new car every few years is easily the most expensive habit of your life and a colossal waste of resources.
• Heating/air-conditioning is easily your biggest energy consumer. Install temperature and humidity sensors in all the residential rooms and make the heating controllable so you can only use the energy you really need.

Questions You Need To Ask Yourself

Having a smart home can save you money, increase comfort and safety, and make your life more sustainable, mainly by reducing your energy consumption. But there are some important questions:

• Could you build it yourself, even if you choose to use a contractor?
• If not, do you understand it well enough to communicate your desires, needs, and concepts to the contractor?
• Do you trust the contractor?
• Is the design clear and well-documented enough for somebody else to continue maintaining the system in case you want to change the contractor?
• Are you able to reconfigure the system yourself after it is built or will you need ongoing support here as well? What about repairs?
• Have you thought enough about the sustainability of the system?
• Did you avoid pitfalls related to closed systems?

Be honest with yourself, the answers to these questions are important! Depending on them, your smart home can be an awesome thing or a source of SEVERE frustration. Good luck!

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

The problem

A 3D printer is the most versatile tool any maker can have, but it has possible pitfalls and one of the more insidious ones is damp filament.

What happens: You have the printer dialled-in perfectly, everything works perfectly, a couple of weeks pass and then you try to print something again. It comes out looking terrible: blobs, stringing, ugly surfaces.

This is due to humidity absorbed by the filament. Once the filament enters the hot extruder, humidity expands into steam and plays havoc with the flow of molten material in the nozzle. In really bad cases you can actually hear the pops from the tiny steam bubbles during printing.

Some materials are more sensitive than others—you will be able to leave ABS or PLA out longer than, say Nylon, the worst of them. But one month outside in summer heat will make any filament unusable.

You can delay these problems a lot by storing filaments in an enclosed container and adding some desiccant helps even more. But eventually, any filament will get humid enough to need drying.

The Most Common Solution

On the surface, this looks like a solved problem: e.g. Sunlu dryer boxes work well and are not that expensive. But this kind of dryer box is not without problems:

• They are not cheap, a two-roll box will cost you about ~90€. If you are serious about printing, you will need at least two of those.
• They have 150-200W heaters. If you are paying German electricity prices, each day you use one will cost ~1-2€. And each year has 365 days…

So is there a different way?

How Does Drying Even Work?

The Usual Dryer Boxes

The dryer boxes I mention above work by heating up the air. Hotter air can carry more moisture (relative humidity is reduced) and this “sucks” moisture from the filament due to osmosis (which happens faster due do higher temperature as well). The hot and humid air is then blown out of the enclosure automatically or you need to do it manually after the end of each cycle. Some will take advantage of moisture condensing on the cooler walls, which you must then wipe down.

See this explanation for extra info.

The Proper Way To Dry Things

If you look at industrial dryers or modern clothes dryers, these work differently.

The first step of the process is the same: Blow hot air into the chamber to capture the humidity. The next step is very different, though: The hot humid air is cooled, which causes the excess moisture to condense away, leaving you with dry cool air that you can then heat up again to dry the filament, in an endless circle.

At first glance, this seems like a very wasteful process: instead of simply heating the air, you need to cool it too. But here comes the magic part: You can use a heat-pump to transfer the heat from cooling to the heating part of the cycle. A modern heat-pump is extremely efficient and will only consume about 25% of energy it is able to transfer. So if you need 200W of heating power, you will only need about 40W of electricity for the same effect. What is more, because you are cooling the return air, the return air is very dry and the drying effect is even stronger.

My Solution

The parameters

I wanted a solution that does the following:

• There should be enough space for at least 10 rolls of filament.
• It should be able to work continuously, no wiping down etc.
• It should consume no more than 50W of electricity (a quarter of the consumption of a normal dryer)
• Some monitoring would be nice

The hardware

There are many possibilities:

I could possibly build a really big dryer out of a second-hand clothes-dryer. My neighbor and I actually converted one into a big fruit dryer so his apples and plums don’t spoil after the harvest. But while this is a good way to dry out large amounts of moisture, filaments only contain a few grams of moisture each at most and the dryer will consume 700W of electricity. So this would be a really wasteful way of doing it and it would take up a lot of space.

Maybe a mini fridge? I could use an air duct to heat up the air at the rear heat-exchanger, blow it into a box, and then return it to the cold side of the mini fridge. But this would take extra space and I’m not sure how to cool the air effectively.

In the end I decided to buy a very simple and very cheap room air-dryer on Aliexpress. These small units will consume about 15W and dry out a couple of tens of grams of moisture a day from the surrounding air.

They use a Peltier element instead of a proper heat-pump, but since we need so little drying capacity, this is good enough. The Peltier element, the two heat-sinks and the fan are combined into one compact unit like this:

There is also a power-supply, so you only need some more fans, a control board and a new housing.

The Box

I decided to use a simple plastic storage box I kept the filaments in already. IKEA is a good place to find one that is large enough for your needs. Mine is about 40 x 50 x 60 cm, enough for about 12 rolls.

The Housing

My idea was to put the entire Peltier block along with two temperature sensors (DS1820, hot and cold side), a humidity sensor (AHT20, for monitoring) and two fans (hot and cold side) inside the box as a drying unit.

A small hole in the side of the box connects this drying unt with the control box outside. The control box contains the power supply, an ESP8266 controller and a couple of relays for control.

There is also a small outlet for the condensed water on the bottom of the cold side housing. This is connected to a small tube and routed outside the box.

Here is the Fusion project, if you want to play with it.

The First Prototype

Control

I decided to use ESPHome and integrate it into my Home Assistant system to control the whole thing.

The first version was over-engineered, with PWM control of both fans and measurements on hot and cold side. It turns out you only need to monitor humidity and control two relays, one for the Peltier element and the hot side fan, the other for the cold side fan. You could even do without the cold side fan at the expense of a slightly lower drying power.

The Algorithm

The algorithm is simple:

1. Turn on the Peltier and the hot side fan.
2. Wait for a while for the water to condense on the cold side. (The hot side fan is strong enough to ensure the circulation on the cold side too.)
3. Turn off the Peltier and turn on cold side fan to blow the water off the heat sink ribs down into the water outlet. A minute is enough. This is optional, water will drip down on it’s own until there is very little moisture left.
4. Repeat.

It also needs a safety feature to turn off the whole thing if the hot side heats up above 45 °C (i.e. fan problems).

I also added an automation that only turns the dryer on when there is extra power available from the solar plant I have installed. This is optional, but it does keep the whole thing from taking energy from the grid.

Final Thoughts

The whole thing cost me about 70€ at most and it works. There is one drawback: It takes a few days to dry a moist filament roll, but it keeps everything nice and dry afterwards. It seems that putting in a moist roll does not affect the rest of the stored rolls at all.

The ESPHome Code and Planned Improvements

Planned improvements

The code is for the current over-engineered system. The next version will have no PWM, no cold side fan, and no cold side temperature sensor. The hot side fan power will be fixed using a resistor. There will be only one relay that controls both the Peltier and hot side fan. The power supply will be next to the hot side fan to use the wasted energy to heat the box.

The Code

esphome:
  name: susilnik
  friendly_name: susilnik

esp8266:
  board: esp01_1m

# Enable logging
logger:

# Enable Home Assistant API
api:
  encryption:
    key: "secret"

ota:
 —platform: esphome
    password: "secret"

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password

  use_address: secret

one_wire:
 —platform: gpio
    pin: 13

sensor:
 —platform: aht10
    temperature:
      id: temperatura
      name: "Temperatura"
    humidity:
      id: vlaznost
      name: "Vlaznost"
    update_interval: 60s
 —platform: dallas_temp
    address: 0x090417b10b0cff28
    name: "Temperatura topla stran"
    id: temperatura_topla_stran
 —platform: dallas_temp
    address: 0x690517a0c505ff28
    name: "Temperatura hladna stran"
    id: temperatura_hladna_stran

i2c:
  sda: 4
  scl: 5
  frequency: 10kHz

switch:
 —platform: gpio
    pin: 16
    name: "Vklop 12V"
    id: vklop_12v
    restore_mode: ALWAYS_ON

output:
 —platform: esp8266_pwm
    pin: 12
    frequency: 10 Hz
    id: pwm_hladni_ventilator
 —platform: esp8266_pwm
    pin: 14
    frequency: 10 Hz
    id: pwm_hladilni_ventilator

fan:
 —platform: speed
    output: pwm_hladni_ventilator
    name: "Hladni ventilator"
    id: hladni_ventilator
 —platform: speed
    output: pwm_hladilni_ventilator
    name: "Hladilni ventilator"
    id: hladilni_ventilator

time:
 —platform: homeassistant
    id: homeassistant_time
    on_time:
      #Safety functions
     —minutes: /1
        seconds: 0
        then:
          if:
            condition:
              switch.is_on: vklop_12v
            then:
             —if:
                  condition:
                    or:
                     —sensor.in_range:
                          id: temperatura_topla_stran
                          above: 45
                     —sensor.in_range:
                          id: temperatura
                          above: 40
                  then:
                    switch.turn_off: vklop_12v
     —minutes: 55
        seconds: 0
        then:
          if:
            condition:
              switch.is_on: vklop_12v
            then:
              fan.turn_on:
                id: hladni_ventilator
                speed: 50
     —minutes: 57
        seconds: 0
        then:
          fan.turn_off: hladni_ventilator
      #Start cooling fan for PSU
     —minutes: /1
        seconds: 0
        then:
          if:
            condition:
              switch.is_on: vklop_12v
            then:
              fan.turn_on:
                id: hladilni_ventilator
                speed: 50
            else:
              fan.turn_off: hladilni_ventilator

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

What Do I Mean by Low Power?

I was involved in an art project where we wanted to use a smallish (10 x 15cm) solar panel to power an e-paper display inside a gallery, controlled by an ESP32 micro controller.

This would be a pretty trivial job outdoors: the panel has 5W peak power and I could just put a small DC-DC converter on it to get stable 3.3V power from it during normal daylight.

Indoors, the game changes completely, due to two main issues: low illuminance and low solar panel efficiency at low illuminance.

Outdoors, the illuminance will be anywhere from 1000 to 100000lux during the day. On the other hand, normal indoor lighting would normally range from 100 to 500lux. This alone reduces the available power from the solar cell by a factor of 200 or more. 5W turns into 25mW.

But there is another problem: The solar panel efficiency drops at low light. At full illuminance, the total power conversion efficiency of a modern solar panel can exceed 20%, but the same panel will have a much lower efficiency at low light due to interior current leakage. The expected 25mW turns into 5 or 10mW at most with normal indoor lighting.

To put this in perspective: ESP32 will consume somewhere around 900 mW transferring data via WiFi and some 20 to 70 mW with radio off. See this helpful article.

So is there no way to power the ESP32 using our solar panel?

The Solution

Our project involves refreshing an e-paper display at certain intervals and e-paper consumes power only during the refresh (drawing). So the solution is to somehow store the miniscule amount of available energy until there is enough to draw the next picture, turn everything on, draw the picture, save the data for the next one, and power off.

The Hardware

On the hardware side, I achieved this using a solar harvester chip AEM10941 evaluation board that very efficiently charges a single super-capacitor. This super-capacitor in turn powers a low-power, low-voltage boost converter and this powers the ESP32.

The Software

But the hardware alone is not the solution yet: I needed a way to turn off everything so the harvester has the chance to charge the capacitor up, do the drawing only when the capacitor is full and then turn off everything again until there is enough power available.

ESP32 Deep Sleep

The solution is to implement the deep sleep on the ESP32. While in deep sleep, the ESP32 chip only consumes 10μA, but it powers off almost everything, leaving only a small portion of slow RTC RAM and a counter that periodically wakes it up.

So how does it all work?

1. The system spends most of the time in deep sleep, where the combined power usage of the power harvesting system, converter and ESP32 never exceeds about 150μW.

2. Every 5 or 10 seconds it wakes up for a fraction of a second to measure the capacitor voltage:

   2a. If the voltage is not high enough, it goes to deep sleep again.

   2b. If the voltage is high enough, it draws the picture, stores the sequence number into the RTC RAM and goes to deep sleep again.

3. Rinse and repeat.

Pick the Right ESP32 Board!

There is a possible pitfall here: Some ESP32 development boards, like the basic ESP32 Dev Module, power additional circuitry (level converters, USB-to-RS232 chips etc.) from the 3.3V rail. This means they will always use at least 10mW of power, regardless of the deep-sleep mode, which is useless for our use case. I had really good experience with the Olimex ESP32-DevKit-LiPo boards in this respect, but there are other well built development boards out there.

There Are Always Unintended Consequences

Remember how the chip powers off almost everything when in deep sleep? All the regular RAM contents are lost too, only the sequence number in RTC RAM remains. So when I try to draw the next picture, the system doesn’t know a picture was already drawn previously and simply draws over it. The results are really ugly:

I spent way too much time thinking how to fix this…

One option would be to use a full refresh, but that would entail the annoying blinking of the whole display. Then I thought about adapting the library and storing some of it’s variables in the RTC RAM. This seemed like a sure way to lose all my remaining hair, though.

After a lot of thinking, I finally thought of a nice hack. The system doesn’t know what was displayed previously? I should draw the exact same picture as the last time to “refresh it’s memory” and right afterwards draw the new one.

This worked beautifully:

Conclusion

Super-capacitors are a wonderful way to power small devices that work at intervals when there is not much power available. They are preferable to batteries due to their much better cycling ability. I like things that you can put on a wall and expect them to work for years and years instead of becoming electronic waste soon.

And if you use deep sleep with ESP32, always keep in mind the lost RAM contents when the chip wakes up again.

The Code

#include <GxEPD2_BW.h>

#include "GxEPD2_display_selection_new_style.h"

#include "bitmaps/images.h"
#include <pgmspace.h>

#include <driver/adc.h>
#include <esp_sleep.h>

RTC_DATA_ATTR int pic_index = 0;
const int adcPin = 34; // GPIO34 (ADC1_CH6)
const int sleepTimeSeconds = 3; // Sleep time in seconds
const int array_size = sizeof(images)/sizeof(images[0]);
const int refresh_size = 30;

void setup()
{
  // Configure ADC
  adc1_config_width(ADC_WIDTH_BIT_12);
  adc1_config_channel_atten(ADC1_CHANNEL_6, ADC_ATTEN_DB_11);
  
  // Read the voltage on pin 34
  int adcValue = adc1_get_raw(ADC1_CHANNEL_6);
  float voltage = adcValue * (3.3 / 4095.0); // Convert ADC reading to voltage

  if (voltage>2.45) { // Only if voltage is high enough
    if (pic_index%refresh_size == 0 || pic_index%array_size == 0) {
      display.init(0, true, 2, true); // first update should be full refresh
    } else {
      display.init(0, false, 2, true); // following updates should be normal refresh + draw previous picture to avoid artifacts
      display.drawImage(images[(pic_index-1)%array_size], 0, 0, 400, 300, false, false, true);
    }

    display.drawImage(images[pic_index%array_size], 0, 0, 400, 300, false, false, true);
  
    display.hibernate(); //Turn off voltage converters inside the display to save power

    pic_index++;
  }

  // Configure the ESP32 to wake up after a fixed delay
  esp_sleep_enable_timer_wakeup(sleepTimeSeconds * 1000000);
  esp_deep_sleep_start();
}

void loop()
{
}

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

E-paper displays are a niche display technology that uses electric fields to move colored particles in a controlled way to make a very paper-like display.

Most people first saw it in the smart price tags in supermarkets, another widespread use is for e-book readers, and there are used more and more in signage.

These are all very good ways to use a technology with some pronounced advantages and disadvantages:

Advantages:

• Extremely low power requirements: They only need power during refresh and consume no power once the image is displayed. This is perfect e.g. for a price tag that normally only needs to be changed once a day or less.
• Paper-like display: They really do look like printed paper with all the advantages this brings: no need for backlight, extremely broad viewing angle, no eye strain.

Disadvantages:

• Low refresh rate: You can forget playing video games on e-paper, it takes anywhere from hundreds of milliseconds (smaller black and white) to tens of seconds (large multi-color) to refresh the display.
• Limited color display options: E-paper display are monochrome (black and white) by default. Lately, gray-scale (4 or 16 level) and multicolor e-paper displays became available, but these are still limited to 3, 4 or 7 colors. You can’t control them in the same way as RGB displays, so these displays are best for art that looks like comics, i.e. with clear lines and large single-colored surfaces.
• Full refresh involves blinking: When you initialize e-paper, this involves fast blinking; the duration depends on number of colors and size. Black and white displays can do partial refresh with no blinking, but even these must do a blinking full refresh from time to time.
• Not a mainstream technology yet: When you decide to use e-paper, there are resources available, from libraries to displays themselves. It is a technology that has seen some widespread use, especially in e-readers. But e-paper displays are much less standardized and more diverse than other display technologies. One display might allow partial refresh, the other doesn’t. A display that supports partial refresh might make a clean update or blink just once. The libraries I’ve seen are sometimes poorly documented. You might stumble upon unforeseen problems and will have to study some issues for sure. It’s doable, but using an OLED or LCD display is much more straightforward.

How To Use It?

E-paper is normally controlled by a small, low-power micro controller to take advantage of the low power requirements. It does not require much computing power and I’ve seen systems running on a simple Arduino Nano. Most systems will use a modern micro controller like a Pico or ESP32, but some people also use a Raspberry Pi, eg. to display computer- or AI-generated art.

I chose to use the ESP32 micro controller.

Why Use an ESP32 for E-paper?

• It’s ubiquitous: There are many development tools available and a big community of developers to help you on your way.
• It has all the periphery you need: WiFi, Bluetooth, SPI, a lot of flash
• It will work with very low power in deep sleep. This enables compact battery- and solar-powered systems with no need for extra wiring and power supply.

Development Tools

There are several options to develop apps for ESP 32:

• The ESP IDF: A very powerful development environment that includes an IDE, but you can use it in VSCode and Platformio too.
• The Arduino ESP32 core: An Arduino core for ESP32 that you can use in Arduino and Platformio environments.

Pros and Cons of ESP IDF

ESP IDF is the native development environment of the manufacturer, so you can use all the options the chips offer. I would prefer to use it, but there is a problem: Libraries for e-paper are limited.

I found only one promising library for e-paper, the CALE EPD, but the GitHub project is not active lately (since 2023). This is a problem due to changes being introduced in the ESP IDF by ongoing development which mean you will have to fork and repair the library. The range of e-papers seems to be somewhat limited as well, even if it is still the most versatile option. In the end, I wasn’t able to get it working, which is mostly due to me not being an experienced developer, but should still tell you something.

Pros and Cons of the Arduino Core

It looks like the Arduino core is not prioritized by Espressif, but it is reasonably up to date and does not have many limitations. Arduino is a mature environment that puts a lot of emphasis on being backwards compatible, which I really like, but the main advantage in this case is the fact you have a great e-paper library available:

GxEPD2 is a really comprehensive e-paper library with very broad coverage of e-paper displays. It builds on Adafruit GFX, so the interface should be somewhat familiar if you worked with displays in Arduino before. It should work with all the chips Arduino supports, from the old Atmel ones, to the STM, Pico, ESP32 etc.

It’s main disadvantage is the lack of comprehensive documentation There are extensive examples that will enable you to get where you are going, but there will be pitfalls.

The very best thing about this library is that you simply take the example project, wire the display, and select the options in the configuration files: it should work on the first try. There is also a lot of information about it in the internet.

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

City Bikes

A city bike will normally have smoother tires and a heavier frame, your posture will be rather upright, they can have a cargo basket in the front and the back. Most people will use it for commuting, shopping or errands around the city, but you can do road trips too, as long as it is mostly on paved roads and the road is not extremely steep. It’s a wonderful replacement for a scooter and can even replace your car, if you live in a city and your winters are not too harsh. This kind of e-bike works best with a small (250W) front hub motor and a small to medium size battery (~300Wh). You should probably buy a ready-made one, there is not much advantage to DIY here and they are the cheapest kind of e-bikes sold.

Cargo Bikes

A cargo bike is much like a city bike, but will have an even heavier frame and more storage space. Many even have a trailer or dedicated storage units. If you live in a large European city to the north of say, Adriatic, you probably see them every day. People use them for work (transport and deliveries for small businesses) and shopping. Like city bikes, there are many ready-made options here, but there is more space for DIY, since the needs are more diverse: Do you need a stronger motor for your heavy load? Do you drive a lot each day and need to make the battery larger? Would you like to convert your city bike to a cargo bike? Do you already have a cargo bike, but just want to electrify it?

Depending on your needs you could with a hub motor or a mid-motor setup. A (bigger) hub motor should still be enough for the lighter cargo bikes, as long as there are no very steep hills to climb. If this is not the case, a mid-motor setup is a must. You will need a bigger battery: Take the weight of a fully laden bike with you on it in kilograms (e.g. 200 kg) and multiply by 3-5 to get an estimate of what you need in Watt-hours. A somewhat oversized battery on a cargo bike is less of an issue weight-wise than on other types of bikes.

Mountain Bikes

A mountain bike should be familiar to you already. The posture is intermediate and the tires are usually thicker with more profile for a better grip on gravel and mud. Almost all have front suspension and some have rear suspension too. Mountain bikes with front suspension are a good candidate to DIY-electrify, but beware the rear suspension: it is likely it will be hard to work around the linkages and there is less space for the motor/battery. It’s probably best to buy a ready made fully-suspended e-bike instead, but it can be expensive. It makes sense to pick a slightly larger frame size for an e-bike conversion, but if you like your existing bike, just go for it.

A mid-motor setup is a must with mountain bikes, the hub motors simply do not work well on very steep climbs. When I look at people electrifying mountain bikes, I see a clear tendency to oversize the motors and batteries. People will install 1kW or larger motors and huge 72V batteries, but this is not a bike anymore—we will discuss mopeds later. Instead, think about your physical fitness and size:

• A thin and fit person will hardly need the motor in any case, except for steep climbs. A 250W or 350W mid motor is more than enough for them, along with a small 350Wh battery. The reward for not over-sizing is a lighter bike and a much cheaper conversion.
• Most people (medium height/build, not totally sedentary) should choose a 350W or 500W motor with ~500Wh battery.
• Bigger people (tall and/or overweight, sedentary) will need a 500W or 750W motor. Choose the battery size by taking the combined weight of the fully laden bike (saddlebags and all) and the rider in kilograms (e.g. 150-170kg), and multiply by 4-5 to get the battery size in Wh. This should last you the whole day.

Gravel Bikes

A gravel bike is a bit of a cross between a mountain and a road bike, with no suspension, but a sturdier build. The posture is usually quite low. Most of my comments about mountain bikes apply, but these bikes are normally chosen by fitter people and you will likely want to keep the motor and battery size on the lower end of the ranges I mention there.

E-mopeds

An e-moped is an e-bike with a massively oversized motor and battery. Several kilowatts of motors and thousands of watt-hours of batteries are not uncommon—all bets are off here. To me, these are simply electric motorbikes and out of scope here. But they do have (mostly unused) pedals, obviously make for a fascinating hobby, and seem to have a lively community of people building them.

What If You Just Want To Build Something?

What if you have no clue about what to build, but still want a DIY e-bike? The answer is simple: Get a second-hand mountain bike and buy a decent mid-drive kit in line with my recommendations for a mountain bike. It will be a cool thing to build, quite useful for anything from commuting to bike trips to errands, but it should not break the bank. After you ride it for a while, you will know what you want/need, and if you need a different bike, you will be able to recoup most of the costs by selling what you made.

During that cool period people started writing about e-bikes and I got curious. I wanted to build one and check out all these cool new technologies on my own. It was a bit of a journey and I’ll simplify somewhat:

• My first e-bike was a used city bike with a front hub motor and rear hub gearbox.

  

  I got it from my neighbor as payment for helping them run some wires in their new guest house. It was missing a battery and the motor controller was one of the brand-locked ones where the manufacturer will not let you use it unless you had their battery too. So I ditched it and bought a cheap chinese motor controller and battery off e-bay.

  It was a minimal investment to start with and so I 3d-printed a custom battery mount with controller housing. It worked well, considering, and I started using it for daily exercise; it lasted a couple of seasons until the old hub motor started developing insulation faults. I guess it was just a bit underpowered for the controller I bought. I removed all the electrics from the bike and sold it to a friend who still uses it.

• Next I bought a used midsize mountain bike and converted it to rear hub motor system, building my first homebrew battery as well.

  

  It was similar to the city bike, but it had some more torque and could go up steep hills better. But the main advantage was not the motor, it was the mountain bike: I could finally be more relaxed on gravel and mud I sometimes encountered on my drives.

  But the bike had a fatal flaw, the combined weight was too much for the rear wheel spokes and I spent more time repairing these than driving. Turns out rear spokes are a limiting factor for an e-bike with a big guy like me driving it and it gets worse with a rear hub motor. It also still had limited torque on the really steep climbs.

• After rethinking everything, I decided to buy a larger used mountain bike and go with a mid-drive system. I was by now used to building homebrew batteries, so I only had to buy a Bafang BBS system and the rest was homebrew.

  

  This was the jackpot—mid drive (which lets you use gears better) and larger bike were the combination that let me drive anywhere. I bought some saddlebags and suddenly I was able to do the same kind of summer vacations I did with my motorbike, just with slightly shorter daily distances. The motorbike soon lost my interest, so I sold it after a few seasons :)

  The bike needed just a few more upgrades: 4-piston disc brakes and a stronger rear wheel to handle the extra weight, and larger tires to make it even easier to drive anywhere I liked. Now, everything just works!

I love e-bikes! I love how they make you a superman and give you the option to just go almost anywhere. I love how I can do vacations with them. When you drive and see an attraction at the side of the road, a motorbike requires extra work: first you need to stop safely, then get out of your hot protective gear, lock it up, the shoes are not really built for longer walks etc. With a bike, you just stop, hang the helmet on handlebars and throw a lock on the bike; 20 seconds and you can do whatever you like. (E-)bikes are pure freedom!

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.

If you happen to use the Wiznet220UI modules like me, you may have noticed that the configuration tool stopped working in Windows 11. As it starts up, there is a strange error message (it was probably originally written in Chinese and my OS does not know how to display that properly).

You can fix this by right-clicking the tool shortcut, choosing Open in folder, then right-clicking the shortcut, selecting Properties and then selecting the Compatibility tab. In my case, I set the compatibility to Windows 8 and it started up normally. But it did not find any modules when I clicked Search. As I closed the files, Windows asked me if compatibility settings worked. I answered No and it set some different compatibility settings that solved all the problems.

It’s not rocket science, but it works 🙂

It is also a good reminder that most software tools will simply stop working in about a decade or so, unless the author is really diligent about updating them regularly. This will usually not matter for computer software like image and document editors, but it becomes very relevant when you are, for example, building a smart home; you probably don’t want to strip all the hardware out every 10 years or so just because the configuration software is out of date.

Specifically – it’s a dream of people who have the most pipes built: the oil and natural gas industry. They want to keep using these pipes, climate crisis or not, so they are trying their best to confuse us, using tactics perfected by the tobacco industry.

If you are not an expert, it is hard to understand these complex issues, but there are some shortcuts, like this one simple illustration:

What does it all mean? If you want to drive about 7km with your car, you need about 1kWh of energy brought to your wheels. For a battery-powered EV, this means a power plant somewhere must produce about 1.5kWh of energy. On the other hand, if you have a typical hydrogen-powered car, it must produce about 4.3kWh (almost three times as much) of energy to produce, pump, deliver and convert the hydrogen needed to travel the same distance.

An EV wastes less than a third of energy while a hydrogen car wastes more than three quarters. Unfortunately, it is impossible to improve this in any significant way because of the underlying rules of physics. And keep in mind that this is just the main issue with hydrogen (there is a myriad of others; for starters, you will never ever be able to fill your car with hydrogen at home, period).

To be fair, hydrogen does have it’s uses, but these are all extremely capital-intensive and not something you can do at home. This article is a good starting point, if you want to learn more.

But What About Synthetic Fuels?

Synthetic fuels are an extension of the hydrogen pipe dream.

Remember how inefficient hydrogen is? All synthetic fuels proposed so far (e-fuels, ammonia, etc.) use hydrogen as feedstock. This means you lose half the energy before you even start making the fuel itself from hydrogen, lose even more to the chemical conversion, and then you burn it in an internal combustion engine that wastes two thirds of the little energy you have left. Compared to that, even hydrogen is a less worse solution.

There are some use cases where it’s hard to use any other energy sources than hydrocarbons (long-haul aviation and shipping), but these would be better served by using bio-fuels, once we stop wasting them on fuel cars and trucks.

A good source of nuanced info about viable green energy sources is Michael Barnard on Medium.