SURVIVAL EQUIPMENTS

This is the Graham Brothers Jackyl! One of the most well made knives I've ever had the privilage of owning!
It was a lot of fun doing this sheath. Craftsmanship is key!

Great little neck knife from Blind Horse Knives!

Its one of my favorite knives and a very
inexpensive way to buy a custom knife. Blind Horse knives make some really great "user" knives and I would recommend them to any one looking for a custom knife without the worry of spending a whole lot of cash!

In the tradition of Martin Swinkels, over at Sheaths for Knives, this sheath is made to mount horizontally on your belt, however it can be attatched to a backpack for hiking or what ever your hearts desire.

The kydex insert is a attached in such a way that you can take it out if you need to clean it or if you simply want to use the kydex as your M.O.

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;
}

}

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! :)

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! :)