My Projects

Recent LCD Discovery

2011-10-30T15:18:00.000-07:00

I recently visited an electronics surplus store while working in Minneapolis. This place was packed with electronic components. Bin after bin of switches, connectors, components and everything else you can imagine. I came across a bin full of LCDs that were not identified. $4.50 later, I was the proud owner of an unidentified LCD display. I knew it was new because a thin piece of protective plastic was still stuck to the front of the LCD display. :)

After getting to my hotel room that night, I started doing a little research online. I was disappointed to find very little information about the display - this is what I knew:

1. Manufacturer: Optrex

2. ID: PWB50244A-CEM printed on the display

3. Pin header has 15 pins

The only thing I could find was this data sheet, and it only identified a "DMC 50244". It also showed the display having a 4x20 display layout. In the data sheet, I found a pinout listing and decided to take a chance and see if it worked.

Here's the implementation using an Arduino Duemilanove.

Here is how I wired the display to the Arduino.

Display   Arduino
1         GND
2         5V
3         Variable Resistor Sweeper (10K)
4         12
5         GND
6         11
7         NC
8         NC
9         NC
10        NC
11        5
12        4
13        3
14        2
15        NC

I had trouble at first, nothing was showing up and I decided to look closer at the Vee pin specifications. I found very little from Optrex but did discover I needed to use a 10k variable resistor and dial in a proper contrast setting. This worked and the display came to life!

Here is the code I used to run this program.

#include <liquidcrystal.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() 
{
  lcd.begin(20, 4);
  lcd.print("Optex PWB-50244-A");
  lcd.setCursor(32,0);
  lcd.print("LCD Display Example");
  lcd.setCursor(0,1);
  lcd.print("Arduino Duemilanove");
  lcd.setCursor(32,1);
  lcd.print("Mark Was Here!");
}

void loop() 
{
}

You'll notice I use "lcd.setCursor(32,0)" to position the cursor on the first column in the second line. That's because the LCD controller treats this display as a 2 line display (as far as I can tell) and requires you to treat the first column of the second line as the 32nd column of the first line. Odd. But it works.

I have not been able to figure out what pin 15 is for - I did try connecting it through a 1K resistor to both Vcc and Gnd. I was hoping there may be a back-light...but I discovered nothing. A little tracing on the board didn't seem to illuminate it's purpose either. Oh well - maybe one of you will know the answer! :)

Good luck finding unmarked parts and making them come to life! Let me know how it goes for you!

Transmitting IR Data

2011-06-04T08:22:00.000-07:00

Some time ago, I wanted to see if I could control my Westinghouse TV using an Arduino micro-controller platform.

When I started, I didn't know what communication protocol was being used by my TV, so I used the same approach described earlier in this post, to look at the data being transmitted from my remote control. After analyzing the output, I matched it's protocol signature to the already well defined and commonly used Sony SIRC standard. This website was extremely helpful in doing that analysis.

I then began the process of implementing the protocol in the Arduino language. I broke the protocol definition into three simple transmission parts:

- sending the header

- sending a 0 bit

- sending a 1 bit

Here's some code to help you get started - a method for each part of the protocol:

//send message header

void sendHeader()

{

int i = 0;

while(i < T_HEADER)

{

digitalWrite(LED_PIN, HIGH);

delayMicroseconds(T_CARRIER);

digitalWrite(LED_PIN, LOW);

delayMicroseconds(T_CARRIER);

i+=(2 * T_CARRIER);

}

delayMicroseconds(T_SHORT);

}

//send an On Bit

void sendOneBit()

{

int i = 0;

while(i < T_LONG)

{

digitalWrite(LED_PIN, HIGH);

delayMicroseconds(T_CARRIER);

digitalWrite(LED_PIN, LOW);

delayMicroseconds(T_CARRIER);

i+=(2 * T_CARRIER);

}

delayMicroseconds(T_SHORT);

}

//send an Off Bit

void sendZeroBit()

{

int i = 0;

while(i < T_SHORT)

{

digitalWrite(LED_PIN, HIGH);

delayMicroseconds(T_CARRIER);

digitalWrite(LED_PIN, LOW);

delayMicroseconds(T_CARRIER);

i+=(2 * T_CARRIER);

}

delayMicroseconds(T_SHORT);

}

I then assembled those into the proper sequence to produce the IR blast required to control the TV. Here is a simple explanation of the sequence used to control the TV:

1. Send header

2. Send command (this is info like raise the volume, channel up or mute...etc.)

3. Send device ID (this is like TV, DVD, Tuner...etc.)

This needs to be repeated a minimum of 3 times for the receiver to verify that it indeed is a correct message being sent. Here is a brief video showing a simple looping program that sends commands to my TV.

More to come...

Arduino Stepper Motor Control

2010-07-30T10:21:00.001-07:00

I've had a number of stepper motors sitting in my shop for years. If we really want to do anything fun with our Arduino, we are eventually going to have to run a stepper motor. So, here we go!

A little background on stepper motors and how they are different compared to a typical electric motor. Unlike a conventional electric motor that spins when power is applied, stepper motors incrementally spin (step), allowing control over exactly how far the motor's shaft spins, even to the degree.

Stepper motors have a series of electromagnets that encircle an armature containing a magnet. Think of a compass with a shaft attached to the center of the needle. That needle becomes like the armature of the motor. To spin the armature, electromagnets are turned on and off around the outside of the compass, causing the needle to "step" (or point) from one electromagnet to the next. This picture may help illustrate the movement within a stepper motor.

There are two common types of stepper motors: Bipolar and Unipolar See this article to help explain the differences. I've chosen to use a bipolar stepper motor in this project. It can be somewhat more difficult to use because of the need to reverse polarity on the stepper motor electromagnets to provide the proper stepping. Here's a couple pictures of the motor I used:

A bipolar stepper motor has two electromagnetic winding sets. Because of this, it's necessary to use some circuit to reverse the polarity of the winding. A common way to do this is through the use of an H-Bridge circuit.

I used this circuit to create my H-Bridge controller:

I implemented the circuit on a perf board with a small 6 pin 90 degree header. I also added some LEDs to the circuit, just because everyone likes blinking lights, and I'm no exceptions. After all, that's what got me into this as a child ... blinking lights. Here's a picture of the H-Bridge:

I used the following diagram to pull the whole circuit together. There is an Inferred LED Interrupt sensor in this diagram. I'll talk about that in a subsequent post, so disregard for now.

I loaded the following very simple circuit onto the Arduino. It sets the speed of the motor to 10 RPM. Also, it turns the motor one revolution and then waits 2 seconds before looping.

#include

//create an instance of a stepper motor object
Stepper stepper(96, 8, 9, 10, 11);

void setup()
{
// set the speed of the motor to 10 RPMs
stepper.setSpeed(10);
}

void loop()
{
stepper.step(96); //on revolution
delay(2000); //wait 2 seconds
}

Lastly, here's a video to show this program in action with the whole circuit:

Platinum Arts Sandbox Tutorial 8

2010-03-21T15:04:00.000-07:00

Hi, this is Paul. Mark is my dad. I'm making a series of Platinum Arts Sandbox Tutorials and posting them on here. Platinum Arts Sandbox is a 3D game creator and world builder. It's quite easy to use. These tutorials will only need knowledge such as movement (arrow keys for movement and mouse for aiming), selecting (click and drag or click and right click for other corner), and opening a new map (E + Esc + New Map). Besides that everything will be taught to you. Note that some of these entries may require info presented in other tutorials.

How To Import a Mapmodel

1.Select where you would like to import your mapmodel at

2.Open the Main Menu (Esc)

3.Choose “New Mapmodel”

4.Choose the mapmodel of your choice

5.You can copy (Ctrl + C) and paste (Ctrl + V) as many as you want

Platinum Arts Sandbox Tutorial 7

2010-03-21T13:39:00.000-07:00

How To Make Hills/Valleys

1.Select the area you would like to make into a hill or valley

2.Press the H key

3.Scroll to make hills or valleys (scrolling away from you makes valleys and scrolling towards you makes hills)

4.Fill them will water to make a lake and fill them with lava to make a lava pit

Platinum Arts Sandbox Tutorial 6

2010-03-21T13:38:00.000-07:00

How To Make a Basic Water/Lava Pit

1.Select the area that you want the water pit to cover (first I'll show you how to make a water pit, because lava and water pits are very similar)

2.Scroll away from you until you get the depth you would like

3.Select one whole side of the pit

4.Right-click on the opposite side of the pit once your selecting square appears

5.Open the Materials window (F3)

6.Switch to the “Materials” tab

7.Click “Water”

8.Switch to player mode and go swimming in it

9.To make a lava pit do the exact same thing, except choose “Lava” at the Materials screen instead of “Water” (if you fall in a lava pit you die)

Platinum Arts Sandbox Tutorial 5

2010-03-21T13:37:00.002-07:00

How To Make 3D Grass

1.Select the entire map area

2.Open the Materials window (F2)

3.Choose the one with these coordinates: 3rd Page, 2nd Row, 5th From the Left

4.Press the question mark key

5.Type “grass 1”

6.You should see 3D grass

7.Press the question mark key again

8.Type “grass 0”

9.The 3D grass should have disappeared (you can turn grass on and off in player mode or edit mode)

Platinum Arts Sandbox Tutorial 4

2010-03-21T13:37:00.001-07:00

How To Change Textures

1.Select the area you would like to change the texture of

2.Open the Texture Window (F2)

3.Choose the texture of your choice

4.Press F2 to close the window

Platinum Arts Sandbox Tutorial 3

2010-03-21T13:34:00.000-07:00

How To Make a Simple Creature Game

1.Create the creature(s) of your choice (this does not work with butterflies or dragons)

2.Create a long, river-like lava pit with the creature(s) on one side (not on the end)

3.Make sure the lava pit is skinny enough that you can jump over it in player mode

4.In player mode, get near the creatures so they start chasing you

5.Jump over the lava pit when they are chasing you

6.They will attempt to follow you

7.They should fall into the lava pit

8.It will either say you won or you cleared the game

Platinum Arts Sandbox Tutorial 2

2010-03-21T13:29:00.000-07:00

How To Make Creatures

1.Select a square you would like your creature to be located in

2.Open the Main Menu (Esc)

3.Choose “Editing GUI”

4.Switch to the “Ents” tab

5.Choose “New creature Entity” from the list

6.Press the period key

7.Backspace until you get to the second number (it should be a zero)

8.Replace this number accordingly to the chart below

0 - Butterfly

1 - Dragon

2 – Golem (Rock Monster)

3 - Bear

4 - Rat

5 - Snake

6 – Wolf

9.Press Enter

10.Switch to player mode and try it out (all creatures will start chasing you if you get near them)

Platinum Arts Sandbox Tutorial 1

2010-03-21T13:14:00.000-07:00

How To Make a Bouncepad

1.Select a square that you would like you bouncepad to be placed (you can always move it)

2.Open the Main Menu (Esc)

3.Choose “Editing GUI”

4.Switch to the “Ents” tab

5.Choose “New jumppad Entity” from the list

6.Press the period key

7.Backspace until you get to the first 0

8.Replace it with a 50 (this number is the intensity of the jump, so you can change it as you like)

9.Press Enter

10.Select the square underneath the bouncepad (the bouncepad should now be a sparkling thing that you cannot see in player mode)

11.Import the jumppad2 mapmodel

12.The mapmodel should be on top of the sparkling bouncepad module (if it's not drag the mapmodel over it)

13.Switch to player mode and try it out

Arduino and IR Receiver

2010-01-02T06:48:00.000-08:00

In my last post, I used my USB oscilloscope to decode a discarded remote control's IR output. My next goal was to see if I could get my Arduino to read the data coming from the remote I had decoded.

The first challenge was finding an IR receiver. IR receivers are different from a typical IR transistor in that they are tuned to a certain carrier frequency - also called a "center frequency".

The boys and I dismantled retired DVD player from a company called CyberHome. It was a cheap and junk - it really only lasted a year or so (maybe we watch too many DVDs). :) We had dismantled it and a few circuit boards were left for me to scavenge through. One had a IR receiver that I decided to use for this project.

I used my desoldering tool and soldering iron to remove the component from the circuit board, and also did a little reverse engineering to see how it was wired. I discovered that careful attention had been placed to create adequate filter capacitors and a small current limiting resistor in series with it's power.

I wired it with this circuit on a breadboard and was pleased to find out that the LED flickered each time I pressed a key on the Insignia remote control.

IR1 - unknown (CyberHome DVD player)
C1 - 470uf 16V
C2 - 0.02uf
R1 - 100 ohms
R2 - 1k ohms
LED1 - small green

I then transferred the circuit to a small perf-board and built a small shield to fit onto the Arduino that will allow me to read the output. I used a piece of yellow stranded wire and a single header pin to allow me to connect the output of the IR receiver to whichever I/O pin I wanted to use on the Arduino. Here's some pictures of the completed shield attached to an Arduino Duemilanova 328 from SparkFun.

I then wrote a program to read the data from the IR receiver, first detecting the header and later walking through each of the pulses that I discovered in my last blog entry. Here's a code snippet that shows the basics of reading the data:

lengthHeader = pulseIn(pinData, LOW);
if(lengthHeader > 5000)
{
//step through each of the 32 bits that streams from the remote
byteValue = 0;
for(int i = 1; i <= 32; i++)
{
bit = pulseIn(pinData, HIGH);

//read the 8 bits that are specifically the key code
//use bitwise operations to convert binary to decimal
if (i > 16 && i <= 24)
if(bit > 1000)
byteValue = byteValue + (1 << (i - 17));
}

You may have noticed three important things about this code:

1. I used the "pulseIn" function. This function allows me to measure the length of a pulse coming from the I/O pin in microseconds. This allowed me to differentiate between a long pause or short pause in the signal stream - producing for me 1's and 0's.

2. I used bitwise shift "<<" to convert the binary data into decimal data. I had first used the "pow" function but was disappointed with it's performance, and it didn't seem to accurate report that x to the 0 power equals 1, it was reporting zero. I may have done something wrong - not sure.

3. I only deal with bits 17 through 24. That's because the first two 8-bit bytes are not relevant, so I just want to skip them.

I then returned the results of the decimal data to a serial connection so I could see it on my computer. Sure enough - after a little messing around with setting proper "bounds" and flushing the serial buffer explicitly, I saw great results.

Lastly, I wanted to do something fun with the data results. So, I decided to make a Processing program that would show which button on the remote was being pressed. Here's a screen shot of the resulting UI. As you'll see by the following picture of the remote - they are relatively close in appearance. When the button is pressed, the UI illustrates it by turning the button red.

Here's a short video showing it working!

[coming...]

Here are the code listings. If you do something similar, be sure to let me know - I would love to hear about your projects too! Thanks for reading!

ARDUINO CODE

//setup variables
int pinData= 12;
unsigned long lengthHeader;
unsigned long bit;
int byteValue;

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

void loop()
{
//look for a header pulse from the IR Receiver
lengthHeader = pulseIn(pinData, LOW);
if(lengthHeader > 5000)
{
//step through each of the 32 bits that streams from the remote
byteValue = 0;
for(int i = 1; i <= 32; i++)
{
bit = pulseIn(pinData, HIGH);

//read the 8 bits that are specifically the key code
//use bitwise operations to convert binary to decimal
if (i > 16 && i <= 24)
if(bit > 1000)
byteValue = byteValue + (1 << (i - 17));
}

//send the key code to the processing.org program
Serial.print(byteValue);
Serial.flush();
}

delay(100);
}

PROCESSING CODE

import processing.serial.*;

//define variables used thourghout the program
Serial arduinoPort;
int rowPressed = 0;
int colPressed = 0;
int code = 0;
String codeText;
PFont font;

void setup()
{
//create the window
size(210, 325);
background(220,220,220);

//write the brand name at the bottom of the window
smooth();
font = loadFont("Calibri-Bold-16.vlw");
textAlign(CENTER);
textFont(font);
fill(0,0,255);
text("I N S I G N I A", 105, 310);

//draw the silk screen colors on the remote
translate(-10, -15);
stroke(0,0,255);
ellipse(184,80,34,34);
ellipse(184,120,34,34);
ellipse(92,120,70,70);
ellipse(46,120,34,34);
ellipse(138,120,34,34);
ellipse(92,80,34,34);
ellipse(92,160,34,34);
rect(167,80,34,40);
rect(75,80,34,80);
rect(46,103,88,34);

//prepare for serial communication
String portName = Serial.list()[1];
arduinoPort = new Serial(this, portName, 9600);
}

void draw()
{
//initialize a few things each time.
rowPressed = 0;
colPressed = 0;
translate(-10, -15);
smooth();

//see if there is a serial message from the arduino
if (arduinoPort.available() > 0)
{
codeText = arduinoPort.readString();
code = int(codeText);
findPressed(code);
}

//use loops to draw the buttons on the remote
for(int col = 1; col <= 4; col++)
for(int row = 1; row <= 7; row++)
{
//draw the buttons different colors
if(row == rowPressed && col == colPressed) //red if pressed
fill(255, 0, 0);
else if((row == 4 && col == 1) || (row >= 5 && col <= 3)) //silk screened blue buttons
fill(0, 0, 255);
else //unpressed buttons
fill(240, 240, 240);
ellipse(col * 46, row * 40, 30, 30);
}
delay(100); //delay to leave the button lit a moment
}

//use the code id from the arduino to map to a button on the remote
void findPressed(int code)
{
switch(code)
{
case 28:
rowPressed = 1;
colPressed = 1;
break;
case 4:
rowPressed = 1;
colPressed = 2;
break;
case 17:
rowPressed = 1;
colPressed = 3;
break;
case 12:
rowPressed = 1;
colPressed = 4;
break;
case 80:
rowPressed = 2;
colPressed = 1;
break;
case 20:
rowPressed = 2;
colPressed = 2;
break;
case 81:
rowPressed = 2;
colPressed = 3;
break;
case 30:
rowPressed = 2;
colPressed = 4;
break;
case 84:
rowPressed = 3;
colPressed = 1;
break;
case 26:
rowPressed = 3;
colPressed = 2;
break;
case 85:
rowPressed = 3;
colPressed = 3;
break;
case 31:
rowPressed = 3;
colPressed = 4;
break;
case 18:
rowPressed = 4;
colPressed = 1;
break;
case 23:
rowPressed = 4;
colPressed = 2;
break;
case 73:
rowPressed = 4;
colPressed = 3;
break;
case 27:
rowPressed = 4;
colPressed = 4;
break;
case 5:
rowPressed = 5;
colPressed = 1;
break;
case 6:
rowPressed = 5;
colPressed = 2;
break;
case 7:
rowPressed = 5;
colPressed = 3;
break;
case 16:
rowPressed = 5;
colPressed = 4;
break;
case 9:
rowPressed = 6;
colPressed = 1;
break;
case 10:
rowPressed = 6;
colPressed = 2;
break;
case 11:
rowPressed = 6;
colPressed = 3;
break;
case 72:
rowPressed = 6;
colPressed = 4;
break;
case 13:
rowPressed = 7;
colPressed = 1;
break;
case 14:
rowPressed = 7;
colPressed = 2;
break;
case 15:
rowPressed = 7;
colPressed = 3;
break;
case 88:
rowPressed = 7;
colPressed = 4;
break;
default:
rowPressed = 0;
colPressed = 0;
}

}

Decoding IR Remote Control

2009-12-29T20:03:00.000-08:00

Another Christmas vacation meant spending time at my in-law's dining room table working on a project. This year, I decided to try to figure out the IR communication protocol being used by this retired Insignia portable DVD player remote control. The kids never really used the remote control and it still looks like new. My heart for re-purposing electronics wouldn't allow me to throw it away. Here's what the button layout looks like on the front of the remote.

I decided to use my USB Oscilloscope to read the data coming out of the remote control. My oscilloscope is made by Parallax and has two channels along with a very nice user interface.

I attached an IR LED to the Oscilloscope leads as follows:

I don't really know why using an IR LED works so well to capture IR signals, but it definitely works. I tried using an IR Transistor first to no avail - so this really did work best with the LED.

After the typical fiddling that goes along with grabbing new signals on an oscilloscope, I was able to capture this IR burst of data using the trigger capabilities of my oscilloscope.

I was able to zoom in on the header to figure out the carrier signal. As you can see in the lower right hand corner of my oscilloscope UI, there's a box called "Cursors". I was able to use cursors (or markers) to measure the length of a signal wave and discovered that it's approximately 35.7KHz. A little internet research will show that the typical commercial remote control uses a carrier signal of 36 to 38 KHz - so my measurements weren't too far off. This carrier signal is sometimes referred to as the "Center Frequency".

Next, I decided to measure the header signal along with the following break in the signal. This is used to indicate the beginning of a message or stream of data to the receiver. It appears the header is approximately 9 ms (milliseconds) or rather 9000 us (microseconds). This is followed by a 4500 us pause before the first bit appears.

Now we only need to understand what a bit is, and how to measure a "1" from a "0". I was able to discover that a "0" is a 55 us high followed by a 55 us low. The "1" is a 55 us high followed by a 165 us low. Either way, each bit is either 110 or 220 us long.

I then started counting bits and found out that the data transmitted from the IR remote control is 4 bytes long, with each byte being 8 bits long, adding up to 32 bits of data being sent each time a button is pressed. Here's a summary of my findings (I only analyzed number buttons 0 .. 9 on the remote control).

Carrier Signal = 36Kh
Header = 9000 us
Break = 4500 us
Off Bit = 1100 us
On Bit = 2200 us

"1" = 01000000 11111111 10100000 01011111 = 5
"2" = 01000000 11111111 01100000 10011111 = 6
"3" = 01000000 11111111 11100000 00011111 = 7
"4" = 01000000 11111111 10010000 01101111 = 9
"5" = 01000000 11111111 01010000 10101111 = 10
"6" = 01000000 11111111 11010000 00101111 = 11
"7" = 01000000 11111111 10110000 01001111 = 13
"8" = 01000000 11111111 01110000 10001111 = 14
"9" = 01000000 11111111 11110000 00001111 = 15
"0" = 01000000 11111111 01001000 10110111 = 18

I figured out that the 3rd byte contains the data and the 4th byte has the "not", presumably for error checking the data. So, for example, pressing the "1" key on the remote control sends the data stream 01000000 11111111 10100000 01011111 where 10100000 equals 5 in decimal.

I hope this is helpful to you. If you take time to decode your remote control - let me know how it goes for you! :)

Re-purposed Cool Blue Light

2009-12-17T17:56:00.000-08:00

Hi, this is Paul. Mark is my dad. Here's a project we made. It works great.

What we did was take apart something and found a circuit board with an LCD. We took off the LCD and found its back light. It was a really cool-looking blue color. We figured out how to hook it up to a battery. We cut off the rest of the circuit board in the wood shop so we just had a little more than the part with the back light.

Then we needed a way to hold the circuit board. We used the back of a power inverter my dad blew up. It looked really cool because it had a lot of holes. It also had one end bent over so it will stand up better. We used a metal clip we found as a base for the opposite side so it stands up good. We found a switch that just happened to fit perfectly in one of the holes.

We soldered everything together with wire-wrap wire (super thin wire). We hot-glued the circuit board to the top of the power inverter part. We wired together two AAA batteries and then glued them to the base.

I really like taking junk and turning it into something useful. My dad said it's called re-purposing (hence the name of the blog entry).

Tell us about it if you make your own. Hope it works.

Tricorder Sound Circuit

2009-12-13T12:27:00.001-08:00

Star Trek fans have likely heard the whirling whistle of the Tricorder. After talking with my son Paul about the challenge of designing a circuit to reproduce the sound, I came up with this implementation using three 555 timer chips.

The circuit has three astable multivibrator circuits (oscillators). Two of them have a high enough frequency to create tones, and the other is used to give the wobble sound.

The transistor and capacitor work together with the tone oscillator to make a voltage to frequency converter, allowing the lower frequency pulse generator to raise and lower the frequency of the second tone oscillator circuit. The remaining tone oscillator creates an additional high-pitched background tone heard in the original Tricorders.

Here's the circuit:

Here's the parts list:

R1 - 100k
R2 - 1k
R3 - 10k
R4 - 1k
R5 - 1k
R6 - 56k
R7 - 82 (modify for proper volume with your speaker)
R8 - 56k
R9 - 47k
R10 - 1k
R11 - 100 (modify to proper volume with your speaker)

C1 - 0.01 mf
C2 - 6.8 mf
C3 - 4.7 mf
C4 - 0.01 mf
C5 - 1.0 mf
C6 - 220 mf (power filter capacitor)

D1 - N4148

S1 - SPDT
S2 - SPDT or SPST

BAT1 - 3.7V Li-ion (tone will change with higher voltages - this circuit performed best at this voltage for me)

SPK1 - small 8 ohm speaker

Q1 - 2N3904 NPN bipolar transistor

IC1, IC2, IC3 - NE555 (could be modified to use NE556 dual-timer or NE558 quad-timer)

If you build this circuit - please let me know, I would love to know if it worked correctly for you too! :)

Arduino VFD Hardware Interface Complete

2009-07-05T14:13:00.000-07:00

The VFD is now connected to the protoshield and a test program shows all of the number segments operational. Here's some pictures of the finished shield mounted to an Arduino.

Next is writing the driver and encapsulating it into an Arduino library. :)

VFD Circuit Diagram

2009-07-03T20:54:00.001-07:00

I did some tests and discovered that the plates (segments in each display) will need to be driven by the full 12 volts while the grids can be supplied by the Arduino's typical 5 volt digital output. This requires me to use a transistor to drive each plate along with a resistor driving the base of each transistor. The circuit (minus the resistors driving the transistors) should look something like this.

It appears I will be using 11 (7 plates + 4 grids) to drive the VFD. This just squeezes into the IO ports available on my Arduino.

Next step will be to get the VFD attached to my protoshield, along with the transistors and resistors so that I can begin writing code... :) Can't wait...

Vacuum Fluorescent Display (continued)

2009-07-03T17:11:00.001-07:00

I've continued to work with the display I referred to in my last entry. It may seem like a small step, but I carefully calculated what resistor I would need to properly power the VFD filament from a 12 volt power supply. I did indeed power the filament and saw in a dark room the soft glow of the orange heaters.

Next, I decided to power the actual grids and plates to see the display light it's blue display elements. Here is a picture of the display I am using. It's a Futaba 6-BT-65ZK (Part Number 4230782). I know very little about Futaba part numbers, but I did find that most followed this format. I was unable to find a reference sheet on this actual display.

I attached 12 volts to each grid and tested each plat to see which elements lit up. After documenting the display connections, I arrived at this pin out for my display. As you can see, there are not many elements and it's geared towards a clock radio in a car.

Letters A - G apply to the segments in the 7-segment display characters. For more information on which element corresponds with which letter, see this Wikipedia image.

Next, I will be trying to figure out how to drive the display using a multiplexer circuit in conjunction with an Arduino. I'll keep you posted on what I discover along the way. :)

Vacuum Fluorescent Display

2009-06-26T08:51:00.000-07:00

Years ago, I saved a car radio from a Chrysler that had a digital display. I estimate 20 years later, I've finally taken time to tear it apart and scrounge parts from it. Inside I found a Vacuum Fluorescent Display (VFD). I didn't realize it was in there and found its glass package an immediate draw.

This is an example picture - my display has less elements. :)

I wanted to do a little investigating about VFDs and found this website. Much to my surprise, there were a number of online examples of people using them to amplify audio signals since they have the basic structure of a Triode vacuum tube. Apart from the unique implementation of the device, I did find the theory information helpful at this site.

My plan is to use this display in conjunction with an Arduino. My first challenge was to figure out how to run the filament. I chose 12 volts as my available input voltage and have estimated that the required voltage is 2.5 volts. With that in mind, I needed to figure out exactly what resistor would be needed to provide that voltage.

Here are the only input parameters to my problem:
Input voltage: 12 VDC
Filament voltage: 2.5 VDC (this was determined through tests)
Filament current: 75 mA (this was determined through tests)

Here is what I want to figure out: Ohms of the resistor I need in series with the filament to achieve the 2.5 VDC across the filament. Here is a good source I used to figure out my series resistor values.

E = I * R

E = voltage (volts)
I = current (amps)
R = resistance (ohms)

We know that current is constant across the series circuit, so using this equation, we find that the resistance of the filament is .

3 = .075 * R
R = 40 ohms

Expanding our equation, we can say that:

E = I * (R1 + R2) where R2 is our filament resistance. Substituting what we know, our equation looks like this:

12 = .075 * (R1 + 40)

solving to: R1 = 120 ohms

Entertainment Cabinet

2008-12-27T15:04:00.001-08:00

After getting a LCD TV, we realized our over-sized entertainment cabinet needed to be replaced with a smaller and more contemporary cabinet. We drew the cabinet on Sketchup first, then created the cabinet using a construction technique using lamination.

The sides, top and shelves are 1 1/4 thick and appear to be solid oak. They are actually laminated as follows:

1/4 inch plywood top
3/4 inch filler stock in a frame shape (pine)
1/4 inch plywood bottom
Adhesive backed edge banding (heat applied)

Here's the finished product.

Arduino LM35 Sensor

2008-12-27T12:14:00.000-08:00

My son Paul and I recently finished a project using the Arduino Diecimila microcontroller in conjunction with the Processing open source programming environment to monitor temperature.

The project contains 3 parts:
1. The Arduino board with sensor circuit.
2. The Arduino program.
3. The Processing program.

The Arduino Board with Sensor Circuit
The Arduino circuit board is connected to the LM35 Celsius Temperature sensor. Here is a picture of the project circuit with illustrated wires connected to the temperature sensor.

We used the on board power source (5v and Gnd) to power the LM35 and analog pin 0 (zero) to read the analog output from the sensor. Here's a picture of the circuit wired on a breadboard.

The LM35 temperature sensor's pin-out and package information is as follows:

The Arduino Program

The open-source Arduino environment allows us to write code and load it onto the Arduino board's memory. The development environment is written in Java and based on Processing, avr-gcc, and other open source software.

The Arduino code loops every second to read output from the LM35, converting the analog output into Celsius and sending the data to the computer via a serial communication connection (USB).

Here's the code used to run the Arduino board:


//declare variables
float tempC;
int tempPin = 0;

void setup()
{
Serial.begin(9600); //opens serial port, sets data rate to 9600 bps
}

void loop()
{
tempC = analogRead(tempPin);           //read the value from the sensor
tempC = (5.0 * tempC * 100.0)/1024.0;  //convert the analog data to temperature
Serial.print((byte)tempC);             //send the data to the computer
delay(1000);                           //wait one second before sending new data
}

The Processing Program
The software client portion of this project runs on a PC and is written in Processing. Processing is a language and development environment similar to Arduino and designed for creating visual effects programs. We used Processing to create a small client that can read the serial data from the Arduino board and display the temperature on a slider and in both Celsius and Fahrenheit. We also added a rolling 100 data point graph to display historical temperature data. Here's a screen shot of the Processing application:

Here is the code used for the visual portion of the project:


//import Serial communication library
import processing.serial.*;

//init variables
Serial commPort;
float tempC;
float tempF;
int yDist;
PFont font12;
PFont font24;
float[] tempHistory = new float[100];

void setup()
{
  //setup fonts for use throughout the application
  font12 = loadFont("Verdana-12.vlw"); 
  font24 = loadFont("Verdana-24.vlw"); 
  
  //set the size of the window
  size(210, 200);
  
  //init serial communication port
  commPort = new Serial(this, "COM10", 9600);
  
  //fill tempHistory with default temps
  for(int index = 0; index<100; index++)
    tempHistory[index] = 0;
}

void draw()
{
  //get the temp from the serial port
  while (commPort.available() > 0) 
  {
    tempC = commPort.read();
  
    //refresh the background to clear old data
    background(123);

    //draw the temp rectangle
    colorMode(RGB, 160);  //use color mode sized for fading
    stroke (0);
    rect (49,19,22,162);
    //fade red and blue within the rectangle
    for (int colorIndex = 0; colorIndex <= 160; colorIndex++) 
    {
      stroke(160 - colorIndex, 0, colorIndex);
      line(50, colorIndex + 20, 70, colorIndex + 20);
    }
    
    //draw graph
    stroke(0);
    fill(255,255,255);
    rect(90,80,100,100);
    for (int index = 0; index<100; index++)
    {  
      if(index == 99)
        tempHistory[index] = tempC;
      else
        tempHistory[index] = tempHistory[index + 1];
      point(90 + index, 180 - tempHistory[index]); 
    }
  
    //write reference values
    fill(0,0,0);
    textFont(font12); 
    textAlign(RIGHT);
    text("212 F", 45, 25); 
    text("32 F", 45, 187);
  
    //draw triangle pointer
    yDist = int(160 - (160 * (tempC * 0.01)));
    stroke(0);
    triangle(75, yDist + 20, 85, yDist + 15, 85, yDist + 25);
  
    //write the temp in C and F
    fill(0,0,0);
    textFont(font24); 
    textAlign(LEFT);
    text(str(int(tempC)) + " C", 115, 37);
    tempF = ((tempC*9)/5) + 32;
    text(str(int(tempF)) + " F", 115, 65);
  }
}

End.

Wooden Deck Table

2008-09-23T19:32:00.000-07:00

Our deck has a nice place for a table and chairs. This summer I finally took time to make a cedar table that fit nicely into it's awaiting spot on the deck.

I made the top first in the shop, rounding over the edges of each slat with the router. In all, the top is made of 23 individual boards.

Best of all, as you can see, it works! :)

Pummer

2008-01-05T07:25:00.000-08:00

Here's some information on the pummer I built over Christmas break. I decided to take a few components and breadboard a flashing circuit. After looking on the Internet and trying some different things, I found a very low current 2 LED flashing transistor circuit. The circuit alternates the LEDs and gives a nice brisk attention grabbing look.

I also created a sensor circuit using an IR detector transistor and a switching transistor that disables the flashing circuit in the presence of light. Interestingly enough, florescent light bulbs (of which are common place in our home's lamps now) don't seem to emit enough IR to keep the flashing circuit disabled. So, evenings finding this pummer flashing away even with the lights are on in our home. Just a touch of sunlight seems to shut it off.

For power storage I've gone outside the bounds of true BEAMing by using two NiMH AAA batteries. These are charged by the 4.5 volt solar panel, so there is plenty of charging potential during the day. I use a diode to prevent leakage back through the solar panel which could prematurely discharge the batteries.

The mast is a single piece of 14 guage copper wire used as the common conductor for the two LEDs. The LEDs are soldered directly to the mast and are connected through a thin 2-conductor ribbon cable back to the circuit.

Here is a video demonstrating the flashing - sorry for the low light in the picture. Oh, yes, the spot lights in our kitchen are still the old fashion incandescent - so this demonstration worked well. :)

BEAM Head (Version B)

2007-12-28T07:06:00.000-08:00

I have completed (with the help of my friend Matt) the mechanical platform for my BEAM Head (Version B). It was milled by Matt on a Hurco CNC Milling Machine. I showed up with my two gear motors and some ideas and Matt really took it from there. Here are pictures of what was created.

The motor that I am using seems to be widely available. I got mine from BGMicro.

The following driver and sensor circuit has been breadboarded - it contains 3 parts:

signal sensing circuit
signal inverter
h-bridge

The final product is shown in this video. It is fully autonomous and tracks the brightest object in the room. If the light source contains enough energy, it will charge the onboard batteries. There is a small on-off switch to shut down the system, still allowing charging.

Chairs

2007-12-24T08:53:00.001-08:00

I have enjoyed working with The Brighter Day Group for the last two years making chairs. The Brighter Day Group works with volunteers to make furniture for the less fortunate for free. I enjoy making chairs and have done my part to contribute to their effort to make dining room sets. My friend Donny (the founder of TBDG), has worked with me on much of the fabrication, assembly and finishing.

All the construction is mortise and tenon and is of the highest heirloom quality. Above a form is used to make curved backs for the mission style chairs shown in the first picture.

A closeup of the front leg joining the cross members of the seat.

A chair waiting to be finished with the Java colored stain and clear polyurethane finish.

Here is a closeup of the back of the chair and some chairs in my garage receiving more polyurethane.

PIC Micro Programmer

2007-12-24T08:10:00.000-08:00

The idea of programming small micro-controllers has been an interest of mine for a long time. Microchip makes a number of small micro-controllers, and after some studying on the topic, my target chip had become the 16F628A. This chip has 8 I/O pins, plenty of program memory for a guy like me and is in a small package (18-DIP).

After doing some research and a failed attempt to make a programmer kit that came with a book I purchased from Barnes and Noble, I decided it was time to make my own. I found a simple programmer developed by Byron Jeff - the Trivial Low Voltage Programmer (TLVP). Here is my version of that programmer (which works well).

The programmer uses a 9V batter and a LM7805 voltage regulator as a supply power to the 74HCT573 Octal D-Type Latch. This chip is used to buffer the data from the PC's parallel port to the target micro-controller chip. I put the components on a perf-board and added a switch to turn the power on and off.

Pinewood Derby Car

2007-12-23T18:08:00.000-08:00

My son attends AWANA at our church. Each year the kids have a pinewood derby race where they compete for both the fastest race times and the best design. My son and I teamed up (as is encouraged by the AWANA organization *grin*). After discussing different options, he decided he wanted a sleek racing coup with headlights and tail lights.

We did some sketching and came up with a fast flat body, a canopy (made from the side of a liquid soap dispenser), and some headlights and taillights made from LEDs. The two AA batteries are inset and housed under the canopy.

His car performed fairly well in the race and much to his joy it placed 1st in the Design Competition.

A very proud Paul with his trophy and winning car!

Floor Lamp

2007-12-23T17:43:00.000-08:00

My father-in-law could use a new floor lamp for Christmas, so with some persuasion from my wife, I decided to make one for him. Earlier in the year he had given to me (as a birthday gift) some rough cut hickory. This summer I planed it down and I was just waiting for the right project. After buying a lamp shade at Target and some electrical supplies from Lowe's, I had everything I needed to build the lamp.

It has a wooden handle connected to the pull chain of the light fixture to make turning the light on a bit easier and a little more unique.

Sump Pump Monitor

2007-12-23T17:17:00.000-08:00

We have have an extremely active sump system. At times during strong rainfall, our pump may actually stay on as it pumps the water out as fast as it comes into our sump pit. I found myself forever going down to the basement to look into the pit and see how deep the water was. Also, after installing a backup pump (yes, I learned the need for that the hard way), I also was forever checking to see which pump was running.

Eventually after growing tired of peeking about my sump pit, I decided to create a monitor that would both determining the depth of the water in the sump pit and indicate which (if either) pump was running. My first challenge was to create the depth sensor.

I used a capped piece of PVC pipe with stainless steel bolts spaced every 2 inches. I then wired those from the inside of the pipe to a DB-9 connector.

Transistors amplify the signal from each sensor in the pipe. Those signals are then used to light LEDs on a monitoring panel.

I also built a current sensor by wrapping 12 gauge shielded wire around a 1/2 steel core (I cute the head of a lag bolt). Then, I attached a small hall effect device to the end of the core to sense a magnetic field. Each time a pump draws current through the coil, it produces a 60Hz magnetic field that is sensed by the hall effect device. That signal is then filtered using a filter capacitor and then used to light an LED. Here is a video of the prototype current sensor.

Here is a video of the finished monitor panel working. It is both monitoring the depth of the sump pit and also monitoring the pumps.

Curved Ceiling

2007-12-23T14:48:00.000-08:00

After deciding to finish a room in our basement, we thought it would be an opportunity to be creative and make a curved ceiling. We created a form in the cieling that looked a bit like an upside down boat, then applied plywood to it to create the curved surface.

Some crown molding and rope lights created a nice look, espcially at night. The room is 16x11 and is framed with steel studs, drywall, oak trim to match the rest of the house and modular carpet in case we ever have water problems. Everything turned out well and we've been pleased with the results.

Automated Nightstand

2007-12-23T14:15:00.000-08:00

This was an attempt to declutter our bedroom. I had grown weary of the clutter next to the bed and decided to make a nightstand that matched the ALF Group bedroom set we purchased from Italy. In this hybrid project, I combined woodworking, mechanics and electronics to create a nightstand that hid away our clock, X10 light control and any other clutter that potentially could pile up.

Microswitches inside the front panel of the nightstand control the raising and lowering of the hidden compartment. A relay is used to electronically lock into the raise and lower modes even after the microswitches are released. The top is mounted in a break-away fashion for safety (we don't want anyone to lose a finger). The linear actuator installed in the rear of the nightstand raises the top with its overrated 500 lbs capacity. The linear actuator uses internal microswitches to control the start and stop positions of the top.

Here are some videos of the nightstand during construction and the finished product.

BEAM Phototrope

2007-12-23T13:48:00.000-08:00

My second effort in BEAM Robotics has been the creation of a Phototrope Photophile. Phototropes are small BEAM-bots that respond to light and are mobile. This phototrope is attracted to light, so it is a photophile (verses a photophobe which fears light).

This photophile uses a two photopopper circuits. Photopoppers are a store and release circuit that uses a capacitor to collect electricity gathered by the solar panel(s). A flashing LED (FLED) is used to determine the threshold at which the capacitor is discharged into the motor(s). FLEDs have a unique attribute in that they function less efficiently when exposed to light, allowing the photophile to respond directionally to light.

Here's a video of the little guy working his way across the tile entry in our house. This video is taking in late December - so the sun's angle is at it's lowest. I've bent his bottom down a bit to give him a better angle of attack towards the sun - it helps a bit but his is a somewhat slow mover (as you will see).

BEAM Head (version A)

2007-12-23T07:13:00.000-08:00

I have been captivated by Mark Tilden's BEAM Robotics cult-like following and decided to join the many people that have built a BEAM-bot. My first BEAM project was a 1D Squirmer Head. For those of you that are not familiar with the BEAM movement, that may seem to be odd terminology.

Here are some links to help you learn more about BEAMing (if your interested):

Here are some pictures of my Squirmer Head:

Like all Squirmers, this BEAM-bot is stationary. The head is solar powered and requires no batteries. It's goal in life is to look for the Sun and track it. It has three basic parts:

Motor that drives the head movement (this is the M (mechanical) of BEAM).
Tilden H-Bridge motor controller that changes signals into directional movement (this is the E (electronic) of BEAM).
Solar panel and light sensors to power from and look for light (this is the B (biological) of BEAM).

Here is the circuit I used to build my version of the head. The design is actually quite inefficient - this is not a smoke-less H-Bridge design, so if both photo transistors allow current to pass through them, the circuit is effectively shorted out through both sides of the H-Bridge. I have come up with a design that is smokeless and hope to be putting that into a new head soon.

Also, the A of BEAM stands for "aesthetics". I hope you find this BEAM head to be handsome. :) Here are some additional pictures.

Would you like to see this little guy in action? Check out this YouTube video of him tracking a lamp.