bildr

Tilt Sensing with the RPI-1031 + Arduino

ameyer — Tue, 14 Feb 2012 13:16:29 +0000

Once in a while something comes out that I think is going to be really awesome, but when you get it, it is just so so. Im sure you all know what I mean… But yeah… This is one of those.

The RPI-1031 available from sparkfun is a pretty simple (heck, it is dead simple) sensor for sensing when it is tilted. And it does this really well. But it seriously only does that. If it is not tilted, it freaks out and reports tilt anyways.

It actually just uses a metal ball that rolls around inside (you can hear it moving around when you tip it). Because of how it is made, the ball is always up against one side even when it is flat. Unfortunately this means you can never know the difference between a reading, and it being flat, only changes in reading.

Hooking it up

This is as simple as it gets I guess. Just power and ground, then connect the 2 digital pins and you are done. These 2 digital pins will output LOW/LOW, LOW/HIGH, HIGH/LOW and HIGH/HIGH depending on the wall it is touching. Again, even if it is flat, it is still touching a wall.

Code

The code for this guy is really simple, it just checks 2 pins, to see what side is being touched – The simple function just takes the 2 digital outputs and returns 0,1,2 or 3 depending on the side.

Copy Code

//For the RPI-1031 - http://www.sparkfun.com/products/10621 

int tilt_s1 = 2;
int tilt_s2 = 3;

void setup(){
 pinMode(tilt_s1, INPUT);
 pinMode(tilt_s2, INPUT);
 Serial.begin(9600);
}

void loop(){
  int position = getTiltPos();
  Serial.println(position);
  delay(200); //only here to slow down the serial output
}

int getTiltPosition(){
   int s1 = digitalRead(tilt_s1);
   int s2 = digitalRead(tilt_s2);
   return (s1 << 1) | s2; //bitwise math to combine the values
}

Unless otherwise stated, this code is released under the MIT License – Please use, change and share it.

Sensing color with the ADJD-S311 + Arduino

ameyer — Tue, 31 Jan 2012 13:41:05 +0000

A year ago we had an article called Sensing color with the ADJD-S371. Well the ADJD-S371 is long gone, and its replacement is the ADJD-S311 (breakout board available from sparkfun). It is basically the same all around, so without shame, I will be copying a lot of that article, because… Why reinvent the wheel?

A few things you should know about the ADJD-S311 before we dive in too deep: I have never been able to get perfect color sampling from this guy without limiting the colors it would detect to just 6, and accurately reproducing color on an LED is not as simple as one would hope. The color reading from the sensor could be spot on, but the reproduced color on the LED may be way off. (you can blame your eyes and the LEDs)

Hooking it up

The ADJD-S311 is an I2C device (I2C is a 2-wire serial connection), so we just need to connect the SDA (Data) and SCL (Clock) lines to your Arduino for communication. On your Arduino (everything but the mega) SDA is on analog pin 4, and SCL is on analog pin 5. On an arduino mega, SDA is digital 20, and SCL is digital 21. (The Arduino Leonardo will also be different). Other than these 2 lines, we just need to connect power(3.3v), ground, and the onboard LED to digital 2 (you can change that in code if you want).

The ADJD-S311 has 4 sensors built into it to detect Red, Green, Blue, and Clear. It reports back an individual reading from each sensor. The white, or clear, sensor is mainly for sensing brightness.

The ADJD-S311 is designed to sense reflected light using the onboard LED, but I have found that by turning the onboard LED off, it works even better for sensing projected light (like from your monitor or projector). If you are interested in using the sensor for sensing reflected colors, you want the sensor to be about 1-2mm from the subject so the onboard LED can bounce off the material and back to the sensor.

Code

The code for this guy is long and obnoxious, so we made a library out of it. This code is based on the sparkfun code, that was based on the old bildr code, that was based on the code by Marcus over at Interactive Matter. I love open source!

This library is really simple, you can call calibrate to calibrate to white (make sure you have a white objet or light source in front of it when you do this), you can turn the LED on and off, and you can read. Reading gives you back a RGBC (red,green,blue,clear) variable that has the readings from the sensor. See the code for how to use it.

To make this code work, before you load the code, or even open the Arduino program, we need to place the “ADJDS311″ folder into your Arduino Library. If you don’t know where that is by default, Look to the right.

If you click the download button to the right of “Arduino” you can download the whole thing as a zip, so you dont need to copy all the files.

Default Library Folder Location

On your Mac:: In (home directory)/Documents/Arduino/libraries
On your PC:: My Documents -> Arduino -> libraries
On your Linux box:: (home directory)/sketchbook/libraries

Quickly: KS0108B Graphic LCD 128×64 + Arduino

ameyer — Thu, 13 Oct 2011 03:32:58 +0000

This is an incredibly quick post, and it is actually here simply because this thing was a pain to figure out how to hook it up. But, I wasn’t able to do anything with it more than the Arduino library was able to do out of the box.

So, if you have this screen sold from SparkFun, and you wanted to hook it up to your Arduino, here is how you do that.

Hooking it up

LCD screens of this type are more difficult to work with than ones specifically designed for text. With these you have individual pixel control, so you can draw completely custom graphics with it. But it also means you have to keep track of a lot of pixels, hence all the extra wires. Making matters worse, many of these screens actually require a negative voltage on the dimmer pot to get an image from it. But luckily this particular one includes all the circuitry needed.

Note: this is hookup for the non-mega Arduino. The Arduino Megas actually connect differently to this screen. Just make sure to connect all the wires to the Arduino as seen on the right. You can click on the image to get a closer look.

To drive this graphic display you need a library, and for that, Arduino has you covered: http://www.arduino.cc/playground/Code/GLCDks0108

I know this is a lame excuse for an article. But like I said, it is just here incase you need to know how to hook it up.

High Sensitivity Light Sensor TSL230R + Arduino

ameyer — Fri, 09 Sep 2011 12:03:37 +0000

A while back we covered the TEMT6000, a great little analog sensor for getting ambient light readings when you need something a bit more sensitive than a simple Photoresistor. Well in the spirit of documenting everything we can get our hands on, this week we will be taking the sensitivity to the next level with the TSL230R Light Intensity Sensor.

I actually bought this a long time ago simply because it looked awesome. I mean really… How often do you see a clear chip? That was enough, I had to have it. Well, aside from looking downright awesome, it is also an incredibly sensitive digital light sensor. This awesome guy is sensitive enough to be used for photography light metering, or be able to tell when someone walks by a lamp on the other side of the room. Also, to top it all off, it actually has 3 sensitivity settings, so if you are in a low-light situation, it has you covered!

Hooking it up

So the TSL230R is actually pretty simple, it really only has power, and signal out. But it has a bunch of extra pins so you can change sensitivity and output type if you want. We don’t care about changing the output format, but I did want to keep the “sensitivity select” open for you incase you need it.

So just connect it up to your Arduino as shown in the image. Make sure to take note of either the larger pin in the bottom left (pin 4) or the circle on the top left (pin 1) to make sure you have it facing the right way.

Code

Before we get to far! If you are looking for a photo-ready reading from this sensor, in ISO, ASA, Lux or other, you are in the wrong place. You want this article here: Arduino and the Taos TSL230R Light Sensor: Getting Started.

If you want to be able to check for changes in light, and have some simpler code to tame this beast, keep reading.

So what the TSL230R does, is it sends out a digital Square Wave (simple up and down) signal that gets longer with less light, and shorter with more light. So we need to look at how long the wave is so we can figure out the brightness. We will actually be taking a few samples and averaging them so the signal will be more accurate and smoother. If you are looking at using a threshold to trigger something, you may want to up the number of samples it takes so it is even smoother and you don’t get false positives. (but this will slow down how long it takes to read)

This code simply checks the output of the TSL230R, and prints to the Arduino’s software serial terminal. With higher readings meaning brighter. You can change the sensitivity of the TSL230R as well. In the sketch, under setupTSL230, you can set TSL230_s0, and TSL230_s1 HIGH or LOW to make the sensor more or less sensitive to light. Great for low-light, or ultra-bright situations.

Copy Code

// Reports the frequency from the TSL230, higher number means brighter
// Part: http://www.sparkfun.com/products/8940
// Article:  http://bildr.org/2011/08/tsl230r-arduino/ 

int TSL230_Pin = 4; //TSL230 output
int TSL230_s0 = 3; //TSL230 sensitivity setting 1
int TSL230_s1 = 2; //TSL230 sensitivity setting 2

int TSL230_samples = 6; //higher = slower but more stable and accurate

void setup(){
  Serial.begin(9600);
  setupTSL230();
}

void loop(){

  float lightLevel = readTSL230(TSL230_samples);
  Serial.println(lightLevel);

}

void setupTSL230(){
  pinMode(TSL230_s0, OUTPUT);
  pinMode(TSL230_s1, OUTPUT); 

  //configure sensitivity - Can set to
  //S1 LOW  | S0 HIGH: low
  //S1 HIGH | S0 LOW:  med
  //S1 HIGH | S0 HIGH: high

  digitalWrite(TSL230_s1, LOW);
  digitalWrite(TSL230_s0, HIGH);
}

float readTSL230(int samples){
//sample light, return reading in frequency
//higher number means brighter

  float start = micros();
  int readings = 0;

  while(readings < samples){
   pulseIn(TSL230_Pin, HIGH);
   readings ++;
  }

  float length = micros() - start;
  float freq = (1000000 / (length / samples)) * 10;

  return freq;
}

Unless otherwise stated, this code is released under the MIT License – Please use, change and share it.

Displaying on Paper – Thermal Printer + Arduino

ameyer — Tue, 30 Aug 2011 11:48:03 +0000

The following code and library are compatible with arduino software 1.0+ ONLY. You can download the newest version of the arduino software here.

Outputting data can be extremely useful, and typically when we look at doing this, it is either to the Arduino’s serial terminal, or to some sort of display. But what about making physical copies of the data? So a few months back, SparkFun started selling a thermal printer that you could connect to a microcontroller (or via adafruit ). That same day my brain filled with crazy thing you could do with it, like a giant fortune cookie that could print your fortune on the fly.

Anyways… If you dont know about thermal printers, they are most often the printers your store’s receipts are printed on. The reason for this is that they dont use ink, or use a cartridge of any sort. The paper it prints on turns black when heated. So this printer simply applies heat where another printer would apply ink. Eventually the printers head will wear out, but this after several miles of printing. Yes, miles – about 30 of them. So given that the rolls of paper are 34ft long, you can print about 4,600 rolls before the print head dies, meaning for most of us, you will never see that happen.

Hooking it up

So this printer can be powered off of 5V, but NOT the 5v pin on your arduino, and no via USB. It uses very little power when it is is just sitting by, but uses around a full amp when it is printing! And because the most USB can handle is half of that, we need an external power supply. Something between 5 and 9V, and a minimum of 1400ma output (larger is fine). I found that powering the printer with 9v, it printed much faster, and slightly darker than 5v, and if you have it available, I recommend using 9v.

There are two ways of connecting the power supply as shown in the illustrations. You can either power your arduino and the printer separately, or you can power the arduino, and power the printer off of the arduino.

To do the latter, the printer’s power wire (red) needs to connect to the VIN pin on the arduino, not the 5v pin. The reason is that the 5v pin goes through a regulator and is not meant to supply this kind of power, but the VIN pin is directly connected to the power input on the arduino. So it can supply much more.

Now just connect the rest of the wires as shown.

Code

The printer needs a serial connection to the arduino. And normally that would mean we would connect to digital pins 0,1 but, if we did this, anything you printed to the serial terminal for debugging or otherwise the printer would see and possibly print out. We don’t want that, so we will be using a libraty so that you can keep those pins free.

This printer has a huge amount of features. 2 different barcode, text output, size settings etc, and each one needs a new configuration to get it working. So we created a library for this so that you could keep your code clean, and simple.

To make this code work, before you load the code, or even open the Arduino program, we need to place the “Thermal” folder into your Arduino Library. If you don’t know where that is by default, Look to the right.

If you click the download button to the right of “Arduino” you can download the whole thing as a zip, so you dont need to copy all the files.

Default Library Folder Location

On your Mac:: In (home directory)/Documents/Arduino/libraries
On your PC:: My Documents -> Arduino -> libraries
On your Linux box:: (home directory)/sketchbook/libraries

darkness And Speed Calibration

If you want to get a little more speed, or darkness out of the printer, you can change some settings in the thermal.cpp file of the Thermal library.

Copy Code

heatTime = 120; //80 is default from page 23 of datasheet. Controls speed of printing and darkness
heatInterval = 50; //2 is default from page 23 of datasheet. Controls speed of printing and darkness

Unless otherwise stated, this code is released under the MIT License – Please use, change and share it.

Changing heatTime and heatInterval to lower values, will yield a faster, but lighter printing, and raising them will yield a slower, but darker printing. If you are running off of 5V, and find the printing too light, try changing both values to 255.

You can make changes to the file with the arduino sketch open. Just save the Thermal.cpp file and re-upload the sketch to see the changes.

Help expand the library

We would love help expanding the library if you are interested. We would like to add to support for bitmap printing and other text setting. Also there may be a better way to set many of the settings than we are now. If you are interested in helping, let us know in the forum.

Polar Heart Rate Monitor Interface + Arduino

ameyer — Wed, 24 Aug 2011 12:17:53 +0000

The following code and library are compatible with arduino software 1.0+ ONLY. You can download the newest version of the arduino software here.

When you start to talk about biometrics in electronics, heart-rate is usually the first thing to come up. And why not? I think it is often the thing we are most aware of changing when we get excited, nervous, are being active, or very calm. There are several ways of sensing heart rate that dont require lots of heavy equipment and electrodes taped to you. A lot of work has been done on wrist worn IR based sensing, but it tends to be error prone, especially with movement. Currently, the best available method at a reasonable price seems to come from the company Polar. And, what makes it better is that Sparkfun in conjunction with danjuliodesigns, created a microcontroller compatible receiver for the polar monitors. So let’s take a look at using the Polar Heart Rate Monitor Interface and getting it running with your arduino.

The annoying thing about all of this is that you do need to wear a sensor on your body to get this going. I picked up this guy off amazon and had pretty good results most of the time.

This transmitter band is a reusable electrode that wirelessly transmits to a receiver. A note when you are testing, the band will only transmit when it is on person, or you have semi-wet thumbs pressed into the sensor plates. Also because it is an electrode, it wants a good connection with your skin… meaning sweat. They sell electrode gel you can use with it for a better connection when the skin is dry, but I never tried it. In the humid summer nights I was testing this in, I never really had an issue.

Hooking It Up

Ok… so this board is capable of a ton of stuff. But we are just looking today at using this with the Arduino, and the simplest way is to get this guy running in I2C mode because it will allow us to get the heart rate from it easily into our Arduino.

I2C is a 2-wire serial connection, so you just need to connect the SDA (Data) and SCL (Clock) lines to your Arduino for communication. On your Arduino (everything but the mega) SDA is on analog pin 4, and SCL is on analog pin 5. On an Arduino Mega, SDA is digital 20, and SCL is digital 21.

The board doesn’t come setup for I2C by default, so we need to make a few changes. There are two solder-jumpers on the board that need to be changed to make this happen. The first is SJ1 just to the right of the 5V pin. Remove the solder from there using solder wick or a solder sucker so that the two parts are not connected. (like in the illustration). Next look at the row of pads at the top of the board labeled OP0 – OP7. We need to solder OP0 so the two pads are connected (See the illustration).

Ok, so once you have the board modified and ready for I2C communication, we can actually just power it up with 5v to check if it is able to communicate with the band. With the board on, moisten your thumbs and press them firmly into the back of the band where the electrodes are and hold it less than a food from the monitor board. You should see a green LED on the board start to blink. If it does… Awesome, the band and the board are communicating! If not, try it a bit more, and see if you can get it going.

So, now that we know they communicate with each other, connect the board to the arduino as shown, and load up the code below.

When it is actually running, you will need to wear the band on your chest to get a heart rate signal.

code

This code is pretty simple. It will take the info from the sensor band (average of 20 of the samples) and report that back in the Arduino’s serial terminal as BPM (beats per minute). If it dosnt have a connection, or the band does not have a good connection to the skin, it will report a BPM of 0.

You should know better than I, but your BPM reading should be between 55 and 140. If you are just sitting around, and you see it around 200, it probably means it has a bad connection. Make sure it has a good connection with your skin, and restart the receiver board/ Arduino. – A note… I did have an hour reading that was very off, but all the other time, it was very accurate.

Copy Code

//Arduino 1.0+ Compatible only
//Arduino 1.0+ Compatible only
//Arduino 1.0+ Compatible only

// Code to retrieve heartrate information from the Polar Heart Rate Monitor Interface via I2C
// Part: http://www.sparkfun.com/products/8661
// Article:  http://bildr.org/2011/08/heartrate-arduino/

#include "Wire.h"

#define HRMI_I2C_ADDR      127
#define HRMI_HR_ALG        1   // 1= average sample, 0 = raw sample

void setup(){
  setupHeartMonitor(HRMI_HR_ALG);
  Serial.begin(9600);
}

void loop(){

  int heartRate = getHeartRate();
  Serial.println(heartRate);

  delay(1000); //just here to slow down the checking to once a second
}

void setupHeartMonitor(int type){
  //setup the heartrate monitor
  Wire.begin();
  writeRegister(HRMI_I2C_ADDR, 0x53, type); // Configure the HRMI with the requested algorithm mode
}

int getHeartRate(){
  //get and return heart rate
  //returns 0 if we couldnt get the heart rate
  byte i2cRspArray[3]; // I2C response array
  i2cRspArray[2] = 0;

  writeRegister(HRMI_I2C_ADDR,  0x47, 0x1); // Request a set of heart rate values 

  if (hrmiGetData(127, 3, i2cRspArray)) {
    return i2cRspArray[2];
  }
  else{
    return 0;
  }
}

void writeRegister(int deviceAddress, byte address, byte val) {
  //I2C command to send data to a specific address on the device
  Wire.beginTransmission(deviceAddress); // start transmission to device 
  Wire.write(address);       // send register address
  Wire.write(val);         // send value to write
  Wire.endTransmission();     // end transmission
}

boolean hrmiGetData(byte addr, byte numBytes, byte* dataArray){
  //Get data from heart rate monitor and fill dataArray byte with responce
  //Returns true if it was able to get it, false if not
  Wire.requestFrom(addr, numBytes);
  if (Wire.available()) {

    for (int i=0; i<numBytes; i++){
      dataArray[i] = Wire.read();
    }

    return true;
  }
  else{
    return false;
  }
}

Unless otherwise stated, this code is released under the MIT License – Please use, change and share it.

But it’s not working!

If it is not working, 99% of the time, it is simply a sensor-band placement issue. Make sure you have a blinking light on the board. If you don’t have that light, the band is not communicating with the board. It wont communicate unless it thinks it is on your body, so your skin could be too dry or the placement is off.

If you see the communication light, but nothing in the arduino, make sure you soldered/ unsoldered the solder-jumpers as described above.

Arduino: Individually Control Shift Register Pins

ameyer — Tue, 23 Aug 2011 12:28:48 +0000

If you want an article on general 74hc595 shift register usage with detailed explanition on how it works/what it’s doing, you want this article here: http://bildr.org/2011/02/74hc595/

The following code and library are compatible with arduino software 1.0+ ONLY. You can download the newest version of the arduino software here.

Earlier this year we did an article on using the 74hc595 shift register with your arduino. It has been, by far, our most popular article. It seems that a lot of people want to control a lot more LEDs (or other) than the arduino can do without help. So we actually went to the guys over at sparkfun and said… “Hey! Let’s make this even easier”. And so we came up with the 74hc595 breakout board.

So now you find your self asking “Why?” Well… chainability! Using right-angle headers you can chain a ton of these together. AND! With the code we have for you, you get an additional 8 digital outputs per board you have connected. That means if you have 1000 of these chained together, you will be able to say “setPin 7,432 HIGH”, and BAM! Just like that pin 7,432 goes HIGH. It will literally be like you have more digital outputs on your arduino, no funny business.

Hooking it up

At first this board may look confusing to hookup… But just click on the illustration to get a better view of how it is hooked up. We won’t be using Reset, so just connect that to power, and connect /OE to ground (enables the board). For VCC you can connect this to 3.3 or 5V on your arduino, and the outputs will just reflect this. So if you power the board with 3.3v, the outputs on the board will output 3.3v as well. We just need 3 digital pins to control the board, and after that we are done.

You can chain as many of these as you would like. I used right-angle header pins to make it modular and clean. I picked up some 7 pin right-angle headers from digikey to make it even easier. But you dont have to use header pins for this if you don’t want. You can easily just wire them together too. Either way, see the illustration below to see how you do this.

Code

Because it is so much easier to use a lot of these now, we wanted the code to be the same. So we made an Arduino library that is capable of controlling near 2000 of these chained together and still enable you to call each pin individually. (this library can be used with the plain 74hc959 chip as well)

The library by default will only support a chain of 25 of these. But that can easily be changed by changing one number in the file “Shifter.h” . If you find your self with a larger chain, hit us up in the discussion area, and we can help you out.

To use the library, you just need to create an instance of the Shifter library, then you have a few functions to do everything.

shifter.clear(); – This sets all of the pins on the register chain to LOW
shifter.setPin(20, HIGH) – Turn pin 20 (or whatever) HIGH/LOW
shifter.write() – Displays the changes made.

Best practice is to only call shifter.write only when you need to display the changes. This is because shifter.write() can be slow if you have a ton of these chained together (about 1ms per 10 registers (80 pins))

Make sure to check out the discussion area. We came up with a few cool sequences to test out/ play around with – including the one in the video

To make this code work, before you load the code, or even open the Arduino program, we need to place the “Shifter” folder into your Arduino Library. If you don’t know where that is by default, Look to the right.

If you click the download button to the right of “Arduino” you can download the whole thing as a zip, so you dont need to copy all the files.

Default Library Folder Location

On your Mac:: In (home directory)/Documents/Arduino/libraries
On your PC:: My Documents -> Arduino -> libraries
On your Linux box:: (home directory)/sketchbook/libraries

Video

User Project: High Voltage Temperature Control

ameyer — Tue, 09 Aug 2011 03:01:47 +0000

So typically we don’t cover too many user projects here. But I had been following the progress of a project by user K-Mob, and thought it looked really cool, so I asked if he would share it. The fact that the end result looks like something from a 1960′s mad-scientist’s lab dosnt hurt either. So without further ado… Here it is.

Suppose you want to keep something (e.g. a room, sous-vide steak, autoclave) at a certain temperature with, say, an immersion water heater; you could use an off-the shelf temperature controller, OR save some money (but not time), and build your own from the ground up. If, like me, you’re cash poor, time rich, and intellectually curious, you may consider building one yourself. I’d say this isn’t a quick build, but I think it is pretty straight-forward.

Bill of Materials:

numeric display (x2)
potentiometer
thermistor or thermocouple
10 K resistor
Arduino
microSD shield (if you want to log data)
AC power control, digital pot/relay, etc…

Let me try to break this down into three parts. You need something to measure temperature with, something to control temperature with, and some UI to view/control the temperature.
To read the temperature, I went with a thermistor, but a thermocouple would do just as well (sort of depends on the temperature range of your application); it’s just not as easy to get up and running.

For the display, I have found these Sparkfun displays are the best balance of relatively low cost and saving me a lot of pins, wiring, coding, etc. headaches.

Obligatory Disclaimer: AC POWER CAN KILL YOU

For Pete’s sake, be careful, and never handle any circuitry without unplugging everything first. Use a GFCI outlet; if something goes awry, it will minimize the current going where it isn’t supposed to before cutting off power.

As far as controlling AC power goes, you have a few options, depending on your application and comfort level. No matter what you choose, I highly recommend making sure the Arduino connections are optically isolated, and the dangerous bits (anything with high voltage) are safely inside a separate, insulated box. I’d say the easiest way to introduce AC power into your project would be to use a relay of some sort; this gives you limited on/off control, and it is relatively straightforward. I wanted to be able to control the power level, so my circuit is a little more complicated, turning the AC current on and off every cycle to dial in exactly how much current/power gets delivered.

Okay, so bildr already has a pretty good page (if I do say so myself) about how to use a thermistor to read temperature; it only takes one analog input (plus power and ground), as well as a resistor. So that’s easy as pie to setup.

Furthermore, there’s also an article on setting up and using the Sparkfun 4-digit serial display. I think it’s pretty easy to set up with SPI communication; it minimizes the pins you have to use for one or two displays, and using the NewSoftSerial library for Arduino, you can use any digital pin you want to send SPI communications. Of course, we don’t care what the board has to say back to us, so you really only need to hook up the transmission (TX) pin to the display’s RX pin.

That only leaves AC power control as the real beast. I’ll save the gory details for getting under the hood of AC power control for a future post. For the purposes of this, I literally put a black box into the schematic.

So how to tell the Arduino what temperature to shoot for? I wired up a potentiometer for each heater I had. One serial display displayed the current temperature; the other displays a number I control by turning the potentiometer. At first, I tried simply controlling the “target” temperature, utilizing the Arduino PID library to do the dirty work calculating the power that should be delivered to the heater to reach and maintain the target temperature.

Experimental setup of two of the temperature controllers (all displays are of temperature b/c I was still trying PID control)

I don’t think it was a problem with the library, but more with my setup and lacking of proper “tuning” of the parameters, but this type of control didn’t work for me. So I ended up using the potentiometers to just control the power delivered to my heaters (basically, turning my elegant Arduino AC control into a dimmer). Then the second displays were just used to output the percent power of AC being delivered.

The last little bit of complexity I added (not shown) was to do some data recording using Sparkfun’s microSD shield (note, it doesn’t come with header pins). To get it up and running, make use of their Quickstart Guide; it involves downloading a new library and learning a few new commands, but it’s a great shield to mix into your Arduino rotation.

By the time I got everything wired up (and when I use it, I actually double the number of thermistors and heaters, as well as measure the relative humidity), I use nearly all of the Arduino I/O pins. But I guess that what an Arduino MEGA or 4051 is for. One thing I did to maximize output while minimizing hardware was to add a flip switch that I would monitor and let it dictate what is output on my serial displays instead of just adding more displays (e.g. an open switch means I’ll output relative humidity; a closed switch, and I’ll send temperature as an output).

About The Author

K-MOB
K-MOB is a mechanical engineer who has learned to stop worrying and love electronics. He discusses Mythbusters, physics and everyday science at warningsciencecontent.com.

One Wire Digital Temperature. DS18B20 + Arduino

ameyer — Fri, 08 Jul 2011 12:22:43 +0000

I know… you are probably thinking “Another Thermometer! How many do you need to cover?” – Well… All of them. But really, they all have something different to offer. For instance this guy, the DS18B20, has a unique serial-number sent with it’s data, so if you needed to have 50 of these on one bus, you could and still know exactly where the reading came from. And… It’s digital serial bus it uses to transmit the date is just one wire.

For this tutorial we will be using just one of them, and our code will only support the one. So if you need to read from a few or a lot of these, contact us in the forum and we can help you out. There is also a good amount of code out there for using a bunch of these at once, but no examples of just the one.

Hooking it up

This is by far one of the more simple digital sensors to hookup. Aside from power and ground, it has a single digital signal pin that we will be connecting to digital pin 2 on our arduino. It also requires a 4.7k pull-up resistor between the signal and power pin as shown in the illustration. (I tried the internal pull-ups on the arduino but it did not work)

There is a way this sensor can be hooked up with just 2 wires (no power), but it slows the code down, so I decided not to go that way.

Code

The code on the official Arduino site was overly complex and didn’t even return a number value at the end. This is much simpler, but only supports a single sensor on the bus as it is. Again, if you need more, ask us in the comments. This code will simply print a decimal value of the temperature in degrees Celsius to the serial terminal.

To make this code work, before you load the code, or even open the Arduino program, we need to place the “OneWire” folder into your Arduino Library. If you don’t know where that is by default, Look to the right.

If you click the download button to the right of “Arduino” you can download the whole thing as a zip, so you dont need to copy all the files.

Default Library Folder Location

On your Mac:: In (home directory)/Documents/Arduino/libraries
On your PC:: My Documents -> Arduino -> libraries
On your Linux box:: (home directory)/sketchbook/libraries

Line Sensing. QRE1113 Reflectance Sensor + Arduino

ameyer — Mon, 27 Jun 2011 13:41:33 +0000

The QRE1113 is a common reflectance sensor often used in robotic line followers. The sensor works by shining an IR LED down and seeing how much of that light bounces back using a phototransistor. Because dark colors will bounce back less of the light, the sensor can be used to tell the difference between white and black areas. So an array of these can be used to help a robot determine where a dark line is on the ground so it can follow it. But they can also be used to determine proximity under an inch.

Both Pololu and Sparkfun sell digital and analog models of a QRE1113 breakout board. The analog version is very simple, it just outputs an analog voltage on the signal pin relative to how much light was reflected. And you might think the digital version, especially being called a line sensor by sparkfun, would just output HIGH when it sees a line, and LOW when it does not. But this is not the case.

The digital version is designed for times you do not have an analog input on your microcontroller but still need an analog reading of how much light was reflected. It does this by allowing you to charge a capacitor on the board, and then timing how long it takes to discharge. The more light that is reflected, the less time it takes to discharge the capacitor. In my tests, the times ranged between 10 microseconds (10/million) to 2.5 milliseconds, so this is all done very quickly and wont put much of a delay in your code.

Hooking Them Up

Hooking the QRE1113 to your Arduino is very simple. It just needs power (5V), ground, and an analog or digital pin depending on what version you have.

Code

The method of reading the values from the analog and digital version is very different, so we have 2 code examples for you.

Analog Version

Copy Code

//Code for the QRE1113 Analog board
//Outputs via the serial terminal - Lower numbers mean more reflected
int QRE1113_Pin = 0; //connected to analog 0

void setup(){
  Serial.begin(9600);
}

void loop(){

  int QRE_Value = analogRead(QRE1113_Pin);
  Serial.println(QRE_Value); 

}

Unless otherwise stated, this code is released under the MIT License – Please use, change and share it.

Digital Version

Copy Code

//Code for the QRE1113 Digital board
//Outputs via the serial terminal - Lower numbers mean more reflected
//3000 or more means nothing was reflected.

int QRE1113_Pin = 2; //connected to digital 2

void setup(){
  Serial.begin(9600);
}

void loop(){

  int QRE_Value = readQD();
  Serial.println(QRE_Value); 

}

int readQD(){
  //Returns value from the QRE1113 
  //Lower numbers mean more refleacive
  //More than 3000 means nothing was reflected.
  pinMode( QRE1113_Pin, OUTPUT );
  digitalWrite( QRE1113_Pin, HIGH );
  delayMicroseconds(10);
  pinMode( QRE1113_Pin, INPUT );

  long time = micros();

  //time how long the input is HIGH, but quit after 3ms as nothing happens after that
  while (digitalRead(QRE1113_Pin) == HIGH && micros() - time < 3000);
  int diff = micros() - time;

  return diff;
}

Unless otherwise stated, this code is released under the MIT License – Please use, change and share it.