Monday, 30 March 2015

Thermo-Bot Project

In this post, I describe how I took a stepper motor, some Lego(R) and a temperature probe to make a temperature sensitive robot. Basically it's a Pi-on-wheels that moves to the correct position on a temperature scale to indicate the current room temperature. Don't ask why I thought this was a good idea, but I'm quite proud that it works!

Video of it working here (time lapse of 50 minutes)

I bought a stepper motor with a view to making some kind of robot.

This tutorial from Simon Monk on the Adafruit site is all you need for Pi-controlled stepper motors:

I bought my stepper motor from ebay with the controller chip included on a board with some LEDs, which were really helpful in debugging, since the wires in the Adafruit diagram don't 'line up' obviously with the Pi GPIO pins. My motor would only go forwards until I followed the diagram MUCH more carefully. (The fault was with me not Simon's diagram.)

I also did some work with the single wire temperature sensor, again using the Adafruit tutorial from Simon Monk:

Although some of the Python code came from here:

However, this time it wasn't my fault when it didn't work. With model B+ Pis you have to add this to the /boot/config.txt file:


Once this was in place the sensor worked fine.

The robot is cobbled together really quickly (badly) using lego. Initial belt-drive version had problems with the elastic-band drive belt jumping off the drive wheel, so direct drive was used instead.

Then it was time to combine the two tutorials and with a few extra lines of code I have a robot that moves up and down a temperature scale according to the current room temperature.

Here's the code I used. You'll notice most of it is pretty much left as per the Adafruit example and the modmypi link above, so credit to Simon Monk and the ModMyPi guru.

import RPi.GPIO as GPIO
import time
import os

#initialise bot settings (stepper motor))
enable_pin = 18
coil_A_1_pin = 7
coil_A_2_pin = 8
coil_B_1_pin = 23
coil_B_2_pin = 24
GPIO.setup(enable_pin, GPIO.OUT)
GPIO.setup(coil_A_1_pin, GPIO.OUT)
GPIO.setup(coil_A_2_pin, GPIO.OUT)
GPIO.setup(coil_B_1_pin, GPIO.OUT)
GPIO.setup(coil_B_2_pin, GPIO.OUT)
GPIO.output(enable_pin, 1)
delay = 2

def forward(delay, steps):
 for i in range(0, steps):
  setStep(1, 0, 1, 0)
  setStep(0, 1, 1, 0)
  setStep(0, 1, 0, 1)
  setStep(1, 0, 0, 1)
def backwards(delay, steps):
 for i in range(0, steps):
  setStep(1, 0, 0, 1)
  setStep(0, 1, 0, 1)
  setStep(0, 1, 1, 0)
  setStep(1, 0, 1, 0)
def setStep(w1, w2, w3, w4):
 GPIO.output(coil_A_1_pin, w1)
 GPIO.output(coil_A_2_pin, w2)
 GPIO.output(coil_B_1_pin, w3)
 GPIO.output(coil_B_2_pin, w4)

#load drivers for temperature probe
os.system('modprobe w1-gpio')
os.system('modprobe w1-therm')

temp_sensor = '/sys/bus/w1/devices/28-0414607111ff/w1_slave'

#Get the raw data from the sensor:

def temp_raw():

 f = open(temp_sensor, 'r')
 lines = f.readlines()
 return lines

def read_temp():

 lines = temp_raw()
 while lines[0].strip()[-3:] != 'YES':
  lines = temp_raw()
 temp_output = lines[1].find('t=')

 if temp_output != -1:
  temp_string = lines[1].strip()[temp_output+2:]
  temp_c = float(temp_string) / 1000.0
  return temp_c

#initialise current temperature start value (and place bot on 14 deg C mark before running)
currentTemp = 14.00

#run the bot
while True:
  oldTemp = currentTemp
  currentTemp = read_temp()
  tempDiff = currentTemp - oldTemp
  print (oldTemp, currentTemp, tempDiff,)
  if tempDiff >= 0:
   steps = tempDiff * 256
   forward(int(delay) / 1000.0, int(steps)) 
   steps = tempDiff * -256
   backwards(int(delay) / 1000.0, int(steps))
It works!

Tuesday, 10 March 2015

Pi-based Domestic Electricity Monitor - Part 6 - First Log - Success and Failure


I logged 24hrs of data from my domestic electricity meter, but discovered that writing each event to the db with SQlite seemed to be taking 4 seconds, making the program as it stands no good for logging an event which can happen more than twice a second on occasions of high consumption. Values below 1kW were recorded accurately I believe.

To run the program via SSH I used nohup for the first time so that it would run even once I closed the session...and then had to learn how to find and kill said program:

To hunt running program: 

$ ps -e | grep python

To kill running program:

$ sudo kill 3861


I used the program below to log the meter for around 24 hrs

(House averages 1kW, or 800 flashes per hour. 24hrs is therefore around 20,000 flashes)

This was to test the logging process and to see the size of the data file that would be created.

However, on analysing the data I soon noticed the data was suspect:
a) not enough readings for 24hrs (~9000, rather than ~20,000)
b) readings which never go above around 1kW:

(graph created in Libre office after exporting data from sqlite. This site was helpful here:

 Here's a sample of the data: (Time|Consumption|Meter Reading)

Tue Mar 10 07:23:49 2015|0.980246908963771|16791
Tue Mar 10 07:23:54 2015|0.939329897684513|16791
Tue Mar 10 07:23:58 2015|0.978048032653337|16791
Tue Mar 10 07:24:03 2015|0.977999583707987|16791
Tue Mar 10 07:24:08 2015|0.959483188529128|16791
Tue Mar 10 07:24:12 2015|0.955398819345674|16791
Tue Mar 10 07:24:17 2015|0.97396251715844|16791

Every interval is around 4 seconds and 1kW at a time when it should be well above this.

When I remove the lines that write the data to the db, the consumption data becomes correct, so I think that writing the data to the db is taking around 4 seconds.

The size of the data file is not going to be a problem: ~9000 readings is ~500kB.

Here's the code I used:

It features a facility for calculating the meter reading based on initial values and 800 flashes of the LED being 1kWh.

#!/usr/bin/env python
#First go at logging data from the meter

import RPi.GPIO as GPIO, time, os
import sqlite3

#initiaise database tools
conn = sqlite3.connect('elecmeter.db')
c =  conn.cursor()

#create database
#what to send to db: ascitime, power consuption, meter reading
c.execute("CREATE TABLE e_meterlog01 (time float, power float, meter_reading integer)")

#initialise pins     
GPIO.setup(23, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)

#procedure to wait for LED flash front edge
def wait_for_flash():
    except KeyboardInterrupt:
        GPIO.cleanup()       # clean up GPIO on CTRL+C exit 
#initialise meter reading tools 
meter_rdg = 16777

#timing and kW calcs based on 800 imp / kWh:

for i in range (0,22000):
    elapsed_time = time.time()-start_time
#increment the meter reading every 800 pulses:
    if impulse_count < 800:
        impulse_count += 1
        meter_rdg +=1
    print (elapsed_time,kW,meter_rdg,impulse_count)
    c.execute("INSERT into e_meterlog01 VALUES(?,?,?)",(time.asctime(),kW,meter_rdg))
    time.sleep(0.3) #to allow for LED to turn off
GPIO.cleanup()           # clean up GPIO on normal exit        

print("Ending Program")

Saturday, 7 March 2015

Remote accessing a Raspberry Pi

Just a few tweeks to the pi to make it easier to work on it remotely:

1) Autostart the VNC server - (EDIT - I had to turn this off. After the first time of working, thereafter the remote screen was just grey with an 'x' mouse pointer. Starting manually works fine)

2) Get LAMP installed to allow remote access:

3) Install and get no-ip working -

It all works:

However I installed no-ip using some other instructions, which I won't link to, which put the noip client in the home directory, which I think is why I can't start noip the same way as I start TightVNC. It needs root privileges to run noip now, and I don't think it should if you install it properly.

(EDIT - My mobile network provider is blocking access to this site, but I can access it from everywhere else I've tried. Will try changing the re-direct settings on my router and the no-ip settings.)

Next task is writing the data continually to a sqlite db for 24 hours, to gauge the file size.