Tuesday, November 29, 2011

Arduino going mainstream

I saw an announcement that Sparkfun has put together an Arduino Invetors kit and it's available to order on Amazon US (SparkFun Inventor's Kit for Arduino)

It's great to see the Arduino going proper mainstream.  Up until now I've bought my Arduino bits from specialist electronics hobby sites or ebay.  It looks like tinkering is becoming more popular.

Saturday, November 12, 2011

Arduino - Light Dependent Resistor used to control brightness of LED


A light dependent Resistor (LDR) changes it's resistance based on how much light hitting it.

I know this can be done without the Arduino, I am dong this to get the bits together for a more complex project.
Making sure the individual pieces work before putting them together.

I read the LDR on analog pin 1 and then used PWM on pin 6 to set the LED.




// Background Light (the brightest it will be)
int LDRMax;

// When LDR is value returned (depends on the resistor in line with the LDR (I used a 1.5K)
int LDRMin = 50;

// Ratio of range to 255 (max analog out reading)
float LDRRatio;

// Analog Pin for reading LDR
int LDRPin = 1;

// The Value read for the LDR
int LDRValue;

// PWM Pin for the LED
int ledPin = 6;

void setup() {               
  // Initalize LED Pin
  pinMode(ledPin, OUTPUT);    

  // Enable Serial Communication - useful for debugging
  Serial.begin(9600);
 
  // Get the maximum LDR Reading
  LDRMax = analogRead(LDRPin);

  // Print to serial
  Serial.print("LDRMax: ");
  Serial.println(LDRMax);

  // Calculate the ratio (note the use of float - since the calculation is being done on integers you have to state this is a float calculation
  LDRRatio = (float)255/(LDRMax-LDRMin);

  // Print to serial
  Serial.print("LDRRatio: ");
  Serial.println(LDRRatio);

}

void loop() {
  // Read the LDR
  LDRValue = analogRead(LDRPin) - LDRMin;

  // Print the value to the monitor so I can see it
  Serial.println(LDRValue);

  // Modify reading to match analogWrite range using Ration calculation
  LDRValue = (LDRValue
  ) * LDRRatio;
  // Sometimes the number is over 255 or under 0 - rounding errors !!!!!
  if (LDRValue < 0){LDRValue = 0;}
  if (LDRValue > 255){LDRValue = 255;}
 
  // Print to Monitor 
  Serial.print("LDRValue after calculation: ");
  Serial.println(LDRValue);

  // Set the value for the LED
  analogWrite(ledPin, LDRValue);
   
  delay(100);
}

Still figuring out the Arduino coding and also auto calibrate the LDR so I have the full range.
In the video the range of readings was from 30 to 155.  The scale is 0 to 1023 so I'm only getting a small portion of the range which means I have to get this right to go from full brightness to off.

Tuesday, November 8, 2011

Arduino - Continuous Rotation Servo

As part of my usual trawl around the Internet to learn a bit about electronics I came across the following page on Maker Wiki page.

http://makeprojects.com/Wiki/Servos

It explains how to modify a servo so that it can rotate continuously clockwise and anti-clockwise.  Since I bought a pack of 4 servos on ebay I decided I would see if I can get this to work with my really cheap servos.

I took apart the servo and found it was a bit different.  Firstly, it had screws rather than being held together with plastic clips.  A bit of a result for me as it meant I could easily take it apart without fear of breaking the housing.

The base metal stopper was the same but the plastic stopper was on one of the cogs rather than being on the casing.  Again, fairly easy to take into account.

I then had to disconnect the little PCB and wire in the 2 resistors.  This is where I found out I'm a bit ham fisted and out of practice on the soldering.  I eventually got it done and re-assembled the servo.  It's a really tight fit in there but the screws made it easier to 'squeeze' it all back in.
I didn't have 2 x 2.2k Ohm resistors so I used 2. 1.5k Ohm resistors.  No idea what difference it makes but it worked.  If somebody can explain the affect I would really appreciate it.

Then it was down to attaching it to the Arduino.

I chose Pin10 for no other reason than I used it before to control a Servo.

As per the Maker guide I had to find the centre value.  For this servo it was 77.  If you do this your will probably be different..

I attached the servo.
Brown - Ground
Red - 5V
Orange - Analog in

It started rotating so I knew the mechanical bit worked.

The code below for the Arduino is quite simple as it was just for a test. 

// Servo Continuous
// Code to spin a servo modified to do continuous rotation
// Small cheap 9g servo modified using 2 x 1.5k Resistors
// and details from: http://makeprojects.com/Wiki/Servos

#include <Servo.h>

int CStop = 77;  // The value where the Servo is Stopped

Servo myservo10;  // create servo object to control a servo on pin10

void setup()
{
myservo10.attach(10);  // attaches the servo on pin 10 to the servo object
pinMode(13, OUTPUT);   // Using the LED on the Arduino UNO to know what is going on - not reallt needed 
}

void loop()
{
    // STOP - Setting to CStop stops the Servo
  myservo10.write(CStop); // Put servo stop
  digitalWrite(13, HIGH);   // set the LED on

  // Pause
  delay(5000);

  //
  myservo10.write(5); // Rotate servo CLOCKWISE
  digitalWrite(13, LOW);   // set the LED on
  // Pause
  delay(5000);


    // STOP - Setting to CStop stops the Servo
  myservo10.write(CStop); // Put servo stop
  digitalWrite(13, HIGH);   // set the LED on


  //
  myservo10.write(150); // Rotate servo ANTI-CLOCKWISE
  digitalWrite(13, HIGH);   // set the LED on
  // Pause
  delay(5000);
 

Video showing it rotating - yeah...


 My real aim is to use at least 2 of these to drive a vehicle of some sort.  Maybe use the PS2 controller to control it.  Or try to create a line following robot (not really a robot but that's appears to be what people call them)

I promise next time I will take pictures of the process for modifying the servo so that you can see what it looks like.

As a guide to do this first one it took me over an hour to get it done.  As I said a bit rusty...

Wednesday, August 17, 2011

Arduino - TVOut Library


I love that the community around the Arduino way smarter than I am.
How about connecting your Arduino to your TV (Composite - yellow wire) with just a connector cable and 2 resistors for the circuit.

The following YouTube video shows it running Tetris.  Also, in the description for the video is a link to the code.



I don't know who is but they are definitely way smarter than I am and might cause me to not get rid of the crappy 14" TV we have sitting around gathering lots of dust.

Who'd have thought that such a little board would provide som much fun.



Thursday, July 14, 2011

Arduino - Web server controlled LED using serial connection between the Arduino and web server

I was chatting to a friend who was working on home automation.  Controlling lights, heating and other stuff around the house using a touch screen controller and I thought if you used a web site as the interface then connected to the Arduino over a serial link it would be possible to switch things on and off from any devlice that could display a web page and access the web server.

Personally, I would not recommend using a serial link from the server to the Arduino as the Arduino resets itself everytime something is sent over serial,  More correctly an ethernet shield would be great.  Giving more scalability as the web server can talk to mutliple Arduinos with no great extra effort.

I installed XAMPP on my netbook as the webserver and used PHP code on the server to present the web interface and send the command to the Arduino over serial.  The Arduino is waiting for a serial command and then depending on what it is will turn on or off the mounted LED.

So, not the most impressive looking demo, but as a proof of concept if I can turn on a LED I can control a relay to turn on an kind of device.


Below is the code.  Be aware I'm more about getting the Arduino to do something and so the code will be a bit rough around the edges.  It works but I definitely do not consider it best practise or even efficent code.
Use at your own risk.


PHP on the server:

<?php

exec('mode com4: baud=9600 data=8 stop=1 parity=n xon=no');

$switch1 = "";

/* Serial script for pan/tilt Camera with servos */
/* Script by Aneal Khimani, 2-12-10 */

//check the GET action SuperGlobal var to see if an
//action is to be performed

if (isset($_GET['action'])) {

$switch1 = $_GET['action'];

//Action required

switch ($switch1) {
case "on":
$fp = fopen("com4", "w");
fwrite($fp, chr(97));
fclose($fp);
break;

case "off":
$fp = fopen("com4", "w");
fwrite($fp, chr(98));
fclose($fp);
break;


}
}

?>

<html>
<body>
<center>

<p>
<font size="4">Flick Switch</font><br />
<table width="30">
<tr><td><a href="<?=$_SERVER['PHP_SELF'] . "?action=on" ?>">On</a></td><td><?php if($switch1 == 'on'){echo "<b>ON</b>";} ?></td></tr>
<tr><td><a href="<?=$_SERVER['PHP_SELF'] . "?action=off" ?>">Off</a></td><td><?php if($switch1 == 'off'){echo "<b>OFF</b>";} ?></td></tr>
</table>
</p>

</center>
</body>
</html>


Arduino Code:

/*

  Used with the PHP code
  http://localhost/arduino.php
 */

void setup() {               

  Serial.begin(9600); // initialize serial communication:

  // initialize the digital pin as an output.
  // Pin 13 has an LED connected on most Arduino boards:
  pinMode(13, OUTPUT);    
}

void loop() {

// read the serial port:

if (Serial.available() > 0) {
int inByte = Serial.read();

switch (inByte) {
case 'a':
  digitalWrite(13, HIGH);   // set the LED on
  Serial.println("HIGH");
 
break;

case 'b':
  digitalWrite(13, LOW);   // set the LED off
  Serial.
  println("LOW");

break;
}

}

}

Wednesday, June 8, 2011

Arduino Servo mounted maze controlled by 4 buttons

OK, this one is a bit less impressive than I wanted it to be.  Then I found out that really cheap servos cannot take the weight of a decent sized maze.  So, plan B was to use a small maze as a 'proof of concept'.

Using 4 buttons for up, down, left and right to move the maze to get the bead from the start to the finish.

The code (which is below) is actually quite straight forward.  Most of my time was spend gluing bits of cardbaord together to make the various bits that are needed to mount the servos and the maze itself..

In case you need recommends on cardbaord the box that the bumper packs of pampers nappies come in are ideal.  (yes I have small kids)


Below is the code.  Be aware I'm more about getting the Arduino to do something and so the code will be a bit rough around the edges.  It works but I definitely do not consider it best practise or even efficent code.
Use at your own risk.


// Balance Table for Maze
// Winkleink
// 2011

// Pin 7 Left
// Pin 6 Right

//Pin 5 Up
//Pin 4 Down

// Pin 10 Servo - Up/Down
// Pin 9 Servo - Left/Right

// Library that makes working with Servos easier
#include <Servo.h>

// Set Button variables
int bLeft = 5;  // Left Button
int bRight = 4;  // Right Button
int bUp = 7;  // Up Button
int bDown = 6;  // Down Button

// Set Servo variables
Servo servoUD;  // Servo Up/Down on Pin 10 
Servo servoLR;  // Servo Left/Right on Pin 9

//Set Servo position variables
int posUD = 100;    // variable to store the Up/Down servo position
int posLR = 100;    // variable to store the Left/Right servo position

void setup()
{
  servoUD.attach(10);    // attaches the servo on pin 10 to the servo object
  servoLR.attach(9);    // attaches the servo on pin 9 to the servo object

  pinMode(bLeft,INPUT);  // bLeft - Left Button
  pinMode(bRight,INPUT);  // bRight - Right Button
  pinMode(bUp,INPUT);  // bUp - Up Button
  pinMode(bDown,INPUT);  // bDown - Down Button


void loop()
{
// Position the Serrvo
// As the initial variable are center this also centers the table when it starts
servoUD.write(posUD);
servoLR.write(posLR);
 
if (digitalRead(bLeft) == HIGH){
posLR--;
}

if (digitalRead(bRight) == HIGH){
posLR++;
}

if (digitalRead(bUp) == HIGH){
posUD--;
}

if (digitalRead(bDown) == HIGH){
posUD++;
}

delay(50);
}

Sunday, May 22, 2011

Arduino Servo Catapult

Decided to put my cardboard gluing skills to a new use and tried to build a catapult.
Did the whole cutting and gluing the tower and the arm,  Mounted the servo and did the coding.

Everything worked - except the servo is too slow so the projectile (the bead) just kind of falls out.

The code is very simple.
Read a button.
Move the servo and the arm
Pause
Reset the servo and the arm


Below is the code.  Be aware I'm more about getting the Arduino to do something and so the code will be a bit rough around the edges.  It works but I definitely do not consider it best practise or even efficent code.
Use at your own risk.

// Catapult
// Read a button press on pin 4
// and Sweep the servo on pin 10

#include <Servo.h>

int button4 = 4;  // Used to start servo10
Servo myservo10;  // create servo object to control a servo on pin10

void setup()
{
myservo10.attach(10);  // attaches the servo on pin 10 to the servo object
pinMode(button4,INPUT);  // button4 used to start myservo10
myservo10.write(180); // Put servo all the say back
}

void loop()
{
  // Check if button2 has been pressed
  if (digitalRead(button4) == HIGH){

    // Fire catapult - fully
  myservo10.write(80); // Put servo all the say back

  // Pause after firing
  delay(500);

  // Reset to all the way back
  myservo10.write(180); // Put servo all the say back
  }
}

Monday, May 16, 2011

8x8 LED Matrix Scrolling Message Changing In Serial Monitor

The classic scrolling message with the ability to enter a message from the serial monitor and while it is scrolling if you enter a lowercase 'a' in the monitor it stops and you can enter a new message.

To do this I created my own character set (reminds me of the olden days with my Commodore 64 - yes I am that old)

It took 3 evenings to create the character set and then 2 evening to create the code.  So, if you are looking to do something similar the code below with the character set defined may save you some time.


Below is the code.  Be aware I'm more about getting the Arduino to do something and so the code will be a bit rough around the edges.  It works but I definitely do not consider it best practise or even efficent code.
Use at your own risk.

// Control an 8x8 LED display with 2 x 74HC595 shift registers
// Using only 3 pins from the Arduino

// while condition variable
int whileVar = 0;

//Pin connected to Pin 12 of 74HC595 (Latch)
int latchPin = 8;

//Pin connected to Pin 11 of 74HC595 (Clock)
int clockPin = 12;

//Pin connected to Pin 14 of 74HC595 (Data)
int dataPin = 11;

uint8_t led[8];
uint8_t letters[672];
uint8_t currentdisplay[8];

long counter1 = 0;

// Current Character in the charMessage Array
int charMessageCurrent = 0;

// Current line in Letter
int lineLetter = 672;

//currentChar is the current character in the charMessage that is being chekced
char currentChar =32;

// Used to store the message instead of displayMessage
char charMessage[40];

// scrollMessage is array holding the message that will be displayed
uint8_t scrollMessage[480];

// Serial read Byte
int incomingByte = 0;

void setup() {

Serial.begin(9600);
 
// Seed Random Generator with noise from analog pin 0 
randomSeed(analogRead(0));
 
//set pins to output
pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, OUTPUT);

// Symbol [ ] space
letters[0] =  B00000000;
letters[1] =  B00000000;
letters[2] =  B00000000;
letters[3] =  B00000000;
letters[4] =  B00000000;
letters[5] =  B00000000;
letters[6] =  B00000000;
letters[7] =  B00000000;

// Symbol !
letters[8]  =  B00000000;
letters[9]  =  B00000000;
letters[10] =  B00000000;
letters[11] =  B00000000;
letters[12] =  B11110011;
letters[13] =  B00000000;
letters[14] =  B00000000;
letters[15] =  B00000000;

// Symbol "
letters[16] =  B00000000;
letters[17] =  B00000000;
letters[18] =  B00000000;
letters[19] =  B11100000;
letters[20] =  B00000000;
letters[21] =  B11100000;
letters[22] =  B00000000;
letters[23] =  B00000000;

// Symbol #
letters[24] =  B00000000;
letters[25] =  B00100100;
letters[26] =  B11111111;
letters[27] =  B00100100;
letters[28] =  B00100100;
letters[29] =  B00100100;
letters[30] =  B11111111;
letters[31] =  B00100100;

// Symbol $
letters[32] =  B00000000;
letters[33] =  B01001110;
letters[34] =  B10010001;
letters[35] =  B10010001;
letters[36] =  B11111111;
letters[37] =  B10010001;
letters[38] =  B10010001;
letters[39] =  B01100110;

// Symbol %
letters[40] =  B00000000;
letters[41] =  B10000111;
letters[42] =  B01000101;
letters[43] =  B00110111;
letters[44] =  B00011000;
letters[45] =  B11100100;
letters[46] =  B10000010;
letters[47] =  B11100001;

// Symbol &
letters[48] =  B00000000;
letters[49] =  B01100000;
letters[50] =  B10010101;
letters[51] =  B10010011;
letters[52] =  B10010101;
letters[53] =  B10011001;
letters[54] =  B01011001;
letters[55] =  B00111110;

// Symbol '
letters[56] =  B00000000;
letters[57] =  B00000000;
letters[58] =  B00000000;
letters[59] =  B11100000;
letters[60] =  B00000000;
letters[61] =  B00000000;
letters[62] =  B00000000;
letters[63] =  B00000000;

// Symbol (
letters[64] =  B00000000;
letters[65] =  B00000000;
letters[66] =  B10000001;
letters[67] =  B01000010;
letters[68] =  B00100100;
letters[69] =  B00011000;
letters[70] =  B00000000;
letters[71] =  B00000000;

// Symbol )
letters[72] =  B00000000;
letters[73] =  B00000000;
letters[74] =  B00011000;
letters[75] =  B00100100;
letters[76] =  B01000010;
letters[77] =  B10000001;
letters[78] =  B00000000;
letters[79] =  B00000000;

// Symbol *
letters[80] =  B00000000;
letters[81] =  B10010010;
letters[82] =  B01010100;
letters[83] =  B00111000;
letters[84] =  B11111111;
letters[85] =  B00111000;
letters[86] =  B01010100;
letters[87] =  B10010010;

// Symbol +
letters[88] =  B00000000;
letters[89] =  B00010000;
letters[90] =  B00010000;
letters[91] =  B00010000;
letters[92] =  B11111111;
letters[93] =  B00010000;
letters[94] =  B00010000;
letters[95] =  B00010000;

// Symbol ,
letters[96]  =  B00000000;
letters[97]  =  B00000000;
letters[98]  =  B00000000;
letters[99]  =  B00000110;
letters[100] =  B00000001;
letters[101] =  B00000000;
letters[102] =  B00000000;
letters[103] =  B00000000;

// Symbol -
letters[104] =  B00000000;
letters[105] =  B00000000;
letters[106] =  B00000000;
letters[107] =  B00010000;
letters[108] =  B00010000;
letters[109] =  B00010000;
letters[110] =  B00000000;
letters[111] =  B00000000;

// Symbol .
letters[112] =  B00000000;
letters[113] =  B00000000;
letters[114] =  B00000000;
letters[115] =  B00000011;
letters[116] =  B00000011;
letters[117] =  B00000000;
letters[118] =  B00000000;
letters[119] =  B00000000;

// Symbol /
letters[120] =  B00000000;
letters[121] =  B10000000;
letters[122] =  B01000000;
letters[123] =  B00100000;
letters[123] =  B00011000;
letters[125] =  B00000100;
letters[126] =  B00000010;
letters[127] =  B00000001;

// Number 0 - zero
letters[128] =  B00000000;
letters[129] =  B00111100;
letters[130] =  B01000010;
letters[131] =  B10100001;
letters[132] =  B10010001;
letters[133] =  B10001001;
letters[134] =  B01000010;
letters[135] =  B00111100;

// Number 1
letters[136] =  B00000000;
letters[137] =  B00000000;
letters[138] =  B00000001;
letters[139] =  B11111111;
letters[140] =  B01000001;
letters[141] =  B00100001;
letters[142] =  B00000000;
letters[143] =  B00000000;

// Number 2
letters[144] =  B00000000;
letters[145] =  B01100001;
letters[146] =  B10010001;
letters[147] =  B10001001;
letters[148] =  B10001001;
letters[149] =  B10000101;
letters[150] =  B10000011;
letters[141] =  B01100001;

// Number 3
letters[152] =  B00000000;
letters[153] =  B01111110;
letters[154] =  B10011001;
letters[155] =  B10011001;
letters[156] =  B10011001;
letters[157] =  B10000001;
letters[158] =  B10000001;
letters[159] =  B01000110;

// Number 4
letters[160] =  B00000000;
letters[161] =  B00000100;
letters[162] =  B11111111;
letters[163] =  B01000100;
letters[164] =  B00100100;
letters[165] =  B00010100;
letters[166] =  B00001100;
letters[167] =  B00000100;

// Number 5
letters[168] =  B00000000;
letters[169] =  B10001110;
letters[170] =  B10010001;
letters[171] =  B10010001;
letters[172] =  B10010001;
letters[173] =  B10010001;
letters[174] =  B10010001;
letters[175] =  B11100010;

// Number 6
letters[176] =  B00000000;
letters[177] =  B01001110;
letters[178] =  B10010001;
letters[179] =  B10010001;
letters[180] =  B10010001;
letters[181] =  B10010001;
letters[182] =  B10010001;
letters[183] =  B01111110;

// Number 7
letters[184] =  B00000000;
letters[185] =  B11100000;
letters[186] =  B10010000;
letters[187] =  B10001000;
letters[188] =  B10000111;
letters[189] =  B00000000;
letters[190] =  B00000000;
letters[191] =  B00000000;

// Number 8
letters[192] =  B00000000;
letters[193] =  B01100110;
letters[194] =  B10011001;
letters[195] =  B10011001;
letters[196] =  B10011001;
letters[197] =  B10011001;
letters[198] =  B10011001;
letters[199] =  B01100110;

// Number 9
letters[200] =  B00000000;
letters[201] =  B01111110;
letters[202] =  B10001001;
letters[203] =  B10001001;
letters[204] =  B10001001;
letters[205] =  B10001001;
letters[206] =  B10001001;
letters[207] =  B01110010;

// Symbol :
letters[208] =  B00000000;
letters[209] =  B00000000;
letters[210] =  B00000000;
letters[211] =  B00000000;
letters[212] =  B01100110;
letters[213] =  B00000000;
letters[214] =  B00000000;
letters[215] =  B00000000;

// Symbol ;
letters[216] =  B00000000;
letters[217] =  B00000000;
letters[218] =  B00000000;
letters[219] =  B00000000;
letters[220] =  B01100110;
letters[221] =  B00000001;
letters[222] =  B00000000;
letters[223] =  B00000000;

// Symbol <
letters[224] =  B00000000;
letters[225] =  B00000000;
letters[226] =  B00000000;
letters[227] =  B10000010;
letters[228] =  B01000100;
letters[229] =  B00101000;
letters[230] =  B00010000;
letters[231] =  B00000000;

// Symbol =
letters[232] =  B00000000;
letters[233] =  B00000000;
letters[234] =  B00000000;
letters[235] =  B00100100;
letters[236] =  B00100100;
letters[237] =  B00100100;
letters[238] =  B00100100;
letters[239] =  B00000000;

// Symbol >
letters[240] =  B00000000;
letters[241] =  B00000000;
letters[242] =  B00010000;
letters[243] =  B00101000;
letters[244] =  B01000100;
letters[245] =  B10000010;
letters[246] =  B00000000;
letters[247] =  B00000000;

// Symbol ?
letters[248] =  B00000000;
letters[249] =  B00000000;
letters[250] =  B01100000;
letters[251] =  B10010000;
letters[252] =  B10001101;
letters[253] =  B10000000;
letters[254] =  B01100000;
letters[255] =  B00000000;

// Symbol @
letters[256] =  B00000000;
letters[257] =  B01111000;
letters[258] =  B10100101;
letters[259] =  B10100101;
letters[260] =  B10100101;
letters[261] =  B10011001;
letters[262] =  B10000001;
letters[263] =  B01011110;

// Letter A
letters[264] = B00000000;
letters[265] = B00111111;
letters[266] = B01001000;
letters[267] = B10001000;
letters[268] = B10001000;
letters[269] = B10001000;
letters[270] = B01001000;
letters[271] = B00111111;

// Letter B
letters[272]  = B00000000;
letters[273]  = B01110110;
letters[274] = B10001001;
letters[275] = B10001001;
letters[276] = B10001001;
letters[277] = B10001001;
letters[278] = B10001001;
letters[279] = B11111111;

// Letter C
letters[280] = B00000000;
letters[281] = B00100100;
letters[282] = B01000010;
letters[283] = B10000001;
letters[284] = B10000001;
letters[285] = B10000001;
letters[286] = B01000010;
letters[287] = B00111100;

// Letter D
letters[288] = B00000000;
letters[289] = B00111100;
letters[290] = B01000010;
letters[291] = B10000001;
letters[292] = B10000001;
letters[293] = B10000001;
letters[294] = B10000001;
letters[295] = B11111111;

// Letter E
letters[296] = B00000000;
letters[297] = B10000001;
letters[298] = B10000001;
letters[299] = B10010001;
letters[300] = B10010001;
letters[301] = B10010001;
letters[302] = B10010001;
letters[303] = B11111111;


// Letter F
letters[304] = B00000000;
letters[305] = B10000000;
letters[306] = B10000000;
letters[307] = B10010000;
letters[308] = B10010000;
letters[309] = B10010000;
letters[310] = B10010000;
letters[311] = B11111111;

// Letter G
letters[312] = B00000000;
letters[313] = B00101100;
letters[314] = B01001010;
letters[315] = B10001001;
letters[316] = B10000001;
letters[317] = B10000001;
letters[318] = B01000010;
letters[319] = B00111100;

// Letter H
letters[320] = B00000000;
letters[321] = B11111111;
letters[322] = B00001000;
letters[323] = B00001000;
letters[324] = B00001000;
letters[325] = B00001000;
letters[326] = B00001000;
letters[327] = B11111111;

// Letter I
letters[328] = B00000000;
letters[329] = B00000000;
letters[330] = B10000001;
letters[331] = B10000001;
letters[332] = B11111111;
letters[333] = B10000001;
letters[334] = B10000001;
letters[335] = B00000000;

// Letter J
letters[336] = B00000000;
letters[337] = B10000000;
letters[338] = B10000000;
letters[339] = B11111100;
letters[340] = B10000010;
letters[341] = B10000001;
letters[342] = B10000001;
letters[343] = B10000010;

// Letter K
letters[344] = B00000000;
letters[345] = B10000001;
letters[346] = B01000010;
letters[347] = B00100100;
letters[348] = B00011000;
letters[349] = B00001000;
letters[350] = B00000100;
letters[351] = B11111111;

// Letter L
letters[352] = B00000000;
letters[353] = B00000001;
letters[354] = B00000001;
letters[355] = B00000001;
letters[356] = B00000001;
letters[357] = B00000001;
letters[358] = B00000001;
letters[359] = B11111111;

// Letter M
letters[360] =  B00000000;
letters[361] =  B01111111;
letters[362] =  B10000000;
letters[363] =  B10000000;
letters[364] = B01110000;
letters[365] = B10000000;
letters[366] = B10000000;
letters[367] = B01111111;

// Letter N
letters[368] =  B00000000;
letters[369] =  B11111111;
letters[370] =  B00000010;
letters[371] =  B00000100;
letters[372] =  B00011000;
letters[373] =  B00100000;
letters[374] =  B01000000;
letters[375] =  B11111111;

// Letter 0
letters[376] =  B00000000;
letters[377] =  B00111100;
letters[378] =  B01000010;
letters[379] =  B10000001;
letters[380] =  B10000001;
letters[381] =  B10000001;
letters[382] =  B01000010;
letters[383] =  B00111100;

// Letter P
letters[384] =  B00000000;
letters[385] =  B00110000;
letters[386] =  B01001000;
letters[387] =  B10000100;
letters[388] =  B10000100;
letters[389] =  B10000100;
letters[390] =  B10000100;
letters[391] =  B11111111;

// Letter Q
letters[392] =  B00000000;
letters[393] =  B00111101;
letters[394] =  B01000010;
letters[395] =  B10000101;
letters[396] =  B10001001;
letters[397] =  B10000001;
letters[398] =  B01000010;
letters[399] =  B00111100;

// Letter R
letters[400] =  B00000000;
letters[401] =  B00110001;
letters[402] =  B01001010;
letters[403] =  B10000100;
letters[404] =  B10000100;
letters[405] =  B10000100;
letters[406] =  B10000100;
letters[407] =  B11111111;

// Letter S
letters[408] =  B00000000;
letters[409] =  B01001110;
letters[410] =  B10010001;
letters[411] =  B10010001;
letters[412] =  B10010001;
letters[413] =  B10010001;
letters[414] =  B10010001;
letters[415] =  B01100110;

// Letter T
letters[416] =  B00000000;
letters[417] =  B10000000;
letters[418] =  B10000000;
letters[419] =  B10000000;
letters[420] =  B11111111;
letters[421] =  B10000000;
letters[422] =  B10000000;
letters[423] =  B10000000;

// Letter U
letters[424] =  B00000000;
letters[425] =  B11111100;
letters[426] =  B00000010;
letters[427] =  B00000001;
letters[428] =  B00000001;
letters[429] =  B00000001;
letters[430] =  B00000010;
letters[431] =  B11111100;

// Letter V
letters[432] =  B00000000;
letters[433] =  B11111000;
letters[434] =  B00000100;
letters[435] =  B00000010;
letters[436] =  B00000001;
letters[437] =  B00000010;
letters[438] =  B00000100;
letters[439] =  B11111000;

// Letter W
letters[440] =  B00000000;
letters[441] =  B11111110;
letters[442] =  B00000001;
letters[443] =  B00000001;
letters[444] =  B00001110;
letters[445] =  B00000001;
letters[446] =  B00000001;
letters[447] =  B11111110;

// Letter X
letters[448] =  B00000000;
letters[449] =  B10000001;
letters[450] =  B01000010;
letters[451] =  B00100100;
letters[452] =  B00011000;
letters[453] =  B00100100;
letters[454] =  B01000010;
letters[455] =  B10000001;

// Letter Y
letters[456] =  B00000000;
letters[457] =  B10000000;
letters[458] =  B01000000;
letters[459] =  B00100000;
letters[460] =  B00011111;
letters[461] =  B00100000;
letters[462] =  B01000000;
letters[463] =  B10000000;

// Letter Z
letters[464] =  B00000000;
letters[465] =  B10000001;
letters[466] =  B11000001;
letters[467] =  B10100001;
letters[468] =  B10010001;
letters[469] =  B10001001;
letters[470] =  B10000101;
letters[471] =  B10000011;

// Symbol !
letters[472] =  B00000000;
letters[473] =  B00000000;
letters[474] =  B00000000;
letters[475] =  B00000000;
letters[476] =  B11110011;
letters[477] =  B00000000;
letters[478] =  B00000000;
letters[479] =  B00000000;

// Symbol "
letters[480] =  B00000000;
letters[481] =  B00000000;
letters[482] =  B00000000;
letters[483] =  B11100000;
letters[484] =  B00000000;
letters[485] =  B11100000;
letters[486] =  B00000000;
letters[487] =  B00000000;

// Symbol #
letters[488] =  B00000000;
letters[489] =  B00100100;
letters[490] =  B11111111;
letters[491] =  B00100100;
letters[492] =  B00100100;
letters[493] =  B00100100;
letters[494] =  B11111111;
letters[495] =  B00100100;

// Symbol $
letters[496] =  B00000000;
letters[497] =  B01001110;
letters[498] =  B10010001;
letters[499] =  B10010001;
letters[500] =  B11111111;
letters[501] =  B10010001;
letters[502] =  B10010001;
letters[503] =  B01100110;

// Symbol %
letters[504] =  B00000000;
letters[505] =  B00000000;
letters[506] =  B01000110;
letters[507] =  B00110000;
letters[508] =  B00011000;
letters[509] =  B00000100;
letters[510] =  B01100010;
letters[511] =  B00000001;

// Symbol &
letters[512] =  B00000000;
letters[513] =  B00000000;
letters[514] =  B00000101;
letters[515] =  B01000010;
letters[516] =  B10100101;
letters[517] =  B10101001;
letters[518] =  B01010001;
letters[519] =  B00101110;

// Symbol '
letters[520] =  B00000000;
letters[521] =  B00000000;
letters[522] =  B00000000;
letters[523] =  B11100000;
letters[524] =  B00000000;
letters[525] =  B00000000;
letters[526] =  B00000000;
letters[527] =  B00000000;

// Symbol (
letters[528] =  B00000000;
letters[529] =  B00000000;
letters[530] =  B10000001;
letters[531] =  B01000010;
letters[532] =  B00100100;
letters[533] =  B00011000;
letters[534] =  B00000000;
letters[535] =  B00000000;

// Symbol )
letters[536] =  B00000000;
letters[537] =  B00000000;
letters[538] =  B00011000;
letters[539] =  B00100100;
letters[540] =  B01000010;
letters[541] =  B10000001;
letters[542] =  B00000000;
letters[543] =  B00000000;

// Symbol *
letters[544] =  B00000000;
letters[545] =  B10010010;
letters[546] =  B01010100;
letters[547] =  B00111000;
letters[548] =  B11111111;
letters[549] =  B00111000;
letters[550] =  B01010100;
letters[551] =  B10010010;

// Symbol +
letters[552] =  B00000000;
letters[553] =  B00010000;
letters[554] =  B00010000;
letters[555] =  B00010000;
letters[556] =  B11111111;
letters[557] =  B00010000;
letters[558] =  B00010000;
letters[559] =  B00010000;

// Symbol '
letters[560] =  B00000000;
letters[561] =  B00000000;
letters[562] =  B00000000;
letters[563] =  B11000000;
letters[564] =  B00100000;
letters[565] =  B00000000;
letters[566] =  B00000000;
letters[567] =  B00000000;

// Symbol -
letters[568] =  B00000000;
letters[569] =  B00000000;
letters[570] =  B00000000;
letters[571] =  B00010000;
letters[572] =  B00010000;
letters[573] =  B00010000;
letters[574] =  B00000000;
letters[575] =  B00000000;

// Symbol .
letters[576] =  B00000000;
letters[577] =  B00000000;
letters[578] =  B00000000;
letters[579] =  B00000011;
letters[580] =  B00000011;
letters[581] =  B00000000;
letters[582] =  B00000000;
letters[583] =  B00000000;

// Symbol /
letters[584] =  B00000000;
letters[585] =  B10000000;
letters[586] =  B01000000;
letters[587] =  B00100000;
letters[588] =  B00011000;
letters[589] =  B00000100;
letters[590] =  B00000010;
letters[591] =  B00000001;

// Number 0 - zero
letters[592] =  B00000000;
letters[593] =  B00111100;
letters[594] =  B01000010;
letters[595] =  B10100001;
letters[596] =  B10010001;
letters[597] =  B10001001;
letters[598] =  B01000010;
letters[599] =  B00111100;

// Number 1
letters[600] =  B00000000;
letters[601] =  B00000000;
letters[602] =  B00000001;
letters[603] =  B11111111;
letters[604] =  B01000001;
letters[605] =  B00100001;
letters[606] =  B00000000;
letters[607] =  B00000000;

// Number 2
letters[608] =  B00000000;
letters[609] =  B01100001;
letters[610] =  B10010001;
letters[611] =  B10001001;
letters[612] =  B10001001;
letters[613] =  B10000101;
letters[614] =  B10000011;
letters[615] =  B01100001;

// Number 3
letters[616] =  B00000000;
letters[617] =  B01111110;
letters[618] =  B10011001;
letters[619] =  B10011001;
letters[620] =  B10011001;
letters[621] =  B10000001;
letters[622] =  B10000001;
letters[623] =  B01000110;

// Number 4
letters[624] =  B00000000;
letters[625] =  B00000100;
letters[626] =  B11111111;
letters[627] =  B01000100;
letters[628] =  B00100100;
letters[629] =  B00010100;
letters[630] =  B00001100;
letters[631] =  B00000100;

// Number 5
letters[632] =  B00000000;
letters[633] =  B10001110;
letters[634] =  B10010001;
letters[635] =  B10010001;
letters[636] =  B10010001;
letters[637] =  B10010001;
letters[638] =  B10010001;
letters[639] =  B11100010;

// Number 6
letters[640] =  B00000000;
letters[641] =  B01001110;
letters[642] =  B10010001;
letters[643] =  B10010001;
letters[644] =  B10010001;
letters[645] =  B10010001;
letters[646] =  B10010001;
letters[647] =  B01111110;

// Number 7
letters[648] =  B00000000;
letters[649] =  B11100000;
letters[650] =  B10010000;
letters[651] =  B10001000;
letters[652] =  B10000111;
letters[653] =  B00000000;
letters[654] =  B00000000;
letters[655] =  B00000000;

// Number 8
letters[656] =  B00000000;
letters[657] =  B01100110;
letters[658] =  B10011001;
letters[659] =  B10011001;
letters[660] =  B10011001;
letters[661] =  B10011001;
letters[662] =  B10011001;
letters[663] =  B01100110;

// Number 9
letters[664] =  B00000000;
letters[665] =  B01111110;
letters[666] =  B10001001;
letters[667] =  B10001001;
letters[668] =  B10001001;
letters[669] =  B10001001;
letters[670] =  B10001001;
letters[671] =  B01110010;


for (int i = 0; i < 8; i++){
  led[i] = letters[i];
  currentdisplay[i] = letters[i];
  }
}

void loop() {

// Clear the screen before starting
for (int i=448; i <456; i++){
  led[i-448] = letters[i];
  currentdisplay[i-448] = letters[i];;
}
screenUpdate();

// Reseting variables
whileVar = 0;
counter1 = 0;
charMessageCurrent = 0;
lineLetter = 672;
currentChar =32;

//  Start Reading the Serial Data

while (whileVar ==0){
screenUpdate();
 
// send data only when you receive data:
    if (Serial.available() > 0) {
        // read the incoming byte:
        incomingByte = Serial.read();

                // If the byte read is an 'a' stop, otherwise add the byte to the string
                if (incomingByte ==97){
                whileVar =1;
                }
                else
                {
                charMessage[charMessageCurrent] = incomingByte;
                charMessageCurrent++;
                } 
        }
}

// End Reading Serial Data 
 

// prints charMessage
Serial.write("charMessage is: ");

for (int i=0; i<charMessageCurrent; i++){
Serial.write(charMessage[i]);
}
Serial.println("");

// Making the first 8 Bytes - character a space
for(int i =0; i <8; i++){
  scrollMessage[i] = B00000000;
}
// Move counter1 to 8 so that the space stays in place
counter1=8; 
 
for (int i=0; i < charMessageCurrent; i++){
currentChar = charMessage[i];

for (int x=7; x >= 0; x--){
  scrollMessage[counter1] = letters[((currentChar-32)*8)+x];
  counter1++;
  }
}
// End Sorting out the message for scrolling

// Clear the screen before starting
for (int i=0; i <8 ; i++){
  led[i] = B00000000;
  currentdisplay[i] = B00000000;;
}
screenUpdate();

// Reseting current1 to 0 as it is used for the delay in the code below
counter1=0;

// Resetting whileVar so it can be used again
whileVar=0;

while (whileVar ==0)
{
// Check if I enter just an a - lower case a to exit the system
    if (Serial.available() > 0) {
        // read the incoming byte:
        incomingByte = Serial.read();

                // If the byte read is an 'a' stop, otherwise add the byte to the string
                if (incomingByte ==97){
                whileVar =1;
                }
        }  
// counter1 used for delay in animation
counter1++;

// set the LEDs
screenUpdate();

// Loop for the action - counter1 used for the delay in scrolling
if (counter1 >= 25) {
counter1 = 0;
lineLetter++;

if (lineLetter >(((charMessageCurrent)*8)+7)){
  lineLetter = 0;
  }
// Do scrolling

for (int i = 8; i > 0; i--){
  led[i] = currentdisplay[i-1];
  }
led[0] = scrollMessage[lineLetter];

for (int i=0; i <8; i++){
  currentdisplay[i] = led[i];
  }

}

}

}

void screenUpdate() {
uint8_t row = B00000001;

for (byte k = 0; k < 9; k++) {
// Open up the latch ready to receive data
digitalWrite(latchPin, LOW);
shiftIt(~row );
shiftIt(led[k] ); // LED array

// Close the latch, sending the data in the registers out to the matrix
digitalWrite(latchPin, HIGH);
row = row << 1;
  }
}

void shiftIt(byte dataOut) {
// Shift out 8 bits LSB first,
// on rising edge of clock

boolean pinState;

//clear shift register read for sending data
digitalWrite(dataPin, LOW);

// for each bit in dataOut send out a bit
for (int i=0; i<8; i++) {

  //set clockPin to LOW prior to sending bit
digitalWrite(clockPin, LOW);

// if the value of DataOut and (logical AND) a bitmask
// are true, set pinState to 1 (HIGH)
if ( dataOut & (1<<i) ) {
pinState = HIGH;
}
else {
  pinState = LOW;
}

//sets dataPin to HIGH or LOW depending on pinState
digitalWrite(dataPin, pinState);

//send bit out on rising edge of clock
digitalWrite(clockPin, HIGH);
digitalWrite(dataPin, LOW);
}

//stop shifting
digitalWrite(clockPin, LOW);
}

Sunday, May 8, 2011

Arduino 8x8 LED driving game

8x8 LED matrix used for a driving game.
There's a single LED at the bottom that is the 'car'

The track is random and moving from the top to the bottom.
The car is controlled by a potentiometer (pot)



Below is the code.  Be aware I'm more about getting the Arduino to do something and so the code will be a bit rough around the edges.  It works but I definitely do not consider it best practise or even efficent code.
Use at your own risk.

// Control an 8x8 LED display with 2 x 74HC595 shift registers
// Using only 3 pins from the Arduino

// Random Number - used to decide if to go back 1, stay the same line or forward 1
int randNumber;

//currentLine is used to record the current position of the track
int currentLine = 3;

// Postion of car
int carPosition = 3;

// Arduino Pin for the Pot used as the controller input for the car
int potPin = 2;

// Reading for the pot
int potRead;

// Range for the Pot as full travel would be too much to be practical
int potLow;
int potHigh;

//Pin connected to Pin 12 of 74HC595 (Latch)
int latchPin = 8;

//Pin connected to Pin 11 of 74HC595 (Clock)
int clockPin = 12;

//Pin connected to Pin 14 of 74HC595 (Data)
int dataPin = 11;

uint8_t led[8];
uint8_t car[8];
uint8_t trackLine[5];
long counter1 = 0;

void setup() {

// Seed Random Generator with noise from analog pin 0 
randomSeed(analogRead(0));
 
//set pins to output
pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, OUTPUT);

// Set Track to straight
led[0] = B11100011;
led[1] = B11100011;
led[2] = B11100011;
led[3] = B11100011;
led[4] = B11100011;
led[5] = B11100011;
led[6] = B11100011;
led[7] = B11100011;

// Set car position - looks backward, but the display is LSB so a 1
// on the right will show as a 1 on the left of the screen
car[0] = B00000001;
car[1] = B00000010;
car[2] = B00000100;
car[3] = B00001000;
car[4] = B00010000;
car[5] = B00100000;
car[6] = B01000000;
car[7] = B10000000;

// used to set the track decision
trackLine[0] = B10001111;
trackLine[1] = B11000111;
trackLine[2] = B11100011;
trackLine[3] = B11110001;
// trackLine[4] = B00001001;

potRead = analogRead(potPin);
potLow = potRead - 70;
potHigh = potRead + 89;

}

void loop() {
// counter1 used for delay in animation
counter1++;

// set the LEDs
screenUpdate();

potRead = analogRead(potPin);

if (potRead > potHigh){
  potRead = potHigh;}
if (potRead < potLow){
  potRead = potLow;}
 
carPosition = (potRead - potLow)/20;

// Loop for the action
if (counter1 >=75) {
counter1 = 0;

// Do track
for (int i = 0 ; i < 7 ; i++){
  led[i] = led[i+1];
}
// check of the car has crashed if it has then do a crash signal
if (led[0] & car[carPosition]){
 
  crash();
 
}

led[0] = led[0] | car[carPosition];

randNumber = random(3)-1;

currentLine = currentLine +randNumber;
if (currentLine == 0){
  currentLine = 1;}
 
if (currentLine == 5){
  currentLine = 4;}

led[7] = trackLine[currentLine-1];
}

}

void screenUpdate() {
uint8_t row = B00000001;

for (byte k = 0; k < 9; k++) {
// Open up the latch ready to receive data
digitalWrite(latchPin, LOW);
shiftIt(~row );
shiftIt(led[k] ); // LED array

// Close the latch, sending the data in the registers out to the matrix
digitalWrite(latchPin, HIGH);
row = row << 1;
  }
}

void shiftIt(byte dataOut) {
// Shift out 8 bits LSB first,
// on rising edge of clock

boolean pinState;

//clear shift register read for sending data
digitalWrite(dataPin, LOW);

// for each bit in dataOut send out a bit
for (int i=0; i<8; i++) {

  //set clockPin to LOW prior to sending bit
digitalWrite(clockPin, LOW);

// if the value of DataOut and (logical AND) a bitmask
// are true, set pinState to 1 (HIGH)
if ( dataOut & (1<<i) ) {
pinState = HIGH;
}
else {
  pinState = LOW;
}

//sets dataPin to HIGH or LOW depending on pinState
digitalWrite(dataPin, pinState);

//send bit out on rising edge of clock
digitalWrite(clockPin, HIGH);
digitalWrite(dataPin, LOW);
}

//stop shifting
digitalWrite(clockPin, LOW);
}

void crash(){
// Used to set all bits on or off
int allBits = B11111111; 
 
// Do 10 loop so of on and off
for (int show=0; show <10; show++){
 
for (int i=0; i <8; i++){
led[i] = allBits;


for (int delaylots=0; delaylots<200; delaylots++){
  screenUpdate();
}

if(allBits == B11111111){
  allBits = B00000000;
}
else
{
  allBits = B11111111;
}


}

// Reset the position of the car to the middle of the track 
potRead = analogRead(potPin);
potLow = potRead - 70;
potHigh = potRead + 89; 

for (int i =0; i <8; i++){
 led[i] = trackLine[2];
}

}

Sunday, May 1, 2011

Arduino Alien Animation on an 8x8 LED display

A little animation of a space invaders alien on an 8x8 LED display

Using a pair of 74HC595 shift registers.



Below is the code.  Be aware I'm more about getting the Arduino to do something and so the code will be a bit rough around the edges.  It works but I definitely do not consider it best practise or even efficent code.
Use at your own risk.

// Control an 8x8 LED display with 2 x 74HC595 shift registers
// Using only 3 pins from the Arduino

//Pin connected to Pin 12 of 74HC595 (Latch)
int latchPin = 8;

//Pin connected to Pin 11 of 74HC595 (Clock)
int clockPin = 12;

//Pin connected to Pin 14 of 74HC595 (Data)
int dataPin = 11;

uint8_t led[8];
uint8_t ledo[8];
uint8_t ledn[8];
long counter1 = 0;
int setn=0;

void setup() {
//set pins to output
pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, OUTPUT);

// 1st animation for the character
ledo[0] = B01000010;
ledo[1] = B00100100;
ledo[2] = B00111100;
ledo[3] = B01111110;
ledo[4] = B11111111;
ledo[5] = B10111101;
ledo[6] = B11000011;
ledo[7] = B01100110;

// 2nd animation for the character
ledn[0] = B11000011;
ledn[1] = B00100100;
ledn[2] = B00111100;
ledn[3] = B01011010;
ledn[4] = B11111111;
ledn[5] = B00111100;
ledn[6] = B00100100;
ledn[7] = B00100100;

// set the display to the 1st character
  for (int i=0; i<8; i++) {
  led[i]= ledo[i];
  }
}

void loop() {
// counter1 used for delay in animation
counter1++;

// set the LEDs
screenUpdate();

if (counter1 >=150) {
counter1 = 0;

// setn is used to decide id ledn or ledo is used for the animation
if (setn ==0){
  for (int i=0; i<8; i++) {
  led[i]= ledn[i];
  setn = 1;
  }
  }
  else {
  for (int i=0; i<8; i++) {
  led[i]= ledo[i];
  setn = 0;
  }
  }
}

}

void screenUpdate() {
uint8_t row = B00000001;

for (byte k = 0; k < 9; k++) {
// Open up the latch ready to receive data
digitalWrite(latchPin, LOW);
shiftIt(~row );
shiftIt(led[k] ); // LED array

// Close the latch, sending the data in the registers out to the matrix
digitalWrite(latchPin, HIGH);
row = row << 1;
  }
}

void shiftIt(byte dataOut) {
// Shift out 8 bits LSB first,
// on rising edge of clock

boolean pinState;

//clear shift register read for sending data
digitalWrite(dataPin, LOW);

// for each bit in dataOut send out a bit
for (int i=0; i<8; i++) {

  //set clockPin to LOW prior to sending bit
digitalWrite(clockPin, LOW);

// if the value of DataOut and (logical AND) a bitmask
// are true, set pinState to 1 (HIGH)
if ( dataOut & (1<<i) ) {
pinState = HIGH;
}
else {
  pinState = LOW;
}

//sets dataPin to HIGH or LOW depending on pinState
digitalWrite(dataPin, pinState);

//send bit out on rising edge of clock
digitalWrite(clockPin, HIGH);
digitalWrite(dataPin, LOW);
}

//stop shifting
digitalWrite(clockPin, LOW);
}