For a while now I've wanted to create something that used the Raspberry Pi Compute Module 4, along with that I've also wanted to build something in the style of Microconsoles like the OUYA, Steam Link, Onlive etc.

Introducing the Raspberry Pi CM4 Microconsole

It's quite a simple board it has the headers for the CM4, a HDMI port, Ethernet, SD Card Slot, USB C socket and 2xUSB 2.0 ports and that's it. Nice and simple.

One little quirk is that because of the orientation I've put the Compute Module 4 in that the built in Wi-Fi / Bluetooth antenna doesn't work. However I designed this with primarily wired Ethernet operation in mind (it was just a co-incidence out of the 2 compute modules I ordered the one with Wi-Fi arrived first). However the external antenna connector works perfectly with a little stick on antenna.

But couldn't you have just used a Raspberry Pi in a case? What does this add?

This adds literally nothing apart from athstetics in my view, one of the goals was that all of the ports are on one side which make it quite nice to go in a TV unit as all of the cables are then a tad neater. Whilst I could have used a case for this, it was a good enough excuse to design a board which I wanted to do for a while.

I know some cases also do re-route the ports, but there's no fun in using them either so custom board it is.

Compute Module 4, not as hard to solder as I expected?

One of the things that I expected to be more difficult with the Compute Module 4 was that it would be harder to solder. However I found with some decent solder paste and a toaster oven based reflow oven it soldered fairly well, the main issue I had on a couple of boards was bridging but that's more solder pasting to blame.

Easier circuitry too!

The original compute modules also required a fair bit of circuitry extra to work, primarily all relating to power. One very nice thing of the Compute Module 4 is that you can pretty much just supply it 5V power and you're good to go, handily with then a USB C power connector and the correct resistors you can use pretty much any complaint supplies.

Case

I got a Friend of mine (@Eplop) to design a basic little case for me and printed it out on my Prusa Mini and it's come out excellent, I then used a little PCB antenna in the case for the Wi-Fi Bluetooth antenna.

Does it work?

Yes! It's fully tested and working well. My usecase as a microconsole was for it to replace my Steam Links and to run Moonlight on them which works perfect.

Both USB Ports work meaning that the USB Hub is all working, the HDMI connection seems to work at 4K60p (once enabled in the boot config). The network does work at a full gigabit with iperf measuring around 850-900Mbps, and the USB C power connector is wired up correctly as it works with both the official Pi power supply which outputs 5v at 1A all of the time

Can I buy one of these boards?

Currently I'm not planning on selling these however if there is the interest I may consider potentially doing a kickstarter. I don't have a good price estimate but a rough guideline would be £25 per board excluding the Compute Module. If you are interested pop me an email or Toot me on Mastodon.

One thing I have had suggested is using it as a more reliable Raspberry Pi Home Assistant host using an CM4 with an EMMC onboard. Which is certainly a viable project and may be something I even use one of the boards for.

Liked this project?

If you liked this project and would like to see more of it, then it'd be great if you could give me a tip over on Ko-Fi just by clicking the button below.

For the last few months I've started to game exclusively over streaming, I have a dedicated gaming rig that I then can stream to a mixture of TVs, Computers & Android devices around my house.

To make this slightly easier to do I use a HDMI Dummy plug which is basically just a HDMI plug with an I2C Chip to present the EDID to the graphics card and make it think that a monitor or TV is plugged in.

Whilst this works fine, I have been wanting to experiment with HDR which the dummy plug I have doesn't say to the computer that the display is capable. I was then thinking that as it's just an I2C EEPROM there shouldn't be anything stopping me from re-flashing it or creating my own dongle with a custom programed EDID.

The benefit of doing it this way is that the profile that is on the dongle the exact EDID that my TV has will be presented to the computer.

There may be better ways on doing this, using other tools etc. However the below worked for me and is more of a log of what I done rather than the best way to do it.

The Tutorial

Disclaimer

This process may not work, try it at your own risk.

You'll need

• A Raspberry Pi, I did this on a Raspberry Pi 4 but it should theoretically work on others. You'll need this setup with an OS such as Raspberry Pi OS, but you only need the Lite version installed.
• Remote access - For this to be easier, I'd recommend you enable and setup your Raspberry Pi to be accessible via SSH so you can run the terminal commands on a laptop or desktop.
• Possibly - A HDMI adaptor, you may need a Micro or Mini HDMI to full size HDMI adaptor depending on the Model of Pi you're using and assuming you're using a HDMI dongle that is full size HDMI too.
• A HDMI Dongle, these are relatively cheap and available from multiple places. I used this one from Amazon, theoretically it shouldn't matter if you get a 1080p, 2k or 4k dongle as we're overwriting the profile anyway.

Step 1 - Dump the TV or Monitor's EDID that you wish to use.

1.1 - Prepping the Pi

The first step is dumping the EDID of the TV or monitor that you wish to dump the data from. Connect the Raspberry Pi to your TV / Monitor and power it up, then  connect to it via SSH or such.

First we need to check / confirm the GPU driver is the correct one to be able to use the tvservice command. To do this you can use an editor like nano to confirm & / edit it.

You're looking for a line that if it's added will be either dtoverlay=vc4-fkms-v3d or dtoverlay=vc4-kms-v3d partially depending on what you may have configured previously. Ensure this is set to the fkms option, if it's the kms option change the line to the fkms one, save and reboot your Raspberry Pi.

1.2 - Dumping the data

Now we know the fkms driver is in use, we should be able to dump the EDID from the TV / Monitor.

Re-connect to the Pi via SSH or similar, and then run tvservice -d edid.dat , you can change the edid.dat to a different filename. But this command should then dump the TV's.

This will create a file (usually in your home directory) named edid.dat, you can confirm the file is correct by using a tool such as edid-decode edid.dat which will decode and display the data for the device. There's also tools online that you can upload the file to, to decode it such as https://edid.tv.

Step 2 - Write to the HDMI Dongle

2.1 - Prepping to write

Next we need to repeat / reverse what we did in step 1.1, and set the Raspberry Pi to use the kms driver instead. Once again open your /boot/config.txt again in your favourite editor and look for that same line that should be dtoverlay=vc4-fkms-v3d

Now edit the line to the kms driver by changing it to dtoverlay=vc4-kms-v3d and again save the configuration and reboot.

Re-connect to your pi, and unplug your TV / Monitor and instead plug in your HDMI Dongle. If you're using the Pi 4 make sure it's inserted into the HDMI 0 port (closest to the USB C Socket).

Finally we can confirm that the correct driver is loaded by seeing if the Raspberry Pi's i2c bus on the HDMI port is available. You can do this by scanning it with i2detect -y 20.

You should see in the 50 row that the number 50 shows, if you see this then the EEPROM on the dongle has been detected, if not try re-inserting it and re-running.

2.2 - Prepare to write

To write it, I found I needed a third party tool to write i2c. I found a site that referenced an EEPROM writing program which the link didn't work on. But handily wayback machine had archived it so I was able to download it from there.

I then ran the following on my Pi to download that file using wget.

wget https://web.archive.org/web/20220308192506if_/http://darkswarm.org/eeprog/eeprog-0.7.6-tear12.tar.gz

And then extracted using tar -xzvf eeprog-0.7.6-tear12.tar.gz. Finally navigate into the folder and run make to build the package. (You may need to install build-essential to do this).

2.3 - Write!

Now confirming that your dongle is in the Raspberry Pi, we're ready to write.

Run this command to write the data, this assumes that the edid.dat is in your home folder. Adjust it if not.

cat ~/edid.dat | ./eeprog -f -w 0 -t 5 /dev/i2c-20 0x50

And that's it! If it worked you should get a nice success message, if it doesn't then you  may just need to re-try or see what error is produced. Whilst the HDMI Dongle I used didn't have the chip write protected others may.

Step 3 - Test

And the simplest test is the easiest, now plug it into the computer or such that you wish the fake display to be on. The windows gaming rig in my case thinks my TCL TV is connected even though it's just the dummy dongle.

Finishing up

Overall this was actually quite easy to do and didn't require any special tools to do it, I believe there are ways of doing it via windows directly but this method for me was slightly easier using hardware I had connected to the TV anyway.

It's been a while since I did any electronics work as my job involves mostly software and customer support. However recently I've wanted to do a few electronics projects where having a LoRa Gateway on TTN running again would be handy.

While I have pieces of old gateways I've worked on, none of them quite are what I'm looking for now either being too basic or too complicated.

The Goal

So my Goal was to build a new LoRa gateway that has the following specs:

• Outdoor - I wanted this one to be an outdoor unit. The indoor market is now quite competitively filled but I felt the outdoor one isn't quite full yet.
• Lightweightish - The other issue with quite a few outdoor solutions is that they are HEAVY. So the goal is to be small and relatively lightweight.
• Keep It Simple Stupid - It needs to be no thrills, just a basic 8 Channel LoRa gateway powered via POE and nothing else. No 4G backup, more channels, less channels, extra sensors, solar panels, battery backup etc. Just a basic 8 channel gateway.
• Cheapish & Available - I wanted it to be a reasonable price, even in this mad components market. At the same time I tried not to use components that seemed extremly hard to get hold of.
• Easy to re-produce - I'm not sure if I'm going to be selling this ever or not, or to make it open source instead etc. Therefore making it fairly easy to solder the main PCB.

The Brains

My first challenge was finding a good brain to use as the centre of the gateway, the most obvious is the Raspberry Pi however unfortunately at the moment the parts shortages has affect them too. At the same time I had already found a good case and unfortunately a full Size Pi wouldn't fit. And to use a Pi Zero or A+ would have required all the extra circuitry for Ethernet.

I looked at a few chinese Pi alternatives, some I've used before like the Nano Pi Duo but the availability of those isn't great and the software didn't look like it had been updated for a while.

After that I looked further into one I've tried before many years ago, the Onion Omega 2+. It's price is fairly good, it has ethernet and runs enough linux for the packet forwarders to work.

But when I tried it about 4 years ago I found there was unfortunately a bug in the hardware SPI which meant that full duplex just never quite worked and I was never able to get it running.

After more hunting around I then found there's a Software SPI alternative method! So I connected it to one of my breakout boards for a RAK LoRa Module, tested it with the software and it works!

The Other Components

Overall I wanted to try and make it fairly simple and cost effective, as I don't need to optimise for batch manufacturing I was able to use quite a few off the shelf modules.

Having POE support was key to me, I wasn't sure between Passive or 802.11AF POE. However when searching around I found this neat little module sold via Adafruit & The Pi Hut from china. You simply wire up the POE magnetics to it and it has a full bridge rectifier and step down circuitry to regulate it to 5V at 1.5A which was Perfect. The price seems quite reasonable and I  don't think I could save a lot of money by buying all the components seperately and it made assembly a lot easier.

Apart from that the majority of it is just passives, I've used two linear voltage regulators for cheapness. One for the Onion and one for the LoRa module (also spreading the heat dissapation by having them at two locations on the board.

Finally I used a Magjack that has all the magnetics in ready for POE too.

Designing the V1 PCB!

Designing the PCB was interesting, this was my first PCB in Kicad. It certainly has some quirks but overall wasn't too bad to design in. As the design was quite simple it made this easy.

I used 0805 passives to make soldering easy, the other components are mainly through hole with the exception being the M-PCIE socket for the radio module itself.

One thing I did find quite nice with Kicad was that the 3D viewer is very good and makes it easy to see how it's looking. Certainly the main benefit for me over Eagle.

Assembling the Prototypes

A week and a bit later the PCBs and Components arrived from JLCPCB & LCSC, the boards themselves are a really nice purple colour which I selected at time of ordering.

Unfortunately out of the first 5 PCBs I was only able to solder 1 correctly. I think that maybe my soldering iron's element is faulty as it seemed to struggle to flow correctly even with leaded solder on the PCI-E Socket without bridges.

After I got that soldered though, the rest was very easy. The SMDs were rather easy due to going for a big size and the through holes were perfect.

Resulting in this.

I then began testing by connecting my POE injector without any modules plugged in to check for shorts and all was fine, I then added the POE module and that worked well. After checking the voltages on the regulator I first tested with the Onion inserted, and then added the LoRa module on.

However there was an issue, the ethernet on the Onion wasn't working. Luckily after a little debugging I found it was just a bridge on the header that I soldered for the onion module connecting RX + & - together. After unbridging that it worked.

The Final Piece

After resolving the ethernet issue it was complete! Working first time which I'm very happy with.

Finally it was a case of putting it into the case itself. Which all the holes aligned first time!

Now all I need to do is get some new screws and mounting posts for it, otherwise I'm quite happy.

The resulting budget is roughly £200-250 per unit all in all which I think for an outdoor LoRa gateway is quite good. There's cheaper indoor units but I haven't found a good outdoor unit at this price.

What's next?

Next up on the to-do list is getting basics station to work and trying it with SEEED studio's SX1302 module. I don't expect too much of an issue with these so that should be fine.

After that I'm not sure if I'm going to open source the design, at the same time I may look at doing some small batches of the PCBs with base components soldered on. If you are interested ping me a tweet @Ryanteck to let me know and if there's enough interest I'll consider it.

Since getting solar installed I've been debating about getting a solar capable EV charger, however the cost for them seemed quite high. However when browsing around I found this charger at Replenishh for only £354 which seemed like a great deal.

Features claim to be that it supports solar and other smart charger features which is what I was looking for, my previous charger was a fully dumb unit and worked well for what it does but otherwise was a bit basic.

From initial impressions it looked good, I then found an open box unit on ebay that I purchased alongside the matching CT Clamp for the solar.

However while looking through the docs I did notice in the pictures, it looked like there was a Raspberry Pi inside! Perfect.

Inspecting the Unit

The unit itself does look nice, it's very compact and does look nice. The case feels a bit more robust than others I've had and it feels a bit more premium.

When looking through the paperwork of the unit, I then hit my first hurdle, it turns out to get the smart features enabled you have to be an "approved installer". After a few emails I was able to get it activated under the basis I would void my warranty but went ahead with this.

Upon getting my account activated it was installation time.

The charger itself is split into two parts, the main charger itself has actually been built into the front of the case, and then a "Smart card" has been added to the back box. To drill the holes out of the back box for the cable glands I first removed this smart card to avoid damaaging it and used a step drill bit.

Next I put the smart card back in and ran the wires into the box, this was a slightly tricky process as the main power cable has to attach to the front case, which then attaches to the board on the back case to provide it with power and data communication.

Once all fitted it was then time to set the unit up, I had connected the mains to the terminal bocks on the front, and the CT clamp to the terminal blocks marked solar (using a CAT5E cable as an extenstion to reach from where the clamp was to the charger).

I then shut the case, screwed it shut and then flicked the power onto the unit. It booted up and was ready to setup via the app.

The installer setup was fairly easy, it asked me to scan the QR Code on the unit and it connected it to a hotspot the Pi had setup. Once connected it asked me to specify if the Load Balancing or Solar Clamps were in use along with the voltage of the site (240V) .

Once this was done it then did some further checks and confirmed the CT Clamp and wi-fi connectivity was there.

The only odd thing here was it asked for me to confirm the CT clamp reading, however there didn't seem to be a way to apply a correction offset. However I also found it odd that it wasn't reading a negative value as we were exporting at the time.

I continued the setup and it was then ready for customer linking, of which I then re scanned the QR code and linked it to my account. Oddly it wanted my address to know where my charger was installed for some reason, apart from that the rest seemed reasonable.

Then it was ready!

But then it got worse

On this screen you can then swipe left or right to see different information, one being the readings from the CT clamps. I noticed it didn't seem to know a difference between import and export still, things weren't looking good...

To the right was the settings screen to configure solar etc, excellent! But then I hit a buggy mess.

Unfortunately the settings screen seems very buggy, text keeps overlapping and sometimes the text won't appear at all to configure bits. However when you are able to get the correct fields show this is how the solar configuration looks.

I was confused on why it was asking for times to solar charge, but for now I put in the times we export the most.

Solar Hassle

I then plugged the car in ready for it to start solar charging the next day which as soon as it hit 10AM the next day it certainly did. But it was quite weird as it was charging even though we wern't exporting.

I had another look at the paperwork and noticed that it said you'd put the clamp to monitor solar generation just after the inverter and not between your meter and the house. Something seemed odd.

After a bit of figuring out, it looks like this charger doesn't have a proper solar integration. Instead it seems to work on the basis that you set a minimum charge speed of say 6A, it'll start charging at the time specified (e.g 10AM) and then with the clamp on your solar inverter if your solar starts producing 8A for example it'll increase the charge rate to 10A.

However this is honestly useless, most solar chargers on the market go on the basis where they monitor your import / export and will increase as you export more. But decrease if you're not exporting. So say like you're consuming 2A of the 8A your solar is producing, the car would charge at 6A, but in this implementation it'd charge the car at 8A leaving you to import 2A.

Due to this for now I've disabled the solar implementation for now.

Conclusion time

Overall I don't think I can recommend this charger, expecially if you're hoping to use it as a solar charger. I know other people who have Zappis which operate as expected charging based on what they export etc.

It does have other smart functionallity such as monitoring how much power is being used, and offering a timer but neither of these to me make it worth it. The monitoring power consumption has never fussed me too much and most cars have a built in timer.

It's not even like it then has integration for smart home systems or smart tarrifs like Octopus Agile either, so you're paying a premium for a smart charger which doesn't really offer many features. Along with the app being quite buggy too it's just not great considering the price which usually installed is £779, I'd likely say you're better off either getting a dumb charger installed cheaper or a more expensive charger that offers more useful smart features (such as a better solar integration, smart home integration or smart tarrif integration).

Technical Deep Dive

Why can't it detect export vs import?

So I was interested as to why it can't detect import vs export, previously in my DIY solution the issue was due to it not having a proper energy monitoring IC to calculate the phase angle. But as this has AC mains running to it I didn't think it'd be an issue.

Before installing I had taken some pictures of the smart board and removed the Pi Zero to see underneath and the chips that were there.

Zooming onto the IC that runs from the CT terminals, we can identify it's an ADE7858.

While it does seem to indicate that you can supply it with a mains voltage input I to do phase angle calculation (which is used to identify between a positive or negative reading). From what I can tell on this board they've shorted these pins all together.

Hacking it better

Well, as it's brains is a Raspberry Pi it's certainly possible to modify, it looks like the Pi itself just sends commands to the main charger board using an RS485 bus (also indicated by the usual labelling of this with the 0V, A & B on the terminal block header that connects to the main unit. The code itself is all written in python that hasn't even been obfuscated either.

Maybe if I can figure out what commands to send to the main board to enable and disable charging I may then be able to use the data from my HASSIO instance to decide if it should charge based on export or not.

I recently wrote an article on a DIY energy monitoring solution using CT Clamps and an ESP8266.

This has been working fairly well, however had one flaw I couldn't figure out how to resolve. Measuring export from excess power generated by solar.

While I don't currently have solar we should be having it fitted in the next month, so I wanted to sort out export measuring.

Options

So essentially with some searching I had a few potential options for monitoring both import and export for our house which were:

• Upgrade the ESP board to something that used a ATM90E32, these breakouts require an AC transformer that produces ~9V AC output. This chip then has the AC voltage, frequency and from what I understand the phase so it can measure import vs export.
  The biggest issue of this was fitting a Mains outlet in the meter box.
• Try and use another couple of normal clamps on the fuse board possibly if the solar is wired up in a way that was slightly different. However this was unlikely.
• Find another solution, which in this case was the Glowstick.

So, the Glowstick

Upon Googling around for MQTT Smartmeters both the Glowstick & IHD version, now these are semi limited in meter compatability. Being either a SMETS1 version that from what I can tell requires you to have a SECURE branded smart meter (Which is what Octopus installed for us) (With possibly compatability for other SMETS1 Meters but I can't quite tell), Or a SMETS2 version with wider compatability. (Noting the stick currently is SMETS1 only, the display offers both versions).

After comparing this against the ATM90E32 solution this worked out most cost effective (Approx £60-70 excluding the socket fitting), or this at £50. I wasn't worried about the display myself so just ordered the stick, I had to verify our bill with them but after that was done the stick was on it's way!

As I had also downloaded the App ready and signed up for an account which was the same email address as I ordered from, they had also pre-linked it to my account ready.

How does it work?

From what I can tell without cracking it open, the stick is essentially a Zigbee and ESP based board. It just uses USB for power and bridges the data from the smart meter using Zigbee to the internet via Wi-Fi.

When it arrived it creates a wi-fi hotspot which I connected to with my phone. Used the app to specify my Wi-Fi credentials and it then connected to that, within about 5 minutes it had then linked to the smart meter and Glow's cloud server and was pumping data through.

At time of purchasing I asked for MQTT access which was setup without an issue, while they don't provide support for MQTT the info they sent through worked first time.

Simply connect to their MQTT via the username and password I signed up with on the app and subscribe to the topic and voila data!

Configuring HASSIO

Configuring HASSIO to then get this data was fairly easy and broken down into a 2 step process.

MQTT Subscription Bridging

The first part is getting the MQTT data into your HASSIO's MQTT instance, I run my Mosquitto broker on the Pi that I run HASSIO On.

To do this I SSHd into the Pi running it, and created a file for mosquitto at /share/mosquitto/smartmeter.conf

# Bridge to Smartmeter
connection smart-meter-bridge
address glowmqtt.energyhive.com:8883
remote_username <GLOW_USERNAME>
remote_password <GLOW_USERNAME>
bridge_insecure true
bridge_capath /etc/ssl/certs/
topic SMART/HILD/<GLOW_MAC> in 0
bridge_protocol_version mqttv311

In total you just need to set your username and password you used for the Bright App, and the MAC of the IHD / Stick.

Then reboot your Mosquitto broker. You should then see the data in your local broker if you use something like mqtt-explorer.

Setting up the sensors

As it's MQTT you'll then need to add the sensors in, there's a little discussion and some examples of this at https://gist.github.com/ndfred/5bb51b567f8cfaf2bb06da6393169321

I used a combination of two posts, I wasn't quite worried about all of the data so used the following and put it in the sensors section.

  - platform: mqtt
    name: "Home Instant Electricity"
    state_topic: "SMART/HILD/<GLOW_MAC>"
    unit_of_measurement: 'W'
    value_template: "{{ value_json['elecMtr']['0702']['04']['00']|int(base=16) }}"
    icon: 'mdi:flash'
  - platform: mqtt
    name: "Home Instant Export"
    state_topic: "SMART/HILD/<GLOW_MAC>"
    unit_of_measurement: 'W'
    value_template: "{{ value_json['elecMtr']['0702']['00']['01']|int(base=16) }}"
    icon: 'mdi:flash'
  - platform: mqtt
    name: "Home Electricity Import Meter"
    state_topic: "SMART/HILD/<GLOW_MAC>"
    last_reset_topic: "SMART/HILD/<GLOW_MAC>"
    last_reset_value_template: homeassistant.util.dt.utc_from_timestamp(0)
    unit_of_measurement: 'kWh'
    device_class: energy
    state_class: total_increasing
    value_template: "{{ value_json['elecMtr']['0702']['00']['00']|int(base=16) * value_json['elecMtr']['0702']['03']['01']|int(base=16) / value_json['elecMtr']['0702']['03']['02']|int(base=16) }}"
    icon: 'mdi:counter'

  - platform: mqtt
    name: "Home Electricity Export Meter"
    state_topic: "SMART/HILD/<GLOW_MAC>"
    last_reset_topic: "SMART/HILD/<GLOW_MAC>"
    last_reset_value_template: homeassistant.util.dt.utc_from_timestamp(0)
    unit_of_measurement: 'kWh'
    device_class: energy
    state_class: total_increasing
    icon: 'mdi:counter'
    value_template: "{{ (value_json['elecMtr']['0702']['00']['01']|int(base=16) * value_json['elecMtr']['0702']['03']['01']|int(base=16) / value_json['elecMtr']['0702']['03']['02']|int(base=16)) }}"
    
  - platform: mqtt
    name: "Home Gas Meter M3"
    state_topic: "SMART/HILD/<GLOW_MAC>"
    last_reset_topic: "SMART/HILD/<GLOW_MAC>"
    last_reset_value_template: homeassistant.util.dt.utc_from_timestamp(0)
    unit_of_measurement: m³
    value_template: "{{ value_json['gasMtr']['0702']['00']['00']|int(base=16) * value_json['gasMtr']['0702']['03']['01']|int(base=16) / value_json['gasMtr']['0702']['03']['02']|int(base=16) }}"
    icon: 'mdi:counter'
    device_class: gas
    state_class: total_increasing

(Note the Export data is currently untested until we get solar fitted).

I then reloaded the Manual MQTT enteries in Hassio, went into Configuration -> Energy then under Grid consumption clicked Add Consumption.

I was then able to select the Home Electricity Import Meter as the source, and I set it to track the price from the Octopus Go entry I configured in a previous blogpost (https://ryanteck.uk/octopus-go-hassio/)

And then I was all done and getting data in HASSIO! At the same time I configured the export function ready for when we get solar.

Pros & Cons

Now after using it for just after a day here's some of the main Pros & Cons of the Glowstick

Pros of the Glowstick

• It's quick and easy to get going, I spent much longer tweaking the clamp system where as for fairly DIY solutions go this was very Plug & Play, no calibration or anything needed.
• It does Export! If I didn't need export I likely wouldn't have brought this, but it does! As a double bonus if I can get Octopus to fit a Smart gas meter in then we'd be able to monitor gas through too which I would never say to do any DIY system on.
• It's technically more accurate, as it's what the meter is reporting there's no issues with having to get a voltage reading for a DIY clamp system either.
• The updates are very responsive, roughly HASSIO gets data updates over MQTT every 10 seconds. Where as previously I could only view smartmeter data every half hour and even the DIY Clamp system was recommended for 30-60 seconds updates.

Cons of the Glowstick

• It uses the Cloud - This is the biggest issue to a certain extent, partially the idea of HASSIO is that it's fully self hosted. And this is the first device I got which isn't fully local.
  
  You'd think that being an ESP based widget you could just get it to connect to your local MQTT server directly, while with some hacking of the widget it might be possible. I strongly suspect this is due to licensing of the smart meter network in the UK, To get it I had to verify our meter number as they're registered with the smart meter network to read data.
  
  Primarily this is why I can't just use a Zigbee bridge is because of the smart meter network licensing. So it's kinda a necessary evil.
  
• Accuracy* - Now I know I said in the previous part that it's more accurate, however one thing I've noticed is it seems the data over MQTT seems to round up to the closest 0.05kWh which just bugs me slightly. Maybe this could be fixed or is just the MQTT template I've used for Hassio is slightly wrong.
  
  In the end HASSIO reported for the full previous day we used 14.7kWh. Octopus logged 14.729. I'd be quite happy if it was just one DP more accurate in HASSIO of say 14.73.
  
• Meter Changes - If my meter has to get changed in the future, or gets upgraded to SMETS2 the stick may have to be replaced with a new one. I did query and they might be able to do a discount if this were to happen, however for now Octopus is still the best for us.

Conclusion

Overall I'm quite happy with the Glowstick after about 48 hours of use, it's doing what it says on the tin which after all is all I expect.

The price at £50 is mixed, while for essentially a posh Zigbee bridge it's a bit expensive. I suspect part of this cost goes towards the Smart Meter Communications Network licensing, with the second part being that because it goes via their cloud servers there is some cost involved to run them. The likely alternative being a cheaper stick but a monthly subscription.

But apart from that there's nothing else really to complain about, maybe if the accuracy improved slightly that was about the only issue I found.

So overall I would recommend it if you need to monitor export too, if it's just for import monitoring I'd say go the DIY route unless you can't get power to a sensor there.

Within the last couple of months the Home Automation Software I use, Home Assistant (HASSIO) has added some new Energy monitoring features which look really handy.

It had a few recommended methods for monitoring power, being:

• A data protocol on meters that seem based primarily in Netherlands, Belgium and Luxembourg. So basically useless to me being in the UK.
• A DIY solution where you put a light sensor onto the blinking LED on the meter, this LED blinks every time you use X of a unit.
• A DIY Solution of a Current Clamp on the mains cables from the meter.

I decided to go for the third option as the parts were quite easy to get hold of, plus I could use two clamps, one on the feed into the house and the other onto the feed to my EV charger.

The main issue I found with this was routing a power source for the microcontroller to the meter box, my meter is outside however luckily I had a 12V cable running to something else near the meter so ran a 12V cable into the meter cabinet.

The BOM

The BOM was quite low

You'll need:

• A CT Clamp Sensor, the most recommended is these SCT-013-000 sensors. They're less than £10 each from eBay or even less than £5 from Aliexpress if you don't mind the wait.
• A Wemos D1, you could technically use any ESP8266 but I chose one of these for ease.
• Some circuitry to connect the CT Clamp to the ESP8266, this typically is a capacitor, some resistors plus a connector for the clamp.

For the last one I found an eBay seller that was already selling boards, I originally ordered just one of the basic boards that supports one sensor and is powered by the ESP8266 at https://www.ebay.co.uk/itm/133077015640 .

However later on I then switched to the 4 channel version that has an ADC at https://www.ebay.co.uk/itm/133377327840 , this also was powered by 12V so resolved the part too.

More accurate Voltage Source

One flaw with the CT method is that you need to provide it with a voltage, some tutorials say to just manually set this, however while our mains should be 230V in the UK it can vary quite a range all the way from 240 to 247V throughout today.

I have a few sockets in my house which monitor and report the voltage to, I calibrated one that's on 24/7 as close as I could and then noted down the entity this shows up on in HASSIO.

Setting it up

Once all the parts arrived the hardware assembly was simple, just push the Wemos onto the carrier board, connected the two current clamps to the board and it was ready to go.

Next I flashed ESPHome onto it, here's the code I used. This code will work for the first CT sensor on the board which has 4 sockets and the I2C ADC, you'll have to copy and edit the code for the other 3 sockets.

esphome:
  name: house_power
  platform: ESP8266
  board: d1_mini

# Enable logging
logger:

# Enable Home Assistant API
api:

ota:
  password: "<generatedbyesphome>"

wifi:
  networks:
  - ssid: "<WIFI_SSID>"
    password: "<WIFI_PASSWORD>"

  # Enable fallback hotspot (captive portal) in case wifi connection fails
  ap:
    ssid: "House_power Fallback Hotspot"
    password: "<WIFI_FALLBACK>"

captive_portal:

i2c:
  sda: 4
  scl: 5
  scan: true
  id: bus_a
  
ads1115:
  - address: 0x48

sensor:
  - platform: homeassistant
    name: "Voltage From Home Assistant"
    entity_id: sensor.<VOLTAGE_ENTITY_HERE>
    id: home_voltage

  - platform: total_daily_energy
    name: "import_ct_total"
    power_id: import_live
    unit_of_measurement: "kWh"
    id: import_ct_total


  - platform: ct_clamp
    sensor: adc_sensor0
    name: "import_live"
    id: import_live
    update_interval: 15s
    filters:
      - calibrate_linear:
        - 0 -> 0
        - 0.01764 -> 2.479 
      - lambda: return x * id(home_voltage).state / 1000;
    unit_of_measurement: "kw"   
    

  # Example source sensor
  - platform: ads1115
    multiplexer: 'A0_GND'
    gain: 6.144
    name: "ADS1115 Channel A0-GND"
    id: adc_sensor0

time:
  - platform: sntp
    id: my_time

There's a few variables you'll need to change if you use the above which are:

• Wi-Fi SSID & Password along with Fallback Password
• A new ESPHome Key - Typically generated by it.
• The entity in HASSIO you'll use for voltage.

Finally you'll then have to calibrate the sensors using the calibrate_linear function. I did this by adjusting the value based on what my smart meter was reading.

Once this was done, I had to just approve the ESPHome integration in HASSIO and it worked!

Final Overview & Flaw

The above CT clamp method works fairly well, the hardest part was getting power to the ESP8266.

However one unfortunate thing is that the above method doesn't work to monitor exporting power to the grid, while the clamp sensors have arrows to indicate which way round they monitor. For this to work with AC power you typically require a more complicated breakout board and ideally a mains socket within reach of the breakout board.

I'll work on another solution for the whole home power monitoring, however will be keeping a clamp on the feed to my car charger and when we get solar installed soon setup another on the power generated by the solar inverter.

With the recent new Energy management feature being added to HASSIO I've started work on building some DIY sensors to use.

One of the features is for you to be able to track the cost of the energy used by providing a pricing entity, back when I was on Agile I did find a plugin for tracking that cost. But recently I was unable to find one for Octopus Go.

I then figured out a simple cheat way to do this.

Automations!

Compared to agile where we need to track a price from an API, we can mostly cheat with Octopus Go / Go Faster.

I'm still on the "Legacy" Go so at 12:30AM the electric drops to £0.05 per kWh and at 4:30AM it goes back up to £0.141 per kWh. Essentially to make it match your Go or Go Faster Tarrif you just change the start and end times below.

Step 1 - Create a "Helper"

Home Assistant allows you to create "Helper" sensors / inputs, these can then be used with automations to provide extra values. Excellent!

To do this go into Configuration, and then Helpers and then the Add Helper Button.

For the type select Number, which will present you with a screen like below. I've pre-filled it out with what I've set.

This will create a new "Helper" which is configured for pricing in GBP per kWH for Hassio. Essentially as a blank sensor.

This should then create the entity input_number.octopus_go

Step 2 - The "Start" automation.

Next we need to create the automation that will start the pricing, I've decided to do the Start as the Start of the cheap period.

Go back to Configuration, then Automations and then Add Automation.

Here click Start with an empty automation, then in the top right click the three dots icon clicking the Edit in YAML button.

Now you can copy the below in as a starter template.

alias: Octopus Go Start
description: ''
trigger:
  - platform: time
    at: '00:30:00'
condition: []
action:
  - service: input_number.set_value
    target:
      entity_id: input_number.octopus_go
    data:
      value: 0.05
mode: single

And then save!

This automation is fairly simple, and you can adjust it as required with the "at" time being your Octopus Go start time. You may need to set this to another start time of the cheap period if you're on the Go Faster plan. At the same time you may need to adjust the value if you're on a Go Faster plan to your unit rate.

Step 3 - The "End" automation.

And then we need to replicate the same for the end of the cheap period, similarly go back to automations and create a new empty automation, then in the top right click the three dots icon clicking the Edit in YAML button.

Now you can copy the below in as a starter template.

alias: Octopus Go End
description: ''
trigger:
  - platform: time
    at: '04:30:00'
condition: []
action:
  - service: input_number.set_value
    target:
      entity_id: input_number.octopus_go
    data:
      value: 0.141
mode: single

And then save!

Similarly you may need to adjust the time for a different end time if you're on Go Faster, and the value to the actual unit rate you're paying.

You can find the times along with the prices in your Octopus Account.

Step 4 - Test it!

I'd recommend you then go back into automations and manually run each one to confirm that they are configured correctly. You should then see the price on the entity (I've configured Lovelace to show the price as an entity).

As you can see where I manually set the times. Over time this should then get automated by the Automations.

Step 5 - Integration

Finally you can then integrate it with your energy source, if you go into configuration then energy. You should be able to edit a power source to set the costs to "use an entity with current price" and set the octopus_go sensor we created.

Summary

So if all the above worked correctly you should now have an entity in Hassio that provides your Octopus Go cost to then integrate into power consumptions throughout HASSIO.

I'm still testing mine so if I find over the next week any issues I'll update this post with fixes.

Recently my EV Charger has been tripping out, unfortunately meaning that a few times I've woken up to no charge.

From the best diagnosis I could do I determined it was the charger, which I did buy used so suspect it was sold due to possibly the same issue.

I looked around at chargers and decided to get the QUBEV, I did originally almost buy it instead of the used charger to begin with and this time decided to go for it.

QUBEV / EVONESTOP or ROLEC?

One thing I noticed is that on some parts of the branding was EVONESTOP, others QUBEV and others Rolec.

From what I could research Rolec are the actual company behind it, with essentially the QUBEV being the budget brand / model.

EVONESTOP is basically Rolec's direct outlet to buy the goods cheaper than via Distributors.

I ordered mine directly from EVONESTOP to save £5 over buying via Amazon or eBay. However one thing to note is if you need it quickly pay the £5 to get it via Amazon as my order placed on Sunday didn't arrive until Wednesday.

Replacing a Teathered charger with an Unteathered Charger

One of the things I had to decide was if I was fine with an Unteathered charger as I currently had a Teathered one. (Weather the cable is wired in or if it has a socket).

Originally with teathered you think it makes it easier to put away, however unless you just leave the cable hanging about un-neatly really the process is just the same.

Finally in my case I had a Type 1 teathered, however if in the future I do upgrade my car by having a socket it futureproofs it on this

The Charger Itself

The charger is rather small in comparison to my previous pod-point, it's approximately 150x200x100MM , you do have to account for the socket itself when plugged in as it does stick out in comparison to a teathered charger.

What's included is very minimal, in the package was just the charger, a short installation booklet and 4 Wallplugs and Screws for installation. You will need to buy a cable gland for installation.

The first step was to open it up by unscrewing the 4 screws in each corner., carefully opening reveals the internals.

Really there was no room to be able to work with the cables being this short, so my first step was to unscrew the cables from the socket to open it up fully.

This is one of the cheapest units on the market, and it shows. Inside we have a DIN rail with 3 connector blocks, a contactor and a EV charge controller. It really is a minimal design.

We have 5 cables going to the socket, 3 power (L, N, & E) along with 2 smaller wires which are Proximity Pilot and Control Pilot.

The Live And Neutral connect via the contactor to the mains, essentially the contactor is a electrically controlled switch which the EV Charge controller uses to connect the car to the mains. Earth is connected directly so is active all the time.

The proximity pilot on this side tells the charge controller when a cable is connected, and the control pilot is then used to communicate from the EV to the charger which state it should be in (Charging, Not charging, Waiting to charge, Fault) and from the charger to the car to indicate the maximum power allowed.

The socket surprsied me, typically in a charger the Type 2 socket has a little motorised pin lock the plug in place making it hard to remove while charging and hopefully making the cable less likely to be stolen.

However on the QUBEV this was missing which likely helps it acheive it's low cost. I'm not too worried but I wonder if it's as safe without it.

Installation

To begin I first carefully removed the cover from the charge controller (on the right) to get access to the DIP switches. The spur mine is on is only suitable for 20A so I configured it for a 16A charge rating by turning Dipswitch 2 on. (Edit, the photo below shows dipswitch 1 on, however this actually is for 10A, I had to change it to 2 after finding this out).

Next I replaced the cover and went outside, first I drilled a hole in the bottom of the unit for my cable gland, next I went outside and with the included template (a square of the packaging) drilled out the holes in the wall for the charger.

After I drilled all 4 holes and inserted the wallplugs I then screwed the unit on the wall, one thing I quite liked is how on this the screws are in their own compartment helping with water resistance.

I then inserted the cable gland and cable ready for the next step.

Next I crimped new bullet connectors onto my cable and screwed them into the 3 connectors to the left, these did feel slightly flimsy when screwing in but once completed held in well.

Finally I reconnected the socket and sealed the charger up and then turned the power back on.

It went through it's self test and shortly after the light turned Blue indicating it was ready to charge.

I then next plugged my car in and tried it out!

The light turned to Green and my car started charging, success!

Rounding it up

Overall the QubEV charger was very easy to install, I did already have all the wiring to the location and other circuitry already in place (RCBO etc) . If you don't already have this then some other solutions which have an internal RCBO and additional circuitry may be beneficial.

But as a replacement it's quite a nice charger, it's very compact and looks better on the wall than my previous one.

It's definitely built down to a price, it very much seems like an off the shelf IP rated box with a din rail and the bits added in. There wasn't even a knockout for the cable gland and I feel that either a pre-drilled hole or at least an easy knock out would have been better. While some may want them to come in from other angles with this I feel that the only suitable location was from the bottom.

However for £225 it's hard to not recommend if you need a cheap and cheerful EV charger.

A simple project that I whipped up, What Helium Region (https://whatheliumregion.xyz) is a website I built to help people find what is the correct Region of Hotspot to order for the Helium LoRa Network.

You can simply enter the country you wish to use the hotspot in and it will provide you with the correct* region making it simple to know which one you need to order.

Primarily with LoRa networks there is a mixture of Hardware Frequencies (433, 470, 868 & 915 Mhz) along with Region Plans (EU868, US915, AU915, IN865 etc etc) making it sometimes confusing to know which is correct to order.

The site is designed to be as simple and minimal as it can be to handle high numbers of users while only being ran off a budget VPS.

Primarily it's a static webpage with a little bit of backend PHP scripting and use of javascript libraries to enhance the experience. It uses a Javascript library to autocomplete a country field and then submits a GET request. Of which PHP looks up in the JSON configuration file the correct region for the country and presents it to the user.
To enhance the experience the site also automatically detects the country based on IP Geolocation, typically making the country shown on initial page view the correct one for the user.

The site gets on average 400 visits a day according to Google Analytics.

* The region is provided from a configuration file in the Helium Miner, this does update over time and may mean some regions get updated to a different one.

Company: Nebra LTD.
Tasks: Electrical Design, PCB Design, Embedded Software Development, Python Software Development, Production Management, Quality Control, Hand Assembly of Prototypes, Certification Management, Documentation & Testing.
Date: First produced January 2021
Status: In Production
FInd out more at: https://helium.nebra.com/indoor-hotspot/overview

Overview

The Nebra Indoor Helium Hotspot, designed as a more user friendly variant of the Nebra Hotspot Range.

One of the biggest projects I've worked on at time of writing, the Nebra Indoor Hotspot is designed for use with the Helium Network and rewards people in HNT for providing LoRaWAN coverage on the Helium Network.

Hardware

The hardware is a more simplified design than the outdoor unit to optimise it more for mass production along with being in a more compact form factor.

Designed to use the Compute Module 3 Daughterboard, the motherboard contains circuitry to regulate the 12v down into the respective voltage rails for main components, a USB hub and headers to provide spaces for Bluetooth & Wi-Fi adaptors and built in networking with finally space for the LoRa Radio Module.

The Indoor Hotspot comes as a completed product which has also undergone CE & FCC certification and is designed to be plug and play.

Software

The software has been a significant part of making this project what it is.

As the main software developer for this project I was responsible for getting all the required software for the unit to operate as intended, along with writing creating our own software to improve user experience.

To provide OTA updates we decided to use Balena & Balena OS as our base, this provided us with a stable and reliable base for our software to run on top and ensures we have a robust system to keep the units in the wild up to date.

The software is then comprised of multiple docker containers running the software responsible to get the unit to work including:

• Configuration Tool - Communicates over BTLE to the Helium App that allows users to setup their hotspots with ease. This was a full re-implementation to add in our own customisation and make it compatible with the Linux Network Manager.
• Diagnostics Tool - Provides a basic webpage that users can access on their local network to ensure the hotspot is operating as intended.
• Packet Forwarder - Configures on boot, then runs the software required to operate the radio module.

The unit also runs a tool to configure port forwarding on boot using UPNP, a tool that runs on first setup to program chips during production.

Finally it runs the Helium Miner itself, this is provided to us as a ready made container by Helium and has some tweaks to help speed up initial setup.

All of the docker containers and software are open source, and can be found at https://github.com/nebraltd/helium-miner-software

Production

For this product I was also responsible for organising some crucial production stages.

Being a fully finished product, I created step by step assembly guides for the assembly partners to use. Rigs used to test and store to a database crucial information such as serial numbers with finally automating printing labels for each unit with their respective serial numbers, model numbers and certification logos for the regions the hardware variation would be sold in.

Company: Nebra LTD.
Tasks: Electrical Design, PCB Design,  Hand Assembly of Prototypes, Documentation & Testing.
Date: First produced December 2020
Status: In Development
FInd out more at: https://github.com/NebraLtd/FlashStick/tree/main/Raspberry Pi Compute Module 3

Overview

To make flashing the software onto Raspberry Pi Compute modules easier, I was tasked with making a minimal adaptor to be able to use to program modules quicker by being able to plug them into a Computer or flashing device with ease.

A rather simple design, this project was designed and sent for prototyping within 48 hours It has minimal circuitry but has the same reliable power circuit recommended for the Compute Module 3.

This design was open sourced making it free for all to see, modify and maufacturer.

In this tutorial we'll connect up the SnowPi RGB to the micro:bit and getting it to light up.

Hardware Assembly

First we need to connect the SnowPi RGB to the micro:bit using the included micro:bit adaptor.

In your package you should have one SnowPi RGB board, micro:bit adaptor, and 3-5 M3 Screws & Nuts

If you have 5 screws then you can screw all 5 through, if you have less then only the 3 most right are required. On the micro:bit V2 you may only be able to use the 3 as shown due to new components possibly causing it to not align up.

The easiest way to do this is to put one screw through one of the micro:bit's holes first, we'll start with the ground. then underneath place the adaptor board and loosely tighten up with one of the nuts.
Ideally just enough so it stays together but can still slightly wiggle, repeat with the remaining screws. Then tighten up with a screwdriver to ensure good contact.

Next place your SnowPi RGB into the adaptor and connect a Micro USB cable into the micro:bit.

Programming

Start by visiting https://makecode.microbit.org and then click on new project, type in a name for your project such as SnowPi Demo and then it should bring you to the programming area.

Next in the top right of the screen click the cog icon next to the microsoft logo , and then extenstions.

Now we want to click neopixel and this will import the library.

To access this library we'll select the tab on the left hand side.

Now we're ready to program!

First click the neopixel library icon, and then drag in the "set strip to Neopixel" block into the On start section.
Next we have two items we want to change here, first change the drop down which says P0 to P2 and then change the number 24 to 12. By doing this we set the correct GPIO pin for the SnowPi adaptor and configure it to 12 LEDs which is the amount the SnowPi Has.

Next we need to change the maximum brightness of the LEDs, without doing this the LEDs may be a bit too bright and also cause issues with the micro:bit's limited power supply.

To do this click the neopixel library again, then more and drag in the "strip set brightness" block to be directly underneath the on start block and change the value of 255 to 32. Your code should now look like this.

Finally we're ready to start making the rainbow pattern, begin by dragging into the on start block the "strip show rainbow" block. This will set it so the SnowPi displays a rainbow across it.

If you click the download button and save the hex file to your micro:bit you should see it light up!

Now, we want to animate it so the rainbow "rotates" around the board, or put simply so that the LEDs change their colour in sequence.

To do this click the neopixel library again and drag in the "strip rotate pixels by" block into the forever block, next we need to add in from the same library the "strip show" block directly underneath. This means now it'll swap the colours around once per loop and then show the result.

Finally we want to add in a short delay between each loop, to do this click the basic library and drag in the "pause (ms)" block underneath the show block, this can be left at the 100ms delay.

And that's it! Your code should now look like this.

ryanteck.uk/ghost/#/editor/post/62cade4b52228e040b97eb14

Click download and copy it over to your microbit, it should update the code and you'll have your snowman blinking away with rainbow goodness!

In this tutorial we'll connect up the SnowPi RGB to the Raspberry Pi and getting it to light up.

All models of Raspberry Pi should work fine, in this tutorial I'll be using a Model 3 A+ Myself.

The Raspberry Pi needs to be connected to the internet to be able to download all the software too.

Hardware Assembly

First we need to connect the SnowPi RGB to the Raspberry Pi, to do this is simple as:

Ensure the Raspberry Pi is unplugged, and then simply connect it to the first 6 Pins in the top right of the header closest to the Micro SD card slot.

Pre Preparation

This tutorial will assume that you've already got your Raspberry Pi setup and ready to use, including being connected to the internet already. A getting started with Raspberry Pi guide can be found at https://projects.raspberrypi.org/en/projects/raspberry-pi-setting-up

While shown in this tutorial we're using the GUI, for the entire tutorial we'll be using the Terminal so if you prefer to use SSH you can do so for this tutorial.

Installing the Python Library

To begin open the terminal by clicking the icon with the >_ characters in it, your screen should then look like this.

Then to ensure all software is updated type sudo apt update && sudo apt upgrade and press enter, if prompted press enter to continue to update. If you've recently updated nothing may happen.

Only if you're using the "Lite" version of Raspberry Pi OS then run sudo apt install python3-pip to install Python 3 Pip which is the tool we use to install the library.

The SnowPi RGB uses the rpi_ws281x library which is available at https://github.com/rpi-ws281x/rpi-ws281x-python , in the below tutorial we install this and the demo program is based on this library.

Next we can install the library with sudo pip3 install rpi_ws281x.

Finally we can download our demo programs, to do this type:

git clone https://github.com/ryanteck/snowpirgb-python.git

Then navigate into the folder by typing cd snowpirgb-python and then we're ready to run the demo program.

Finally type in sudo python3 demo.py -a  and your SnowPi RGB should start blinking!