Category Archives: Interesting

Arduino, Electronics, Hardware, Interesting

Multiple buttons on one pin with an Arduino

16th September 2015 Karl 2 Comments

Here is a circuit that allows you to use five buttons; up, down, left, right and select, on one analogue pin with the Arduino. It is a adaptation of one used on this LCD shield manufactured by DF Robot. I have used a 10K pull-up resistor and added a 100nF capacitor to help with debounce. The downside is that this can only detect one button press at a time, the button with the lowest resistor value is returned, and the output varies when different voltages are used to power it requiring an update to your software.

In this post I am looking to explore the effect of the existing resistor values, and how to choose your own resistors. This kind of circuit is called a multiple voltage divider or voltage ladder where each rung of the ladder, the switches in the diagram above, produces a different output voltage. Pressing one of the buttons on our circuit changes the output to the analogue port from 5V to a lower one determined by the number of resistors (R1 to R4) in series before the button, as you go down the ladder the output voltage to the pin increases. Here is a short sketch I used to test the circuit and show the voltage reading for each button:

//converts analogue reading to volts
int sensorPin = A0;   
int sensorValue = 0;  
float volts = 5; 
float maxVal = 1023;   // maximum value read for 5v
float max3V3 = 671;    // maximum value read when 3.3 volts used.

void showVolts(int val) {  
  float voltage = val * (volts / maxVal);  
  Serial.print(val);  
  Serial.print(", volts: ");
  Serial.println(voltage);  
}

void setup() {
  
  // the arduino uno is set to read analogue ports at 5v. So has a lower maximum at 3.3 volts.
  if (volts == 3.3) {
    maxVal = max3V3;
  }
  
  Serial.begin(9600);  
  delay(1000);  
  showVolts(analogRead(sensorPin));  // with no button pressed, this should equal volts.
  Serial.println("--------------------");
  delay(4000);
}

void loop() {

  sensorValue = analogRead(sensorPin);   
  if (sensorValue <= (int) maxVal-1) { // ignore input when no button pressed
    showVolts(sensorValue);    
  }
  delay(20);

}

//converts analogue reading to volts

int sensorPin = A0;

int sensorValue = 0;

float volts = 5;

float maxVal = 1023; // maximum value read for 5v

float max3V3 = 671; // maximum value read when 3.3 volts used.

void showVolts(int val) {

float voltage = val * (volts / maxVal);

Serial.print(val);

Serial.print(", volts: ");

Serial.println(voltage);

}

void setup() {

// the arduino uno is set to read analogue ports at 5v. So has a lower maximum at 3.3 volts.

if (volts == 3.3) {

maxVal = max3V3;

}

Serial.begin(9600);

delay(1000);

showVolts(analogRead(sensorPin)); // with no button pressed, this should equal volts.

Serial.println("--------------------");

delay(4000);

}

void loop() {

sensorValue = analogRead(sensorPin);

if (sensorValue <= (int) maxVal-1) { // ignore input when no button pressed

showVolts(sensorValue);

}

delay(20);

}

The results from this are shown in the chart below, for the power I used the regulated 5V and 3.3V outputs on the Ardunio Uno, if you run this set-up yourself you may notice an anomalous reading when you release the button, more about this later. Note that a button press drops the power down to the recorded value, the pin is normally high (5V/3.3V) through the 10K resistor.

1: Total value of the resistors in series at the button. 2: this is an average, the actual reading can vary.
	Resistance¹		at 5v		at 3v3
Btn	Value	Meter	reading²	volt	reading²	volt
S1	none		0	0V	0	0V
S2	330Ω	334Ω	31	0.15V	19	0.10V
S3	950Ω	964Ω	88	0.43V	57	0.29V
S4	1950Ω	1948Ω	166	0.81V	108	0.53V
S5	5250Ω	5270Ω	352	1.72V	230	1.14V

There are two columns for the resistance, the value marked on the resistors and the multimeter reading. It is best to use 1% tolerance resistors for this circuit to reduce the chances of the readings drifting close to the next. A good spread of output voltages ensures accurate switching.

All this works very well, but what to do if you wish to add more buttons, or have different output voltages? Looking at the circuit, each button can be seen as a voltage divider, such as shown in the diagram on the left. Where R1 is the 10K pull-up resistor and R2 is the sum of the resistors for the button being pressed.

With this simplified model we can calculate any missing value, but for now there are a couple of things to do; calculate the output voltage for the given input voltage and resistance and more usefully for us, work out a value for R2 to give us the desired output voltage.

Calculating the Output Voltage

Using Switch 2 in our existing circuit for example, with 5 volt power:

$Vout = Vin \times \frac{R_2}{R_1 + R_2} \hspace{15 mm}with\ numbers:\hspace{4 mm} 5 \times \frac{330}{10,000 + 330} = 0.16V$

And again with Switch 4. This has three resistors in series so the value for R2 in the voltage divider is: 330R + 620R + 1K = 1950 ohm:

$5 \times \frac{1,950}{10,000 + 1,950} = 0.82V$

its rather satisfying when your calculations closely agree with the real world readings.

Setting the output Voltage

So, lets try working out some resistors based on the following specification: powered at 5V with five buttons, each 0.20V apart; S1: 0V, S2: 0.20V, S3: 0.40V etc. We know the input voltage, output voltage, and resistor R1, but not R2, here is the formula for finding the resistance of R2:

$R_2 = Vout \times \frac{R_1}{Vin - Vout}$

$S2: 0.20 \times \frac{10,000}{5 - 0.20} = 417\X\Omega \hspace{5 mm} S3: 0.40 \times \frac{10,000}{5 - 0.40} = 870\X\Omega \hspace{5 mm} S4: 0.60 \times \frac{10,000}{5 - 0.60} = 1364\X\Omega \hspace{5 mm} S5: 0.80 \times \frac{10,000}{5 - 0.80} = 1905\X\Omega$

These values show the resistance required for each switch and to find the resistor the previous resistance value needs to be deducted. As these values probably won’t be in the E24 Standard Value range and won’t be available in the shops I have the nearest available value in the Standard Resistor column:

1: actually the nearest is 510Ω, but 560Ω was the closest I had
Btn	Resistance	Resistor	Standard Resistor
S1	none
S2	417Ω	417Ω	R1:	390Ω
S3	870Ω	453Ω	R2:	430Ω
S4	1364Ω	494Ω	R3:	560Ω¹
S5	1905Ω	541Ω	R4:	560Ω

Obviously, we will need to get this onto breadboard for testing.

Using the same sketch as before I re-ran the tests with the new resistor values, the results are shown below; I have also included an Expected column to show the calculated voltage using the method shown earlier.

				at 5v			at 3v3
btn	Resistor		Resistance	expected	reading	volt	expected	reading	volt
S1	none			–	0	0V	–	0	0V
S2	R1	390Ω	390Ω	0.19V	39	0.19V	0.12V	25	0.12V
S3	R2	430Ω	820Ω	0.38V	76	0.37V	0.25V	50	0.25V
S4	R3	560Ω	1380Ω	0.61V	122	0.60V	0.40V	81	0.40V
S5	R4	560Ω	1940Ω	0.81V	165	0.81V	0.53V	108	0.53V

That, to me, looks close enough to the 0.20V separation at 5V specified to provide some stable hardware. Here is a short sketch to demonstrate the use of analogue buttons, it returns a number corresponding to the button pressed. When you release a button its resistance changes momentarily to give the Arduino a false reading, to fix this I have added de-bounce functionality to this program:

// analog button test

#define ANALOG_BTN A0

byte btnVal = 0;
byte lastButton = 0;
unsigned long lastBtnPress;

// changes the sensorValue into the number of the button pressed
byte getButton(int sensorValue) {
  // change these sensorValue numbers to suit your own button readings
  if (sensorValue > 150) {
    return 5;
  }
  if (sensorValue > 110) {
    return 4;
  }
  if (sensorValue > 70) {
    return 3;
  }
  if (sensorValue > 30) {
    return 2;
  }
  if (sensorValue >= 0) {
    return 1;
  }  
  return 0;
}

// which analog select button has been pressed?
//   byte imp   analog input 
byte whichSelectBtn(byte imp) {

  const int sensorMax = 1023;  // 671 for 3.3 volts
  // return when no buttons are being pressed
  if (analogRead(imp) >= sensorMax-1) {
    return 0;
  }

  byte buttonOut = 0;
  const int samples = 150;
  const int debounce  = 30;    // no of milisecs to wait before accepting a button change  
  
  // take an average reading
  unsigned int sensorValue = 0;
  for (int i = 0; i < samples; i++) { 
     sensorValue = sensorValue + analogRead(imp); 
  } 
  sensorValue = sensorValue / samples; 
  buttonOut = getButton(sensorValue); 

  // if buttonOut changes too rapidly, then ignore the change - debounce 
  if (buttonOut != lastButton && lastBtnPress > millis()) {
    buttonOut = 0;
  }  
  lastBtnPress = millis() + debounce; 
  lastButton = buttonOut; 
  return buttonOut;
}
  
void setup() {  
  Serial.begin(9600);  
  delay(1000);
  Serial.println("ready");
}

void loop() {

  btnVal = whichSelectBtn(ANALOG_BTN);
  if (btnVal > 0) {
    Serial.print("button ");
    Serial.println(btnVal);

    if (btnVal == 5) {
      Serial.println("select button");
    }
    // etc...   or use a switch statement    
  }
  
}

// analog button test

#define ANALOG_BTN A0

byte btnVal = 0;

byte lastButton = 0;

unsigned long lastBtnPress;

// changes the sensorValue into the number of the button pressed

byte getButton(int sensorValue) {

// change these sensorValue numbers to suit your own button readings

if (sensorValue > 150) {

return 5;

}

if (sensorValue > 110) {

return 4;

}

if (sensorValue > 70) {

return 3;

}

if (sensorValue > 30) {

return 2;

}

if (sensorValue >= 0) {

return 1;

}

return 0;

}

// which analog select button has been pressed?

// byte imp analog input

byte whichSelectBtn(byte imp) {

const int sensorMax = 1023; // 671 for 3.3 volts

// return when no buttons are being pressed

if (analogRead(imp) >= sensorMax-1) {

return 0;

}

byte buttonOut = 0;

const int samples = 150;

const int debounce = 30; // no of milisecs to wait before accepting a button change

// take an average reading

unsigned int sensorValue = 0;

for (int i = 0; i < samples; i++) {

sensorValue = sensorValue + analogRead(imp);

}

sensorValue = sensorValue / samples;

buttonOut = getButton(sensorValue);

// if buttonOut changes too rapidly, then ignore the change - debounce

if (buttonOut != lastButton && lastBtnPress > millis()) {

buttonOut = 0;

}

lastBtnPress = millis() + debounce;

lastButton = buttonOut;

return buttonOut;

}

void setup() {

Serial.begin(9600);

delay(1000);

Serial.println("ready");

}

void loop() {

btnVal = whichSelectBtn(ANALOG_BTN);

if (btnVal > 0) {

Serial.print("button ");

Serial.println(btnVal);

if (btnVal == 5) {

Serial.println("select button");

}

// etc... or use a switch statement

}

With this substitution on R3, changing the desired 510 ohm resistor for a 560 ohm, It may be interesting to see what kind of tolerance range we may be able to use. So, for the 0.60V output the optimal resistor would be 494 ohm but we only have Standard Resistor values available and to find the resistance value for our calculation to find the output voltage we need to add 820 ohm (R1 + R2) to R3:

Resistor	Resistance	Volts
430Ω	1250Ω	0.5556V
470Ω	1290Ω	0.5713V
510Ω	1330Ω	0.5869V
560Ω	1380Ω	0.6063V
620Ω	14400Ω	0.6294V

Clearly, using four decimal places shows is that a 510 ohm resistor is rounded up to 0.60V, while the 560 ohm rounds up to 0.61V, so for our purposes both are suitable. The other resistors will be outside the specification.

Finding the Power Consumption

We also need to look at how much power our circuit is consuming, this is for two reasons: to ensure that our resistors are properly rated and that the power supply can supply enough power. The Ardunio Uno provides a regulated supply of 20mA at 5V and 50mA at 3.3V. The calculation is done with Ohms law:

$I = \frac{V}{R}$

So, in the original circuit the shortest path to ground is through Switch 1 and the 10K resistor:

$\frac{5}{10,000} = 0.0005A \times 1000 = 0.5mA$

a very low current, this is the maximum the circuit can use. Optionally, to work out the power use for another button add up all the resistors before the switch, for example in the original circuit Switch 5 comes to: 15250 ohm

$\frac{5}{15,250} = 0.00034A \times 1000 = 0.34mA$

Voltage Divider Calculations

Just to round things off, here are four formulae for finding any resistor and voltage in the divider circuit:

$find\ resistor\ value: R_1 = \frac{Vin \times R_2}{Vout}-R_2 \hspace{20 mm} R_2 = Vout \times \frac{R_1}{Vin - Vout}$

$find\ the\ voltage: Vin = \frac{Vout \times (R_1 + R_2)}{R_2} \hspace{20 mm} Vout = Vin \times \frac{R_2}{R_1 + R_2}$

Links and Sources

https://www.arduino.cc/en/Tutorial/ReadAnalogVoltage
http://www.freetronics.com.au/pages/16×2-lcd-shield-quickstart-guide
https://en.wikipedia.org/wiki/Voltage_ladder and https://en.wikipedia.org/wiki/Resistor_ladder
http://www.diyaudioandvideo.com/Electronics/ResistorColorCodes/
https://learn.sparkfun.com/tutorials/voltage-dividers
Practical Electronic for Inventors 3rd Ed. 2013, isbn:9780071771337. p7
Art of Electronics 3rd Ed. 2015, isbn:9780521809269. p61

Arduino, Electronics, Hardware, Interesting

Solenoids on the Arduino with MOSFET power

22nd February 2015 Karl 1 Comment

I am needing to control a solenoid from the Arduino to do some high speed water splash photography. The Solenoid works at 12v and draws up to 2.5w when open, obviously a direct connection to the Arduino is out of the question. Looking in my parts bucket I found an FQP30N06L MOSFET and recalled that I’d used these to control a small motor.

The FQP30N06L MOSFET in a TO-220 package,
the heatsink tab is connected to the Drain

The FQP30N06L is a N-Channel MOSFET and can switch up to 60V DC at 32A, this is more than chunky enough for the solenoid. For use with the Arduino it needs to have ‘logic-level’ switching of 5V, looking at the datasheet for the Static Drain-Source On-Resistance – R_DS(on) we can see a test condition where V_GS=5V (or 4.5V) exists then we know the MOSFET is suitable.

Looking for logic-level volts in the On Characteristics (source: FQP30N06L datasheet)

The Circuit:

D1: 1N4002 Diode – provides surge suppression from the solenoid, this protects the MOSFET from inductive voltage ‘kickback’.
L1: the Solenoid or motor (a solenoid is just a linear motor)
Q1: FQP30N06L MOSFET being used as a switch
R1: 220R Resistor – current limiting, see below.
R2: 100K Resistor – this keeps the Gate closed when the Arduino output is off/LOW

The resistor R1 is there to protect the Arduino. On a MOSFET when a voltage is first applied to the Gate it can appear as a short to ground, limiting the current will prevent a surge that may cause damage. The Arduino supplies 5V at 40mA on a digital I/O pin.

A MOSFET switches when there is a charge at the Gate, the higher the charge the wider the gate opens and more current can flow through the Source to the Drain. Looking on the datasheet for our MOSFET the Gate Threshold Voltage V_GS(th) shows a minimum of 1V and a maximum of 2.5V, this means that below 1V the gate is closed, at 1V the gate is ajar, as the voltage increases the gate opens wider until you reach 2.5V where it is fully open, power can go above this but the gate will not open any further. Going above 20V on the gate V_GS will break the MOSFET.

So we need a resistor low enough to fully open the gates, but high enough to prevent the Arduino spluttering. So I chose to limit the current to 20mA and calculated the resistor with Ohms Law:
R = V / I
5V / 20mA = 250R (I used a 220R as that’s the nearest I had, this limits the current to 23mA)

Ground on the Ardunio is shared with the 12V power supply for the solenoid.

Programming

Connect the circuit to your Arduino, the MOFSET’s gate to a digital output and ground. You may want to avoid digital pins 0 and 1 as these are on the serial port and can cause the solenoid to rattle unexpectedly.

Here is the Solenoid equivalent of blink, with the solenoid circuit connected to digital pin 3 it is switched on and off once a second:

#define SOLENOID 3
#define LED 13

void setup() {
  pinMode(SOLENOID, OUTPUT);
  pinMode(LED, OUTPUT);   
}

void loop() {
  digitalWrite(SOLENOID, HIGH);   
  digitalWrite(LED, HIGH);
  delay(1000); 
  digitalWrite(SOLENOID, LOW);   
  digitalWrite(LED, LOW);
  delay(1000);
}

#define SOLENOID 3

#define LED 13

void setup() {

pinMode(SOLENOID, OUTPUT);

pinMode(LED, OUTPUT);

}

void loop() {

digitalWrite(SOLENOID, HIGH);

digitalWrite(LED, HIGH);

delay(1000);

digitalWrite(SOLENOID, LOW);

digitalWrite(LED, LOW);

delay(1000);

}

Comedy effect can be had by reducing the timings to milliseconds, although keeping that up for too long will probably knacker the solenoid.

References and Links:

FQP30N06L Datasheet: http://www.farnell.com/datasheets/1774697.pdf
MOSFET for Beginners: http://blog.oscarliang.net/how-to-use-mosfet-beginner-tutorial/
Using MOSFET at TTL levels: https://arduinodiy.wordpress.com/2012/05/02/using-mosfets-with-ttl-levels/
MOSFET Gate resistor: http://electronics.stackexchange.com/questions/135133/calculate-mosfet-gate-resistor
MOSFET Gate current: http://electronics.stackexchange.com/questions/31594/mosfet-when-can-we-not-assume-that-the-gate-current-is-0
MOSFET limitations: http://www.embeddedrelated.com/showarticle/77.php

Arduino, Electronics, Interesting

Rotary Encoders in Colour on the i2c Bus

24th January 2015 Karl 9 Comments

This is a follow-up to my previous writings on the subject of rotary encoders: Rotary Encoders on the i²c Bus. This time I am using the Sparkfun Rotary Encoder – Illuminated (RGB) (Part: COM-10982), this has the same rotary goodness as the SparkFun 12-step rotary encoder but with the addition of three LED’s to provide a whole host of colours on the rotating shaft.

Test Setup

Again I will be using the MCP23017 port expander to add 16 digital I/O ports to the Arduino via the i²c bus, the rotary encoder part operates in the same manner as before and we can use the internal pull-up resistors to reduce the number of components. The LED’s operate with a common anode and the push button also operates on 5v rather than the usual switching to ground.

For my test setup I have connected the rotary encoder to GPA0 and GPA1, the push button to GPA2 and the Red, Green and Blue LED’s to GPA5, GPA4 and GPA3. Note the 10K pull-down resistor on the push button.

My program on the Arduino changes the colours as you rotate the shaft, you will see seven colours, to see more you would need to use PWM to control the LED’s brightness. With the common anode on the LED’s the logic for switching them is inverted, so HIGH = off, LOW = on. You will need the Adafruit MCP23017 Arduino Library.

#include <Wire.h>
#include "Adafruit_MCP23017.h"  // https://github.com/adafruit/Adafruit-MCP23017-Arduino-Library

// setup the port expander
Adafruit_MCP23017 mcp0;

#define ROT_A 0
#define ROT_B 1
#define ROT_BTN 2
#define ROT_RED 3
#define ROT_GRN 4
#define ROT_BLU 5

// some colours to display
// because of the common anode on the LED's, logic is inverted: 0 = on, 1 = off
//                         R  G  B         
boolean colours[8][3] = { {1, 1, 1},  // off (black)
                          {1, 1, 0},  // blue
                          {1, 0, 1},  // green
                          {1, 0, 0},  
                          {0, 1, 1},  // red
                          {0, 1, 0},  
                          {0, 0, 1},  
                          {0, 0, 0}}; // white                         

int colPointer = 0;
unsigned long currentTime;
unsigned long loopTime;
int rotAprev=0;
const int leds[3] = { ROT_RED, ROT_GRN, ROT_BLU }; 

void setColours(boolean colour[]) {           
    for (int i=0; i<3; i++) {  
       mcp0.digitalWrite(leds[i], colour[i]);    
    }  
    return;
}

void setup() {  

  Serial.begin(9600);
  mcp0.begin(0);                // 0 = i2c address 0x20
   
  mcp0.pinMode(ROT_A, INPUT);     // Rotary switch A
  mcp0.pullUp(ROT_A, HIGH);       // turn on a 100K pullup internally
  
  mcp0.pinMode(ROT_B, INPUT);     // Rotary switch B
  mcp0.pullUp(ROT_B, HIGH);       // turn on a 100K pullup internally
  
  mcp0.pinMode(ROT_BTN, INPUT);   // Push Button
  
  mcp0.pinMode(ROT_RED, OUTPUT);  // Red
  mcp0.pinMode(ROT_GRN, OUTPUT);  // Green
  mcp0.pinMode(ROT_BLU, OUTPUT);  // Blue
  
  mcp0.digitalWrite(ROT_RED, HIGH);  // all colours off
  mcp0.digitalWrite(ROT_GRN, HIGH);  // HIGH = off, LOW = on
  mcp0.digitalWrite(ROT_BLU, HIGH);
  
  currentTime = millis();
  loopTime = currentTime;
  Serial.println("ready");
  setColours(colours[0]);
}


void loop() {
  
  currentTime = millis();
    
  // check every 5 millisecs  
  if(currentTime >= (loopTime + 5)) {
    int rotA = mcp0.digitalRead(ROT_A);
    int rotB = mcp0.digitalRead(ROT_B);  
    
    // turn white if the button is pressed
    if (mcp0.digitalRead(ROT_BTN) == true) {
      setColours(colours[7]);  
    }
    
    // see if there has been any rotation
    if((!rotA) && (rotAprev)) {
      if (rotB) {
        Serial.println("clockwise");
        colPointer++;
      }    
      else {
        Serial.println("counter-clockwise");  
        colPointer--;
      }
      
      // make sure the pointer stays within range
      if (colPointer > 7) {
        colPointer = 0;
      }
      if (colPointer < 0) {
        colPointer = 7;
      }
      
      Serial.print("pointer: ");
      Serial.println(colPointer);
      // set the shaft colour to that in pointer
      setColours(colours[colPointer]);
    }    
    rotAprev = rotA;
    loopTime = currentTime;  // Updates loopTime
   }
}

100

101

102

103

104

105

106

107

108

#include <Wire.h>

#include "Adafruit_MCP23017.h" // https://github.com/adafruit/Adafruit-MCP23017-Arduino-Library

// setup the port expander

Adafruit_MCP23017 mcp0;

#define ROT_A 0

#define ROT_B 1

#define ROT_BTN 2

#define ROT_RED 3

#define ROT_GRN 4

#define ROT_BLU 5

// some colours to display

// because of the common anode on the LED's, logic is inverted: 0 = on, 1 = off

// R G B

boolean colours[8][3] = { {1, 1, 1}, // off (black)

{1, 1, 0}, // blue

{1, 0, 1}, // green

{1, 0, 0},

{0, 1, 1}, // red

{0, 1, 0},

{0, 0, 1},

{0, 0, 0}}; // white

int colPointer = 0;

unsigned long currentTime;

unsigned long loopTime;

int rotAprev=0;

const int leds[3] = { ROT_RED, ROT_GRN, ROT_BLU };

void setColours(boolean colour[]) {

for (int i=0; i<3; i++) {

mcp0.digitalWrite(leds[i], colour[i]);

}

return;

}

void setup() {

Serial.begin(9600);

mcp0.begin(0); // 0 = i2c address 0x20

mcp0.pinMode(ROT_A, INPUT); // Rotary switch A

mcp0.pullUp(ROT_A, HIGH); // turn on a 100K pullup internally

mcp0.pinMode(ROT_B, INPUT); // Rotary switch B

mcp0.pullUp(ROT_B, HIGH); // turn on a 100K pullup internally

mcp0.pinMode(ROT_BTN, INPUT); // Push Button

mcp0.pinMode(ROT_RED, OUTPUT); // Red

mcp0.pinMode(ROT_GRN, OUTPUT); // Green

mcp0.pinMode(ROT_BLU, OUTPUT); // Blue

mcp0.digitalWrite(ROT_RED, HIGH); // all colours off

mcp0.digitalWrite(ROT_GRN, HIGH); // HIGH = off, LOW = on

mcp0.digitalWrite(ROT_BLU, HIGH);

currentTime = millis();

loopTime = currentTime;

Serial.println("ready");

setColours(colours[0]);

}

void loop() {

currentTime = millis();

// check every 5 millisecs

if(currentTime >= (loopTime + 5)) {

int rotA = mcp0.digitalRead(ROT_A);

int rotB = mcp0.digitalRead(ROT_B);

// turn white if the button is pressed

if (mcp0.digitalRead(ROT_BTN) == true) {

setColours(colours[7]);

}

// see if there has been any rotation

if((!rotA) && (rotAprev)) {

if (rotB) {

Serial.println("clockwise");

colPointer++;

}

else {

Serial.println("counter-clockwise");

colPointer--;

}

// make sure the pointer stays within range

if (colPointer > 7) {

colPointer = 0;

}

if (colPointer < 0) {

colPointer = 7;

}

Serial.print("pointer: ");

Serial.println(colPointer);

// set the shaft colour to that in pointer

setColours(colours[colPointer]);

}

rotAprev = rotA;

loopTime = currentTime; // Updates loopTime

}

Candle

Image 15th December 2012 Karl

Computer, Hardware, Interesting, Raspberry Pi

Can a Pi Raspberry?

9th August 2012 Karl 2 Comments

The Raspberry Pi is a small computer, and as such an obvious but important question occurred to me, and despite Google, I was unable to find an answer. So using science, LEGO, a balloon, and a compressed air supply I set out to discover if the Raspberry Pi could indeed blow a raspberry.

To embark on this scientific discovery, first, I needed to be able to control a motor, for this I built a dual relay board that can be switched using a couple of the Pi’s GPIO pins:

Here is the circuit diagram:

LEGO PF Motor Controller v3 - Circuit — LEGO PF Motor Controller v3 – Circuit

And the Python source code:

#! /usr/bin/python
 
from time import sleep
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
 
PARP_ON  = 23
PARP_OFF = 24
 
# Set up the GPIO channels
GPIO.setup(PARP_ON, GPIO.OUT)
GPIO.setup(PARP_OFF, GPIO.OUT)
 
def parpON():
 
    GPIO.output(PARP_ON, True)
    sleep(0.4)
    GPIO.output(PARP_ON, False)
    return
 
def parpOFF():
 
    GPIO.output(PARP_OFF, True)
    sleep(0.4)
    GPIO.output(PARP_OFF, False)
    return
 
if __name__ == "__main__":
    print "The Incredible Pi Raspberry Machine";
 
    for i in range(0,5):
        print "parp ",i
        parpON()
        sleep(2)
        parpOFF()
        sleep(0.7)
 
    GPIO.output(PARP_ON, False)
    GPIO.output(PARP_OFF, False)

#! /usr/bin/python

from time import sleep

import RPi.GPIO as GPIO

GPIO.setmode(GPIO.BCM)

PARP_ON = 23

PARP_OFF = 24

# Set up the GPIO channels

GPIO.setup(PARP_ON, GPIO.OUT)

GPIO.setup(PARP_OFF, GPIO.OUT)

def parpON():

GPIO.output(PARP_ON, True)

sleep(0.4)

GPIO.output(PARP_ON, False)

return

def parpOFF():

GPIO.output(PARP_OFF, True)

sleep(0.4)

GPIO.output(PARP_OFF, False)

return

if __name__ == "__main__":

print "The Incredible Pi Raspberry Machine";

for i in range(0,5):

print "parp ",i

parpON()

sleep(2)

parpOFF()

sleep(0.7)

GPIO.output(PARP_ON, False)

GPIO.output(PARP_OFF, False)

To which I connected a large LEGO PF motor. This is used to switch the pneumatic valves via a clutch cog and a large cog. I used a 9v power supply for this, but a PF Battery box can be used, cut an PF extension lead in half, use the light grey side for the motor, and the dark grey end to connect to the battery box. My compressed air supply operates at 2bar / 30 psi, it was built to work with LEGO pneumatics, I found that anything much above that pressure would cause the pipes to pop off the connectors.

Obviously I needed something that would make a sound. For this, a balloon (the sausage type), a small pop bottle, and some more LEGO were suffice. The air is injected into the bottle trough a couple of holes at the rear.

I would like to say thanks to the people on the Raspberry Pi forum for their advice on the electronics: http://www.raspberrypi.org/phpBB3/ and further reading about LEGO PF motors can be found here: http://www.philohome.com/pf/pf.htm, and the raspberry http://en.wikipedia.org/wiki/Blowing_a_raspberry

Interesting

Karl’s Roast Calculator

24th June 2012 Karl 5 Comments

Because of this website makeover, my incredibly useful Roast Calculator which, not only, helps you work out the time you need to cook your joint of meat for, but also works out what time to put it in the oven, now has a new link: https://www.g7smy.co.uk/roast

Calculating the Output Voltage

Setting the output Voltage

Finding the Power Consumption

Voltage Divider Calculations

Links and Sources

The Circuit:

Programming

References and Links:

Test Setup

Links

COMPUTERS, ROBOTS AND PHOTOGRAPHY