Skip to content

The Internet of Spas

Somewhere in my yard, there is an appliance which is not connected to the Internet... yet. Last summer, after a power outage, I realized the pumps were not working. The heater was running, but without water circulating the spa went quickly in Overheat mode, throwing errors on the top display. As it was summer and being a lot outside, I had plenty of time to notice the issue and not worry about freezing conditions.

Being out of warranty, I decided to cut the power to the spa and open the control box. This is where I discovered a Cal Spa CS6200DV branded Balboa circuit board, with SSID 100 66 45. Going through standard components, I noticed a blown out 30A fuse that was feeding the pumps. Replaced the fuse, powered back the spa, everything worked for a total of 2,95$.

Wondering how I could have remotely caught this issue, I started searching the web for a WiFi remote or RF option to the spa. While I noticed a WiFi Balboa bridge, it didn't seem to fit my need or even be compatible. It also needed a paid cloud membership and was well overpriced.
Continue reading "The Internet of Spas"

Honey, where are my amps?

Honey, where are my amps?
I have been using the great ESP-01 for a while now, either as a side WiFi chip for software running on various Atmel AVR chips (ATmega328, ATtiny84, ATtiny85) or as a standalone micro controller. While what you can do with an ESP8266 is impressive, it also has its drawbacks: it uses a lot of power.

If you are using batteries to power your project, you need to make sure you can sleep the WiFi chip most of the time or use a different less power hungry radio, like the various RFM69 chips. However, using something different than WiFi also means you need some kind of receiver.

If you are building gadgets for IoT, you will eventually need a way to connect to the Internet. Having WiFi directly on the gadget saves an extra step.

How much power is the ESP really consuming? Continue reading "Honey, where are my amps?"

Hacking the Red Light (Part I)

Arduino layout
Two years ago, I decided to buy a Budweiser Red Light to enhance our hockey night experience. While the product is quite expensive for what it does, I couldn't be happier with the end result. You have to admit, every goal from your team feels and sounds worth jumping around shouting loudly.

This being said, while the product by itself is great, I couldn't resist the urge to hack it. One of my goal was to connect the house Hue lights to the Red Light so that they would shine red as goals were scored. Googling around, I found some ways of achieving this:

Continue reading "Hacking the Red Light (Part I)"

Snowshoeing

It's snowing, the river is frozen, time to go snowshoeing:


Dell LCD Display

Dell LCD Display control from shell.

#!/bin/bash

# Max length the LCD can accept. Typically 62
MAXLENGTH=62

# Read from first argument if present, else take first line of stdin
if [ $# -lt 1 ]; then
	read INPUT
	INPUT=$(echo $INPUT | tr -d [:cntrl:])
else
	INPUT=$(echo $1 | tr -d [:cntrl:])
fi

# Check if we respected the max length after removing control chars
if [ ${#INPUT} -gt $MAXLENGTH ]; then
	echo "Cannot use more than $MAXLENGTH characters"
	exit 1
fi

# Split by bytes and encode them as hex strings (0xff)
BYTES=$(echo -n $INPUT | od --width=1 -v -t x1 | grep " " |
	awk '{print $2}' | awk '{print "0x"$1}')

# Encode length of string as hex digit also
LENGTH=$(printf "0x%x" ${#INPUT})

# Go through all bytes, grouping them by chunk of 16 bytes
i=3
CMD="0x0 0x0 $LENGTH"
LINES=()
for BYTE in $BYTES; do
	# Chunk ready, append it to array and reset counters
	if [ $i -gt 16 ]; then
		LINES[${#LINES[*]}]="$CMD"
		CMD=$(printf "0x%x" ${#LINES[*]})
		i=1
	fi

	# Push byte on accumulator
	CMD="$CMD $BYTE"
	let i+=1
done

# Put last chunk into array
LINES[${#LINES[*]}]="$CMD"

# Tell BMC text to print on LCD, chunk by chunk
for i in "${LINES[@]}"; do
	/usr/bin/ipmitool raw 0x6 0x58 0xc1 $i > /dev/null
done

# Tell BMC to output our User String on LCD
/usr/bin/ipmitool raw 0x6 0x58 0xc2 0x0 0x0 0x0 0x0 0x0 0x0 0x0 0x0 0x0 0x0 0x0 0x0 > /dev/null