48. Robotics with PiBot. III - Running the Test Programs

12,000 page views!!
We're nearly at the point where we can start doing some exciting robotics!  There are currently four test programs for the PiBot - python programs which put the current system through its paces, to make sure all the hardware is working as it should. 

Firstly here is a listing of the firmware, which has to be running on the Bot Board's Arduino:

	//
	// PiBot arduino code - PiBot_Firmware_Alpha
	// James Torbett 2014
	// v. 0.1
	// EARLY ALPHA RELEASE
	//
	// Todo:
	// ADC implementation
	// Temperature (thermistor)
	// Voltages
	// Neopixel display
	// Wheel odometry
	// Better stepper timings
	// Serial terminal
	// i2c interface
	#include <Adafruit_NeoPixel.h>
	#include <Servo.h>
	#include <NewPing.h>
	#include <SPI.h>
	#define MAX_DISTANCE 200 // Maximum distance we want to ping for
	// (in cm). Maximum sensor distance is rated at 400-500cm.
	#define SPI_IDLE 0 // initial state of SPI bus
	#define SPI_READ 1 // next byte is a READ from here
	#define SPI_WRITE 2 // next byte is a WRITE to here
	// vars to hold register value and write data. Read data is
	// passed directly out on next clock cycle.
	byte spiRegister = 0;
	byte spiData = 0;
	// pin definitions
	byte pin_motor1dir = 2; // direction of motor 1
	byte pin_motor2dir = 4; // direction of motor 2
	byte pin_motor1pwm = 3; // PWM (speed) of motor 1
	byte pin_motor2pwm = 5; // PWM (speed) of motor 2
	byte pin_stepperDir = 7; // direction of stepper motor
	byte pin_stepperStep = 6; // cycle this pin to perform 1/32 of
	// step
	byte pin_stepperDisable = 8; // low = stepper enable,
	// high = disable to save power
	byte pin_neopixelData = 14; // neopixel data in pin
	byte pin_uSoundTrig = 16; // trigger pin of the ultrasound
	// (ping) module
	byte pin_uSoundEcho = 15; // echo pin of the ultrasound module
	byte pin_servoData = 17; // pin for the servo data
	byte spiReceived = 0; // flag to say we've received an SPI byte
	byte spiByte = 0; // value of the byte received over SPI
	const int SPI_BUFFER_SIZE = 128; // AB: This may need to be
	// a power of 2 for the producer consumer algorithm to work
	volatile unsigned int gSpiProduceCount = 0;
	volatile unsigned int gSpiConsumeCount = 0;
	volatile byte gSpiBuffer[ SPI_BUFFER_SIZE ];
	volatile byte gSpiResult = 0;
	volatile byte gSpiClash = 0;
	unsigned int sonarInterval = 100; // number of loops per sonar
	// measurement
	unsigned int stepperInterval = 100; // number of loops per
	// stepper step
	unsigned int neoPixelInterval = 1000; // number of loops per
	// neopixel array update
	byte stepperValue = 0; // increments. Bit 0 used for stepper
	// pin value.
	// internal data registers
	byte motor1dir = 0;
	int motor2dir = 0;
	byte motor1pwm = 0;
	byte motor2pwm = 0;
	int servoPos = 0;
	byte stepperSpeed = 0;
	byte stepperDir = 0;
	int uSoundDistance = 0;
	const int NUM_NEOPIXELS = 8;
	byte neoPixelData[51] = { 0 };
	// count of hex 0x55 character received on SPI (01010101)
	// if this is received 3 times in a row, reset the SPI state
	// machine
	byte spi55count = 0;
	unsigned int controlCounter = 0;
	byte spiState = SPI_IDLE;
	// define some library objects
	Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUM_NEOPIXELS,
	// pin_neopixelData, NEO_GRB + NEO_KHZ800);
	Servo tiltServo;
	NewPing sonar(pin_uSoundTrig, pin_uSoundEcho, MAX_DISTANCE);
	// NewPing setup of pins and maximum distance.
	void setup()
	// setup: set pin modes and any other associated stuff
	{
	Serial.begin(9600);
	pinMode(pin_motor1dir, OUTPUT);
	pinMode(pin_motor2dir, OUTPUT);
	pinMode(pin_motor1pwm, OUTPUT);
	pinMode(pin_motor2pwm, OUTPUT);
	pinMode(pin_stepperDir, OUTPUT);
	pinMode(pin_stepperStep, OUTPUT);
	pinMode(pin_stepperDisable, OUTPUT);
	pinMode(pin_neopixelData, OUTPUT);
	// start the servo
	tiltServo.attach(pin_servoData);
	// start SPI
	enableSPI();
	}
	ISR (SPI_STC_vect)
	// SPI interrupt routine, activates when a byte is received.
	{
	byte c = SPDR; // grab byte from SPI Data Register
	if ( gSpiProduceCount - gSpiConsumeCount == SPI_BUFFER_SIZE )
	{
	// SPI buffer is full
	gSpiClash = 1;
	}
	else
	{
	gSpiBuffer[ gSpiProduceCount % SPI_BUFFER_SIZE ] = c;
	gSpiProduceCount++;
	}
	SPDR = gSpiResult;
	} // end of interrupt routine SPI_STC_vect
	void enableSPI()
	// enable the SPI bus as slave device (PI is master)
	{
	// have to send on master in, *slave out*
	pinMode(MISO, OUTPUT);
	// turn on SPI in slave mode
	SPCR |= _BV(SPE);
	// Set SPI mode
	SPI.setDataMode( SPI_MODE0 );
	// now turn on interrupts
	SPI.attachInterrupt();
	}
	void controlMotors(void)
	// set the motor drives to values defined in the variables
	{
	digitalWrite(pin_motor1dir, motor1dir);
	analogWrite(pin_motor1pwm, motor1pwm);
	digitalWrite(pin_motor2dir, motor2dir);
	analogWrite(pin_motor2pwm, motor2pwm);
	}
	void controlServo(void)
	// write to the servo
	{
	tiltServo.write(servoPos);
	}
	// toggle the stepper pin
	void doStep(void)
	{
	if (stepperSpeed > 0)
	{
	stepperInterval = 256 - stepperSpeed;
	digitalWrite(pin_stepperDisable, 0);
	digitalWrite(pin_stepperDir, stepperDir);
	digitalWrite(pin_stepperStep, stepperValue & 0x01);
	stepperValue++;
	}
	else
	{
	digitalWrite(pin_stepperDisable, 1);
	}
	}
	void readDistance()
	// read the distance reported by the ultrasound module.
	// make sure to leave at least 50mS between calls to this
	{
	unsigned int uS = sonar.ping();
	uSoundDistance = uS / US_ROUNDTRIP_CM;
	}
	void processSPI(void)
	{
	// finished clocking in a byte
	// process the sync byte regardless of state
	if(spiByte == 0x55)
	{
	//Serial.println( "Sync byte" );
	// increment sync counter
	spi55count++;
	if (spi55count > 2)
	{
	// go back to the idle state
	spiState = SPI_IDLE;
	spiReceived = 0;
	spi55count = 0; // Reset sync conter
	return; // yes, it's an unconditional jump
	// out of subroutine
	}
	}
	if (spiState == SPI_IDLE)
	{
	if (spiByte < 60)
	{
	// Write operation
	spiState = SPI_WRITE;
	spiRegister = spiByte;
	}
	else if (spiByte >= 100)
	{
	spiState = SPI_READ;
	spiRegister = spiByte;
	processSPIRead();
	}
	}
	else if (spiState == SPI_WRITE)
	{
	// we've got a data value now
	spiData = spiByte;
	processRegister();
	spiState = SPI_IDLE;
	}
	else if (spiState == SPI_READ)
	{
	// SPDR data register will have been clocked out now.
	// Return to idle.
	spiState = SPI_IDLE;
	}
	spiReceived = 0;
	}
	void processSPIRead()
	{
	// only one case for now: to read the ultrasound distance.
	switch (spiRegister)
	{
	case 100:
	gSpiResult = uSoundDistance;
	break;
	default:
	break;
	}
	}
	void processRegister()
	{
	switch(spiRegister)
	{
	case 01:
	motor1dir = spiData;
	break;
	case 02:
	motor2dir = spiData;
	break;
	case 03:
	motor1pwm = spiData;
	break;
	case 04:
	motor2pwm = spiData;
	break;
	case 05:
	stepperDir = spiData;
	break;
	case 06:
	stepperSpeed = spiData;
	break;
	case 07:
	servoPos = spiData;
	break;
	case 8 ... 59:
	neoPixelData[spiRegister-8] = spiData;
	// wow departure from ANSI-C
	break;
	default:
	break;
	}
	}
	void updateNeoPixel()
	{
	// todo: actually copy the register data into the
	// neopixel strip
	for ( int pixelIdx = 0; pixelIdx < NUM_NEOPIXELS; pixelIdx++ )
	// sizeof( neoPixelData ) / 3; pixelIdx++ )
	{
	strip.setPixelColor( pixelIdx, neoPixelData[ 3*pixelIdx ],
	neoPixelData[ 3*pixelIdx+1 ], neoPixelData[ 3*pixelIdx+2 ] );
	}
	strip.show();
	}
	void loop(void)
	// main loop
	{
	// do stuff.
	controlCounter++;
	if ( gSpiProduceCount - gSpiConsumeCount > 0 )
	{
	spiByte = gSpiBuffer[ gSpiConsumeCount % SPI_BUFFER_SIZE ];
	spiReceived = 1;
	gSpiConsumeCount++;
	}
	if (spiReceived) processSPI();
	if ( gSpiClash )
	{
	//Serial.println( "Serial clash occured" );
	gSpiClash = 0;
	}
	controlMotors();
	controlServo();
	//Serial.println( controlCounter );
	// only read distance every sonarInterval loops
	if((controlCounter % neoPixelInterval) == 0)
	{
	updateNeoPixel();
	}
	// only read distance every sonarInterval loops
	if((controlCounter % sonarInterval) == 0)
	{
	readDistance();
	}
	// only step stepper based on interval (derived from speed)
	if((controlCounter % stepperInterval) == 0)
	{
	doStep();
	}
	}

view raw PiBot_Firmware_Alpha hosted with ❤ by GitHub

Notice that I have embedded these code listings from my Gist account on GitHub, which is where the open source software from the PiBot Team is published. These are my versions of the PiBot Team's software. Hopefully my future versions, on following Blog posts, will be advanced versions of these. As these are embedded, any changes I make to these on GitHub will be reflected in these listings, so I must be careful to generate new Gists.
The four python programs are:
1. drive_in_square.py,
2. monitor_ultrasonic.py,
3. robot_teleop.py and 
4. test_pibot_hardware.py.  
The code listings that I will give here contain some small adjustments which I made to suit my particular needs.

drive_in_square.py
This test program allows the PiBot to proceed in a straight line for a fixed time, make a right-angled turn, do a straight line, do a right angle, do a straight line and do a right angle - making a square shaped track.  The program continues indefinitely, so it has to be interrupted by performing a Ctrl-Z on the Pi's remote terminal on the PC, followed by touching together the two flying leads on the PiBot to do an Arduino reset. 

You've seen this program in action in the last post, but here's the version with a shortened square:

OK - it's not quite a square - when I changed the speed, I should have adjusted the delay times too - anyway you get the gist! (where have I heard that word before?).

Here's the code:

	#! /usr/bin/env python
	# drive_in_square.py
	import time
	import pibot
	import sys
	bot = pibot.PiBot()
	# speed = 255
	speed = 64
	if len( sys.argv ) > 1:
	speed = int( sys.argv[ 1 ] )
	while True:
	# Drive forward
	bot.setMotorSpeeds( speed, speed )
	time.sleep( 3.0 )
	# Turn right
	bot.setMotorSpeeds( speed, -speed )
	time.sleep( speed /(255*4.0) )

view raw drive_in_square.py hosted with ❤ by GitHub

Notice that the speed can be specified in the command line which runs the program.  Lines 11 and 12 pick up the argument if you put it in, and otherwise it assigns a default value. For example, if you enter the command:
python drive_in_square.py
the default value of speed at line 9 will be used, while the command
python Drive_in_square.py 255
will enable the command line argument with the value 255 to be picked up, and this value will override line 9.

monitor_ultrasonic.py
This program causes the ultrasonic transceiver to transmit and receive, so that the estimated distance to a solid object can be printed on the remote terminal.  The PiBot doesn't move.

Here it is running:

It may be a little difficult to see, but the screen gives a continuous readout of the distance from the ultrasound detector to a solid object - for example, my hand.

Here's the code:

	#! /usr/bin/env python
	# monitor_ultrasonic.py
	import time
	import pibot
	bot = pibot.PiBot()
	while True:
	print "Distance is", bot.getUltrasonicDistance()
	time.sleep( 0.1 )

view raw monitor_ultrasonic.py hosted with ❤ by GitHub

robot_teleop.py
The teleop program makes the PiBot respond to 1-character keyboard commands - f for forward, b for backward, l for left, r for right turn and s for stop, each followed by an Enter. 

Here it is running:

It's not very slick, but remember that these are only test programs for checking that the hardware works properly.  The glamour comes later!

Here's the code:

	#! /usr/bin/python
	# robot_teleop.py
	import pibot
	import time
	TURN_TIME = 0.2
	bot = pibot.PiBot()
	while True:
	# Read commands from the user
	command = raw_input( ": " )
	command = command.strip().lower()
	if len( command ) > 0:
	commandLetter = command[ 0 ]
	if commandLetter == "f":
	bot.setMotorSpeeds( 128, 128 )
	elif commandLetter == "b":
	bot.setMotorSpeeds( -128, -128 )
	elif commandLetter == "l":
	bot.setMotorSpeeds( -128, 128 )
	time.sleep( TURN_TIME )
	bot.setMotorSpeeds( 0, 0 )
	elif commandLetter == "r":
	bot.setMotorSpeeds( 128, -128 )
	time.sleep( TURN_TIME )
	bot.setMotorSpeeds( 0, 0 )
	elif commandLetter == "s":
	bot.setMotorSpeeds( 0, 0 )

view raw robot_teleop.py hosted with ❤ by GitHub

test_pibot_hardware.py
This program tests all hardware connected to the PiBot.  Currently the final kit parts have not been fitted - the panning step motor and the tilting servo for aiming the PiCam, but the code for some of these functions is already there, ready for connection.

Here it is running:

The sound at the start is of bongos, followed by a 'drum-roll', and at the end of the routine there are 4 sounds - a klaxon sound, followed by a 'ding', followed by 2 cat meeows.  The distance estimated by the ultrasound transducer is displayed on the computer terminal, as in the previous program, monitor_ultrasonic.py.  The hardware that is attached appears to be working properly, including the 8-neopixel strip.   

The stepper motor and servo software is included, but this hardware hasn't been attached yet.

Here's the code:

	#! /usr/bin/env python
	# test_pibot_hardware.py
	import time
	import os.path
	import sys
	import pygame
	import pygame.mixer
	import picamera
	import pibot
	MUSIC_VOLUME = 0.5
	TEST_TIME = 10.0
	scriptPath = os.path.dirname( __file__ )
	# Load test result sounds
	pygame.init()
	pygame.mixer.init()
	time.sleep(1)
	pygame.mixer.music.load( scriptPath + "musical073.mp3" )
	pygame.mixer.music.set_volume( MUSIC_VOLUME * 16)
	pygame.mixer.music.play()
	time.sleep(7)
	pygame.mixer.music.load( scriptPath + "drum_roll.mp3" )
	pygame.mixer.music.set_volume( MUSIC_VOLUME * 16)
	pygame.mixer.music.play()
	time.sleep(5)
	camera.Picamera()
	try:
	camera.start_preview()
	time.sleep(10)
	camera.stop_preview()
	finally:
	camera.close()
	# Connect to the PiBot
	bot = pibot.PiBot()
	testStartTime = time.time()
	while time.time() - testStartTime < TEST_TIME:
	curTime = time.time() - testStartTime
	# Set motor speeds
	if int( curTime )%2 == 0:
	bot.setMotorSpeeds( 192, -192 )
	bot.setStepperSpeed( 255 )
	for pixelIdx in range( bot.NUM_NEO_PIXELS ):
	bot.setNeoPixelColour( pixelIdx, 128, 0, 0 )
	else:
	bot.setMotorSpeeds( -192, 192 )
	bot.setStepperSpeed( -255 )
	for pixelIdx in range( bot.NUM_NEO_PIXELS ):
	bot.setNeoPixelColour( pixelIdx, 0, 0, 128 )
	# Set servo angle
	bot.setServoAngle( (curTime / TEST_TIME) * 180.0 )
	print "Ultrasonic distance =", bot.getUltrasonicDistance()
	time.sleep( 0.05 )
	for pixelIdx in range( bot.NUM_NEO_PIXELS ):
	bot.setNeoPixelColour( pixelIdx, 0, 128, 0 )
	del bot
	time.sleep(1)
	pygame.mixer.music.load( scriptPath + "failure.mp3" )
	pygame.mixer.music.set_volume( MUSIC_VOLUME * 4 )
	pygame.mixer.music.play()
	time.sleep(3)
	pygame.mixer.music.load( scriptPath + "success.mp3" )
	pygame.mixer.music.set_volume( MUSIC_VOLUME )
	pygame.mixer.music.play()
	time.sleep(1)
	pygame.mixer.music.load( scriptPath + "animals023.mp3" )
	pygame.mixer.music.set_volume( MUSIC_VOLUME * 16 )
	pygame.mixer.music.play()
	time.sleep(3)
	pygame.mixer.music.load( scriptPath + "animals023.mp3" )
	pygame.mixer.music.set_volume( MUSIC_VOLUME * 16 )
	pygame.mixer.music.play()
	time.sleep(3)
	while pygame.mixer.music.get_busy():
	pass

view raw KCtest2.py hosted with ❤ by GitHub

	#! /usr/bin/env python
	# test_pibot_hardware.py
	import time
	import os.path
	import sys
	import pygame
	import pygame.mixer
	import pibot
	MUSIC_VOLUME = 0.5
	TEST_TIME = 10.0
	scriptPath = os.path.dirname( __file__ )
	# Load test result sounds
	pygame.init()
	pygame.mixer.init()
	time.sleep(1)
	pygame.mixer.music.load( scriptPath + "musical073.mp3" )
	pygame.mixer.music.set_volume( MUSIC_VOLUME * 16)
	pygame.mixer.music.play()
	time.sleep(7)
	pygame.mixer.music.load( scriptPath + "drum_roll.mp3" )
	pygame.mixer.music.set_volume( MUSIC_VOLUME * 16)
	pygame.mixer.music.play()
	time.sleep(5)
	# Connect to the PiBot
	bot = pibot.PiBot()
	testStartTime = time.time()
	while time.time() - testStartTime < TEST_TIME:
	curTime = time.time() - testStartTime
	# Set motor speeds
	if int( curTime )%2 == 0:
	bot.setMotorSpeeds( 192, -192 )
	bot.setStepperSpeed( 255 )
	for pixelIdx in range( bot.NUM_NEO_PIXELS ):
	bot.setNeoPixelColour( pixelIdx, 128, 0, 0 )
	else:
	bot.setMotorSpeeds( -192, 192 )
	bot.setStepperSpeed( -255 )
	for pixelIdx in range( bot.NUM_NEO_PIXELS ):
	bot.setNeoPixelColour( pixelIdx, 0, 0, 128 )
	# Set servo angle
	bot.setServoAngle( (curTime / TEST_TIME) * 180.0 )
	print "Ultrasonic distance =", bot.getUltrasonicDistance()
	time.sleep( 0.05 )
	for pixelIdx in range( bot.NUM_NEO_PIXELS ):
	bot.setNeoPixelColour( pixelIdx, 0, 128, 0 )
	del bot
	time.sleep(1)
	pygame.mixer.music.load( scriptPath + "failure.mp3" )
	pygame.mixer.music.set_volume( MUSIC_VOLUME * 4 )
	pygame.mixer.music.play()
	time.sleep(3)
	pygame.mixer.music.load( scriptPath + "success.mp3" )
	pygame.mixer.music.set_volume( MUSIC_VOLUME )
	pygame.mixer.music.play()
	time.sleep(1)
	pygame.mixer.music.load( scriptPath + "animals023.mp3" )
	pygame.mixer.music.set_volume( MUSIC_VOLUME * 16 )
	pygame.mixer.music.play()
	time.sleep(3)
	pygame.mixer.music.load( scriptPath + "animals023.mp3" )
	pygame.mixer.music.set_volume( MUSIC_VOLUME * 16 )
	pygame.mixer.music.play()
	time.sleep(3)
	while pygame.mixer.music.get_busy():
	pass

view raw test_pibot_hardware.py hosted with ❤ by GitHub

Notice that I am using a couple of mp3 sound bites downloaded from the internet, including one of a cat meeow, hoping to stimulate some interest in our cat, but it doesn't fool her - she just ignores it!

What's next - I hear you say - well, some tidying up of the above, and dreaming up what I could make it do etc.

Some observations so far - the 4 x AA rechargeable batteries work a treat, and for a surprisingly long time.  I have 2 sets of 4 x 2400 mA-h AAs, so one set can be charging while I'm running the PiBot with the other set.  I haven't timed the workload available, but so far I have only had one episode (the Pi wouldn't boot) where the only remedy seemed to be to replace the batteries, and that worked.

Presumably by the time I start running the PiCam, the system will start to eat up batteries.  I'm happy that the Pi I'm using is a Model A because the power consumption is less (1.5W) than that of the Model B (3.5W).

Things I would like to do?

1. I assume that I will be able to use the ultrasound distance system to prevent the PiBot from colliding with things - my SD card is getting an awful battering!
2. Experimenting with combinations of colours of the neopixels.
3. Of course, mounting the camera and transmitting images would be great. (ref HERE).
4. I also have a successful XBee pair system working away (ref HERE), so I will try to think how that could be included in the PiBot.
5. An IR receiver would be great, to smarten up the remote control. (ref HERE).
6. I saw some code for a thermistor, and I would like to incorporate my previously-built thermopile system (ref HERE), which is still working away on my desk, telling me how cold a bag of ice is, or how hot my tea is.
7. Another project which is working away on my desk very successfully, is the recently built light follower (ref HERE) - it works a treat and I would like to somehow incorporate that into the PiBot.
8. I would like to put a powerful headlamp system on.  This could be self-powering like a high-power LED flashlight (or two?) (ref HERE).
9. A talking system would be good.
10. Get it to make my tea, wash the car.........

But first, I will try to fully understand and maybe explain, the current software.

47. Robotics with PiBot. II - Setting up the Software

11,000 page views!!
Here's what the hardware currently looks like:

It's powered up!  There are electrons flowing through its veins, but it's still asleep so it doesn't do anything yet.  It needs some software!  You may be able to see the blue LED lit on the Bot Board, the red PWR LED lit up on the Pi, and the flashing blue LED on the WiFi dongle.

It's on a raised platform just in case the wheels should start turning and it takes off!  The voltage regulator can be seen wrapped in green heat-shrink (I had to change the order of the regulated orange lead and the unregulated red lead before connecting to the Bot Board's power header). 

The wires to the neo-pixel header have been connected, and there are two flying leads - a purple and a green, which are attached to the two pins nearest to the GPIO pins on the Bot Board's 6-pin ISP header near the blue power LED.  These are for when the Bot Board's Arduino needs to be re-set - they just need to be momentarily touched together to do a micro-controller re-set.

The rainbow-coloured 5-wire strip is running from the Bot Board's Serial interface to a USB to CP2102 TTL UART Module which I purchased for £3.70 from ATelecs on ebay.  This module has a USB connection for inserting into the PC's USB socket.  

Be careful not to connect both the Pi's power supply (through the Pi's micro USB connector) and the UART module to the PC at the same time.  There is currently no battery in the PiBot, and in any case, its main switch is in the off position.  This is a third potential power conflict, so pay particular attention to what power sources are connected!

I thought I would start with a clean sheet - a new SD card, for the PiBot.  Actually, it's an 8 GB micro SD card slotted into a micro SD to SD adapter.  Here are the steps I took:

1. Download SDFormatterv4 from https://www.sdcard.org/downloads/formatter_4/eula_windows/
2. Unzip this and put the SD adapter card into the USB/SD adapter, and run SDFormatterv4
3. Download NOOBS from www.raspberrypi.org/downloads, unzip and copy the files onto the SD card.  The NOOBS_v1_3_4.zip was only 1.27GB - much more compact than the images I used to download.
4. Put the SD card into a Model B Raspberry Pi (because it has an Ethernet connector), connect to the WiFi Router via Ethernet, and fire up the Pi
5. Insert the WiFi dongle (the Edimax appears to be the most recommended)
6. Start the WiFi Config program on the Pi's desktop, click on the Scan button, and double-click the required network from the listed networks which have been found.
7. Choose TKIP encryption, enter the WiFi Wireless Key code into PSK, then Add - that's it!
8. Move both the Edimax dongle and the SD card to the PiBot's Pi (mine has a Model A Pi).
9. Download PUTTY (I used this before in an earlier post) to the PC
10. Download TightVNCViewer to the PC (again I used this before in earlier posts)
11. On the Pi, do a sudo apt-get update, and sudo install tightvncserver
12. Run tightvncserver by typing vncserver:1 (I used the same command as before - vncserver:1 -geometry 800x600 -depth24 - the extra attributes -geometry 800x600 specifies the size of desktop to be created - the default is 1024 x 768
    -depth24 : 24 specifies the pixel depth in bits of the desktop to be created - the default is 16 and other possible values are 8, 15 and 24 - don't use anything else.
13. Run  PUTTY and TightVNCViewer on the PC (you can save the VNC session for later convenience) and hey presto - we have the PiBot's Pi desktop running on the PC, through WiFi!!
14. Download the driver for the USB to CP2102 TTL UART Converter from http://www.geeetech.com/Documents/CP2102%20USB%20Driver.rar, unzip, and run the installer file.
15. Download the Arduino sketch for the Bot Board's Arduino from https://github.com/pi-oneers/bot-firmware and upload to the Bot Board via the UART Converter.
     
    Okay -  this brings us to the point where we can communicate with the PiBot from the PC over the WiFi network.  But we still need to fill the PiBot's brain with thoughts and intentions which make it do some proper robot stuff!!  Even before we do this, there's some further preparation to be done - the system needs to be configured:
       
16. Enable the SPI interface on the Raspberry Pi:
    

    a.  first do a sudo raspi-config, choose Advanced Options and then choose Enable SPI interface by default

    b.  do a  sudo nano /etc/modprobe.d/raspi-blacklist.conf to open that file for editing, and make sure that the SPI line is NOT blacklisted, by making sure the line is commented out with a '#' at the start

    c.  restart with a sudo reboot

    d.  check that the module has been loaded with a lsmod | grep spi_bcm2708

17. Install the SPIdev python module:
    sudo apt-get install python-dev
    mkdir python-spi
    cd python-spi
    wget https://raw.github.com/doceme/py-spidev/master/setup.py
    wget https://raw.github.com/doceme/py-spidev/master/spidev_module.c
    cd bot-command && sudo python setup.py install
18. Download the PiBot code repository from Github
    The following command can be used to do a software update:
    git clone https://github.com/pi-oneers/bot-command
19. Test the hardware:
    There are some test programs in the /python-spi/bot-command/examples folder:
    test_pibot_hardware.py,
    drive_in_square.py,
    monitor_ultrasonic.py and
    robot_teleop.py
    which should put the hardware through its paces.  These can be executed by using, for example:
    cd python-spi/bot-command/examples
    sudo python test_pibot_hardware.py
    or sudo python drive_in_square.py
    or sudo python monitor_ultrasonic.pyor sudo python robot_teleop.py

Here's a shot of the PiBot on its pedestal, connected to the laptop, after uploading the Arduino code:

And here's the screen shot to show the headless Pi's desktop and the Arduino IDE with the Bot Board's sketch after loading.

And I got it to move!  Have a look at the following video - it's battery-powered, WiFi-enabled, Arduino-firmwared and controlled by python on the Raspberry Pi!

This python script - drive_in_square.py - simply sends the Bot around the sides of a square (for ever - or until the batteries run out, or, in this case, it collides with something solid!)  I also got the script monitor_ultrasonic.py to run successfully - it gives a continuous reading of distance from the ultrasound transducer to an obstacle, in centimeters.  There are a couple of other test scripts which I have to get going yet - but it's so exciting that the Bot has come to life!!

Next time I will try to explain the software and develop some more python programs.

46. Robotics with PiBot. I - Assembling the PiBot

10,000 page views!!
This is intended to be the first in a set of posts called Robotics with PiBot.  I have no idea how many of these posts there will be, or even if this one is the last, should I blow the whole thing up as soon as I switch it on, making it the end of everything!

The PiBot is a kit for a 2-wheels-at-the-front, one-ball-bearing-behind robot (a tri-bot?), with the Raspberry Pi as its brain.  The kit can be purchased from Team PiBot at http://pibot.org/, where all the current details about the PiBot can be found.  

This is, of course, open source hardware and software, and I get the feeling it will be a long-term project.  Included with the pieces for assembly of the structure of the PiBot is a Bot Board, which allows the PiBot's systems to interact with the Raspberry Pi (which is not supplied).

Hopefully, it will look something like this when it's finished:

The kit currently consists of a chassis, the Bot Board interface, mentioned above, an audio capability (there's a speaker - that round object at the front), independent left and right motors with gearing assemblies, a PiCam control system (on the long arm at the top, Raspberry Pi Camera not supplied) consisting of a stepper motor and a servo (so that's why I was doing all this stuff with motors!), an 8 neo-pixel LED strip (the one illustrated above shows instead, a 16 neo-pixel ring surrounding the speaker), an ultrasound distance sensor (described as its 'eyes') and of course the potential to add almost anything you can imagine!

This post has no circuits, no code, only pictures - but watch this space!

Below are some pictures of the kit and its assembly:

Here are the 8 parts of the kit - straight out of the box, before assembly.

Part 1 before assembly - you can see the speaker near the middle, and the red O-rings used for holding the plastic pieces of the chassis together.	Part 1 assembled

Part 2 before assembly.  The yellow items are the left and right DC motors.	After assembling part 2

Part 3 before assembly.  The small red board is the audio module.	Part 3 assembled and mounted on the PiBot - top view

Part 3 assembled and mounted on the PiBot - there are some 'spare' parts	Part 3 has been assembled and mounted on the other side of the PiBot.

Part 4 before assembly - 4 x AA battery holder and ball bearing castor to act as a back wheel.	Part 4 - the battery holder (sans batteries) and the ball bearing mounted. Underside view.

So that's what the spare parts - perspex plate and 2 O-rings - are for! (a lid to stop the battery holder falling out).

Top view	Top view.  Note the on-off switch at the bottom left.

Underside view.  Contact with the ground is at three points: each wheel, and the ball bearing castor.	Underside view.

Top view	Top view

Part 5 - the interface board (Bot Board) with 2 spare wires (I didn't need them).	Part 5 - underneath the Bot Board. Note the small gel foot at the bottom right, to provide a soft separation from the Pi's capacitor.

The Raspberry Pi (Model A) installed - it has to be a Rev 2 board with the mounting holes.  On the left you can see the SD card protruding from the Pi at the front of the PiBot: 

Top view - before the Bot Board (on the right) has been attached to the Pi. The audio plug has been connected.	Top view - the Bot Board has been mounted on top of the Pi using the Pi's GPIO pins.

I didn't use my Model B as it is a Rev 1 which doesn't have mounting holes. I'm not sure if the Model A will have enough USB sockets etc - I might have to buy yet another Raspberry Pi!

Top view - with some of the wiring connected.	Top view

The total weight at this stage, without batteries and camera assembly etc is 361g.  

I was advised to skip the pan and tilt parts, so I skipped Part 6 and 7 and went on to Part 8, the ultrasound transducer and neo-pixels:

Part 8. The ultrasound transducer (transmitter and detector) - distance sensor (topside), and LED strip (neo-pixels). My strip goes at the rear rather than at the front.	Part 8. The ultrasound transducer (underside)  and the underside of the LED strip (neo-pixels)

Again there was only one place to mount the ultrasound transducer, so this is what the project looks like now:

From the front.	From behind. This is the only place that I could find to place the neo-pixels.

Note that the ultrasound transducer board is upside-down compared with the first picture above, showing how it should look when finished.

But what's this:

This is the voltage regulator, but at the moment I don't know where it goes.  One other thing - the wires go in the order Black, Orange, Red, and apparently they should be Black, Red, Orange, and may need to be corrected?

At this point I will pause while waiting for more details about what to do!!

To do:

Part 6. The stepper motor (to pan the PiCam)	Part 7. The servo (to tilt the PiCam)

Do come back later - there's lots more to come!

45. Improved Light Follower with Wide Field of View

I have made an improvement to the collimation system, which happens to be the same design that Geo Bruce had in his original instructables.com post at http://www.instructables.com/id/Arduino-Solar-Tracker/ !  My previous design of an 'eye' was restricting the field seen, and the tracking system was only making adjustments within a narrow field of view.  Geo's design exposes the light-dependent resistors (LDRs) to light from a much bigger solid angle, and therefore allows the tracker to 'watch' the light levels almost all around it.  (Strictly speaking, the field of view of the whole detection system is a solid angle of almost 2π steradians, [a hemisphere] so the field of view of each LDR is π/2 steradians).  So this makes the system more sensitive to light variations in its vicinity.

Here is what the collimation system looks like now:

I made the collimator's leaves from some cardboard and hot-glued it to a black plastic cap which was screwed onto the pan and tilt bracket.  

The system is now very sensitive - a result of this new collimator, replacing the 10kΩ resistors by 1kΩ resistors in series with the LDRs, and fine adjustment of the two trimmer potentiometers, 'delay' and 'tolerance'.

Here's a video of it working - watch how it follows the beam of the torch - even in a brightly daylight-lit room.  It reacts when I shadow it with my hand.  It even twitches when a tall truck passes by!  I'm watching it slowly pan across the sky as the time passes.  I'm looking forward to seeing it track the sun across the sky (if the sun ever comes out!).

I have also tidied up the software, and here's the code:

1:  // Originally written by Geo Bruce at:  
2:  // http://www.instructables.com/id/Arduino-Solar-Tracker/   
3:  // then slightly modified by S & S Feb 2014  
4:    
5:  #include <Servo.h>                    // include Servo library   
6:    
7:  Servo horizontal;                     // horizontal servo  
8:  int servoh = 90;                      // initialise the position of   
9:                                        // the horizontal servo  
10:    
11:  Servo vertical;                      // vertical servo   
12:  int servov = 90;                     // initialise the position of  
13:                                       // the vertical servo  
14:    
15:  int ldrlt = 0;                       // LDR left top = analog pin 0  
16:  int ldrrt = 1;                       // LDR right top = analog pin 1  
17:  int ldrlb = 2;                       // LDR left bottom = analog pin 2  
18:  int ldrrb = 3;                       // LDR left bottom = analog pin 3  
19:    
20:  void setup()  
21:  {  
22:   Serial.begin(9600);  
23:                                       // servo connections  
24:                                       // attach digital pins  
25:   horizontal.attach(9);   
26:   vertical.attach(10);  
27:  }  
28:    
29:  void loop()   
30:  {  
31:   int lt = analogRead(ldrlt);         // left top  
32:   int rt = analogRead(ldrrt);         // right top  
33:   int lb = analogRead(ldrlb);         // left bottom  
34:   int rb = analogRead(ldrrb);         // right bottom  
35:     
36:   int dtime = analogRead(4)/20;       // read delay potentiometer   
37:   int tol = analogRead(5)/4;          // read tolerance potentiometer  
38:     
39:   int avt = (lt + rt) / 2;            // average value top  
40:   int avd = (lb + rb) / 2;            // average value bottom  
41:   int avl = (lt + lb) / 2;            // average value left  
42:   int avr = (rt + rb) / 2;            // average value right  
43:    
44:   int dvert = avt - avd;              // difference between top and bottom  
45:   int dhoriz = avl - avr;             // difference between left and right  
46:      
47:   if (-1*tol > dvert || dvert > tol)  // check if the difference is within the  
48:                                       // tolerance else change the vertical angle  
49:   {  
50:   if (avt > avd)  
51:   {  
52:    servov = ++servov;  
53:     if (servov > 180)   
54:     {   
55:     servov = 180;  
56:     }  
57:   }  
58:   else if (avt < avd)  
59:   {  
60:    servov= --servov;  
61:    if (servov < 0)  
62:   {  
63:    servov = 0;  
64:   }  
65:   }  
66:   vertical.write(servov);  
67:   }  
68:     
69:   if (-1*tol > dhoriz || dhoriz > tol) // check if the difference is within the   
70:                                        // tolerance else change the horizontal angle  
71:   {  
72:   if (avl > avr)  
73:   {  
74:    servoh = --servoh;  
75:    if (servoh < 0)  
76:    {  
77:    servoh = 0;  
78:    }  
79:   }  
80:   else if (avl < avr)  
81:   {  
82:    servoh = ++servoh;  
83:     if (servoh > 180)  
84:     {  
85:     servoh = 180;  
86:     }  
87:   }  
88:   horizontal.write(servoh);  
89:   }  
90:    delay(dtime);   
91:  }