Posts Tagged ‘programming’

Hello to the UK’s Robot Brighton

September 24, 2009

Thanks for the mention from the UK’s @robotbrighton robotics group. Recently I read @fluffyemily‘s RoboChick Rampant Robotic Rumpus blog post about the book “Making Things Talk“. This is a great book and it influenced my decision to explore the combination of Processing and Arduino through this web site.  The urge to purchase books is great and it’s easy to spend a small fortune on computer books. Another book worth adding to your bookshelf  is “Programming Interactivity“, I’m still forming my opinion on this book but in general I think it is useful.

I checked to see what was showing up on my site’s home page at the time of RobotBrighton’s mention and realized that a little explanation would be helpful. Most of the articles may be considered a Stream of Consciousness and when reading top-down consecutively the articles appear out of proper order and somewhat disconnected. I’m basing this site’s articles on a series of workshops I’m developing titled “Topics in Robotics, Electronics, and Communications”.

I started DIY Robotics Lab as a way to encourage people interested in this technology to begin exploring what they can do at home. So many of the robot kits used by high school students are too expensive for home use.

Presently much of this site is about programming using Arduino and Processing. I believe there are enough similarities when learning to program in one it will help you learn the other. Processing can provide an enjoyable way of interacting with our robotic creations. One series of articles begins with this Processing – Arduino Comparison article.

Another series is an example of low cost robotics projects spanning multiple web sites. Here is an article about our Robotic Labyrinth using a Wii Fit balance board. I saw this as a great way to get kids interested in robotics. An article on this site illustrates using Processing to interact with a simulated joystick. Since publishing that article I’ve added xBox 360 controller support through Processing to control the labyrinth. Another member of our labyrinth project has posted an article showing our labyrinth in action at the Missouri state fair. He also publish this article “Using a PC Joystick with the Arduino“. Since older game port joysticks can be bought at thrift stores for around $3 its another cheap way to encourage home based robotics labs. You can find more information about our labyrinth project at my personal blog SomeoneKnows.

Another series of articles on this site starts with Learning the C Language with Arduino. It explores using C while building circuits to blink LEDs.

I hope you enjoy the site and find the information useful. I would like to learn about your thoughts and comments. Thanks for stopping by.

(c) 2009 – Vince Thompson

Blinking Binary Bits and Bytes…

June 9, 2009

Looking At The Numbers.

Learning to make an LED flash is a great way to begin programming your Arduino, so take what you’ve learned with the LEDBlink program and add more LEDs. How many should we add, 3, 4, 7, 15 or more? Is there a special number of LEDs to choose? The Arduino Duemilanove has a total of 14 Digital pins and 6 Analog pins that we could use for a maximum of 20 individually controlled pins.

Lets take a look at how computers understand numbers, incidentally microcontrollers like those used by your Arduino understand numbers the same way. Arduino uses the Atmel Corporation’s 8-Bit family of microcontroller devices. Atmel manufactures a series of 8 or 16 bit devices. Most modern personal computers use either 32 or 64 bit hardware. This is beginning to suggest that a multiple of eight is important.

Maybe you’ve heard someone say that computers work with binary numbers which are a bunch of ones and zeros. Individually the “1” or “0” values are stored in binary digits that are called bits. The word bits is actually a contraction of the two words “binary” and “digits“. Our computers and microcontrollers both work with these ones and zeros in multiples of eight. Collectively these eight binary digits are known as a byte, so there are generally 8 bits per byte.

Bytes Are Important.

A Byte represents the smallest segment of memory containing data that an Arduino will read or write. A byte of data can save a positive whole number with a value ranging from 0 to 255. Lets create a program to show how a computer can count using binary numbers. Each LED will represent a single byte in an 8-Bit number.

Wiring the Breadboard

The breadboard gets wired up like the example from the “Learning the C Language with Arduino” article. This example adds more LEDs for a total of eight. The LEDs are attached to Digital pins 3 through 10. A total of eight LEDs and eight resistors are needed for this project.

Why are we starting with Digital Pin3? First, we are using the digital pins because they work like switches, either turning on (HIGH) or off (LOW). There is no significance to starting with pin 3 when any of the other digital pins would work just as well. Pins 0 and 1 carry a dual role. They act like other digital pins but also may handle serial communication’s TX and RX (transmit and receive) features.

Breadboard Layout 8 LEDs

Breadboard Layout 8 LEDs

Create a new program named:binaryCount

Type in the following code, typing the comments (shown in green) are optional. You could copy and paste into the program editor but typing your own code helps you learn the programming language too.

/*— Binary Counting with 8 bits —*/
//Associate LEDs with an Arduino Digital pin.

int led0Pin = 3;
int led1Pin = 4;
int led2Pin = 5;
int led3Pin = 6;
int led4Pin = 7;
int led5Pin = 8;
int led6Pin = 9;
int led7Pin = 10;

void setup()
{
//Set up each of the pins for output only.
pinMode(led0Pin, OUTPUT);
pinMode(led1Pin, OUTPUT);
pinMode(led2Pin, OUTPUT);
pinMode(led3Pin, OUTPUT);
pinMode(led4Pin, OUTPUT);
pinMode(led5Pin, OUTPUT);
pinMode(led6Pin, OUTPUT);
pinMode(led7Pin, OUTPUT);
}

void loop()
{
byte iVal; //we’ll define this variable for use in the program.
//A byte is an 8 bit variable.
// begin counting up from 0 to 255

for(iVal=0; iVal<255; iVal++) // loop through each of the values { // Light up LED if its corresponding byte is equal to binary va1ue. digitalWrite(led0Pin, (iVal & B1)); // -------X Decimal value 1 digitalWrite(led1Pin, (iVal & B10)); // ------X- Decimal value 2 digitalWrite(led2Pin, (iVal & B100)); // -----X-- Decimal value 4 digitalWrite(led3Pin, (iVal & B1000)); // ----X--- Decimal value 8 digitalWrite(led4Pin, (iVal & B10000)); // ---X---- Decimal value 16 digitalWrite(led5Pin, (iVal & B100000)); // --X----- Decimal value 32 digitalWrite(led6Pin, (iVal & B1000000)); // -X------ Decimal value 64 digitalWrite(led7Pin, (iVal & B10000000)); // X------- Decimal value 128 delay(1000); } digitalWrite(led0Pin, (iVal & B1)); delay(2000); } [/sourcecode]

Source Code Analysis

Line 4

Why is the first variable, led0Pin named with 0 instead of 1?

The short answer is the C Language starts counting beginning with the number 0. In the led0Pin through led7Pin variables the numeric character is irrelevant except to differentiate between the names. A later article will describe using variable arrays where this becomes important. This way of naming variables was done for some consistency with future examples.

Line 32

The ” for” statement is part of the C language’s control structures.

for(iVal=0; iVal<255; iVal++) // loop through each of the values

There are three parts to the for control loop:

  • Initialization – “iVal=0;” This assigns the value of 0 to the iVal variable. You need to end this portion with a semicolon.
  • Condition – “iVal<255;” This checks if the variable iVal is less than 255. While this condition is true the loop continues again. You need to end this portion with a semicolon.
  • Increment – “iVal++”  After processing the statements within the for loop the variable iVal is incremented by one. This portion does not use a semicolon.

In the iVal++ increment portion the plus plus characters “++“, this is the same as assigning iVal = iVal + 1 or adding one to the iVal variable each time the for loop finished.

Since the for() statement is part of the control structure you don’t put a semicolon at the end of this statement.

Lines 34 through 41

digitalWrite(led0Pin, (iVal &        B1)); // ——-X Decimal value 1

LED Bit Values

LED Bit Values

Bit values

As described above, we are using LEDs to represent each of the eight bits in a one byte value. Each bit signifies a value for that column. If all of the LEDs are off then the number it represents is zero (0). If only the right-most LED in the column labeled “1” is lit up then the byte of data is equal to the number 1. If the left-most column labeled “128” is the only one lit up then the byte of data is equal to the number 128. If all LEDs are lit up then the byte of data is equal to the number 255.

128 + 64 + 32 + 16 + 8 + 4 + 2 + `1 = 255

Any combinations of the eight LEDs that are turned ON or OFF represent a number from 0 to 255. Similarly, we can create a binary representation of the number by using a Bit Formatter. This is a value using the upper case letter B with a combination of only ones (1) and zeros (0) as shown below.

  • – – – – – – – X Decimal value 1  Bit Format:    B1
  • – – – – – – X – Decimal value 2  Bit Format:    B10
  • – – – – – X – – Decimal value 4  Bit Format:    B100
  • – – – – X – – – Decimal value 8  Bit Format:    B1000
  • – – – X – – – – Decimal value 16  Bit Format:  B10000
  • – – X – – – – – Decimal value 32  Bit Format:   B100000
  • -X – – – – – –  Decimal value 64  Bit Format:    B1000000
  • X – – – – – – – Decimal value 128  Bit Format: B10000000

The Bitwise AND “&” Operator

(iVal & B1)

If we have a the variable iVal which contains a value ranging from 0 to 255, how can we use that value to turn the pattern of LEDs on or off that the number represents? Because we’re only checking the iVal value against a single bit each time, the statement (iVal & B1) returns a TRUE (1) or FALSE (0) answer. The ampersand is a bitwise AND operator. In the example if the right most bit in the variable iVal is 1 AND the right most bit as specified by B1 are both 1, then the bitwise AND is 1 if they both aren’t set to 1 then the bitwise AND is evaluated as 0.

(c) 2009 – Vince Thompson

Creating a New Arduino Sketch (Program)

June 6, 2009

How do I create a new Arduino Program?

Arduino’s programs are called Sketches, so how do I create one?

Select the Arduino menu item File -> New

Arduino File New

Arduino File New

You could start entering code right after creating the new sketch but if you are planning to save it anyway why not give it a name now?

Select the menu item File -> Save As… to give your new program a name and directory location.

Setting your Preferences

You can customize your Arduino development environment so anytime you create a new program it will automatically prompt for a program name.

From the Arduino menu select File -> Preferences

Arduino Preferences Dialog

Arduino Preferences Dialog

Select the “Prompt for name when opening or creating a sketch” checkbox. You can also change the default location to save your sketches.

(c) 2009 – Vince Thompson

Correcting Arduino Compiler Errors

June 5, 2009

(Intended) Errors and Omissions

What happens after you select the Arduino menu item Sketch -> Verify/Compile and you get error messages that your program failed to compile properly. Sometimes the compiler warnings help you spot the problem code. Other times the error messages don’t make much sense at all. One way to understand the error messages is to create some intentional errors and see what happens.

Create a new program named: LEDBlink_errors

This is one time when it is better to copy the following code so we don’t introduce more errors into the program than are already there.


/*--- Blink an LED  ---//
//Associate LEDs with an Arduino Digital pin.
//The Arduino already has a built-in LED that we can use on Digital Pin 13.
int ledPin = 23;  \\We're using Digital Pin 23 on the Arduino.

void setup();
{
   pinMode(ledPin OUTPUT);   //Set up Arduino pin for output only.
}

loop()
(
   /The HIGH and LOW values set voltage to 5 volts when HIGH and 0 volts LOW.
   digitalWrite(ledPin, high); //Setting a digital pin HIGH turns on the LED.
   delay(1000):  //Get the microcontroller to wait for one second.
   digitalWrite(ledPin. LOW);  //Setting the pin to LOW turns the LED off.
   Delay(1000);  //Wait another second with the LED turned off.
   }
}

If you run Verify/Compile command you should see a number of compiler error messages at the bottom of the dialog display.

Arduino Compiler Error Messages

Arduino Compiler Error Messages

Line 1 Error

Uncaught exception type:class java.lang.RuntimeException

java.lang.RuntimeException: Missing the */ from the end of a /* comment */

at processing.app.Sketch.scrubComments(Sketch.java:2008) …

/*— Blink an LED  —//

The error messages go on for several more lines without adding much information to help solve the problem. You will find a clue to the problem above the compiler message box stating:

Missing the */ from the end of a /* comment */“.

The article “Introduction to Programming the Arduino” describes the comment styles used by C programs. The error on line 1 is caused by mixing the comment styles. The comment begins with the “/*” characters but ends with “//” instead of the “*/” characters. Correct the line as follows:

/*— Blink an LED  —*/

Now, rerun the Verify/Compile command.

Line 4 Error

error: stray ‘\’ in program

int ledPin = 23; \\We’re using Digital Pin 23 on the Arduino.

This is another problem with incorrect commenting technique. In this line the “\\” characters are used to begin a comment instead of the “//” characters. The correct line follows:

int ledPin = 3;  //We’re using Digital Pin 3 on the Arduino.

Now, rerun the Verify/Compile command.

Line 6 Error

error: expected unqualified-id before ‘{’ token

void setup();

This is an easy mistake to make. The problem is the semicolon “;” at the end of a function declaration. The article “Learning the C Language with Arduino” contains a section about correct usage of semicolons. To correct this problem remove the semicolon as shown below:

void setup()

Now, rerun the Verify/Compile command.

Line 8 Error

In function ‘void setup()’:

error: expected `)’ before numeric constant/home/myDirectory/Desktop/myPrograms/arduino-0015/hardware/cores/arduino/wiring.h:102:

error: too few arguments to function ‘void pinMode(uint8_t, uint8_t)’ At global scope:

pinMode(ledPin OUTPUT); //Set up Arduino pin for output only.

The clue to this problem is found in the message error: too few arguments to function ‘void pinMode(uint8_t, uint8_t)’“. The message includes a list of the function’s arguments and data types (uint8_t). The error is complaining that we have too few arguments. The problem with this line of code is the missing comma between ledPin, and OUTPUT. The corrected code is on the following line:

pinMode(ledPin, OUTPUT); //Set up Arduino pin for output only.

Now, rerun the Verify/Compile command.

Line 11 Error

error: expected constructor, destructor, or type conversion before ‘(’ token

loop()

In this line the type specifier for the function is missing.

To fix this problem place the data type for the function’s return type. In this case we’re not returning any value so we need to add the keyword void in front of the loop function name. Make the following change:

void loop()

Now, rerun the Verify/Compile command.

Line 12 Error

error: function ‘void loop()’ is initialized like a variable

(

The block of code that makes up the loop function should be contained within curly braces “{“ and “}”. In this line a left parenthesis character “(“ is used instead of the beginning curly brace “{“. Replace the left parenthesis with the left curly brace.

Now, rerun the Verify/Compile command.

Line 13 Error

error: expected primary-expression before ‘/’ token At global scope:

/The HIGH and LOW values set voltage to 5 volts when HIGH and 0 volts LOW.

This line is supposed to be a comment describing what the program is doing. The error is caused by having only one slash character “/” instead of two “//”. Add the extra slash character then recompile.

//The HIGH and LOW values set voltage to 5 volts when HIGH and 0 volts LOW.

Line 14 Error

error: ‘high’ was not declared in this scope At global scope:

digitalWrite(ledPin, high); //Setting a digital pin HIGH turns on the LED.

This error message is complaining that the variable “high” was not declared. Programming in C is case sensitive, meaning that it makes a difference if you are using upper or lower case letters. To solve this program replace “high” with the constant value “HIGH” then recompile.

digitalWrite(ledPin, HIGH); //Setting a digital pin HIGH turns on the LED.

Line 15 Error

error: expected `;’ before ‘:’ token At global scope:

delay(1000): //Get the microcontroller to wait for one second.

This error message is helpful in identifying the problem. This program statement was ended with a colon character “:” instead of a semicolon “;”. Replace with the proper semicolon and recompile.

delay(1000); //Get the microcontroller to wait for one second.

Line 16 Error

error: expected unqualified-id before numeric constant At global scope:

digitalWrite(ledPin. LOW); //Setting the pin to LOW turns the LED off.

This error can be particularly troublesome because the comma “,” after the variable ledPin is actually a period “.” making it harder to spot the problem.

The C programming language allows you to build user defined types. The dot operator (period “.”) is part of the syntax used to reference the user type’s value. Since the variable ledPin is defined as an integer variable, the error message is complaining about the unqualified-id.

digitalWrite(ledPin, LOW); //Setting the pin to LOW turns the LED off.

Line 17 Error

In function ‘void loop()’:

error: ‘Delay’ was not declared in this scope At global scope:

Delay(1000); //Wait another second with the LED turned off.

This error was caused by the delay function name being spelled with an incorrect upper case character for the letter “d”. Correct the spelling using the lower case “d” and try the Sketch Verify/Compile again.

delay(1000); //Wait another second with the LED turned off.

Line 18 Error

error: expected declaration before ‘}’ token

}

}

There is an extra curly brace at the end of this program. Delete the extra brace to correct this error.

Now, rerun the Verify/Compile command.

Success (or so it seems)

The compiler completed without any more error messages so why doesn’t the LED flash after loading the program on my Arduino?

Line 4 Error

No error message was given by the compiler for this problem.

int ledPin = 23; \\We’re using Digital Pin 23 on the Arduino.

The Digital pins are limited to pin numbers 0 through 13. On line 4 the code is assigning a non-existant pin 23 to the ledPin variable. Change the pin assignment to pin 3 and the program should compile, upload to your Arduino and flash the LED if everything is wired properly on your breadboard.

int ledPin = 3; \\We’re using Digital Pin 3 on the Arduino.

(c) 2009 – Vince Thompson

Learning the C Language with Arduino

June 4, 2009

Wiring the Breadboard

In this example we’re using a single LED on the breadboard wired to the Arduino. As shown in the example, attach a ground wire (black) to the Gnd location on the bottom of the Arduino. Connect the wire to a ground rail on the breadboard. Using additional black wires jump to the bottom ground rail on the breadboard to complete a circuit adjacent to the LED position on the breadboard.

Place the LED in the breadboard and connect the black ground wire between the ground rail and the cathode lead (-) on the LED. Place a 150 to 220 ohm resistor in the breadboard. Attach another wire from one end of the resistor to the anode lead (+) of the LED. Finally, attach a wire between the remaining end of the resistor and Digital Pin 3 on the Arduino to compelete the circuit. This will allow us to write a program that controls flashing the LED.


Breadboard Wiring LED Circuit

Breadboard Wiring LED Circuit

Programming the Arduino

Create a new program named: LEDBlink

Type in the following code, typing the comments (shown in green) are optional. You could copy and paste into the program editor but typing your own code helps you learn the programming language too.

LEDBlink Arduino Program

/*--- Blink an LED  ---*/
//Associate LEDs with an Arduino Digital pin.
int ledPin = 3;  //We're using Digital Pin 3 on the Arduino.</code>

void setup()
{
   pinMode(ledPin, OUTPUT);   //Set up Arduino pin for output only.
}

void loop()
{
   //The HIGH and LOW values set voltage to 5 volts when HIGH and 0 volts LOW.
   digitalWrite(ledPin, HIGH); //Setting a digital pin HIGH turns on the LED.
   delay(1000);  //Get the microcontroller to wait for one second.
   digitalWrite(ledPin, LOW);  //Setting the pin to LOW turns the LED off.
   delay(1000);  //Wait another second with the LED turned off.
}

C Language Programming

As described in the related article “Introduction to Programming the Arduino“, the programming language used for the Arduino is based primarily on the C language.

Language Reference

The Arduino’s language features used in this program example are described in the Language Reference section of the Arduino web site.

Keywords

In the following program statement we are doing three things as we declare a user defined variable. First we are identifying the data type as being an integer number int”. Second, the variable name ledPin was made up for this program. Third we are assigned a value to this variable. In this case we assigned the value 3 to the variable ledPin.

int ledPin = 13; //We’re using Digital Pin 3 on the Arduino.

Syntax, Punctuation Usage

; semicolons

{} curly braces

Semicolons

One of the differences between programming languages like C and Visual Basic is the use of semicolons to end a statement.

When not to use semicolons.

  • They are ignored if used in comments.
  • They are not used in a function definition like setup()
  • They are not used on the curly braces { }

When to use semicolons.

Semicolons are used to end program statements. In the LEDBlink program they are used to end the variable declaration, ledPin, and to end program statements like pinMode, digitalWrite, and delay functions.

Curly Braces

In the LEDBlink program, the braces are used to completely surround the collection of statements used to make up the setup() function. They are also used separately to surround the loop() function’s program statements.

Standard Arduino Functions

This program only uses three different function calls.

  • pinMode()
  • digitalWrite()
  • delay()

pinMode()

pinMode(ledPin, OUTPUT); //Set up Arduino pin for output only.

In our example project, we’re using one of the Arduino’s digital pins to make an LED turn on and off. These pins are able to operate in an input mode as if to read a switch to see if it is on or off. The pins can operate in an output mode for our LED. As shown in the line of code above we are setting the pin to operate in the output mode.

digitalWrite()

digitalWrite(ledPin, HIGH); //Setting a digital pin HIGH turns on the LED.

The digitalWrite function does the actual work for us by turning the LED on or off. By specifying a High value it causes the output voltage to go high, in this case we’re using 5 volts to light the LED. Causing digitalWrite to go HIGH turns the pin on with 5 volts. When we want to turn the LED off we use digitalWrite and LOW to cause the pin to go to 0 volts.

delay()

delay(1000); //Get the microcontroller to wait for one second.

The article “Microcontrollers as Time Keepers” provides some additional information about the time intervals used within the Arduino’s capabilities. We will be using millseconds (one thousandth of a second) with this program. The delay() function causes the program to wait the specified number of milliseconds, in the following code statement it waits 1000 milliseconds for a total of one second.

Getting it Right the First Time

Hopefully you typed everything correctly getting your punctuation right with the right spelling, upper case and lower case letters as required. Selecting the Sketch -> Verify/Compile will soon let you know if something is wrong. If so, what do you do to correct the problems? Next, we’ll take a look at some possible error conditions and the error messages you might see when writing your own programs.

Check out the article “Correcting Arduino Compiler Errors“.

(c) 2009 – Vince Thompson

Introduction to Programming the Arduino

June 4, 2009

The programming language used for the Arduino is based primarily on the C language. Some features of the C++ language may be used in more advanced programming features but are not used in this introduction.

Each program must include two parts for it to be valid, the setup and loop functions. Any statements included in a setup function are only run once by the program. Any statements in the loop function are executed over and over.

/*--- Minimum Arduino programming functions, setup and loop  ---*/

void setup()
{
}

void loop()
{
}

The first line in the above program is a comment. The comment is not really required but are helpful in explaining what a program is supposed to do.

/*— Minimum Arduino programming statements —*/
Comments can have two forms. The previous comment starts with the /* characters and continues until the ending characters */ are found.

/* This style of
comment can
cross multiple lines
*/

The other comment form is with the double slash characters

// This is a comment too but is only on a single line in the program.

Comments with the // characters can begin anywhere on a line and are often used following a programming statement.

Verify and Compile

Using the Sketch → Verify/Compile command to check your work.

Arduino Sketch - Verify/Compile

Arduino Sketch -> Verify/Compile

If everything compiles successfully the Arduino’ programming environment shows the message “Done compiling”. When the sketch compiles without errors it also shows the message stating the Binary sketch size.

Sketch Successfully Compiled

Sketch Successfully Compiled

This simple program will compile properly but doesn’t do anything useful. It just shows the bare minimum needed to create a program.

(c) 2009 – Vince Thompson