Thursday, 28 September 2017

It's been a while since there’s been a new addition to the family and I’d forgotten how much preparation is involved. All the familiar concerns that I remembered from when the boys were born came flooding back: you need to make sure the new arrival is not too hot or cold, provide a safe environment that they can’t escape from, ensuring they’re safe at night...Snakes, I've discovered, are a lot like children. Except easier to feed.

Anyway, faced with such challenges there is only one response: make some stuff to help.

Of course when the boys were born, the Maker community wasn’t as well established and, Raspberry Pi, the core of many IoT projects had yet to be born itself. So this project gave me an opportunity make up for it now. The Pivarium deals with the the main requirementsmentioned above.

Monitoring the environment inside the vivarium.

Snakes are ectotherms - they have no internal means of regulating metabolic function and maintaining homeostasis. In cold weather, snakes tend to be sluggish as their metabolisms slow down, whereas in warm weather they tend to eat more and move more quickly. So in captivity they need to have a temperature gradient available so that they can move to a cooler place when they get too hot and vice versa. The Kernel’s vivarium has a thermostatically controlled ceramic heat lamp at one end but I wanted to monitor the temperature under it, as well as at the opposite end where there is more ventilation.

I opted for DS18B20temperature sensors because they are cheap and reasonably water -and hopefully snake pee - resistant. I was too lazy to convert the ends of the leads to female jumper sockets so I just used screw terminals and a small breadboard. My excuse is that this will make it easier to replace a faulty sensor in future.

DS18B20 (left) next to probe from thermostat at 'hot end'

ADS18B20 at 'cool end'

The humidity in the Pivarium is also important, especially when the snake is shedding its skin so I wanted to monitor that as well I opted for a DHT22 which can also record temperature as well and is more accurate than the cheaper DHT11. Therefore I placed it in the centre of the vivarium, attached to the roof. This gives me a third temperature reading to provide a good overall idea of what the gradient is like in the vivarium.

DHT22 mounted on roof

While I was testing and The Kernel was settling in, I used a Pi Touchscreen to display a dynamic plot of the temperature and humidity values in real time. This was produced using Jupyter Notebook and the Python Matplotlib library.

Once I was happy that everything was working and reasonably stable removed the touchscreen and swapped the Pi 2 for a Zero W. I still wanted to keep a graphical record of the environment though, so I created a data bucket on InitialState and upload regularly the data to produce a nice dashboard that I can check from anywhere that I can get on the InterWebs.

InitialState dashboard

For a local display, I don’t really need graphs - just the headline readings are fine. I also didn’t want something bright and flashy like an LED matrix so I opted for the excellent Pimoroni InkyPhat. This is perfect as I only need to update the values every 5 minutes or so - things don’t change that rapidly in the Pivarium. Although the InkyPhat is limited to three colours, that’s fine. I want to easily see if a temperature is outside the desirable range for that area of the Vivarium, in which case the value is displayed in red text, otherwise black. I also display the time so I can tell that the readings are current and that the Pi or Inkyphat hasn’t stuck or crashed.

I want to easily see if a temperature is outside the desirable range for that area of the Vivarium, in which case the value is displayed in red text, otherwise black. I also display the time so I can tell that the readings are current and that the Pi or Inkyphat hasn’t stuck or crashed.

Night Vision

The next task was to see what The Kernel was getting up to at night. At a later stage I might put a camera in the vivarium itself, but for now I’m happy to have a second Pi outside with a Pi Noir camera and some IR LEDs, all mounted in a Lego frame. Reflection from the vivarium glass in minimal and I can easily position the whole thing to focus on a particular area (e.g the hot or cold hide, the water bowl etc). I didn’t want to record all the time so I used Motion software to detect when activity was occurring and start recording then.

I’ve been able to capture some good footage of The Kernel’s nocturnal behaviour. My favourite so far has been this clip of him having a big drink and then burping.

Houdini

The final task was to prevent The Kernel from unexpectedly leaving his lovely home. Corn snakes are renowned escape artists and will find a way out through any small crack or opening. A common escape route is cased by the sliding vivarium doors not being closed properly and the patient and surprisingly strong guest levering their way out when nobody is looking. A simple remedy is to always fit the sliding vivarium lock and mark its position on the bar so that you know the doors are fully closed. However it is really easy to forget this or to not lock the doors immediately and then forget to do it later (especially when removing snake poo). So I wanted to add some blinkin LEDs to provide an immediate visual indication that doors were not secure.

I found some nice chunky contact switches (with a satisfying click). These have 3 spade-connector terminals, a different pair of which are connected together when the switch is closed or open. I designed some 3D printable brackets to fit hold them and allow easy fixing to the side of the vivarium. I also added a hole and channel for a blinking LED.

I also 3D printed some handles to fit onto the existing glass squares that are used to slide the doors. These press against and close the contact switches: the advantage of 3D printing these was that I could precisely adjust the size so that the switch is only fully depressed when the door is completely closed.

As usual, the Python gpiozero library makes the code to control these switches embarrassingly easy, especially using source/values.

from gpiozero import Button,LED

leftside = Button(20)

leftside_led = LED(21)

leftside_led.source = leftside.values

rightside = Button(19)

rightside_led = LED(26)

rightside_led.source = rightside.values

You can see the complete Python code for the Pivarium here. The STL files for the various 3D printed files and the Jupyter Notebook file used in testing are also there.

Wednesday, 2 August 2017

Since starting a new job earlier in the year I've had to make a lot of adjustments to my fitness schedule. One thing I really miss are the exercise classes I used to attend. I particularly miss the High Intensity Interval Training sessions which were a great way get a quick cardiovascular workout.

I'd been rolling my own version at home in the back garden for a few weeks and found that although these sessions worked reasonably well, I missed the class instructor who used to call out the next exercises and provide motivational commentary. Keeping track of what exercise I've just done gets increasingly difficult the more tired I get. I also found it annoying to have to check my watch for when to pause between exercises and re-setting a timer every 20 seconds is annoying.

Obviously it would be hard to simulate the enthusiasm of a trainer but the exercise choice and timings seemed like a straightforward thing to automate with a Raspberry Pi.

I wanted a visual and audible alerting mechanism and something that would be small enough to be readily portable and run from a standard power bank.

Here is the finished prototype: my Pi-rsonal Trainer.

BoM

Construction

1) Solder a standard male header onto the Pi Zero.
2) Solder on the Pico HAT Hacker, being careful not to let the solder wick too far up the pins.
3) Solder a small buzzer directly on to the Pico HAT Hacker between the holes for Ground and GPIO 18
4) Solder two buttons onto the Pico HAT Hacker, one between Ground and GPIO 9 and the other between a different Ground pin and GPIO 19.
5) Solder a female header on to the ScrollPhat HD and then mount this onto the Pi.

Operation

For my HIIT sessions I like to have 4 repetitions of 10 x 20s periods of exercise interspersed with 10 second rests.

Some simple Python code runs at startup-up. When the bigger button (on GPIO19) is pressed, the sequence begins with an on/off flash of all the LEDs on the ScrollPhat . An exercise is selected at random from a list and this choice is scrolled across the matrix for 5 seconds, followed by a 5 second countdown accompanied by beeps. Then there's another flash and the 20 second exercise period begins. The exercise being undertaken is constantly scrolled across the LED matrix until the last 5 seconds when there's another beeping countdown. Then there's a 10 second rest period during with the next exercise is scrolled. And repeat 10 times.

Then a 30 second break.

Then repeat all that 4 times!

The LEDs of the ScrollPhat HD are nice and bright, and visible in full sunshine. The beeps are annoyingly shrill so that I can hear them even though I'll normally be listening to music on my earbuds. This means I don't have to keep watching the LED display to now when the various intervals are finished.

The code is easily customisable if you want different exercises or want to alter the timings. You could just as easily program a Yoga session rather than a HIIT workout!

Thursday, 9 February 2017

I funded the
MakeTronix Alarm on IndieGoGo because it contains many of the
components I usd with Raspberry Pi at CoderDojo, but in one compact
package. Don't get me wrong, I'm all in favour of having learners
build the circuit using a breadboard, but sometimes there just isn't
the time to do that and code it.

The board arrived
very quickly and it is a nice, neat package. I was pleased that they
kept the board to 26 pins as this will enable it to work with my
trusty set of original mode Bs.

The online
documentation is easy to find but I have to say I found it a little
disappointing. It seems weird to not show a picture of the board
mounted on a Pi in the “connecting the board” section. The
written description is entirely accurate but a simple diagram would
be much better, especially for younger users. I was also surprised
to find that the code examples downloaded from the MakeTronix github
don't use gpiozero. There's nothing wrong with using the Rpi.GPIO
library – it works perfectly – but I believe gpiozero is much better for
those who are new to Python and this board is being marketed as a
“fantastic educational circuit board for learning programming”.
They've tried to abstract out the key functions into a library file
that the other examples import, but this feels a bit unwieldy, again
especially for novice Pythonistas.

I also couldn't get
the full alarm code to work. It turned out this was nothing to do
with the code: the PIR that shipped with my kit didn't work correctly
and would not trigger on motion at any sensitivity. Luckily I have
plenty of these PIRs and substituting in a replacement got
everything working.

Nevertheless I
decided to write a gpiozero version. It uses a couple of lambda
functions which you might argue are too opaque for beginners (and I'd probably agree) but
they do remove the need to give each button its own when_pressed
function individually.

Here's why I love
gpiozero – all sorts of hardware control is possible with simple,
easy to understand syntax. My MTAlarm code does the following:

1. Activates the PIR
and waits for motion to be detected. The LED glows/pulses to indicate
that the alarm is active.

2. When motion is
detected, the LED starts flashing.

3. If within 10 seconds the correct code
is entered (each key beeps when pressed and DEL acts as backspace) the
alarm is disabled.