ProtoCylon: Control

By Bobby Neal Winters

Again and again I am reminded of the importance of the basic model:  Input information, Process that information, and Output (or Act on!) the processed information.  This simple model helps us to keep the processes separate and keeps us from confusing them.  Indeed, once we understand various, separate processes, we can mix and match ways of inputting with ways of outputting.
This brings us to today’s project: Temperature control.  One way I justify this new hobby of mine to the Other Half is that one day I can use it to control the fan for the greenhouse next door.  The fan has to be turned on when it gets too hot.  
During the summer, there are some days we simply have to anticipate that it will be hot before it actually gets hot and think to turn on the fan before we go to work.  If there were a temperature control for the fan, we would neither have to remember to turn it on in the morning or turn it off in the evening.  
Today’s project will turn a fan on and off at a certain threshold temperature.  It won’t control a fan as big as the one in the greenhouse, but I am into the “baby step” thing.
For the input part, I refer my reader to my last blog entry on Telling the Temperature.  In that, I construct a temperature sensor that connects to the Arduino with one wire.  The sensor itself is a surprisingly tiny component.  You can get ten of them for fifteen dollars.  This is input at its best.  You don’t have to type in anything; you don’t have to turn a dial; you just connect it and let the software do the rest.
The control in this case is easy as well once you have the transistor wired in.  To control the fan, I refer the reader to Beginning Arduino by Michael MacRoberts in the section where he shows how to use a TIP120 transistor to control a motor.  
Transistors are kind of scary to me.  I still don’t understand them very well.  This I know: They have three prongs.  One of the prongs goes to power, one goes to ground, and the third (actually the middle one) connects to the Arduino where it gets instructions for controlling the flow of current.
All of the complication of this project took place on the breadboard.  Wiring the temperature sensor and the transistor are still non-intuitive to me.
The code is simple:

// include the library code:
#include
#include

//Temperature Sensor pin
#define ONE_WIRE_BUS 3

//Pin that controls the transistor

int transistorPin=A1;

// initialize the library with the numbers of the interface pins
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
DeviceAddress insideThermometer, outsideThermometer;
//place to put the temperature
float tempC=20;

void setup() {
 //Set up transistor
 pinMode(transistorPin, OUTPUT);
 // Get the temperature sensors running.
 sensors.begin();
/*The 0 in the second argument is because this is the first transistor.  Computers start counting at 0.*/
 sensors.getAddress(insideThermometer,0);
}

void loop() {
 //Get the Temperatures
 sensors.requestTemperatures();
 tempC=sensors.getTempC(insideThermometer);
 //Is it hot enough for the fan?
 if(tempC>25){
     //Turn the fan on
     analogWrite(transistorPin,255);
 }
 else{
     //Turn the fan off
     analogWrite(transistorPin,0);
 }
 //No reason to be impatient
 delay(1000);
}

ProtoCylon: Telling the Temperature

By Bobby Neal Winters
I remember reading old documents, ages ago, about the computing model that was in three parts: Input, Process, and Output.  I thought it was kind of goofy at the time, but I was younger and smarter then.  Now that I am old and stupid I’ve gained an appreciation of how separating a project into smaller parts--even into three parts--can make doing the project a reality. (When I was younger and smarter, I never actually did anything.)
Thus is the tale of teaching my ProtoCylon to tell the temperature.  It comes in three parts and there is a part where I grow just a little bit.
The Input part I referred to in my post ProtoCylon Senses. This involved the DS18B20 digital temperature sensor.  This is a tiny thing.  It has three pins like a transistor.  Heck, for all I know, it might be a transistor.  The power goes in one side, out the other, and the center pin is connected to the Arduino board.  You can check the wiring at this tutorial.
For the Output, I used an LCD display.  This required growth for me.  I will work with the most obvious part first. This display has 16 pins.  That is a lot of pins. This is eased a bit by the fact that four of them are used for power and one is just grounded out.  This leaves eleven, though, and that is nothing to sneeze at.  This wasn’t the major growth inducer, however.  No, the big this is that I had to solder--yes, solder--those 16 pins to a set of pins that would allow me to plug it into the breadboard before I could even start to hook up the rest. (I will leave out the part where I attempted to hook it up without soldering. Not a happy time.)
After I got it soldered, I hooked it up and it didn’t work.  This is becoming a theme with me, but I am learning from this and recovering quicker each time.  The first stage is not to allow myself to be crushed by each failure.  I stop, take a deep breath, let it out, and try to figure out where I goofed.  
One useful technique is to take it apart and put it together again--slowly from scratch.  For wiring up the LCD display, I recommend the tutorial at Adafruit Learning System.
In between the Input and the Output is the Process.  The process in this case involved the use of libraries.  Libraries are specialized functions that make using hardware easier.  While there is a young turk deep inside me that would like to write my own libraries, there is an old goat who would like to actually get something done without taking it apart electron by electron.  Therefore, I happily use the libraries.
In creating this project, I actually used my creativity to merge two programs.  One of these was a “Hello, world!” program for the LCD that was an example that came with my Arduino compiler.  The other was in the book Beginning Arduino by Michael MacRoberts. I lay claim to the creativity crown because I did have to modify their code mutatis mutandis for the project to work.  The completed project follows:

This is the code:
/*
The uses temperature sensors to take the temperature
and outputs it to an LCD display.
I fused two programs by other people and modified them.

The first was:

The LCD Library originally added 18 Apr 2008
by David A. Mellis
library modified 5 Jul 2009
by Limor Fried (http://www.ladyada.net)
example added 9 Jul 2009
by Tom Igoe
modified 22 Nov 2010
by Tom Igoe

This example code is in the public domain.

http://www.arduino.cc/en/Tutorial/LiquidCrystal

The second was from Begining Arduino by Michael MacRoberts
*/

// include the library code:
#include
#include
#include

#define ONE_WIRE_BUS 3

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(7,8,9,10,11,12);
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
DeviceAddress insideThermometer, outsideThermometer;

void setup() {
 // set up the LCD's number of columns and rows:
 lcd.begin(16, 2);
 lcd.clear();
 // Get the temperature sensors running.
 sensors.begin();
 sensors.getAddress(insideThermometer,0);
 sensors.getAddress(outsideThermometer,1);

}

void loop() {
 //Get the Temperatures
 sensors.requestTemperatures();
 //Print it on the first row, i.e. row 0
 lcd.setCursor(0,0);
 printTemperature(insideThermometer);
 //Print it on the second row, i.e. row 1
 lcd.setCursor(0, 1);
 printTemperature(outsideThermometer);
 //enjoy the weather for one second
 delay(1000);
}


void printTemperature(DeviceAddress deviceAddress){
 //Get the temperature
 float tempC=sensors.getTempC(deviceAddress);
 //print it out.
 lcd.print("TempF:  ");
 lcd.print(DallasTemperature::toFahrenheit(tempC));
}

ProtoCylon Senses

ProtoCylon Senses

By Bobby Winters

I’ve spent the last week on a voyage of discovery in which I’ve discovered myself the same as I’ve always been.
Let me explain.  
Last weekend I tried to get a UltraSonic distance sensor hooked up to my Arduino Uno.  The procedure is easy to find on the Internet.  I wired it, and it didn’t work.  I required it, and...it didn’t work.  In my reading of the reviews in the process of buying this sensor, one of the reviewers had complained the one he bought was trash. I figured I’d had a bit of bad luck, so I bought another one.  Yesterday, I wired it up again.
It worked great.
Then my curiosity got the better of me, so I plugged in the other one to the same wiring.  It worked too.  It had been miswired the first time.  
Now, I am fully capable of screwing up that badly.  I admit that freely.  In my fiddling around, I discovered that one of the jumper wires I had been using was bad.  This is a possibility that hadn’t occurred to me before.  In math your results don’t just go belly-up because your pencil has a crack in its lead.
This is a practice where the real world will check your work for you.
Another project I’d been working on from Beginning Arduino was to connect temperature sensors.  The sensors I’d purchased for this were DS18B20 sensors. You get 10 for that price.  I worked through the book, and, having learned my lesson, I wired the boards painstakingly. I hooked it up and discovered it was 285 degrees centigrade in my house. (For you non-metric types, water boils at 100 degrees centigrade.)  I discovered my error when I looked further in the book and discovered the DS18B20 are a different type of sensor and must be wired in a different way and require a different library of functions to operate.  I hooked them up, and got the temperature down to 85 degrees centigrade.  I changed a resistor in my wiring and it came down to 74 Fahrenheit.
Like I said, the real world checks your work for you.

Proto Cylon v1.0001

By Bobby Neal Winters
I’ve been fiddling with my Arduino board a little more.  The Internet in general and YouTube in particular is rich with examples of projects using the Arduino board.  As with any student, my struggle has been to find the right level of video.  There are those which assume that you know everything about electronics and that you have certain things just lying around.  Then there are those which are very detailed and step-by-step, but don’t do much in creating a conceptual framework.  My hope is to work in a little of that conceptual framework.  It won’t be at the right level for anyone besides me, of course, but it will fit into the general milieu of the Internet as another piece of the puzzle.
The Arduino is able to take in information from the outside world in the form of electrical information.  It can process that information in form of binary numbers.  Then it can output information in such a way as to effect the outside world.
My Proto Cylon v1.0001 is an example of that.  In it I get input from a potentiometer, scale that input to a range from 0 to 255, and then output it in binary form using LEDs.
In this I use:

• A 100 ohm potentiometer I got from Amazon.
• An Arduino Starter Kit I also got from Amazon.
• This included the Arduino Uno board;
• Breadboard;
• Jumper wires;
• And a nice piece of plastic to mount the Arduino and the breadboard on.
• A 9 volt battery connector.
• I also got an assortment of leds and resistors from Amazon.

Before I dive into the project proper, let me remark on a few things that apparently everyone talking about this sort of thing believes everyone knows.  
First let me say that breadboard is the coolest stuff since, uh, sliced bread. You can hook together your components without soldering.  Those of you who have read of my adventures with the crystal radio know of the mental block I have regarding solder.  With breadboard, you just plug stuff in.  The breadboard I used here has power bars along the side with connections that run the length of the board and connections along the middle that run the width.  It has an adhesive backing that you can peel-off and stick to stuff.
The LEDs and resistors come together on purpose.  The LEDs run at a lower level of current than the Arduino board puts out.  The resistors are used to decrease that current.  If you don’t do this, the LEDs will get hot.  I learned that by not using the resistors and touching one.  Resistors come in various denominations. There is a way to figure out what size of resistor that you need to get a particular current.  I am not going to that depth at this point.  I will say that Ohms is the unit of resistance and those cute little stripes you see on the resistor tell you what that resistance is. In order to read them, you need to know the secret language of resistors and it can be found in Wikipedia.
In this project, we do our input from a 100 ohm potentiometer. The potentiometer is basically a knob you turn.  It has three prongs on the bottom: left, right, and middle. The left and the right prongs are where the power is hooked on.  The middle is where it is read out.  It is an entity unto itself and only interacts with the LEDs that we use for output via the Arduino.  The left prong will be hooked to 5 volts, the right will go to ground, and the middle pin will be taken to the A0 pin on the Arduino board. Once hooked to the board, the potentiometer will send a signal to the pin that is interpreted as a number between 0 and 1023. The function that retrieves this value is given below:
 val=analogRead(potPin);
For more detailed information about the syntax of this and the other functions used, look at the Arduino website reference.
Those of you who are attuned to the computer age might be suspicious of that particular range of values.  There are 1024 total values represented there. You might recognize 1024 as being 2 to the tenth power.  It requires 10 bits to represent this number. I discovered that wiring a board for LEDs requires a bit of patience and manual dexterity. I had enough patience to wire 8 LEDs but not enough to wire 10.  Wiring apparently has an accumulative effect on one’s nerves, and I’d run out of hard cider.
This means I needed to scale the value of the potentiometer reading to be in the appropriate range.  This is done via the function below:
 val=map(val, 0, 1023, 0, 255);
Once the value is read and mapped, we want to tear it to bits. (We all love our own puns; please indulge me.) We do this by mathematical functions in the C language.  The eight bits that we are going to use for our binary number from 0 to 255 are numbered from 0 to 7.  The first bit is labeled as 0 for 2 to the 0th power; the second as 1 for 2 to the 1st, and so on.  I write all of this so that I can say bitRead( x, i) with return the value of the ith bit in the number x.  For example for x=1001001 in binary, bitRead( x,0) returns 1 and bitRead(x,1) returns 0.  This is used only at one place in the program, but it is crucial.
I won’t impose the program on you until after the prose is done in interest of not boring you to actual tears. Let me put the lie to those words by now sharing a bit about my programming philosophy.  The program should be easy to read to see what it does.  This means not only should it be documented, but it should be written in functions so that at each level you can see what is done.  In programming the Arduino, after an initial setup, you go into a loop that is executed over and over and over. I put the things in the loop the will happen again and again: the value will be read from the potentiometer and the value will be output to the LEDs.
This is done with two functions.  The input function is fairly straightforward, and the output function isn’t too bad.  Their composition can be followed in the code at the end of this blog entry.
We now come to the wiring of the project.  A picture is indeed worth a thousand words, but a few words can help the picture.  Each LED is wired as follows: its pin on the Arduino goes to a resistor; the resistor goes to the long end of the LED; the short end of the LED goes to ground on one of the side bars of the breadboard.  By putting all of your ground to the side bar of the breadboard, you only need to run one ground wire to the Arduino.  You may see it in the picture below:
The code is below:
//Set the pin for the potentiometer
int potPin=0;

//Map the Arduino pins to bits of a number in the range from 0 to 255
int b0=3;
int b1=4;
int b2=5;
int b3=6;
int b4=7;
int b5=8;
int b6=9;
int b7=10;
//Initiate values for the analog inputs from the potentiometer
int val=0;
const int MAX_VAL=255;
void setup(){
 //Set the led pins for output
 pinMode(b0,OUTPUT);
 pinMode(b1,OUTPUT);
 pinMode(b2,OUTPUT);
 pinMode(b3,OUTPUT);
 pinMode(b4,OUTPUT);
 pinMode(b5,OUTPUT);
 pinMode(b6,OUTPUT);
 pinMode(b7,OUTPUT);  
}          

void loop(){
 //Grab the reading from the potentiometer
 val=grabValue(potPin);
 //light the number
 lightBinary(val);
}

int grabValue( int pPin){
 //Get the value from the pin
 int mVal;
 mVal=analogRead(pPin);
 //Map the reading to our allowed range of values
 mVal=map(mVal, 0, 1023, 0, MAX_VAL);  
 return mVal;
}

void lightBinary( int pN)
{
    //Loop digit by digit turing the led on or off as appropriate
    for(int j=0;j<8 j="j" span="span">
    {
     lightBit(j+3,bitRead(pN,j));

    }
}
void lightBit( int bL, int val)
{
 if(val==1){
    //Light the led if the bit is 1
    digitalWrite(bL ,HIGH);
    //leave the function
    return;
 }
 if(val==0){
    //turn off the led if the bit is 0
    digitalWrite(bL,LOW);
    //leave the function
    return;
 }
 //If you've made it here something is terribly wrong
 Serial.print("Error");
}

The Proto Cylon

By Bobby Neal Winters
I’ve been captured by another enthusiasm.  The Arduino controller card.  If you go to http://arduino.cc/en/, then you can learn as much as I know about it in short order.  There is probably a fancy name for it, and if you read the whole page on the link I just gave you, then you can probably find it.  Regardless of what you call it, it is basically a little computer that you can use to run stuff.  
It costs about $20.
I learned of its existence while looking around for Raspberry Pi. This turns out to be a slightly different kettle of fish, but I will doubtless return to Raspberry Pi eventually.  But I digress.
The Arduino collection of cards give you the ability to interact with the mechanical world. You can control a small amount of electrical current using the C programming language.  This appealed to the same part of my brain that was attracted to the Potato Cannon and the Itty Bitty Ubuntu Box.  
(Since it controls a small amount of current and the potato cannon needs a small amount of current to produce a spark, there is even the possibility of combining the two.  Using an Arduino card to make a potato machine gun. Hmmmm.)
In any case, one of the classical projects for a card such as this is to make a robotic car.  That is my long range goal.  But why stop with just a car?  Why not think really long range and work one’s way up to a Cylon. (I am thinking a Six or an Eight. The Threes aren’t stable.)   In the meantime, we do baby steps.  My first step is learning how to blink LEDs on breadboard. The code is below:

int inputPin=5;
int ledPin1=2;
int ledPin2=6;
int ledPin3=8;

void setup() {
 pinMode(ledPin1, OUTPUT);
 pinMode(ledPin2, OUTPUT);
 pinMode(ledPin3, OUTPUT);
 pinMode(inputPin, INPUT);
 digitalWrite(inputPin,HIGH);
}

void loop() {
 blinkOff(ledPin1, 0);
 blinkOff(ledPin2, 0);
 blinkOff(ledPin3, 0);
 blinkOn(ledPin1, 500);
 blinkOn(ledPin2, 500);
 blinkOn(ledPin3, 500);
 blinkOff(ledPin3, 500);
 blinkOff(ledPin1, 500);
 blinkOff(ledPin2, 500);   
}

void blinkOn( int ledNum, int duration)
{
 int switchOpen=digitalRead(inputPin);
 digitalWrite(ledNum, ! switchOpen);
 delay(duration);  
}
void blinkOff( int ledNum, int duration)
{
 int switchOpen=digitalRead(inputPin);
 digitalWrite(ledNum, switchOpen);
 delay(duration);  
}

This is what it looks like: