Arduino Your Home & Environment

Internet of food: Arduino-based, urban aquaponics in Oakland

2013-05-17T18:36:00.001-04:00

The land in West Oakland where Eric Maundu is trying to farm is covered with freeways, roads, light rail and parking lots so there’s not much arable land and the soil is contaminated. So Maundu doesn’t use soil.

Instead he’s growing plants using fish and circulating water. It’s called aquaponics- a gardening system that combines hydroponics (water-based planting) and aquaculture (fish farming). It’s been hailed as the future of farming: it uses less water (up to 90% less than traditional gardening), doesn’t attract soil-based bugs and produces two types of produce (both plants and fish).

Aquaponics has become popular in recent years among urban gardeners and DIY tinkerers, but Maundu- who is trained in industrial robotics- has taken the agricultural craft one step further and made his gardens
smart.

http://faircompanies.com/videos/view/internet-food-arduino-based-urban-aquaponics-in-oakland/

http://www.green-trust.org/wordpress/aquaponics-project/

Metal Construction Sets for Robotics or Project Assembly

2013-05-12T07:43:00.002-04:00

When I was a kid, I used to make cranes, bridges, and other devices with Erector Sets. Alas, my childhood Erector company is long gone, but a French company called Meccano produces their products in the US under the Erector name. It's not quite the same stuff, and actually is better in my opinion, but not quite compatible. Exacto out of Argentina makes some tougher pieces that conform to the Meccano Standard.

These pieces are great for constructing Arduino projects. You can mount servo's, stepper motors, Arduino boards, and displays, Load cells, or any other adaptation you can think of. You can make Arduino controlled vehicles or robotic arms.

Here's an older document that explains some of the differences, and gives some of the history of the competing standards:

http://www.arrickrobotics.com/erector.txt

Metallus - Meccano compatible http://www.metallus.de/index.php?&page=einzelteile

Exacto - Meccano compatible http://www.exactosystem.com/

Meccano / Erector http://www.meccano.com/ / http://www.erector.us/

Amazon.com Widgets

Introducing MySQL Connector/Arduino

2013-04-18T19:42:00.002-04:00

Have you ever wanted to use a local database server to store data from your Arduino projects? Would you like to be able to send queries directly to a MySQL database from your Arduino sketch? Well, now you can!

The MySQL Connector/Arduino is a new technology made for the Arduino permitting you to connect your Arduino project to a MySQL server via an Ethernet shield without using an intermediate computer or a web-based service.

Having direct access to a database server means you can store data acquired from your project as well as check values stored in tables on the server and keep the network local to your facility including having a network that isn't connected to the internet or any other network.

The Connector/Arduino library allows you to issue queries to the database server in much the same manner as you would through the MySQL client application. You can insert, delete, and update data, call functions, create objects, etc. Issuing SELECT queries are also possible but they incur a bit more thought concerning memory management.

http://drcharlesbell.blogspot.com/2013/04/introducing-mysql-connectorarduino_6.html

BMA180 Accelerometer

2013-04-15T15:54:00.002-04:00

Years ago I saw a neat dash gadget for a Jeep that had two pictures of a Jeep on the unit. As you drove, the two pictures would move, showing pitch and roll angles, with the idea it would help prevent you from tipping over when driving off road.

I received a BMA180 Accelerometer, and decided to build an Arduino version, maybe eventually displaying graphics on a LCD screen. For now I want to get the unit talking to the Arduino, displaying G forces in 3 dimensions:

Pitch (front to back, or X)

Roll (side to side, or Y)

Yaw (pivoting as in a skid, or Z)

I connected a BMA180 breakout as follows:

Although the BMA180 requires a 3.3v input, the TWI interface (SCK/SDI) is 5v logic tolerant.

I then uploaded the following code from http://www.geeetech.com/wiki/index.php/BMA180_Triple_Axis_Accelerometer_Breakout

//BMA180 triple axis accelerometer sample code//
//www.geeetech.com//
//
#include
#define BMA180 0x40 //address of the accelerometer
#define RESET 0x10
#define PWR 0x0D
#define BW 0X20
#define RANGE 0X35
#define DATA 0x02
//
int offx = 31;
int offy = 47;
int offz = -23;
//
void setup()
{
Serial.begin(9600);
Wire.begin();
Serial.println("Demo started, initializing sensors");
AccelerometerInit();
Serial.println("Sensors have been initialized");
}
//
void AccelerometerInit()
//
{
byte temp[1];
byte temp1;
//
writeTo(BMA180,RESET,0xB6);
//wake up mode
writeTo(BMA180,PWR,0x10);
// low pass filter,
readFrom(BMA180, BW,1,temp);
temp1=temp[0]&0x0F;
writeTo(BMA180, BW, temp1);
// range +/- 2g
readFrom(BMA180, RANGE, 1 ,temp);
temp1=(temp[0]&0xF1) | 0x04;
writeTo(BMA180,RANGE,temp1);
}
//
void AccelerometerRead()
{
// read in the 3 axis data, each one is 14 bits
// print the data to terminal
int n=6;
byte result[5];
readFrom(BMA180, DATA, n , result);

int x= (( result[0] | result[1]<<8>>2)+offx ;
float x1=x/4096.0;
Serial.print("x=");
Serial.print(x1);
Serial.print("g");
//
int y= (( result[2] | result[3]<<8>>2)+offy;
float y1=y/4096.0;
Serial.print(",y=");
Serial.print(y1);
Serial.print("g");
//
int z= (( result[4] | result[5]<<8>>2)+offz;
float z1=z/4096.0;
Serial.print(",z=");
Serial.print(z1);
Serial.println("g");
}
//
void loop()
{
AccelerometerRead();
delay(300); // slow down output
}
//
//---------------- Functions--------------------
//Writes val to address register on ACC
void writeTo(int DEVICE, byte address, byte val)
{
Wire.beginTransmission(DEVICE); //start transmission to ACC
Wire.write(address); //send register address
Wire.write(val); //send value to write
Wire.endTransmission(); //end trnsmisson
}
//reads num bytes starting from address register in to buff array
void readFrom(int DEVICE, byte address , int num ,byte buff[])
{
Wire.beginTransmission(DEVICE); //start transmission to ACC
Wire.write(address); //send reguster address
Wire.endTransmission(); //end transmission

Wire.beginTransmission(DEVICE); //start transmission to ACC
Wire.requestFrom(DEVICE,num); //request 6 bits from ACC

int i=0;
while(Wire.available()) //ACC may abnormal
{
buff[i] =Wire.read(); //receive a byte
i++;
}
Wire.endTransmission(); //end transmission
}

As I move the sensor through the X, Y, and Z axis, the serial monitor shows the changing g forces for each axis. Next update will be to show actual angles on a LCD.

This weeks projects: Load cells, Breadboard Power Supply, Temp / Humidity and more ....

2013-04-06T12:20:00.000-04:00

I had a bunch of parts come in this week:

A 85lb. Load Cell (Arduino Scale project)
DHT-11 Temp / Humidity Sensors
Breadboard dual voltage (3.3/5v) power supply
Motion Sensors
3 axis accelerometer

Still in transit:

DHT-22 Temp/Humidity Sensor
Waterproof DS18B20 Temp Sensor

I have my work cut out for me, and updated code and tutorials will be posted. Contact me if you want any of our protoboard projects listed in the various tutorials I post here.

On this load cell (from a Accuteck W-8260-86W Postal Scale) the 4 wires coming from the load cell are:

Red: Excitation +
White: Signal +
Green: Signal -
Black: Excitation -

This matches the GSE / NCI / Sensotec wiring scheme. To increase the output of the load cell so that the Arduino can read it on an analog input, we will need a INA125P amplifier and a 10 ohm resistor.

* 4/11/13 update: Our free sample INA125P came in today from Texas Instruments. Many electronics manufacturers will send you free samples for prototyping projects. Atmel sent us 3 free 328P-PU processors.

* 4/13/13 update: INA125P came in, circuit is connected and the code uploaded, along with the video.

// Arduino as load cell amplifier
// by Christian Liljedahl 
// christian.liljedahl.dk

// Load cells are linear. So once you have established two data pairs, you can interpolate the rest.

// Step 1: Upload this sketch to your arduino board

// You need two loads of well know weight. In this example A = 10 kg. B = 30 kg
// Put on load A 
// read the analog value showing (this is analogvalA)
// put on load B
// read the analog value B

// Enter you own analog values here
float loadA = 10; // kg
int analogvalA = 200; // analog reading taken with load A on the load cell

float loadB = 30; // kg 
int analogvalB = 600; // analog reading taken with load B on the load cell

// Upload the sketch again, and confirm, that the kilo-reading from the serial output now is correct, using your known loads

float analogValueAverage = 0;

// How often do we do readings?
long time = 0; // 
int timeBetweenReadings = 200; // We want a reading every 200 ms;

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

void loop() {
  int analogValue = analogRead(0);

  // running average - We smooth the readings a little bit
  analogValueAverage = 0.99*analogValueAverage + 0.01*analogValue;

  // Is it time to print? 
  if(millis() > time + timeBetweenReadings){
    float load = analogToLoad(analogValueAverage);

    Serial.print("analogValue: ");Serial.println(analogValueAverage);
    Serial.print("             load: ");Serial.println(load,5);
    time = millis();
  }
}

float analogToLoad(float analogval){

  // using a custom map-function, because the standard arduino map function only uses int
  float load = mapfloat(analogval, analogvalA, analogvalB, loadA, loadB);
  return load;
}

float mapfloat(float x, float in_min, float in_max, float out_min, float out_max)
{
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

Our Inspiration:

http://www.controlweigh.com/loadcell_colors.htm
http://cerulean.dk/words/?page_id=42

Ham Radio for Arduino and Picaxe

2013-03-23T09:27:00.000-04:00

Ham Radio Meets Open Source Electronics

Microcontroller technology has exploded in popularity among ham radio operators. The new generation of single-board microcontrollers is easier than ever to use, bringing together hardware and software for project-building most radio amateurs can easily dive into.

With inexpensive microcontroller platforms – such as the popular open-source Arduino board – along with readily available parts, components and accessory boards, the possibilities are limitless: beacon transmitters, keyers, antenna position control, RTTY and digital mode decoders, waterfall displays, and more.

Editor Leigh L. Klotz, Jr, WA5ZNU has assembled this first edition of Ham Radio for Arduino and PICAXE to help introduce you to the rewards of experimenting with microcontrollers. Klotz and many other contributors have designed projects that will enhance your ham radio station and operating capabilities. Or, you can take it to the next step, using these projects as a launch pad for creating your own projects. http://hamradioprojects.com/

Missing Arduino Analog Inputs, and the Random Function

2013-03-17T08:52:00.001-04:00

The Atmel 328P chip used on many of the Arduino boards actually has 8 Analog Inputs, but specifically with the DIP version instead of the SMT, there weren't enough pins on the DIP carrier to bring those ports out for use. On some of the SMT versions, like the Pro Mini, Ports A6 & A7 are available as analog inputs, but not multi purpose (Digital I/O) like A0-A5.

Even on the UNO, which doesn't bring A6 & A7 out to a pin, we can still make use of these ports. The Random function is a common function for many applications, as it seems to provide a random number generator that can be used for dice games, and other applications. However, unless seeded by a varying start number, it actually is quite predictable.

One neat feature of an analog input is referred to as a floating input. This is a input that is not connected to anything. If you try to read it, the values will be all over the place, based on changing electrical fields nearby. We can use either of these two phantom analog inputs as seeds for the random function, ensuring a truly random output.

long randNumber;

void setup(){
  Serial.begin(9600);
  randomSeed(analogRead(A7));
}

void loop(){
  randNumber = random(300);
  Serial.println(randNumber);

  delay(50);
}

More Info:

http://arduino.cc/en/Reference/RandomSeed

http://arduino.cc/en/Reference/Random

http://arduino.cc/en/Reference/AnalogRead

USB / FTDI

2013-02-26T20:52:00.002-05:00

Some Arduino's, like the Arduino Pro Mini, do not have an onboard usb interface. This is the case with our DIY minimal Arduino. So we built a a adapter around a USB/FTDI interface.

One feature we wanted was the auto reset feature of the newer Arduino's, so we don't have to push the reset button when uploading a sketch.

We also wanted an easy way to connect and disconnect the interface, so it can be used with other boards we build, avoiding the cost of having to have multiple interfaces. By putting a header on the Arduino board, this adapter just plugs right in when a code change is necessary.

A .1 uf capacitor connects RTS to pin 1 on the Atmel chip. Opposite to convention, RX on the FTDI connects to RX on the Atmel (Pin 2), and TX on the FTDI connects to TX on the Atmel (Pin 3)!

When uploading sketches, pick Arduino Duemilanove w/ ATmega328 as your board.

The DIY Arduino

2013-02-11T08:55:00.000-05:00

We have finished our DIY Arduino on a solderless breadboard, and are about to move it to a perfboard for adding additional project components. We wanted to share this stage of the project to make it easier for others to do the same.

Components needed (Parts List):

Arduino:
Atmel 328P with bootloader installed
16 mHz Crystal
Qty (2) 22 pF capacitors
Qty (1) 10k Resistor
Qty (1) Reset Switch
Qty (1) .1 uF Capacitor

Power Supply:
Qty (1) 7805 Voltage Regulator
Qty (2) 10 uF Capacitors
Qty (1) 150 Ohm Resistor
Qty (1) LED

Programming:

Qty (1) FTDI / USB Adapter (just need the one for all additional projects, not one for each project)

** A quick note on the Arduino Revised USB FTDI **

Use RTS, not DTR for the auto reset, and opposite to convention, RX on the FTDI connects to RX on the Atmel, and TX to TX!

Breadboard Power Supplies

2013-02-01T20:55:00.000-05:00

A important part of breadboarding is supplying the proper power to the circuits you are building. We prototype on solderless breadboards, then move the circuit to a solder type protoboard that matches the solderless breadboard. We do this to make our projects easier for others to duplicate. We have a favorite power supply that fits both the solderless breadboard, and the solderable protoboard. It has dual 3.3v / 5v power supplies, so each set of power rails on the breadboard is voltage selectable.

Amazon.com Widgets

Burning a Bootloader on New Atmel 328's

2013-01-31T21:50:00.000-05:00

We are in the process of building some projects with an embedded Arduino, instead of using a Arduino board. Hacktronics.com sent us some new Atmel 328-PU chips for this purpose. These chips are new, without a bootloader installed. The bootloader is the difference between a Bare Atmel, and an Arduino. It's what allows the Arduino IDE to upload sketches.

Now the chip that comes on the Arduino UNO and Duemilanove is the Atmel 328P-PU. This is the picopower chip. We received the 328-PU. They have a different signature, so additional steps needed to be taken.

First we wired up a Arduino on a breadboard per the instructions at http://arduino.cc/en/Tutorial/ArduinoToBreadboard.

You can get the parts at Bare Bones Arduino

I used my older Duemilanove as the Host, as the instructions say this process does not work with an UNO.

There is a process if you use a UNO as the Host, I did not have one handy - http://electronics.stackexchange.com/questions/10587/how-to-burn-atmega328-chip-via-arduino-uno-as-isp

When burning the boot loader, we ran into a error because the signature of the chip was wrong. So we followed the instructions at http://arduino.cc/forum/index.php?topic=58670.0 regarding editing the avrdude.conf file from 0F to 14 while burning the bootloader. Don't forget to set it back after the bootloader is burned. It doesn't need the change to upload sketches. You may not have to do this if you use the above Optiboot process.

Now we have several Atmel 328's with the bootloader installed, ready to go into projects. Stay tuned!

Motion Sensors & SSR's

2013-01-13T09:41:00.000-05:00

A Motion Sensor is a good way to save energy, by turning lights on and off based on the presence of a warm body. Walk into a room, the lights come on, walk out, and they go off. We can build in a delay on the off cycle, and a manual override with a switch giving us motion - off - on modes.

Now also on Instructables!

First we start with the PIR Motion Sensor. This connects to a digital input, which we monitor for the presence of a warm body.

int ledPin = 13;
int switchPin = 2;
int value = 0;

void setup() {
pinMode(ledPin, OUTPUT);
pinMode(switchPin, INPUT);
digitalWrite(ledPin, LOW);
}

void loop() {
value = digitalRead(switchPin);
if (HIGH == value) {
digitalWrite(ledPin, HIGH);
} else {
digitalWrite(ledPin, LOW);
} }

This turns on the LED on the Arduino when motion is detected. Now let's add the SSR. This allows us to control 120vac devices with no chance of damaging the Arduino (optically isolated) and reduced chance of getting zapped (not much harder than wiring a light switch). I suggest starting with a corded desk or floor lamp.

IMPORTANT!

Unplug from wall before doing this step!

Separate the two wires going to the lamp, and only cut one of them (preferably the HOT, not the Neutral (wide blade), if your plug is polarized - Larry).
Mike recommends you cut open a short extension cord instead of your lamp cord, so that the project is "portable".

Strip the insulation from the two ends you have from the one line, and insert them under the SSR screws labeled 1 & 2.
Connect screw 4 on the SSR to ground on the Arduino, and screw 3 to pin 13 on the Arduino.
Plug the lamp back into the wall, and power up the Arduino.

Your lamp should light when motion is detected, and go out after a short period of time after you leave the focus area.

Now lets add a manual override switch. You will want a SPDT switch with center off. You will be connecting the center pin to +5vdc on the arduino. The outer two pins will connect to Arduino pins 11 & 12, with a 10k resistor to ground on each.

Now our sketch looks like this:

int inPin1 = 11; // switch connected to digital pin 11
int inPin2 = 12; // switch connected to digital pin 12

int ssrPin = 13;
int pirPin = 2;
int motionDetect= 0;
int manualSwitch = 0;
int motionSwitch = 0;

void setup() {
pinMode(ssrPin, OUTPUT);
pinMode(pirPin, INPUT);
pinMode(inPin1, INPUT);
pinMode(inPin2, INPUT);
digitalWrite(ssrPin, LOW);
}

void loop() {

motionSwitch = digitalRead (inPin1);
manualSwitch = digitalRead (inPin2);

if (motionSwitch == HIGH) // Motion Mode
{
motionDetect = digitalRead(pirPin);
if (motionDetect == HIGH) {
digitalWrite(ssrPin, HIGH);
delay (180000); //Optional 3 minute delayed off

}
else if (manualSwitch == HIGH) // Manual On
{
digitalWrite(ssrPin, HIGH)
}
else // Manual Off

{
digitalWrite(ssrPin, LOW)
}
}

Temperature and Humidity Redux

2013-01-07T17:58:00.000-05:00

A long while back (in a galaxy very far away), we built a temp and humidity monitor with the SHT-21 chip. It's a very accurate, albeit very expensive, solution. What if good enough, is good enough? If you don't need scientific resolution, the DHT-11 is a very inexpensive solution. Today we built a temp and humidity monitor with this module. I started off with a DHT-11 breakout board from geeetech. I used this module because it has the pull up resistor and a conditioning capacitor onboard. I connected S (signal) to pin 2, - to Gnd, and + to 5vdc.

I downloaded the library from github and followed the tutorial from adafruit. I changed the sketch slightly, as it outputs the temperature in C, and I want to see it in F, so I changed two lines from:

Serial.print(t);

Serial.println(" *C");

to:

Serial.print(t*1.8+32);

Serial.println(" *F");

Here is the final result:

// Example testing sketch for various DHT humidity/temperature sensors

// Written by ladyada, public domain

// Fahrenheit conversion added by Steve Spence, http://arduinotronics.blogspot.com

#include "DHT.h"

#define DHTPIN 2 // what pin we're connected to

// Uncomment whatever type you're using!

#define DHTTYPE DHT11 // DHT 11

//#define DHTTYPE DHT22 // DHT 22 (AM2302)

//#define DHTTYPE DHT21 // DHT 21 (AM2301)

// Connect pin + (middle) of the sensor to +5V

// Connect pin S (on the right) of the sensor to whatever your DHTPIN is

// Connect pin - (on the left) of the sensor to GROUND

DHT dht(DHTPIN, DHTTYPE);

void setup() {

Serial.begin(9600);

Serial.println("DHTxx test!");

dht.begin();

}

void loop() {

// Reading temperature or humidity takes about 250 milliseconds!

// Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)

float h = dht.readHumidity();

float t = dht.readTemperature();

// check if returns are valid, if they are NaN (not a number) then something went wrong!

if (isnan(t) || isnan(h)) {

Serial.println("Failed to read from DHT");

} else {

Serial.print("Humidity: ");

Serial.print(h);

Serial.print(" %\t");

Serial.print("Temperature: ");

Serial.print(t*1.8+32);

Serial.println(" *F");

}

Working with the SainSmart 5v Relay Board

2013-01-07T08:54:00.001-05:00

Today we are working with our SainSmart 5v Relay Board. This is a simple and inexpensive 4 port SPDT relay board (there are boards with more or less relays) that takes a digital signal (LOW) from the Arduino, through an optoisolator, which triggers a transistor, pulling in the relay. The relay contacts are rated for 10 amps at 120/240vac, and 10 amps at 30vdc or less.

IMPORTANT!

The contact pins are not numbered, and are reversed if you go by what the schematic appears to be saying. Facing the screw terminals, with the board face up (solder side down), the screw terminals are as follows (from left to right):

1 - Normally Open

2 - Common

3 - Normally Closed

1 - Normally Open

2 - Common

3 - Normally Closed

1 - Normally Open

2 - Common

3 - Normally Closed

1 - Normally Open

2 - Common

3 - Normally Closed

When you send a logic low, that turns on the LED, and energizes the coil. However, a disconnected input will drop out the LED and the coil, as will a logic HIGH. We will send a logic HIGH in setup to ensure the relays are disabled on boot.

There is a 6 pin male header, so you will need a cable or female pins to slide over the header to connect it to your Arduino. Pin 1 connects to Arduino GND, Pins 2-5 to Digital output pins, and Pin 6 to Arduino 5v. A red LED for each relay lights when active (LOW).

int relayPin1 = 7; // IN1 connected to digital pin 7
int relayPin1 = 8; // IN2 connected to digital pin 7
int relayPin1 = 9; // IN3 connected to digital pin 7
int relayPin1 = 10; // IN4 connected to digital pin 7

void setup()
{
pinMode(relayPin1, OUTPUT); // sets the digital pin as output
pinMode(relayPin2, OUTPUT); // sets the digital pin as output
pinMode(relayPin3, OUTPUT); // sets the digital pin as output
pinMode(relayPin4, OUTPUT); // sets the digital pin as output
digitalWrite(relayPin1, HIGH); // Prevents relays from starting up engaged
digitalWrite(relayPin2, HIGH); // Prevents relays from starting up engaged
digitalWrite(relayPin3, HIGH); // Prevents relays from starting up engaged
digitalWrite(relayPin4, HIGH); // Prevents relays from starting up engaged
}

void loop()
{
digitalWrite(relayPin1, LOW); // energizes the relay and lights the LED
digitalWrite(relayPin2, LOW); // energizes the relay and lights the LED
digitalWrite(relayPin3, LOW); // energizes the relay and lights the LED
digitalWrite(relayPin4, LOW); // energizes the relay and lights the LED
delay(1000); // waits for a second
digitalWrite(relayPin1, HIGH); // de-energizes the relay and LED is off
digitalWrite(relayPin2, HIGH); // de-energizes the relay and LED is off
digitalWrite(relayPin3, HIGH); // de-energizes the relay and LED is off
digitalWrite(relayPin4, HIGH); // de-energizes the relay and LED is off
delay(1000); // waits for a second
}

Build the $15 Arduino

2013-01-06T09:27:00.000-05:00

Since I don't want to dedicate a $22 Arduino UNO for every project (for space reasons, not price), I've started embedding a Atmel 328 chip into my projects. You can build your own Arduino UNO compatible for approximately $15 (buy parts in bulk, and make several), depending on the options you want to include. This DIY Arduino will be the foundation for a series of books we are writing based on the Arduino and general electronics.

The bare minimum needed to build is the following:

Qty. (1) ATMEGA328P (with Arduino Bootloader) $2.95
Qty. (1) 28 pin socket (optional, but highly recommended)
Qty. (2) 22pf ceramic capacitors
Qty. (2) 100nf (.1 uf) ceramic capacitors
Qty. (1) 16 mHz crystal $2.57
Qty. (1) 6 pin male header (for FTDI Programming Cable, see parts link above)

Optional:
Qty. (1) 150 ohm 1/4w resistor &
Qty. (1) Green LED (pin 13 indicator)

Qty. (1) PCB Momentary Tactile Push Button Switch (reset)

Power supply:
Qty. (1) LM7805 5v voltage regulator
Qty. (2) 10uf electrolytic caps
Qty. (1) Green LED
Qty. (1) 150 Ohm 1/4w resistor

Full instructions on assembly are located at http://thetransistor.com/projects/arduino/

Working with Reed Relays

2013-01-03T20:59:00.001-05:00

One of the main benefits of Physical Computing is being able to control your environment, not just monitor it. Transistors, MOSFETs, Solid State Relays, and Mechanical Relays all allow you to turn devices on and off based on inputs and decision making processes.

One of my favorite Mechanical Relays is the Reed Relay. They come in a variety of coil voltages, and the one we use has a 5v coil, and is a perfect match for the Arduino. It has a resistance of 500 ohms, so it draws 10ma, right within the range of the Arduino output capabilities. Reed Relays come with or without snubber diodes. Snubber diodes are used to prevent the inductive kick of the coil from damaging the port on the Arduino. We will be using a Reed Relay with a built in snubber.

We will be using a digitalWrite command to output a 5v HIGH to the output pin that connects to the + pin on the reed relay. The Magnecraft W107DIP-5 is a fairly inexpensive Reed Relay, with Normally Open contacts. Normally Closed, and SPDT varieties are also available.

Connect Pin 3 of the reed relay to the output pin (13) on the Arduino. Connect Pin 5 of the reed relay to Gnd. Pins 1 & 7 are your switched contacts. Connect Pin 1 to power, Pin 7 to load, and the other pin of your load to the other power connector. The load and load power can be AC or DC, and up to .5 amp current draw.

int outputPin = 13;       // Relay connected to digital pin 13

void setup()
{
  pinMode(outputPin, OUTPUT);   // sets the digital pin as output
}

void loop()
{
  digitalWrite(outputPin, HIGH);   // sets the relay on
  delay(5000);                  // waits for 5 seconds
  digitalWrite(outputPin, LOW);    // sets the relay off
  delay(5000);                  // waits for 5 seconds
}

Arduino & Android Integration

2012-12-27T08:51:00.005-05:00

I'm working on a project for a friend of mine, which requires a Arduino to be connected to an Android device. The Android is the display and control interface for the Arduino, displaying data from the Arduino, pin status, and sending control messages to turn items on and off, dim with PWM, etc.

2 items we recommend are the Arduino MEGA ADK R3 for Android and Beginning Android ADK with Arduino. Add a Android phone or tablet, and you are on your way to creating some very cool apps, limited only by your imagination.

I just finished reading this book, and I highly recommend it. It makes it easy to create apps and communication between the Arduino and the Android!

Breadboard and Protoboard Combo Pack

2012-12-24T09:02:00.002-05:00

A prototyper's dream combination, I can't recommend this inexpensive ($7) package enough. After working out the bugs in your design on the solderless breadboard, transfer it to the permanent PCB for posterity. Perfect for embedded DIY Arduino designs where shield compatibility is not a concern.

http://www.wrighthobbies.com/product.php?productid=131&cat=18&page=1

Breadboard 400

Standard solderless breadboard with 2 power strips and 400 contact points.

ProtoBoard 400

High quality,double-sided prototype board designed for quick and quality prototyping. These are production quality boards with solder mask and silk screen. The board has 464 plated through holes. The board is laid out to match a 400-point breadboard with the same row and column markings. This allows you to build a circuit on a breadboard then transfer the design to the protoboard exactly as it is on the breadboard. An additional double column of holes runs through the middle of the board for additional power connections.

These boards are durable and easy to work with. You won't have to worry about pads coming loose with this board!

Amazon.com Widgets

Arduino PID Control

2012-12-12T21:06:00.000-05:00

PID you say. What's that?

According to Wikipedia: A proportional–integral–derivative controller (PID controller) is a generic control loop feedback mechanism (controller) widely used in industrial control systems – a PID is the most commonly used feedback controller. A PID controller calculates an "error" value as the difference between a measured process variable and a desired setpoint. The controller attempts to minimize the error by adjusting the process control inputs.

Here's the issue: Let's say you want to heat a tank of water to 150 degrees. you check the temp sensor, and it says 100 degrees, so you turn on the heat full bore. You check again, and it says 160 degrees, so you turn off the heat. But now the water has cooled to 140. Now with a micro-controller like the Arduino, keeping a 10 degree spread (+/- 5 degrees) isn't too hard, but for finer and more intelligent control, it's time for PID!

The Arduino Playground puts it this way: So, you tell the PID what to measure (the "Input",) Where you want that measurement to be (the "Setpoint",) and the variable to adjust that can make that happen (the "Output".) The PID then adjusts the output trying to make the input equal the setpoint.

There is an awesome library for the Arduino that makes this process almost easy.

Read more at http://brettbeauregard.com/blog/2011/04/improving-the-beginners-pid-introduction/

PID Controllers: Theory, Design, and Tuning

Arduino & Model Railroading: Io:duino

2012-12-01T17:56:00.001-05:00

From http://railstars.com/hardware/io/io-duino/

The Io:duino is designed for DIY model railroading, combining the power of NMRAnet and open-source tools. Fully Arduino-compatible, Io:duino makes it easy to design your own digital controls, for layout automation, lighting effects, even controlling your trains via DC or DCC.*

Even better, Io:duino’s built-in Controller Area Network (CAN) support makes it a great tool for hacking your automobile, or for home automation.**

Io:duino is built around the Atmel AT90CAN128 processor, whose 128KB of program space, 4KB of SRAM, and 4KB of EEPROM are just the icing on the cake. This processor has built-in hardware support for the CAN and NMRAnet networking protocols, without sacrificing any of the digital I/O pins.

Arduino compatibility means you have immediate access to hundreds of add-ons called shields, empowering you start building without any additional tools. And it’s easy to write and upload your own custom software over USB.

Like all Railstars products, Io:duino includes a No-Questions-Asked 3-Year Warranty!

Retail Price $90. Available from an Railstars Authorized Dealer or the Railstars Web Store.

*Requires additional hardware, such as a digital power station like RAILbooster, or a motor shield like Ardumotor, not included.

**Requires cable adapter and additional software libraries, not included.

Using a Keypad for Input

2012-11-23T13:08:00.000-05:00

Keypads are handy for a variety of projects, from security access to telephone dialing. In this tutorial, we use a Adafruit membrane keypad, and output the button presses to the serial monitor. Nothing fancy, just a platform for future development. Expand the Library in your sketchbook/libraries/ folder. The next step will be to multiplex the lines so we don't use up 7 inputs with a SN74LS151 (reduces Arduino pins to 3, expands inputs up to 16).

You'll need:
Arduino Uno
Breadboard Kit
Membrane Keypad

#include <Keypad.h>

const byte ROWS = 4; //four rows

const byte COLS = 3; //three columns

char keys[ROWS][COLS] = {

{'1','2','3'},

{'4','5','6'},

{'7','8','9'},

{'*','0','#'}

};

byte rowPins[ROWS] = {8, 7, 6, 5}; //connect to the row pinouts of the keypad

byte colPins[COLS] = {4, 3, 2}; //connect to the column pinouts of the keypad

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

void setup(){

Serial.begin(9600);

}

void loop(){

char key = keypad.getKey();

if (key != NO_KEY){

Serial.println(key);

}

EtherShield SD Card Access

2012-11-23T11:05:00.000-05:00

Since I was playing with my EtherShield SD, I figured I'd load up the example sketch "CardInfo" in the SD folder. I popped in the microSD card from my digital camera, and it started listing the files on my card (but did not recognize the full 16GB partition).

Initializing SD card...Wiring is correct and a card is present.

Card type: SDHC

Volume type is FAT32

Volume size (bytes): 3038248960
Volume size (Kbytes): 2967040
Volume size (Mbytes): 2897

Files found on the card (name, date and size in bytes):
DCIM/ 2011-06-20 14:58:52
100_PANA/ 2011-06-20 19:07:48
P1000812.JPG 2011-09-08 09:19:54 4158647
P1000781.JPG 2011-08-20 21:02:02 4309863
P1000813.JPG 2011-09-08 09:20:00 4258311
P1000814.JPG 2011-09-08 09:20:06 4145655
P1000954.JPG 2011-10-05 19:11:52 3605223
......

/*
SD card test

This example shows how use the utility libraries on which the'
SD library is based in order to get info about your SD card.
Very useful for testing a card when you're not sure whether its working or not.

The circuit:
* SD card attached to SPI bus as follows:
** MOSI - pin 11 on Arduino Uno/Duemilanove/Diecimila
** MISO - pin 12 on Arduino Uno/Duemilanove/Diecimila
** CLK - pin 13 on Arduino Uno/Duemilanove/Diecimila
** CS - depends on your SD card shield or module.
Pin 4 used here for consistency with other Arduino examples

created 28 Mar 2011
by Limor Fried
modified 9 Apr 2012
by Tom Igoe
*/
// include the SD library:
#include <SD.h>

// set up variables using the SD utility library functions:
Sd2Card card;
SdVolume volume;
SdFile root;

// change this to match your SD shield or module;
// Arduino Ethernet shield: pin 4
// Adafruit SD shields and modules: pin 10
// Sparkfun SD shield: pin 8
const int chipSelect = 4;

void setup()
{
// Open serial communications and wait for port to open:
Serial.begin(9600);
while (!Serial) {
; // wait for serial port to connect. Needed for Leonardo only
}

Serial.print("\nInitializing SD card...");
// On the Ethernet Shield, CS is pin 4. It's set as an output by default.
// Note that even if it's not used as the CS pin, the hardware SS pin
// (10 on most Arduino boards, 53 on the Mega) must be left as an output
// or the SD library functions will not work.
pinMode(10, OUTPUT); // change this to 53 on a mega

// we'll use the initialization code from the utility libraries
// since we're just testing if the card is working!
if (!card.init(SPI_HALF_SPEED, chipSelect)) {
Serial.println("initialization failed. Things to check:");
Serial.println("* is a card is inserted?");
Serial.println("* Is your wiring correct?");
Serial.println("* did you change the chipSelect pin to match your shield or module?");
return;
} else {
Serial.println("Wiring is correct and a card is present.");
}

// print the type of card
Serial.print("\nCard type: ");
switch(card.type()) {
case SD_CARD_TYPE_SD1:
Serial.println("SD1");
break;
case SD_CARD_TYPE_SD2:
Serial.println("SD2");
break;
case SD_CARD_TYPE_SDHC:
Serial.println("SDHC");
break;
default:
Serial.println("Unknown");
}

// Now we will try to open the 'volume'/'partition' - it should be FAT16 or FAT32
if (!volume.init(card)) {
Serial.println("Could not find FAT16/FAT32 partition.\nMake sure you've formatted the card");
return;
}

// print the type and size of the first FAT-type volume
uint32_t volumesize;
Serial.print("\nVolume type is FAT");
Serial.println(volume.fatType(), DEC);
Serial.println();

volumesize = volume.blocksPerCluster(); // clusters are collections of blocks
volumesize *= volume.clusterCount(); // we'll have a lot of clusters
volumesize *= 512; // SD card blocks are always 512 bytes
Serial.print("Volume size (bytes): ");
Serial.println(volumesize);
Serial.print("Volume size (Kbytes): ");
volumesize /= 1024;
Serial.println(volumesize);
Serial.print("Volume size (Mbytes): ");
volumesize /= 1024;
Serial.println(volumesize);

Serial.println("\nFiles found on the card (name, date and size in bytes): ");
root.openRoot(volume);

// list all files in the card with date and size
root.ls(LS_R | LS_DATE | LS_SIZE);
}

void loop(void) {

}

Simple Ethernet

2012-11-23T10:31:00.001-05:00

This is the first in a series of Ethernet projects. This first project will display the values coming from the analog ports in a web browser on a remote machine. Additional posts will cover controlling the Arduino from a web browser, and reading and writing to the SD card for logging purposes. Stay tuned!

I popped a Arduino EtherShield SD on to an older Duemilanove (328), and loaded the following sketch. I changed the MAC address to the one printed on the bottom of my EtherShield, and put in a applicable IP address from my network. When I pointed my browser to the new IP address, I got the following output:

analog input 0 is 1023
analog input 1 is 0
analog input 2 is 1023
analog input 3 is 771
analog input 4 is 551
analog input 5 is 437

This makes sense, because I have A0 and A2 connected to 5v, A1 connected to Gnd, and A3-A5 are left floating, and the values change every second or so.

Sketch from examples folder (Ethernet, Web Server)

/*
Web Server

A simple web server that shows the value of the analog input pins.
using an Arduino Wiznet Ethernet shield.

Circuit:
* Ethernet shield attached to pins 10, 11, 12, 13
* Analog inputs attached to pins A0 through A5 (optional)

created 18 Dec 2009
by David A. Mellis
modified 9 Apr 2012
by Tom Igoe

*/

#include <SPI.h>
#include <Ethernet.h>

// Enter a MAC address and IP address for your controller below.
// The IP address will be dependent on your local network:
byte mac[] = {
0x90, 0xA2, 0xDA, 0x00, 0x23, 0x36 };
IPAddress ip(192,168,254, 177);

// Initialize the Ethernet server library
// with the IP address and port you want to use
// (port 80 is default for HTTP):
EthernetServer server(80);

void setup() {
// Open serial communications and wait for port to open:
Serial.begin(9600);
while (!Serial) {
; // wait for serial port to connect. Needed for Leonardo only
}

// start the Ethernet connection and the server:
Ethernet.begin(mac, ip);
server.begin();
Serial.print("server is at ");
Serial.println(Ethernet.localIP());
}

void loop() {
// listen for incoming clients
EthernetClient client = server.available();
if (client) {
Serial.println("new client");
// an http request ends with a blank line
boolean currentLineIsBlank = true;
while (client.connected()) {
if (client.available()) {
char c = client.read();
Serial.write(c);
// if you've gotten to the end of the line (received a newline
// character) and the line is blank, the http request has ended,
// so you can send a reply
if (c == '\n' && currentLineIsBlank) {
// send a standard http response header
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("Connnection: close");
client.println();
client.println("");
client.println("");
// add a meta refresh tag, so the browser pulls again every 5 seconds:
client.println("");
// output the value of each analog input pin
for (int analogChannel = 0; analogChannel < 6; analogChannel++) {
int sensorReading = analogRead(analogChannel);
client.print("analog input ");
client.print(analogChannel);
client.print(" is ");
client.print(sensorReading);
client.println("
");
}
client.println("
"); break;
}
if (c == '\n') {
// you're starting a new line
currentLineIsBlank = true;
}
else if (c != '\r') {
// you've gotten a character on the current line
currentLineIsBlank = false;
}
}
}
// give the web browser time to receive the data
delay(1);
// close the connection:
client.stop();
Serial.println("client disonnected");
}
}

Producing DTMF Tones

2012-11-22T12:45:00.000-05:00

I wanted to teach my Arduino to talk telephone, so I added a HT9000A DTMF chip to produce the familiar "touch tones" (upcoming projects will act upon "heard" DTMF tones, but with a different chip).

The output is really low volume, so you may want to plug in amplified speakers or use an input on your stereo. You could build an amplifier circuit with a LM386 as well.

I used an Ham Radio program that listens for touch tones and displays the number it hears to verify operation. http://downloads.fyxm.net/DTMF-Decoder-47129.html

The code I used (and modified) was built by Brohogan.(don't forget the include file)

/* HT9200A DTMF Generator Test                             BroHogan 7/17/09
* SETUP FOR SERIAL MODE - Requires 3 pins - Data and Clock (100KHz) and CE
* Wire per data sheet - 3.57MHz xtal (4.0MHz won't dial) S/P to GND = serial
* modified by Steve Spence - http://arduinotronics.blogspot.com
*/

#include <HT9200.h>                     // defines for HT9200 DTMF chip
#define DATA_PIN   2                    // Data (serial)
#define CLOCK_PIN 3                    // Clock (serial)
#define CE_PIN     4                    // Chip Enable pin (must control)

#define PHONE_NMBR "2642262"         // phone # to dial
char PhoneNum[] = PHONE_NMBR;           // load phone # for dialer

void setup() {
pinMode(DATA_PIN, OUTPUT);
pinMode(CLOCK_PIN, OUTPUT);
pinMode(CE_PIN, OUTPUT);
Init_HT9200();                        // init the chip
}

void loop() {
Dialer();                             // dials phone
delay(3000);
}

void Init_HT9200 (){
digitalWrite(CE_PIN, HIGH);           // start with chip disabled (else you go nuts)
digitalWrite(CLOCK_PIN, HIGH);        // start with clock pin high
digitalWrite(CE_PIN, LOW);            // now enable the chip
delay(10);                            // delay 10ms to ramp up the ocillator
DTMF_Out (DTMF_OFF,1,0);              // turn off any tone from previous run
}

void DTMF_Out (byte digit, long duration, long pause){ // FOR SERIAL COMM
if (digit == 0) digit = 10;           // take care of 0 here
for (byte i=0; i<5 br="br" i="i">    digitalWrite(CLOCK_PIN, HIGH);      // clock high while setting data
    digitalWrite(DATA_PIN, bitRead(digit,i)); // set data LSB->MSB
    delayMicroseconds(5);               // 1/2 of 100K Clock speed
    digitalWrite(CLOCK_PIN, LOW);       // clock low to latch data
    delayMicroseconds(5);               // 1/2 of 100K Clock speed
}
delay(duration);                      // how long tone will play
if (pause != 0){                      // tone sounds continuously if zero
    for (byte i=0; i<5 above="above" as="as" br="br" i="i" nbsp="nbsp" same="same">      digitalWrite(CLOCK_PIN, HIGH);
      digitalWrite(DATA_PIN, bitRead(DTMF_OFF,i));
      delayMicroseconds(5);
      digitalWrite(CLOCK_PIN, LOW);
      delayMicroseconds(5);
    }
    delay(pause);                       // how long pause between tones
}
}

void Dialer(){ // dials tones from number
for (byte i=0; i<7 i="i" nbsp="nbsp" p="p"> //i<7 11="11" 7="7" br="br" digit="digit" for="for" i="i" number="number">    DTMF_Out(PhoneNum[i]-'0',500,100); // 1/2 sec tone with 1/10 pause
}
}

Arduino Your Home & Environment

Internet of food: Arduino-based, urban aquaponics in Oakland

Metal Construction Sets for Robotics or Project Assembly

Introducing MySQL Connector/Arduino

BMA180 Accelerometer

This weeks projects: Load cells, Breadboard Power Supply, Temp / Humidity and more ....

Ham Radio for Arduino and Picaxe

Ham Radio Meets Open Source Electronics

Missing Arduino Analog Inputs, and the Random Function

USB / FTDI

The DIY Arduino

Breadboard Power Supplies

Burning a Bootloader on New Atmel 328's

Motion Sensors & SSR's

Temperature and Humidity Redux

Working with the SainSmart 5v Relay Board

Build the $15 Arduino

Working with Reed Relays

Arduino & Android Integration

Breadboard and Protoboard Combo Pack

Arduino PID Control

Arduino & Model Railroading: Io:duino

More Ethernet - Read Analog, & Set Digital Pins

Using a Keypad for Input

EtherShield SD Card Access

Simple Ethernet

Producing DTMF Tones