Rob's Tech Blog

Adding Automation to the blog

2023-02-23T00:00:00+08:00

This blog is a static site, meaning that there are no cookies or server-side processing performed to display the content.

I chose to use Pelican for site generation since it is developed with python which I'm most comfortable with. Up until now, I've written the content, process the pages into HTML files and after reviewing the new content uploaded it manually to the web server. This has been fine for a long time however I've made the odd mistake during generation which caused a broken web page for a short period while I fix it.

I recently decided that I should treat the process a little more seriously as it is good practice to follow industry standards when doing personal projects as long as the effort doesn't outweigh the benefit.

The issue

Writing content for the blog is pretty easy however the publishing process isn't as straightforward as I would prefer.

Order of operation:

Write a markdown document in the website project folder.
Preview the new page using pelican built-in web server to check the page looks ok.
Make edits if needed.
When I'm happy with the page, I run the command to generate the page for publishing.
manually upload the html files to the web server.
double-check that the site is loading fine.
commit the changes to my private git repo.

These steps are very easy, to be honest, steps 4-7 probably take five minutes to do.

Repetitive tasks no matter how easy, over time get skipped or forgotten by people.

It kind of reminds me of this footpath design. I'm sure you've seen this in your city/neighbourhood before.

The solution

Automation!!

Why not use automation to minimize the number of manual steps required to create content?

I've taken advantage of the DevOps tools that are built into AWS and are free (if you adhere to the free tier rules.).

I started out by fixing my git hygiene.

A branch for production and a branch for development are all that's needed at the moment since I'm the only one writing content.

Instead of the commits happening at the end of the process, it now needs to happen earlier on in the content writing process. lots of smaller changes are better than one big one at the end.

While writing the content and reviewing the page locally, there may not need to be a whole lot of commits but it does depend on how much is being changed.

Using AWS CodeBuild to generate the pages

Codebuild is a service offered by AWS that takes a list of instructions in the form of a 'buildspec' file, collects all the relevant artifacts and can then build your software automatically.

I started creating a Codebuild project to get pelican to generate the pages, however, while testing the process I got pretty impatient while waiting for codebuild to initialize a worker.

Luckily AWS provides CodeBuild images that can be run locally on docker.

I downloaded the dockerfile for the image I wanted to use and started the process to build the docker image. This took a long time since Australia still has terrible internet... 😠

After the docker image was built, I was able to test the build process on my machine very quickly to ensure that the correct version of pelican was used and a few other checks were performed on the data before the content was generated. Here's a simplified version of the 'buildspec.yml' file I was using while testing the process.

version: 0.2

phases:
  install:
    runtime-versions:
      python: 3.10
    commands:
      - pip3 install "pelican[markdown]" ## downloads pelican onto the codebuild worker.
  build:
    commands:
      - echo Build started on `date`
      - pelican html ## Generates html files

  post_build:
    commands:
      - echo Build completed on `date`

Buildspec files are used to instruct the codebuild worker what files and tools are required to put together the code written and build the software.

I then added a few more steps to the buildspec file to check for errors, detect syntax issues then upload the files to the web server.

Setting up CodePipeline

CodePipeline is another service provided by AWS that joins together all the stages of a build process: repository > build > deploy.

CodePipeline allows for each stage to be automated to the point where after a developer writes the code, the rest of the stages don't require human involvement. Makes things significantly faster with less room for mistakes.

I implemented the pipeline to watch for changes in the source repository, generate the files and deploy it to a staging web server.

Once the staging site is online, I've implemented a few tests to check if the page is rendering correctly. if staging looks good, a pull request is generated for me to manually review. once approved the changes are deployed to production.

The code pipeline looks like this (some parts redacted or hidden):

Since this blog is a static site, a deployment stage is not necessary. when a build is successful, the files are sent to the web server.

The new order of operation:

Write content.
Review the page locally.
Make edits if needed.
commit changes to the development branch.
codepipeline triggers a build of the development version of the site and publishes it to the staging version of the blog. (Automated)
Review to ensure the blog is working as expected. (Automated check)
create a pull request to merge development to the production branch. (Automated)
Codepipeline triggers a build to production and publishes the site to https://blog.s3nt.net. (Automated)

As seen above, steps 5-8 are fully automated now (with the exception of approving the pull request)

Roll back procedure

Rollbacks are just as easy. Changes are tested in staging before going to production.

if there was a problem with the site and I miss it during the review, I can roll back to the last good production release.

Rollback is using CodePipeline and therefore fully automated.

Relay Controller Project

2023-01-06T00:00:00+08:00

I've been running the Solar system for a few years now without much trouble. Over time the battery capacity has slowly decreased to the point where the system gets dangerously low voltage overnight. The batteries I've been using are second-hand sealed "standby batteries" which were never designed to handle constant use and they already had been used for a few years before I bought them.

I've been connecting up a 24V battery charger on an ad-hoc basis over winter and sometimes have had to go turn it on before bed if I could see that the system wouldn't last the night.

I've only been using the system to charge power tools and run a deep freezer (surprisingly low power usage!). Due to the freezer turning on more when the weather heats up, i've found that the batteries just cant handle it any more.

I intend on replacing this ageing battery bank with a new-ish lithium bank that is correctly sized, however even second-hand cells are a little bit out of my budget for something that is pretty much just a hobby system. So in the meantime, I have a solution....

Relay controller

I like the whole IOT-controlled power outlets but I dislike the reliance on the internet/cloud servers due to security and reliability issues. I decided to create my own solution to this problem.

The features that I consider important for designing a home automation/IOT power control:

wired connectivity
- The device must have a wired connection for communications. It can have a wireless control component but it cannot solely rely on wireless.
Manual Over-ride
- The device must have a manual override, where you can turn on the outlet via a switch in the case where the internet/network isn't working or the "bus factor" occurs and someone else needs to turn on the device.
simple function
- The device can be self-contained with some automation such as simple timers or similar. ideally, i want the device to only do what is expected of it and the smart stuff is moved onto a computer for better flexibility around the choice of software.

Designing the relay controller.

The relay controller will be based on an Arduino nano.

I've settled on using off-the-shelf hobby components with a little bit of a challenge to minimize the number of pins used on the Arduino.

Relay board:

I picked up one of these hobbyist boards online. This board takes 1 pin for each relay. since the Nano has limited pins I don't want to waste valuable I/O on turning on and off a relay.

The relays are powered by 12VDC and the MOSFETs require 5V signals. I'll use a 24V to 12V regulator for the relays and for 5V signalling I'll use the 5V supply from the Arduino.

My solution to minimize pin usage is to use a shift register IC to power the relay pins. I've never used a shift register before but I'll figure it out.

Schematic

I did some googling, read some data sheets and watched some youtube about shift registers, they seem simple enough so I made a schematic of the circuit I want to make.

The shift register I decided to use was a 74HC595N 8bit tri-state CMOS IC which is a Serial-in/Parallel-out type.

In the above schematic, I've included 9 toggle switches. 8 switches for relays and 1 for 'manual-override' mode. in normal operation, the Arduino would be controlling the shift register. The Arduino would then take its commands via USB(Serial) connected to my raspberry pi.

Building the relay controller.

I've still not figured out how to create a PCB Mask and etch my own PCBs so it's protoboard again...

I, unfortunately, didn't get any good photos of the protoboard while I was making it.

For those with protoboard experience, I'm sure you can imagine what the solder tracks look like 😂.

I ended up damaging a few shift registers during the breadboarding process, I accidentally gave them 12V instead of their max input of 5V. 🤦‍♂️

It took me a while to figure out that I had damaged the IC since it would work if I manually shifted the bits in using push buttons to simulate the Arduino. But when I used the Arduino, the IC appeared completely dead.

implementing the relay controller

My plan is to use the solar analytics data that I've been collecting with my Raspberry Pi to determine when to turn on the battery charger while continuing to utilise solar power for the majority of the charging.

some Pseudo code that would run on the Raspberry Pi:

If PV_Voltage < 45.00 AND Battery_Voltage < 23.50 
{
    Batt_charger = Enabled
}
Else
{
    Batt_charger = Disabled
}

This IF statement should only turn on the battery charger when the battery bank is Low and when the solar panels are not generating reasonable power. I'm expecting that this should cover most situations. Summer/Winter, Cloudy Days, solar panel fault, etc..

This doesn't account for the increased load from devices, though. I'll need to keep in mind what loads are being left on overnight and ensure I'm not exceeding the battery chargers rated current.

The 7 other relays are not in use yet, but I intend on adding more devices that can be programmed to utilise as much of the excess solar power as possible.

For example, I could use the relay controller to heat water during the day when there's excess power and then use it to provide hot water to the house.

it works!!

I implemented the first version of the scripts and the difference is pretty obvious.

Here's a graph of the battery voltage overnight, with no charger*:

The voltage gets to 22V and as low as 20V just before sunrise. This is way too low for lead-acid batteries and I'm sure this has done some damage.

Here's the graph after I added the relay controller*:

While the voltage does still dip to 23V (still not good) it now doesn't drop to < 22V overnight. I'll need to make some adjustments to allow the charger to turn on earlier to maintain a better voltage.

The small dip and spike between 0500hrs and 0600hrs is the solar panel voltage going over the threshold to keep the charger turned on. Some trees block the solar panels in the morning which would explain why the charger turns off and then back on a short time later.

Some Notes.

*Keep in mind that all battery measurements on this page are measured under load which is not the right way to measure battery State of Charge. I should be doing quarterly capacity tests to get a better idea of the health of these batteries.
The batteries were tested at 80% healthy when I bought them and that was a few years ago. These batteries don't have much life left, I'm just kicking the can down the road for a bit until lithium batteries/cells get a little cheaper which at this rate could be 6 months from now.
The other benefit to using the relay controller over just connecting the battery charger full-time or on a timer is that this solution doesn't need adjustment when the seasons change. Because the charger isn't staying on full-time, the solar panels are doing the majority of the charging and the charger is acting as a safety buffer.
I'm intending on publishing the code used on my personal Github in the future. I'll update this post with links when I do that.

Quadbike Project (Part 07)

2022-10-06T00:00:00+08:00

Links to other parts:

Getting off the breadboard

Now that i've tested the throttle and steering circuits/code, i need to get this stuff into an enclosure.

Motor Controllers

For the enclosure, i've decided to use two cast-aluminum boxes instead of one. My thoughts were that the motor speed controllers may emit a fair amount of EMF, so separating them would be a good idea.

I'm using two motor speed controllers, one for steering control and the other for the brake motor.

The motor controllers fit quite well in the enclosure however the terminals were the wrong way around.

I was able to de-solder and reverse the terminal pins to allow for the wires to fit in the box. These green terminals were reversed to point the other way.

It was a tight fit getting both motor controllers inside the case.

I de-soldered the header pins and soldered the wires directly to the board. i used a combination of Hot glue, dielectric tape and Sikaflex to help prevent anything from moving around.

For cable choice i used 7-core trailer wire for the high-power side and for the signalling wires i used one of those USB-C cables used to connect a laptop to a laptop dock.

Turns out that USB-C cables are a great source of thin but strong cable that is heavily shielded and has plenty of cores (close to 20-cores if i recall).

Arduino and the rest.

I added the throttle circuit components to a breadboard. The board is also hosting "interconnects" that sit between the arduino and the wiring harness.

I've never been able to create a breadboard circuit without it becoming spaghetti. i hope to replace this with a custom printed PCB in the future.

The Arduino was added to another breadboard with all the wires connected. Thankfully the USB-C cable has color coded shielding.

The arduino, throttle breadboard, RC receiver and power regulator were all crammed into the enclosure.

Just like the motor controller enclosure, i used a combo of Sikaflex, Hot glue and high-strength double-sided table to hold everything in place.

I tested everything after installing in the enclosure and it looks good!!

Part 8 Coming soon....

Quadbike Project (Part 06)

2022-08-12T00:00:00+08:00

Links to other parts:

RC Control

As mentioned in part 5, i've purchased a Turnigy GT6 Surface radio. This radio (along with other Hobby RC units) outputs a pulsed signal to control the servos. I cant directly connect the RC receiver to the motors, i need to interpret the signals then drive the steering, brake, throttle on the bike.

I decided to use an Arduino Nano v3 for this task. It will be used as a translator between the RC receiver and the motors on the quad bike.

A high level diagram:

The intention is feed the RC receiver into the arduino, the arduino interprets the pulses and then reacts accordingly. i'm using the 'BTS7960 High power motor driver modules' to control the motors and 10K potentiometers for position feedback.

Getting Steering working

To start off, i've used some code that others have used to interpret RC signals.

There are two main methods of processing these signals on the arduino, PulseIn() function or assigning interrupts for the pins coming from the RC receiver.

PulseIn: is a simple enough function to use, however it is a blocking function. Meaning that while the PulseIn function is running, nothing else can be performed.
Interrupts: this is a far more complicated function however it allows for the arduino to be doing something else and when an interrupt gets triggered, the arduino will quickly process the signal and get back to what it was doing.

when i found that the PulseIn function was blocking, i started imagining the scenario where the bike is driving down the road and it gets stuck processing a signal causing the bike to crash into some bushes or something. I've settled on the Interrupt method as i believe it will be safer.

I wired up the steering motor, controller and RC receiver on my desk and using some basic "move a motor with an RC controller" code i found online.

Here's a short clip of the motor being used with positional feedback:

Your browser does not support the video tag.

I'm using a 10K potentiometer (under the black square) with some scrap wire to link the motor and the pot.

I'm now confident that the steering is sorted out. i still need to mount it and make permanent wiring.

Throttle control

Throttle control is a tricky problem. i can see two different methods in getting this working:

install an R/C servo inside the throttle box to control the throttle sensor.

Pros: simple solution, R/C servo is cheap and easy to source.

Cons: servo would be an interference mechanism, meaning that in some cases the servo may hold the throttle open or prevent the thumb throttle from moving.
bypass the throttle box all together by re-generating the throttle signal.

Pros: non-interference solution since the throttle box is bypassed. A challenge.

cons: more complex, custom circuitry required, i have no experience with this method.

After some more research, i believe option two should be tried first and one can be the fallback.

Generating the throttle signal

I've tested the throttle box hall-effect sensor with my multimeter.

the sensor is generating a linear voltage range that is in relation to the distance from the magnets.

neutral: 3.5V

full throttle: 0.7V

I cant generate a voltage with an arduino, i can only generate a PWM signal. additional circuitry is needed.

My idea for this circuit is that the PWM signal from the arduino can be used to generate an analog signal by charging and discharging a capacitor.

I've created a test circuit on Tinkercad which i feel will do the job.

Your browser does not support the video tag.

The waveform in the above video is not very smooth, it's more of a sawtooth. I don't think this will be an issue as the bike's speed controller is also a digital device.

The speed controller will be sampling the throttle sensor at a set frequency, i just need to tune my circuit to be smooth enough to trick the motor speed controller.

Schematic of the throttle signal circuit:

*msft01 is going to the arduino. I added a 500R multi-turn potentiometer to fine tune the output voltage.

Testing the throttle on the bike

I replicated the Tinkercad circuit onto a breadboard and took it into the workshop.

I used the R/C transmitter to control the PWM duty-cycle.

Here's a video of the throttle test.

Your browser does not support the video tag.

Note the vibrations at full RPM, there's not much i can do about it. This bike is quite poorly built from the factory and those tyres need replacing...

Part 7 Here

Quadbike Project (Part 05)

2022-07-01T00:00:00+08:00

Links to other parts:

Gameplan

As part of the quadbike rebuild project, i want to be able to drive the quad remotely like a R/C car.

There's quite a few things wrong with the design of this bike. it definitely is a cheaply made quadbike, the quality control is terrible.

My plan is to go over the entire bike and re-fabricate sections that would be used for radio control gear, such as servos and sensors. Along with fixing bad design decisions when it was made.

There isn't much room anywhere on this bike. its going to be a challenge to find space to put all of this equipment.

Radio control

For radio control, i've purchased an off the shelf surface radio and receiver.

i'll have enough challenges in this project as it is, i don't need to be troubleshooting radio issues as well.

i've purchased a Turnigy GT6 Surface radio, which has plenty of functionality for what i need.

It has 6 channels along with drifting control and ABS (i'll probably never use this but its cool anyway).

Since this isn't a 1/8th scale RC car, i wont be able to use normal Servos to control this bike, its going to be a custom made solution for this bike.

The intention is to use a Arduino Nano to interpret the R/C receiver's signals, then control the motors.

Steering Control

I'm going down the tried and tested method of using a windscreen wiper motor to steer the bike.

Note: example motor

The benefit of these motors is that they are mated with a gearbox by default along with a powerful motor.

The front of the bike has a little bull-bar, i've found that even with a compact windscreen wiper motor, i can't fit a steering mechanism in.

i've fabricated a new bullbar to allow for the steering mechanism to fit while still allowing the original mudguards/fairings to be used.

The red box is the original chassis that i've cut off. i'm replacing with square box section. in the image, the other side has already had the box section installed.

Test mounting the steering motor

First attempt at a steering linkage seems to work.

Your browser does not support the video tag.

Demo video of the motor steering the bike.

Brake Components

Since this bike has been around for a while, i was hoping there might be spares available to replace the brake components.

The brake line had a small leak, so i had to at least replace that.

I visited a quadbike business that sold chinese quadbikes for kids, they told me "you'll never find spares for these bikes anywhere".

I was able to convince the worker to check their parts bin just in case they had a spare brake line that would suit. 5 mins later they walked back holding the brake caliper, brake pads and a brake line.

The new parts were an exact replacement and fitted the bike fine.

Suspension Bushes

The design of this bike has 3 suspension bushes. The pivot point at the middle of the bike and the 2 bushes for the shock absorber.

I had previously tried to make replacement bushes using Sikaflex. This solution worked well however it wouldn't work for the middle pivot point since the bushing was at least 100MM long.

I had some Nolathane bushes that were originally purchased for my car but i had ordered the wrong ones and they didn't fit.

These bushes fit the pivot point after a little bit of trimming. I ended up replacing the diy Sikaflex bush with a Nolathane one as well.

Wheel bearing replacement

I was expecting this bike to not even have replaceable wheel bearings after my challenges with the brake components. Luckily, the bearings were standard size.

I replaced the two for the rear driveshaft and four for the front wheels.

This is the used bearing. When i replaced them, i found that i probably didn't need to as they don't seem very worn.

Next Steps

Part 6 focuses on the electrical/programming sections of this project.

Part 6 Here

Quadbike Project (Part 04)

2022-06-01T00:00:00+08:00

Links to other parts:

New Battery Upgrade

After killing the batteries previously, the bike has just been sitting around.

I finally decided to purchase a replacement battery bank. Since there are significant performance issues with lead-acid batteries (weight, power characteristics) i purchased a Lithium-Ion battery pack.

I purchased a 48V 15AH lithium pack for bikes.

The pack came with a charger too.

Since the pack doesn't offer any impact protection i knew i had to protect it somehow.

I decided to use an ex-military ammunition box. i found that the 30 cal box was the perfect size for this battery.

The added benefit of using the ammo box is that if the battery went into thermal runaway, the box should keep most of the fire inside.

Foam pad was added to the box to help with shock absorption and to prevent movement.

The battery fit quite snugly.

A hole was drilled in the lid to allow for the power cables.

completed battery enclosure

Angle steel tabs were added to allow for the new battery to slide in. elastic Strap holds the battery in place.

The result was an immediate performance improvement with low-speed torque and overall the bike is a lot nicer to ride.

Bike upgrades

The bike is running great, but now i want it to do more!

Quadbike rebuild project:

re-fabricate motor mount.
replace worn brake components.
upgrade suspension bushes.
replace worn wheel bearings.
re-paint bike frame.
repair fairings and repaint.
add remote control functionality
autonomous/semi-autonomous driving

Part 5 Here

Adventures of Custom Solar Monitoring

2021-10-28T00:00:00+08:00

I've been toying with small solar systems for 15 years or so.

My largest system so far:

800W of free solar panels
1KW MPPT Solar charger
400AH (used) standby batteries
2.5KVA Pure-Sine Inverter

I wanted to monitor my solar controller for solar predictions and load graphing.

I purchased a Epever Tracer3210AN, which is a fantastic solar controller for price and functionality.

I purchased a combo from an eBay seller that included the 'Epever eBox-WIFI-01' WiFi unit. when i set all of this up and used the android app it worked great, however i wanted to capture this data and store it in influxDB with Grafana. i couldn't see an easy way to poll the WiFi module for the data.

further digging around using wireshark to man-in-the-middle the communications between the app and eBox i found that it wasn't using a "web-friendly" protocol like XML or JSON. the communications were instead MODBUS over TCP (later finding that it's actually MODBUS RTU over TCP).

a quick internet search i found that most people just connect the cable directly to their computer instead of messing about with the eBox. i have no idea about modbus other than it is a reliable protocol used in industrial applications heavily.

i ended up putting eBox on the shelf and buying a Epever RS485 to USB cable.

i connected it up to my raspberry pi, slapped together some code to poll the solar controller based off https://github.com/alexnathanson/EPSolar_Tracer repo.

This all worked great for about a year. I then hit the power limitations of running the solar system in a 12v configuration (390W@12V vs 780W@24v), so i purchased more batteries and changed the system to 24V.

When it all went wrong

I had just finished the wiring to upgrade to 24V and the batteries were charging fine.

i was running the Raspberry Pi off the batteries as well, tapping off one of the banks so i could still get 12v then feeding this through a car USB adaptor to get 5V for the Pi. i checked the voltages and 5v was coming into the Pi and it booted fine. I then plugged in the USB cable for the Epever comms, suddenly i heard a *pop* and could smell burning electronics. The pi was dead.

i couldn't figure out what was different (other than the obvious 12 -> 24V change). i had checked multiple times and the Pi power supply was still providing 5V.

i tried another pi after confirming the voltages and again *pop* magic smoke from the pi and this time the controller also put out a bit of smoke (controller still worked the comm port was smelly though??). i put down this project for a bit while i think about what had happened.

i eventually figured out that the comm port ground was grounded to the 24v ground and it must have been feeding the 24v ground into the raspberry pi via the USB port, killing the pi(s) almost instantly.

since i had broken the solar controller's Comm Port now as well, i reluctantly purchased another solar controller. i Purchased the Epever TriRon 4210N. Which is the newer model than the 3210AN.

This time i wasn't going to make the same mistake, i had to protect the comm port while also interfacing it with the raspberry pi. i looked into building a USB cable with opto-isolators but this was going to be a bigger task so i returned back to the eBox WiFi again.

i plugged in the WiFi module and opened the app, all worked good. Now i needed to somehow extract the data from the eBox and get it into the (new) raspberry pi.

So i opened up wireshark, got the Windows Epever software going using a 'virtual com port'. Reading the captured packets just confused me even with the wireshark "Decode As..." set to modbus.

More googling and i found that the python library 'pymodbus' also supported TCP mode. So i updated my code to use the ''ModbusTcpClient". no luck, i enabled debugging and no matter what i tried i couldn't get the eBox to send data at all or if it did it was invalid.

DEBUG:pymodbus.client.sync:Connection to Modbus server established. Socket ('11.11.11.3', 46349)
DEBUG:pymodbus.transaction:Current transaction state - IDLE
DEBUG:pymodbus.transaction:Running transaction 1
DEBUG:pymodbus.transaction:SEND: 0x0 0x1 0x0 0x0 0x0 0x6 0x1 0x4 0x32 0x0 0x0 0x3
DEBUG:pymodbus.client.sync:New Transaction state 'SENDING'
DEBUG:pymodbus.transaction:Changing transaction state from 'SENDING' to 'WAITING FOR REPLY'
DEBUG:pymodbus.transaction:Transaction failed. (Modbus Error: [Invalid Message] No response received, expected at least 8 bytes (0 received)) 
DEBUG:pymodbus.framer.socket_framer:Processing: 
DEBUG:pymodbus.transaction:Getting transaction 1
DEBUG:pymodbus.transaction:Changing transaction state from 'PROCESSING REPLY' to 'TRANSACTION_COMPLETE'
Modbus Error: [Input/Output] Modbus Error: [Invalid Message] No response received, expected at least 8 bytes (0 received)

Above example of the errors i was getting.

I found this Stack Overflow post where OP was seeing a similar issue.

In here i spotted that OP was using a ModBus Framer. Not sure exactly what it does but i suspect it filters out the TCP/IP stuff before it's used by the client object.

I made 2 changes to my script and retried, this time it worked!!!

Here's what my script looked like before the Framer changes:

#!/usr/bin/python3

from pymodbus.client.sync import ModbusTcpClient as ModbusClient

client = ModbusClient('11.11.11.254' ,port=8088,timeout=5)
client.connect()

result = client.read_input_registers(0x3100,16,unit=1)

solarVoltage = float(result.registers[0] / 100.0)
solarCurrent = float(result.registers[1] / 100.0)
solarPowerL = float(result.registers[2] / 100.0)
solarPowerH = float(result.registers[3] / 100.0)
batteryVoltage = float(result.registers[4] / 100.0)
chargeCurrent = float(result.registers[5] / 100.0)
chargePowerL = float(result.registers[6] / 100.0)
chargePowerH = float(result.registers[7] / 100.0)
loadVoltage = float(result.registers[8] / 100.0)
loadCurrent= float(result.registers[9] / 100.0)
loadPower= float(result.registers[10] / 100.0)
batteryPercentage = float(result.registers[0] / 100.0)

# Do something with the data

print("PV Voltage: " + str(solarVoltage))
print("PV Current" + str(solarCurrent))
print("Battery Voltage: " + str(batteryVoltage))
print("Charge Current: " + str(chargeCurrent))
print("Load Current" + str(loadCurrent))
print("Load Power: " + str(loadPower))

client.close()

And after the addition of the Framer:

#!/usr/bin/python3

from pymodbus.client.sync import ModbusTcpClient as ModbusClient
from pymodbus.transaction import ModbusRtuFramer as ModbusFramer

client = ModbusClient('11.11.11.254' ,port=8088,timeout=5, framer=ModbusFramer)
client.connect()

result = client.read_input_registers(0x3100,16,unit=1)

solarVoltage = float(result.registers[0] / 100.0)
solarCurrent = float(result.registers[1] / 100.0)
solarPowerL = float(result.registers[2] / 100.0)
solarPowerH = float(result.registers[3] / 100.0)
batteryVoltage = float(result.registers[4] / 100.0)
chargeCurrent = float(result.registers[5] / 100.0)
chargePowerL = float(result.registers[6] / 100.0)
chargePowerH = float(result.registers[7] / 100.0)
loadVoltage = float(result.registers[8] / 100.0)
loadCurrent= float(result.registers[9] / 100.0)
loadPower= float(result.registers[10] / 100.0)
batteryPercentage = float(result.registers[0] / 100.0)

# Do something with the data

print("PV Voltage: " + str(solarVoltage))
print("PV Current" + str(solarCurrent))
print("Battery Voltage: " + str(batteryVoltage))
print("Charge Current: " + str(chargeCurrent))
print("Load Current" + str(loadCurrent))
print("Load Power: " + str(loadPower))

client.close()

Adding the Framer to the ModbusClient was what fixed it for me.

here's the output:

PV Voltage: 77.95
PV Current: 1.05
Battery Voltage: 27.52
Charge Current: 2.98
Load Current: 0.16
Load Power: 0.0

The solar data is now being sent to my local InfluxDB and Grafana instance.

In Summary

I recommend using the USB cable to poll the controller in most cases. If you're doing something like me where you're trying to get 12V from a 24V battery bank, either purchase the proper "24 to 12 converter" or make sure the 12V devices do not electrically interact with any 24V devices or you may kill the 12V device.

Running a 12V fridge directly off the 12V side of the 24V bank would be fine, if the fridge then connects to another device like a 24V powered fridge controller or something is where the danger arises.
Be aware that tapping 12V from one side of the 24V bank is going to cause an imbalance and probably shorten the life of the batteries. In my case, these are used batteries, so i don't care too much.

Quadbike Project (Part 03)

2021-02-07T00:00:00+08:00

Links to other parts:

How does it drive?

I've been riding the quadbike around for around 6 months now. Just cruising around.

it runs pretty good, it can get uncomfortably fast on the straight.

At top speed (>50KM/h) the steering gets very unstable and the death wobbles start. I've rolled it a few times, thankfully its a small bike so only a few scratches.

I've found that the low speed torque is non-existent, the bike can't really climb hills without getting a run up. i've looked around and cant seem to find an easy way to reduce the gear ratio any further. I'll probably need a metal lathe :-(

Dead Batteries

I've accidentally left the bike turned on for what must have been a month without noticing. all four of the lead-acid batteries are dead, showing around 2V when tested with a meter.

I'm pretty annoyed as these batteries haven't even been used for that long.

Not sure what the next steps are.

Part 4 Here

Quadbike Project (Part 02)

2020-08-13T00:00:00+08:00

Links to other parts:

Part 1

Oh no, A plastic burning smell?

Well the relay configuration worked a little too well i guess?

I suspect this issue arose due to two things, using relays that aren't rated for this amount of power and using lead acid batteries.

lead acid batteries tend to drop in voltage quickly when under load. a voltage drop would increase the current and melt the relay contacts.

I ended up removing the relays all together and instead just wiring the bank for 48V. I reluctantly bought a cheap 48v lead acid bike charger as well.

Quadbike throttle conversion

Until now i'd been using the go-kart pedal that came with the motor kit. Next step was to find a way to use the original 'Thumb Throttle' that the quad originally used.

The original throttle is just the normal wire pull type.

pedal that's included in the kit.

Internally, there's a spring that returns the pedal to idle position. i removed it, cut down the pedal and put a stiffer spring on the outside.

while pulling this housing apart, i discovered that the motor controller uses a hall-effect sensor with two magnets opposing each other.

I drilled holes through the housing, added a random nut to hold the throttle cable in place.

Eh, it does the job.

Your browser does not support the video tag.

Now it can be ridden without having to hold the pedal in your hand.

Part 3 Here

Quadbike Project (Part 01)

2020-01-20T00:00:00+08:00

I've wanted to build an electric vehicle for a long time, due to cost of components i have put it off.

Recently i found a facebook marketplace ad for a children's 50CC quadbike for $150.

The seller advertised that it was only missing a fuel tank and is running. As with all online marketplaces, this was not exactly the truth.

From what i could tell, someone with no technical skill but with plenty of confidence, attempted to get the quadbike running by cutting and joining wires while blindfolded.

There was no way this was going to run without a whole lot of work. I low-balled the seller $90 and took it home.

stripped down to bare chassis.

Converting to electric

The initial plan was to try and do this project as cheap as i could. I started with a Ebay 1800W Brush-less motor kit and some lead acid batteries.

Fabricated battery mount

Dry Fit of Batteries

I was able to clear the frame when testing the suspension movement!

I attempted to use the original sprocket that the petrol motor used. This didn't turn out as there wasn't enough torque with this gearing ratio.

I ended up buying a electric bike sprocket and chain kit that had a far better ratio.

I had to drill new holes in the larger sprocket to align with the bike's driveshaft. Centering this sprocket turned out to be very hard, i wish i owned a metal lathe :-(

Charging 48v batteries with a 12 charger?

Since it was a 48V motor kit, i had this idea to use 4 relays to break up the 48V battery pack into 4 x 12V batteries in parallel for charging, saving me the need for an expensive 48V charger.

gif of the relay circuit, Note that i used DPDT (Double Pole Double Throw) relays which halved the number of relays to 4. DPDT relays aren't supported in falstad circuit simulator so its a mess of wires to get the same functionality.

Your browser does not support the video tag.

This circuit worked as designed. i was able to charge these batteries with a normal 12v car charger.

As mentioned earlier these relays have multiple poles so i only need 4 (instead of 8).

Went out for a drive and it works great!!

Rob's Tech Blog

Adding Automation to the blog

The issue

The solution

I started out by fixing my git hygiene.

Using AWS CodeBuild to generate the pages

Setting up CodePipeline

Roll back procedure

Relay Controller Project

Relay controller

Designing the relay controller.

Schematic

Building the relay controller.

implementing the relay controller

it works!!

Some Notes.

Quadbike Project (Part 07)

Getting off the breadboard

Motor Controllers

Arduino and the rest.

Part 8 Coming soon....

Quadbike Project (Part 06)

RC Control

A high level diagram:

Getting Steering working

Throttle control

Generating the throttle signal

Testing the throttle on the bike

Part 7 Here

Quadbike Project (Part 05)

Gameplan

Radio control

Steering Control

Brake Components

Suspension Bushes

Wheel bearing replacement

Next Steps

Part 6 Here

Quadbike Project (Part 04)

New Battery Upgrade

Bike upgrades

Part 5 Here

Adventures of Custom Solar Monitoring

When it all went wrong

In Summary

Quadbike Project (Part 03)

How does it drive?

Dead Batteries

Part 4 Here

Quadbike Project (Part 02)

Oh no, A plastic burning smell?

Quadbike throttle conversion

Part 3 Here

Quadbike Project (Part 01)

Converting to electric

Charging 48v batteries with a 12 charger?

Part 2 Here