Saturday, December 17, 2011

A platform for microcontrolled electro-mechanical, hydraulics, and pneumatics

We've talked about Grid Beam as a inventors and experimenters dream before, but the more we dig into it, the more we get excited about it. If you missed our last article on the subject, Grid Beam is a system of easy to bolt together modular components made of metal, wood, or plastic. This system has been developed over the past 60+ years, starting with the original inventor, Ken Isaacs. He called the system "Living Structures".

Ideal for rapid prototyping, ease of disassembly, moving and reassembly. Fun for kids and adults. Solar mounts, wind turbines, hydroelectric, electric vehicles (cars, trains, submarines and more) are just some of the ways to use this system. We develop solutions using microcontrollers in a variety of electro-mechanical, hydraulic, and pneumatic applications and have many uses for grid beam as a platform for these solutions. Check it out!

How to build with Grid Beam

Isaacs, Ken - How To Build Your Own Living Structures (Free Download)

Saturday, December 10, 2011

Arduino Robotics

This book by John - David Warren and friends is one of my favorites. A good beginning in electronics and Arduino basics (easily ignored if you are experienced, but I suggest a overview anyway), then jumps into well documented meat and potatoes robotics, including wireless control, motor control, and sensors such as ultrasonic, IR, and tactile. Arduino Robotics by John-David Warren (Author), Josh Adams (Author), Harald Molle (Author)

New Arduino IDE 1.0

A new programming interface, with some pretty major changes to available
routines, functions, and behavior in old functions. This one is important, check
it out at
http://tronixstuff.wordpress.com/2011/12/10/initial-review-arduino-v1-0-ide/

Join the Arduino discussions at http://tech.groups.yahoo.com/group/arduinohome/ .

Saturday, November 19, 2011

Build your own Proto Shield for the Arduino

The biggest issue with protoshields, is the Arduino funky pin spacing. Mike Cook has a way to make larger protoshields with plenty of prototyping space. Handier than breadboards, as the project is more "permanent". Mike has been helping us with our Arduino / Mitutoyo Micrometer project, and has a bunch of great Arduino tutorials on his website. Check them out, though you will need to do a bit of digging, as he has all kinds of fascinating stuff posted.

http://www.thebox.myzen.co.uk/Hardware/Arduino_Shield.html

http://www.thebox.myzen.co.uk/Tutorial/Introduction.html

http://www.thebox.myzen.co.uk/Workshop/Introduction.html

Thursday, October 13, 2011

Digimatic SPC to Arduino

10/14/2015 Update! Now works with Igaging Origin Series Micrometers, Calipers, and Scales.

12/2/2011 Update! We are now reading data from the micrometer, and calculating bin numbers for gear sorting and pump builds. We take 3 samples of a gear, and reject the gear if there is too much variation between the samples.

The Digimatic SPC protocol is a communications protocol developed by Mitutoyu, the big guns in Calipers, Micrometers, Dial Indicators, Scales and more. These devices have a data port that allows you to communicate with a microprocessor or microcontroller, for data logging and other measuring applications.

Mitutoyo 05CZA662, Digimatic Cable, 40", With Data Switch for Coolant Proof Micrometers

Code, diagrams, and specs. -  http://www.green-trust.org/digimatic/

Instructable - http://www.instructables.com/id/Interfacing-a-Digital-Micrometer-to-a-Microcontrol/

Interface Boards - http://arduinotronics.blogspot.com/2012/06/arduino-to-mitutoyo-interface.html

Comments welcome!


Dennis Ritchie, RIP

Dennis Ritchie, best known as the creator of the C programming language and co-creator of the UNIX operating system, has died at the age of 70 after a long, unspecified, illness. News of his death came from past collaborator, Rob Pike, in a message on Google+ which read: "I trust there are people here who will appreciate the reach of his contributions and mourn his passing appropriately. He was a quiet and mostly private man, but he was also my friend, colleague, and collaborator, and the world has lost a truly great mind."
http://www.h-online.com/open/news/item/Dennis-Ritchie-creator-of-C-and-more-has-died-1360480.html

Wednesday, October 12, 2011

Arduino VGA Display

Our Arduino Micrometer Project is off and running. We have the speech module up and running, and now the VGA output module. It's a simple serial interface and only uses two i/o ports. We are using the PICASO QVGA/VGA/WVGA Graphics Controller from Sparkfun - http://www.sparkfun.com/products/10329
The µVGA-II(SGC) is a compact & cost effective drop in embedded graphics engine that will deliver stand-alone functionality to your project. The simple to use embedded commands not only control background color but can produce text in a variety of sizes as well as draw shapes in 256 colors while freeing up the host processor from processor hungry screen control functions. This means a simple micro-controller with a standard serial interface can drive the module with ease.

Saturday, September 24, 2011

Making the Arduino talk, beep and sing

A while back we built a Speakjet project for the Arduino. It allowed us to send sound effects, and program robotic speech to the speakers.

It wasn't terribly intuitive, programming it phonetically, so we added a text to speech ship, the TTS256. The Sparkfun shield we used wasn't designed for the TTS chip, so there weren't enough holes in the breadboard space to accommodate one end of the chip, and their traces are fragile where they suggest the modification.

We set out to design our own shield based on what we did and did not like about the Sparkfun unit. Well, we got scooped. The guys at Droidbuilder built a better mousetrap, er, TTS Speakjet Shield. It has almost all the features we wanted in our shield, but also includes a hefty price tag. It is, however, a worthy unit, and has excellent tutorials. Enjoy the show!

Speakjet Users Guide
TTS 256 Datasheet

Saturday, July 16, 2011

Stepper Motor Project

Since I'm waiting for some more parts to come in for my water level sensor I'm building for our aquaponics project, I thought I'd work on a stepper motor controller.

We use these controllers at work, and I wanted to get more experience with them. The ones at work are driven by a MS-Dos powered 486 computer, with a CIO-DIO24 interface card. These cards are obsolete, expensive ($159), and the PC's are old, bulky, and difficult to upgrade to newer hardware. The code was written in assembly and compiled basic, source code no longer available, and doesn't like newer, faster hardware.

The controller we are using is the SD200 Step Motor Drive Module. These are also obsolete, but still available. They retailed for about $135, but I've seen them online for less than $75.

There are 4 power connections. +5vdc and gnd for the controller, and +12-40vdc and gnd for the motor. Motor current may not exceed 2.5 amps. A low ESR, high ripple current 4700 μf capacitor is installed across the motor inputs, pins 13 & 18.

There are 3 inputs necessary, Enable, CW/CCW, and Pulse. Direction is controlled by applying high or low to the CW/CCW pin. Bring Enable high to activate the controller, and send a pwm signal to the Pulse pin.

There is a startup sequence necessary:

1. Bring Enable low
2. Apply 5vdc
3. Apply motor voltage
4. Bring Enable high

To shutdown the motor:

1. Bring Enable low
2. Drop motor voltage
3. Drop 5vdc

There is overcurrent protection. If there is a short, or the motor pulls more than 2.5 amps, pin 11 (enable) will need to be pulled low, or the shutdown/startup procedure will need to be run to reset. I've written two sub routines, called startup and shutdown, and a third called reset, that I can call from within my program. I've installed transistors on pin 12 & pin 18 so that I can enable/disable module and motor power from these subroutines.

The stepper motor I'm using is a Applied Motion HT17-073.

More details to come!

Tuesday, July 5, 2011

The Water Pressure Sensor

This project uses a device called a differential pressure transducer to measure the water pressure at the bottom of the tank, and from that to calculate how full the tank is. Water pressure increases by about 9.8067kPa per meter of depth so a full tank 2m tall will have a pressure at the bottom of about 19.6134kPa above ambient atmospheric pressure. The "above ambient atmospheric pressure" part is important: it's not enough to simply measure the pressure at the bottom of the tank because varying climate conditions will alter the reading. That's why this project uses a "differential" pressure transducer that has two inlets. By leaving one inlet open to the atmosphere and connecting the other to the bottom of the tank the transducer will output the difference between the two, automatically compensating for varying air pressure and giving a constant reading for constant depth.

http://www.practicalarduino.com/projects/water-tank-depth-sensor

Tuesday, June 21, 2011

What is Gobetwino ?

Gobetwino (go between o) is listening on the serial port, for "commands coming from Arduino, and in response it will do something for Arduino and possibly return something to Arduino.

Gobetwino defines a set of command types that can be used as templates to create actual commands. Arduino can ask Gobetwino to execute these commands, and return something to Arduino.

So what can Gobetwino do? Using the defined command types you can create commands in Gobetwino that Arduino can ask Gobetwino to execute. These commands can:

Start a program on the PC.
Start a program, and wait until it finishes, and tell Arduino it finished.
Send data to any windows program from Arduino, like it was typed on the keyboard.
Send email, optionally with an attached file.
Download a file from the internet.
Read a file and return data to Arduino.
Log data from Arduino to a file, with an optional timestamp.
Periodically check a POP3 mailbox for incoming mails and send commands from the mail to Arduino.
Get the time from the PC.
Get the date from the PC.
Ping a host or IP address.
Copy a file on the PC.


With combinations of these commands you can do things like:

Start any program on your PC, either directly or via an associated file type.
Start Excel, send data from Arduino directly into the Excel sheet, save the sheet and email it, without touching your PC.
Send e-mails to a POP3 mailbox and have Arduino react to the contents of the emails.
Log data directly to a CSV file on the PC, so the data can be used in spreadsheets or databases.
Download a file from the internet and have Arduino ask for a specific line of data from the file.

http://mikmo.dk/gobetwino.html

Saturday, May 28, 2011

Hardware Random Number Generator

I've been playing with various ciphers and encryption schemes, and needed a true random number generator to ensure secrecy. A Pseudo Random Number Generator uses a algorithm to produce a pseudo random number. If the algorithm can be determined, so can the outcome. A Hardware Random Number Generator uses a external event (sound, light, atmospheric noise, etc.) to seed the random number generator. For a neat project, and more info, see

http://robseward.com/misc/RNG2/

http://en.wikipedia.org/wiki/Hardware_random_number_generator

Tuesday, May 24, 2011

Dissolved Oxygen Sensor

Looking for a way to detect dissolved oxygen levels? If you raise fish, this and a ph sensor are two important things to monitor (and of course, temperature), and an Arduino is the ideal platform to build upon. The Sensorex DO1200 ($139) outputs a <1mv - 54 mv signal indicating DO levels. Use

analogReference(INTERNAL1V1);  //Mega & Mega 2560

or


analogReference(INTERNAL); //328p based


to set the top of the input range to 1.1v.

Connect it to one of your analog pins. Very simple to read, just like a potentiometer. Just connect the plus wire (usually red) to your analog input, and the minus wire (black) to Arduino Gnd.

So:


//GND(black original cable)
//A3(red original cable)

int analogPin = 3;     // sensor+ connected to analog pin 3
                       
int val = 0;           // variable to store the value read

 void setup()
{
  Serial.begin(9600);          //  setup serial
  analogReference(INTERNAL1V1); //MEGA 2560
}



 void loop()
{

   val = analogRead(analogPin);    // read the input pin
  Serial.println(val);             // debug value
  delay(500);
}

Sunday, May 15, 2011

Magnetic Core Memory Project - Retro Memory for your Arduino

Magnetic core memory was the most widely used form of digital computer memory from its birth in the early 1950s until the era of integrated-circuit memory began in the early 1970s. Aside from being extremely reliable, magnetic core memory is an appealing technology because it is based on a very simple idea.

A core, a ring of magnetic material, stores one bit by the direction of its magnetization.

 A magnetic core is a ring of ferrite material. It can be permanently magnetized either clockwise or anti-clockwise about its axis just as a vertical bar magnet can be magnetized up or down. We can then turn a magnetic core into a bit of digital memory by letting these two magnetization states correspond to 0 and 1.

It provides non-volatile storage.

The core needs no power to retain its data. In other words, core memory is a form of non-volatile storage like modern hard disk drives, although in its day it fulfilled the ‘high-speed’ role of modern RAM.

http://www.corememoryshield.com/

Wednesday, May 4, 2011

Dual water tank heater thermostat


I am just finishing up a project at work, which requires two water tanks to be maintained at 180F. Each tank has twin 1500 watt, 240vac heating elements, each controlled by a SSR (Solid State Relay). My Arduino Mega 2560 reads two DS18B20 temp sensors (one in each tank), and maintains the temperature with a 5 degree window. I display both tank temperatures on a LCD, and control the color of two RGB LED's, blue for under temp, green for correct temp, red for over temp. The photo's are here. The following is the working code for the project.

#include <OneWire.h>
#include <DallasTemperature.h>
#include <LiquidCrystal.h>

// Connections:
// rs (LCD pin 4) to Arduino pin 12
// rw (LCD pin 5) to Arduino pin 11
// enable (LCD pin 6) to Arduino pin 10
// LCD pin 15 to Arduino pin 13
// LCD pins d4, d5, d6, d7 to Arduino pins 5, 4, 3, 2
LiquidCrystal lcd(12, 11, 10, 5, 4, 3, 2);

int tank1BLED = 37;
int tank1GLED = 39;
int tank1RLED = 41;
int tank2BLED = 43;
int tank2GLED = 45;
int tank2RLED = 47;

// Data wire is plugged into pin 8 on the Arduino
#define ONE_WIRE_BUS 8

// Setup a oneWire instance to 
//communicate with any OneWire devices
OneWire oneWire(ONE_WIRE_BUS);

// Pass our oneWire reference to Dallas Temperature. 
DallasTemperature sensors(&oneWire);

// Assign the addresses of your 1-Wire temp sensors.

DeviceAddress tank2Thermometer = { 0x28, 0x46, 0x3C, 0x16, 0x03, 0x00, 0x00, 0xA9 };
DeviceAddress tank1Thermometer = { 0x28, 0xDF, 0x21, 0x16, 0x03, 0x00, 0x00, 0x1E };

int tank1 = 31; // heater control pins
int tank2 = 33; // heater control pins

float tank1temp = 0;
float tank2temp = 0;

void setup(void)
{
  // Start up the library
  sensors.begin();
  // set the resolution to 10 bit (good enough?)
  sensors.setResolution(tank1Thermometer, 10);
  sensors.setResolution(tank2Thermometer, 10);
  
  
  
  pinMode(tank1BLED, OUTPUT); // Tank LED's
  pinMode(tank1GLED, OUTPUT);
  pinMode(tank1RLED, OUTPUT);
  pinMode(tank2BLED, OUTPUT);
  pinMode(tank2GLED, OUTPUT);
  pinMode(tank2RLED, OUTPUT);
  
  digitalWrite(tank1BLED, HIGH); // set Tank LED's off
  digitalWrite(tank1GLED, HIGH);
  digitalWrite(tank1RLED, HIGH);
  digitalWrite(tank2BLED, HIGH);
  digitalWrite(tank2GLED, HIGH);
  digitalWrite(tank2RLED, HIGH);
  

lcd.begin(20,4); 
// columns, rows. use 16,2 for a 16x2 LCD, etc.
lcd.clear(); 
// start with a blank screen

pinMode(tank1, OUTPUT); // Tank heaters
pinMode(tank2, OUTPUT);

}

void printTemperature(DeviceAddress deviceAddress)
{
  float tempC = sensors.getTempC(deviceAddress);
  float t1tempC = sensors.getTempC(tank1Thermometer);
  float t2tempC = sensors.getTempC(tank2Thermometer);
  if (tempC == -127.00) {
lcd.print("Error");
} else {
// lcd.print(tempC);
// lcd.print("/");
tank1temp = (DallasTemperature::toFahrenheit(t1tempC));
tank2temp = (DallasTemperature::toFahrenheit(t2tempC));
lcd.print(DallasTemperature::toFahrenheit(tempC));
  }
}

void loop(void)
{ 
  delay(2000);

  sensors.requestTemperatures();
  
lcd.setCursor(0,0);
lcd.print("Tank 1: ");

printTemperature(tank1Thermometer);

lcd.setCursor(0,1);
lcd.print("Tank 2: ");

printTemperature(tank2Thermometer);



if (tank1temp <=178.9)
{
  digitalWrite(tank1, HIGH);
  digitalWrite(tank1BLED, LOW);
  digitalWrite(tank1GLED, HIGH);
  digitalWrite(tank1RLED, HIGH);
}

if (tank1temp >= 179 && tank1temp <= 181.9)

{
  digitalWrite(tank1GLED, LOW);
  digitalWrite(tank1RLED, HIGH);
  digitalWrite(tank1BLED, HIGH);
}

if (tank1temp >= 182)
{
  digitalWrite(tank1, LOW);
  digitalWrite(tank1RLED, LOW);
  digitalWrite(tank1GLED, HIGH);
  digitalWrite(tank1BLED, HIGH);
}




if (tank2temp <=178.9)
{
  digitalWrite(tank2, HIGH);
  digitalWrite(tank2BLED, LOW);
  digitalWrite(tank2GLED, HIGH);
  digitalWrite(tank2RLED, HIGH);
}

if (tank2temp >= 179 && tank2temp <= 181.9)

{
  digitalWrite(tank2GLED, LOW);
  digitalWrite(tank2RLED, HIGH);
  digitalWrite(tank2BLED, HIGH);
}

if (tank2temp >= 182)
{
  digitalWrite(tank2, LOW);
  digitalWrite(tank2RLED, LOW);
  digitalWrite(tank2GLED, HIGH);
  digitalWrite(tank2BLED, HIGH);
}




}


Sunday, May 1, 2011

Sine, cosine, and tangent (the dreaded T word)

Why does trigonometry sound so scary? Often in the world of physics, and when the real world comes crashing into the lab, we need to use sine, cosine, and tangent in our calculations for having a way of relating the angles in a triangle to the lengths of the sides. Here is a simple tutorial that will act as a refresher if you have forgotten, or a brand new look at a useful set of equations if you never took trig.

http://www.physics.uoguelph.ca/tutorials/trig/trigonom.html

Sunday, April 24, 2011

What is a Sprout Board?


A sprout board in a basic description would be a motherboard or breakout board. It allows a micro controller to dock with it as well as a accessory shield. It also offers a host of onboard components as well as external connectivity options. The sprout board is designed to allow for flexibility and stability in a single package. Designed for actual use in everyday gadgets we have placed the most important and desired components onboard ready for easy use.

But the sprout board is more than just a circuit board. It is a complete package offering flexibility and applicability in what we are producing. We offer chassis for varied application as well as complete software ready for use. This allows mixing and matching of components and accessories to create a broad verity of real use projects with minimal effort.

http://www.sproutboard.com/

Saturday, April 9, 2011

Erector Sets for Big Kids

We have come across two companies that make structural modular pieces for mechanical, electrical, hydraulic and pneumatic controls and more. Ideal for making Arduino powered equipment and mechanisms. These are the industrial versions of Erector Sets and Lego's. Let's go build something cool!

http://8020.net/

http://www.itemamerica.com/

Wednesday, April 6, 2011

Arduino Mega with LCD Raffle

We are raffling off a Arduino Mega 2560 with a 4 line x 20 character White on Blue LCD. Tickets are $5 each, and the raffle ends April 30th. Ticket sales benefit Water Purification units for developing nations and disaster relief.







Arduino Mega 2560

20 x 4 White on Blue LCD

Sunday, March 27, 2011

Monitoring current and voltage with the TI INA210

This week we received a INA210 from Texas Instruments. Officially it's a "Voltage Output, High/Low-Side Measurement, Bi-Directional Zero-Drift Series Current Shunt Monitor". It allows us to monitor the amps flowing through the shunt, and to display the "right now" amp consumption (or production), volts, watts, and watt hours (with some simple arduino programming).

Combine this with one of our calibrated shunts (100a, 500a, and 1000a), and you have a powerful method of monitoring the power produced by a solar panel, consumed by an inverter or other dc load. Build your own watt or watt hour meter.

We will be working with this chip in a number of future projects.

Sunday, March 20, 2011

Monitoring voltage of a dc battery supply

Since we are involved in off grid solar power systems, we have a need to monitor battery voltage. The Arduino can do this easily with a simple voltage divider. With some simple mods, we can control loads, generators, or notifications based on battery voltage.

To read a maximum of 20vdc, R1 should be 3k ohm, R2 should be 1k ohm, and the code would be as follows:

/*
DisplayMoreThan5V sketch
prints the voltage on analog pin to the serial port
Do not connect more than 5 volts directly to an Arduino pin.
*/

const int referenceVolts = 5; // the default reference on a 5-volt board
//const float referenceVolts = 3.3; // use this for a 3.3-volt board

const int R1 = 3000; // value for a maximum voltage of 20 volts
const int R2 = 1000;
// determine by voltage divider resistors, see text
const int resistorFactor = 255 / (R2/(R1 + R2));
const int batteryPin = 0; // +V from battery is connected to analog pin 0

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

void loop()
{
int val = analogRead(batteryPin); // read the value from the sensor
float volts = (val / resistorFactor) * referenceVolts ; // calculate the ratio
Serial.println(volts); // print the value in volts
}

This example was based on info in Arduino Cookbook (Oreilly Cookbooks)

Saturday, February 12, 2011

Simple Voltage Dividers

A Voltage Divider is a simple circuit for dividing a higher voltage into a lower voltage without cumbersome transformers, etc. The example shows the proper values of two resistors (in ohms) for obtaining 12v from 120v. Using the formula and calculator below, you can adjust the voltage in, and resistance values, to get the output you desire.

If Vin = 120v, R1 = 9000 Ohms, and R2 = 1000 Ohms:

Vout = (R2 /(R1 + R2))* Vin

Vout = (1000 / 9000 + 1000)) * 120v

Vout = 12v


http://www.green-trust.org/voltage_divider/ (Calculator)

Monday, January 31, 2011

Multicolor (RGB) LED with Arduino PWM

This is the next step from our last post, where we take the single color example of PWM brightness control, and expand it to a RGB LED with a whole spectrum of color outputs. Instead of having one potentiometer, we now have three. Instead of using one analog ports, we use 3, and the same on the pwm ports.

The wiring is similar, each pot connects to +5 and ground on the outside legs, and each center pin connects to a analog port. The RGB LED has 4 legs, one for each color and a common anode. Arduino pins 7,6, and 5 connect to R, G, and B respectively (through a 270 ohm resistor). The code is similar, just duplicated lines for the other two colors.

Now you can make pink, turquoise, and more. The next step will be to upgrade to a 1 watt RGB LED, which requires 3 power transistors to handle the increased current.

(video uploaded to youtube)

Hardware:

3 Linear Taper 5k ohm potentiometers
3 270 ohm resistors
1 RGB common anode LED
1 Arduino

Download .pde

int sensorPinR = A0;    // red pot
int sensorPinG = A1;    // green pot
int sensorPinB = A2;    // blue pot
int ledPinR = 7;      // red LED
int ledPinG = 6;      // green LED
int ledPinB = 5;      // blue LED
int sensorValueR = 0;  // red variable
int sensorValueG = 0;  // green variable
int sensorValueB = 0;  // blue variable


void setup() {}

void loop() {
  // read the value from the sensor:
  sensorValueR = analogRead(sensorPinR);  
    sensorValueG = analogRead(sensorPinG); 
      sensorValueB = analogRead(sensorPinB); 
  // converts 0-1023 to 0-255
  sensorValueR /=4;  
   sensorValueG /=4;  
    sensorValueB /=4;   
  // outputs PWM signal to LED
  analogWrite(ledPinR, sensorValueR);  
    analogWrite(ledPinG, sensorValueG); 
      analogWrite(ledPinB, sensorValueB); 
  
                   
}

PWM LED Brightness Control

Pulse Width Modulation at last! In our last example, we read a potentiometer (pot) to get a analog value of 0-1023, and used that number to delay the digital on and off times of a LED. This example will do the same read, but output a analog value (PWM) of 0-255 to control the brightness of a LED. It's still controlling the on and off times, but so quickly the eye doesn't see off, it just sees decreased or increased brightness. this is much more power efficient than using a resistor to shed voltage, dimming a bulb. We will use this same method in an upcoming post to control the speed of a motor.

(video uploaded to youtube)

int sensorPin = A0;    // Analog input pin to pot
int ledPin = 7;      // PWM pin to LED
int sensorValue = 0;  // variable to store pot value


void setup() {}

void loop() {
  // read the value from the sensor:
  sensorValue = analogRead(sensorPin);  
  // converts 0-1023 to 0-255
  sensorValue /=4;   
  // outputs PWM signal to LED
  analogWrite(ledPin, sensorValue);  
  
                   
}

LED Blink Speed / Analog Sketch

I'm doing a series of mini projects that will build up to a motor controller, but need to get some basics across first. This first sketch is a Arduino, reading a potentiometer on an analog port, and using that data to control the blink speed of a LED on a PWM port. The potentiometer (pot) connects to ground and +5 on the outside legs, and Analog 0 on the center leg. The LED connects + to pin 7 and - to a 270 ohm resistor connected to ground. The value of the pot determines the delay on the LED. This not true PWM, that's coming next.

(video uploaded to youtube)

int sensorPin = A0;    // Analog input pin to pot
int ledPin = 7;      // PWM pin to LED
int sensorValue = 0;  // variable to store pot value

void setup() {
  // declare the ledPin as an OUTPUT:
  pinMode(ledPin, OUTPUT);  
}

void loop() {
  // read the value from the sensor:
  sensorValue = analogRead(sensorPin);    
  // turn the ledPin on
  digitalWrite(ledPin, HIGH);  
  // stop the program for <sensorValue> milliseconds:
  delay(sensorValue);          
  // turn the ledPin off:        
  digitalWrite(ledPin, LOW);   
  // stop the program for for <sensorValue> milliseconds:
  delay(sensorValue);                  
}

Monday, January 24, 2011

Ham Radio / Arduino Collisions

There are some neat Ham Radio / Arduino videos posted at http://9w2pju.hamradio.my/2010/04/arduino-toy-for-ham-radio.html. There is a Call Sign Player, Beacon Controller, and other Morse Code examples. Enjoy!

Sunday, January 23, 2011

Ponoko




Ponoko is one of our favorite websites. Need a 2d or 3d item made for you? Don't have a machine shop? Design a gear, or case, or whatever, in Inkscape, Google Sketchup, etc., upload it to Ponoko, and they will ship it to you, or even list it for sale on their website.

One of our favorite items is a Arduino mounting board, to keep our Arduino and a breadboard stable while we experiment.

http://www.ponoko.com/showroom/PhenomEngineering

Documenting Circuits with Fritzing


I use Fritzing to document my Arduino projects for sharing with others, as well as sending out custom circuit board orders.

A simple Fritzing workflow consists of the following steps:

1. Building a real circuit - it is very important that you first build a circuit in the real world and test it, before you rebuild it virtually in Fritzing.

2. Rebuilding the circuit in Fritzing - this is done by dragging parts from the Part Library to the Project View and making connections. If you cannot find a part in the library, Fritzing lets you create your own part using the Part Creator. Alternatively, you can use the Mystery Part (icon looks like a qustion mark - ?), that will let you quickly define a new part and its connectors. Parts are connected using the breadboard and wires. Wires are created instantly by clicking & dragging a part's connector.

3. Editing a circuit - drag & drop, copy & paste, multiple selection, rotation, undo history and more, are all functions integrated in the Fritzing environment sections and the menu bar. You can bend a wire by creating bend points. Just drag them them out of the wire. You can also add Notes (bottom bar menu) or Labels (right click on a part) to your sketch.

Changing a part's properties - properties of parts can be found and modified in the Part Inspector in the Palette Windows section. When a part in the Project View is selected, the relevant part information will show up in the Part inspector.

Switching between the Project Views - using the Navigator palette or the View Switcher, you can switch between the breadboard, schematic and pcb views. Any of these views can be used as the project's main working environment, and can be selected at any time.

Designing a PCB - when the circuit is ready in Breadboard View, you can design a PCB layout in the PCB View. Fritzing features automatic routing and different export formats.

Documenting a Project - a project can be documented and shared using the Export function in the menu bar. "Save as shareable..." saves all necessary files and custom parts related to a project in one shareable folder.

http://fritzing.org/

Friday, January 21, 2011

Building a Handheld Digital Compass

I have decided to build a handheld digital compass for orienteering, with altitude and temperature functions. I haven't used a compass in decades, and some folks have never used one, so I thought I'd post a link to a great tutorial describing the parts of a compass, and how it's used. Enjoy!

http://www.nwcg.gov/pms/pubs/475/PMS475_chap4.pdf

Thursday, January 20, 2011

Compass module with altitude

One of the goodies I received from Hacktronics the other day is the HDPM01 module. The HDPM01 module includes a pressure module and a compass module. Apparently, there is also a barometer and a temperature sensor on this module.

The HDPM01 pressure module includes a piezo-resistive pressure sensor and an ADC interface. It provides 16 bit word data for pressure and temperature related voltage. With the help of a highly accurate calibration of the sensor, 11 unique coefficients were stored on the chip, thus accurate pressure and temperature reading can be realized. HM03 is a low power, low voltage device with automatic power down switching. I2C Serial Interface is used for communications with a microprocessor. Sensor packaging options are SMD (with metal cap)

The HDPM01 is a dual-axis magnetic sensor, it is a complete sensing system with on-chip signal processing and integrated I2C bus, allowing the device to be connected directly to a microprocessor eliminating the need for A/D converters or timing resources. It can measure magnetic field with a full range of ±2 gausses and a sensitivity of 512counts/gauss @3.0 V at 25°C.

http://www.hoperf.com/sensor/compass.htm

http://jeelabs.org/2010/10/26/meet-the-heading-board/

Wednesday, January 19, 2011

Virtual Breadboard - Simulate an Arduino

Want to try out your designs virtually, before committing to hardware? You can sim the Arduino, and many other microcontroller platforms at http://www.virtualbreadboard.com/

See the video at http://www.virtualbreadboard.com/videos/VBB_5_ArduinoShow/ArduinoShow.html


A Helping Hand

This past weekend I picked up a very handy gadget, a Helping Hand. Two adjustable alligator claws to hold circuit boards or small work pieces, a holder for my soldering iron, and a LED lighted magnifier make my Arduino experimentations a lot easier. $10 at "Workshop Tools".

Tuesday, January 18, 2011

Hacktronics Goody Package Arrived

A box arrived from Hacktronics today. Inside was 4 1w RGB LED's, 3 LM317 voltage regulators, 10a Power MOSFETS, 7 npn transistors, resistors, a compass module, 5 potentiometers, and a 12vdc 1a ac adaptor. Over the next few days I'll be posting pics, videos and code.

Monday, January 17, 2011

RGB LED Mood Lighting

While I'm awaiting the delivery of my 1w RGB LED's and the MOSFETS to drive them, I thought I'd share some examples of projects built by Miguel Sánchez that I'm a big fan of.

Monday, January 10, 2011

January's Arduino Freebie - Arduino Mini

This months freebie will be the Arduino Mini, and a Mini USB Adaptor. The Mini has 14 digital input/output pins (of which 6 can be used as PWM outputs), 8 analog inputs, and a 16 MHz crystal oscillator. It can be programmed with the Mini USB Adaptor or other USB or RS232 to TTL serial adapter.

Mini USB Adaptor is a breadboard friendly USB to Serial board with a regular sized USB connector and male pins spaced at 0.1"

This adapter can be used with the Arduino Mini for both programming and host computer communications. It may also me used any time you would need to have an easy to use USB to serial adapter.

Uses the same USB to serial software driver that are included with the Arduino software since it is based on the same FTDI USB to Serial chip as the one built onto most Arduinos, the FT232.

Connection specs:

USB B connector
+5 Volts
Ground
TX (5 volt)
RX (5 volt)

Thanks again to Hacktronics for donating the monthly freebie.

Sunday, January 9, 2011

Making Thing Move: DIY Mechanisms for Inventors, Hobbyists, and Artists

There comes a time when you'd like your Arduino to do more than just sense the environment around it, and light lights or display data on a LCD display. There comes a time when you like to move items, with motors, hydraulics, pneumatics, etc. Unless you are a mechanical engineer, you may not know how to determine the right size motor to develop the torque and hp for a particular task. I bought "Making Things Move", and was blown away by the way the author makes concepts of force, resistance, and work simple to understand, calculate, and implement. This reference is a must have for your bookshelf or Kindle.