Last week I received an Element 14 XL_Star board from Farnell/Newark. My condition for receiving this board was that I do a review. I must admit that I have been on a quest for the perfect controller board for a very long time. In my journey I have gone though pic microcontrollers, Parallax Basic Stamps, Arduinos and Arduino clones, TI MSP430s, mbed rapid prototyping and last the LeafLabs maple controller.

At the heart of the XL_Star is the Freescale MC9S08MM128CLK a very inexpensive 8-bit microcontroller with some impressive specs including a clock speed up to 48Mhz, USB, 128KB flash, 12Kb ram, 4 differential 16bit ADC ports. 8 single ended ADC ports, single 12bit DAC, and 47 GPIO. Also on the board includes a second freescale processor primarily used for programming and debugging the Freescale MC9S08JM60CLD. Last as a bonus feature, this board includes a three axis 14bit accelerometer the MMA845QT.

Software install

I was really hopping that this environment would have Linux support, however that was not the case so I started up an Windows 7 machine in Virtual Box. The CD has a wizard to help guide you though installing all the software and drivers necessary.

This process took a long time, roughly 30min. CodeWarror is a very large package that kept constantly asking for verification to install system drivers. Then on top of that you have to install a couple patches along with updated drivers.

After the install is complete you can start the application and select the Sample XL_STAR project to open the default program

Programming and Debugging

At this point I plugged in the USB to the bottom debugging port and selected “Debug” (F5) from the project menu. Another window opened that showed the source along with the assembly dump, registers and memory.

I must say that this real time debugger is a very cool feature. You start the program by either stepping though the line of code or hitting the start button. You get interactive feedback while the program is running. I ran the default program that shows the data from the accelerometer.

I also tried to modify the code to write my own custom program. This program will uses the led circle method to display a growing circle in a infinite loop.

while(1) {
    for(i=0;i<6;i++) {
        leds_circle(i);
        millisecond_delay(100);
    }
}

Conclusion

I must say that this is a very sophisticated board for it’s price.  I have very mixed feelings about the software. I would really like a Linux option. It may be a future possibility since Freescale does offer tools for linux. Their web page indicates that any download are for evaluation only unless your purchase. The active debugging was a very neat feature that I have not had in the past. I am going to have to spend a lot of time learning more about this board so far I get the impression that it is very complex and the tools are not as user friendly as the microcontrollers I am normally used to running. I hope to incorporate this board in some future projects

Previously I tested a El84 using series of 9 volt batteries to generate the high B+ voltages. While it was very simple by nature, it still fell short of the desired voltages that are required to make a useful audio amplifier. Normally the solution to this problem is to use a step up transformer and rectify the mains current.  These transformers are not cheap, very heavy, and costly to ship, but above all I did not have one at the time. Another option is direct rectification of the mains AC. This technique has been used in radios of the past and is extremely dangerous! Without a fuse this circuit will draw as much current as you house will deliver.  Also the ground of the circuit will be directly coupled to the neutral of your home. If you use a non polarized plug or there is a mis-wiring of your outlets, the ground of your circuit would complete a direct 120v path with the “ground” of another circuit. So for initial testing I decided to go with a boost converter.

The Boost conveterter

The operating principal of a boost converter is very simple, am inductor is charged and then released though a diode to charge a capacitor. This principal is used in switch mode power supply units. Most switching regulators are designed to work at lower voltages, say bump up a 5V supply to a 12V supply. I have a few MC34063A switching regulators I bought a while back for the exactly purpose of running 12V out of a couple AA batteries.

This devices is only rated to 40V. So I had to add some supplementary components in order to ramp the voltage over 100V. To do this I did the switching using a IRF740 MOSFET. At first I tried driving the opamp directly from the regulator. In simulation this would work however I discovered that real MOSFETs have a fair amount of capacitance at high frequencies that will create a lot of resistance. So I had to create a MOSFET driver. For this I chose a 2n222 / 2n907 NPN/PNP pair. When working with high voltages it is important that all the components are rated appropriately. This is espcially important for the capacitor and diode following the MOSFET.  The capacitor I chose was surplus disposable flash capacitor rated at 330V with a capacitance of 270uF. The diode is a simple rectifying diode, I may have had better performance with a Schottky diode however all the ones I have were not rated for voltages this high.

Designing an Audio Amplifier

For designing the audio amplifier I went back to the circuit simulator. Falstad’s  simulator has a triode and the it’s model parameters can be edited by exporting and re-importing the circuit file. I asked Paul how to change the characteristic of the tube and he replied with the model that he used to simulate the triode that is as follows: ((Vgk+Vpk/mu)^1.5)/kg1 where Vgk = gate-cathode voltage and Vpk = plate-cathode.  In order for me to simulate commercially available triodes I needed to find kg1 and mu values that would get me close. For this I wrote a python program using matplotlib to allow me to play with different values and visualize the results.  Below are a couple screen shots.

An 12ax7 Preamp Troide, The y axes is milliamperes and the x is volts

A El84 Poweramp Pentode running in Triode mode

The source code for this project can be found on my Github account under Tube Plot. This code was developed on Ubuntu using python 2.6.5 and matplotlib.

After finding values that were close to the original data sheets (at least for the voltages I intended to run) I then did some simulations.

The Preamp

The Poweramp

Putting it all together

Now that I ran some simulations I deiced to try building it all out. First I tried using the switching power supply and only the power amp state using a function generator as the preamp.

While this did work, it was very stressful on the boost converter. A lot of current had to be drawn. I spent about a day or two playing with different inductors and switching frequencies to get optimal efficiency. In this time I blew a couple mosfets and diodes. Eventually a ham buddy of mine gave me a step up transformer to play with so I deiced to make a traditional power supply.

I used a broken PSU as the case so I could recycle the power connectors and power switch. I also added a fuse along with the rectification circuit. This PSU reads arround 200v unloaded and 180v loaded, about the same as my switching supply.

So I could actually play music from my iPod, I built out the 12ax7 preamp. Both tubes heaters are using a 6V battery in this test. So far everything seems to work well.  In the video blelow I used an old Bose speaker and played some music.

The song being played is “Against all Odds by” Brian Botkiller. The little pocket oscilloscope from  Gabotronics is displaying the voltage ripple of the power supply.

Before the 555 contest was announced I was reading the free online book 50 555 Circuits from talking electronics. I was very amazed with how much could be done with the 555 timer. So I decided the best way to understand the 555 would be to try and build one. First I looked at some generic block diagrams and also the schematic diagram published in the National Semiconductor datasheet. After I understood the theory, I tested it out in my favorite circuit simulator by Paul Falstad. This program should be up to the task of simulating at a very high level.

So far so good, Next I needed to build an SR latch out of transistors. A SR or Set Reset latch consists of two NOR gates. When S is set high Q will stay high until S is set low and R is set high. This circuit is useful in itself for button de-bouncing. I did a simulation building out the latch only using NPN transistors.

After tweaking the resistor values  I went ahead started building out the circuit. For reliability and ease I decided to use the Manhattan Style of construction, a variant of of Ugly Construction. This style is very popular in the QRP Ham Radio community. It consists of using little copper pads on top of a sheet of copper clad. It has many advantages including prototyping speed, high reliability, low noise, high frequency opearation, and last it allows you to mix and match through hole and surface mount parts. The disadvantages is well, it’s ugly looking.

Using a cheap Harbor Freight punch I cut out all the the circular pads in two different diameters. I then clean the corrosion off the pads using sand paper, This helps with soldering and gluing.

Pads are glued to the board with a generic super glue and then fluxed and tinned with solder. I can then cut and bend the parts leads in order to solder them to the board. All NPN transistors are 2n3904 and PNP are 2n2907.

The circuit tested just fine, Now for something a bit more challenging, designing the voltage comparators.  I looked at some transistor op-amps schematics along with the LM555 data sheet schematic. The first op amp appeared to use Darlington pair NPN transistors.  I simplified things a bit by directly using resistors instead of current mirrors. I played with a few variants of the circuit and decided on the one below.

Since I was not too confident about how it would work I tested it on a breadboard first. My major concerns were if it was going to be able to drive the SR latch and if the imperfect current gain (Beta) would throw off the comparator.

When the negative side was connected to the reference and the positive was to the variable power it worked great. However the opposite was not true. Looking back at the data sheet it appears the LM555 uses PNP transistors for the second voltage comparator. I was hopping I could just build two of these and move on. So I had to go back to the simulator and play with some other designs.

The Transistor on the right is not part of the voltage comparator but there to simulate this interfacing with the next stage. When I interfaced with the SR latch I bypassed the 10k resistor connected to the base.

Here I am testing both comparators connecting to the SR latch. The reference voltages is coming from three 22k resistors on the breadboard.  The top refrence should be (Vcc *.66) and the bottom is (Vcc *.33). Vcc is a 9v battery and the input was a variable power supply.

Besides having a huge mess of wires everywhere it seems to work out just fine. The switching is not perfect on 3 and 6 volts but this is probably because the battery is not perfectly 9v and the resistors are not perfect.

Here is the final board with all the modules cleaned up and soldered together with the the series 5k resistors on the board. It should have been obvious before but this was the first time I realized why this device is called the 555, it has to be because of the three 5k series resistors that govern how the device behaves. The transistor to drain the timing capacitor is on the bread board. It was not possible to drive it directly from the latch so I had to use another transistor as a voltage follower. In the video clip it is wired as an astable oscillator with R1 and R1 at 1K and C1 = 470uF and it looks to be working satisfactory.

Here it is running much faster, R1 and R2 are still 1k but C1 is now .015uF. That should equal 34.44khz with a duty cycle of %66. From the scope I roughly measured 31.2k and visually it look to be about %66. So I would say this is functionality correctly.

So after three weeks and using 15 BJTs plus some sacrifices to error I have a huge 555 timer. This particular design does not have the output buffer stage but than can be added easily and not need for this testing. In the unlikely even’t 555s no longer exist I am prepaid. More importantly this project has really help me understand analog circuity, an art I feel that is an art that is dying fast in the digital world.  I hope this information proves to be useful or at least inspire. Maybe I will tackle an LM741 next. You can see the full photo set on my Flickr page.

References

• Fairchild 2n2907
• Fairchild 2n3904
• Paul Falstad
• National Semiconductor LM555 Datasheet
• Talking Electronics
• The 555 Timer at Electronics.dit.ie

I  have always been interested in vacuum tube amplifiers, however the high voltages from the mains has always kept me from experimenting with them. About a year ago I played with an low power tube the 1t4 in a regenerative receiver.  The B+ was set to 45V powered from an array of 9v batteries.  I decided to revisit an old guitar amplifier project I started in high school using an EL84 power pentode.

The first part was to figure out a way to mount the tube so I could experiment with it. I found an small metal box that worked well for mounting the tube socket. I then took some wires from a broken ATX power supply and soldered them to the tube socket.

After I had everything assembled I brought it to the test bench and wired up the test circuit below. I measured the current at the anode versus the voltage at the gate. I kept adding 9v batters to the B+ supply and noted the results.

Below are the results I noted along with a graph. I also included the triode configuration graph from the original datasheet.

So far the data looks consistent with the original datasheet for the tube in triode mode. The tube can sink a lot more current when VG2 is around 350V running in the full pentode configuration. Even with all 12 9V batteries I might be able to drive about 1watt of audio to a speaker. I was also surprised that the heater alone took around .7 amps at 6.3V. This is definitely not the most efficient way to drive a speaker I hope to get an proper impedance matching transformer so I can hear how it performers soon.

This started when I ordered an IR led and phototransistor pair from Spark Fun along with some spare ATMega168 microcontrollers. I first experimented using the IR led to transmit 2400 baud serial to the phototransistor. I programmed my Arduino Diecimila with the sample serial program altering the baud rate and allowing it to run in a continuous loop.

diff ~/arduino-0011/examples/Communication/ASCIITable/ASCIITable.pde laserModem.pde

6c6
<   Serial.begin(9600);
—
>   Serial.begin(2400);
38,40c38,39
<     while(true) {
<       continue;
<     }
—
>     number = 0;
>
45c44
<   delay(100); // allow some time for the Serial data to be sent
—
>   delay(10); // allow some time for the Serial data to be sent

After programing the Arduino, I took out the ATMega168 and wried it into a breadboard along with a 16mhz crystal and 5 volt regulator. For the receiver I used the phototransistor wired into two logic gates of a inverting Hex Schmitt trigger. I used the Schmitt trigger to act as a buffer and ensure only proper logic level enter the USB to serial converter on the Diecimila board. While the first test was successful, I was was not able to place the led more than an inch away from the phototransistor. To allow for more range I used an AD620AN instrumentation amplifier IC. For control I wired the gain pins of the amplifier into a small 10k potentiometer. After adjusting the gain I was able to get about a foot of range with reliable data transfer. Any further and there was too much noise in the signal.

At this moment I wondered if I could use a laser to extend my range. I happened to have a small laser that I pulled from a cheap laser level. I pulled out the laser and wired it where the IR led was minus the resistor. I then pointed the laser at the phototransistor and noticed it instantly reacted. In fact I had to turn the gain on the amplifier way down to use the signal. To test my range I wired my ATMega168 to a 9v battery and mounted the laster in a small vise a few feet away. After adjusting the gain I was able to transmit data easily. Attached is a video along with the final schematic I used.

View the Laser Modem Video Here

The purpose of this project is to create 3d mountain terrain using a recursive midpoint displacement formula. For this project I decided a GUI would be useful, that way manipulations could be seen in real time. This would require a 3d rendering package. My choices were DirectX, OpenGL and Java3d. Since I prefer to do my development in Linux, DirectX was ruled out. I have not been very impressed with the performance of Java3d so that left me with OpenGL. After deciding on my rendering package I needed to choose a language and a GUI framework. GLUI is an excellent framework for leaning OpenGL, but lacks control over the layout of the interface. So I decided on QT by Trolltech which was just recently acquired by Nokia.

Midpoint Displacement Formula

The midpoint Displacement Formula is simply to take two points, find the midpoint and then add or subtract a random number. This formula can then be repeated for each segment creating a fractal. This same concept can be converted to 3d in what is known as the Diamond-Square algorithm. Instead of two points we take a plane defined by four points, calculate the midpoint and add a random number. We can start with one large plane and perform the algorithm. Then divide the plane into four sub-planes and repeat. A recursive function works well for this task. For the mountains to look real, it is best to shorten the range of random numbers as the algorithm progresses. Below is the midpoint Function I wrote for this program in C++.
/****************************************
*This is the recursive algorithm of the
* midpoint formula
****************************************/
int GenFractal::midpoint(int i,int start,int topx, int topy) {
//Base case
if(i<1) {
return 0;
}

//find lenght for this section
int len = (int)pow(2,i);

//Calculate midpoints

//Top middle
int x1 = topx + len/2;
int y1 = topy;

//Right middle
int x2 = topx + len;
int y2 = topy + len/2;

//Bottom middle
int x3 = x1;
int y3 = y1 + len;

//Left Middle
int x4 = x2 – len;
int y4 = y2;

//Midpoint
int xmid = x1;
int ymid = y2;

//Calculate the values of the midpoints

//Top middle
data[x1][y1] = data[topx][topy] +
(data[topx+len][topy] – data[topx][topy])/2;

//Right middle
data[x2][y2] = data[topx+len][topy] +
(data[topx+len][topy+len] – data[topx+len][topy])/2;

//Bottom middle
data[x3][y3] = data[topx][topy+len] +
(data[topx+len][topy+len] – data[topx][topy+len])/2;

//Left middle
data[x4][y4] = data[topx][topy] +
(data[topx][topy+len] – data[topx][topy])/2;

//Midpoint
data[xmid][ymid] = data[x1][y1] + (data[x3][y3] – data[x1][y1])/2;

//Decrease the varence of randomness as iterations go foward
float min = hmin * (((float)start – ((float)start – (float)i)) / (float)start);
float max = hmax * (((float)start – ((float)start – (float)i)) / (float)start);
//Add random value to midpoint from hmin to hmax

data[xmid][ymid] +=  (int)(min + ((float)rand() / (float) RAND_MAX) * (max – min));

//As mountians get larger add less varence of random data

//Decrease I
i–;

//Recursive steps

//Upper left quadrant
midpoint(i,start,topx,topy);

//Upper right quadrant
midpoint(i,start,x1,y1);

//Lower left quadrant
midpoint(i,start,x4, y4);

//Lower right quadrant
midpoint(i,start,xmid,ymid);

return 0;

Building the Framework
For this project I decided on using QT4 with OpenGL. Since I am running Ubuntu, I used apt-get to install the QT4 development packages.

sudo apt-get install libqt4-dev qt4-dev-tools qt4-designer qt4-doc

For my development environment I chose the Eclipse IDE for C/C++ Developers with the QT Eclipse Integration Plugin. This allows for rapid development of QT applications. I decided to use CVS for version control since it is easy to setup and is integrated into eclipse.

Building the Interface
I built the interface using the Qt4 designer. Below you can see a screen shot of my application’s layout.

Rendering
For OpenGL rendering I had to create a QGLWidget Class. Once the class is created you can then paint to this widget using regular OpenGL functions. My OpenGL skills are not nearly as good as I would like. I have a copy of the Red and Blue Book which is enough information to get a rendering window, setup lighting and draw some polygons. For this project I converted the elevation map to triangles with the normals facing up and packed them into a GLfloat array. The polygons can be rendered with the following commands.

//Create array for triangles
GLfloat * vert = fractal.getTriangles();
int length = fractal.getNumTriangles();
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3,GL_FLOAT,0,vert);

GLuint list = glGenLists(1);
glNewList(list, GL_COMPILE);

//Set Color
float colorBlue[] = { 1.0f, 0.5f, 0.0f, 0.0f };
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, colorBlue);

//Draw the triangles from array
glDrawArrays(GL_TRIANGLES,0,length);

glEndList();

This same data can then be used for my RAW triangles export by simply converting it to ASCII.


Windows XP / Vista Port
After I had a satisfactory application I decided to try porting it to windows. This is so windows users can try this program without having to compile it. I simply download QT for Windows with the MinGW GNU compiler and ran ‘qmake’ and ‘make’. Thats was about all that was needed.

Conclusion

This turned out to be a very involved programming project for me. There is a saying that no software is ever finished. This project has really solidified that for me. There are still may improvements and features I would like to add. I am still not 100% satisfied with the terrain generation. I feel that I could use some improvements of my algorithm.

Download
Source Code Tarball: Mountains.Feb-4-2008.tar.gz

Source Code Zip: Mountains.Feb-4-2008.zip

Win32 Binary: Mountains-win32.zip

The other day I was trying to play an old game I bought some time ago on my LAN. I was just trying to enjoy a little cooperative bot killing fun with my buddy, but for some reason, the game kept telling me my ‘master key’ or something along those lines didn’t check out. Needless to say I wasn’t happy with it… I bought this game… and maybe I wasn’t supposed to play it on two machines at once… but at the very least I certainly didn’t want it phoning home for a simple LAN game, a game mode where no master server or internet should be required.

So I decided to see what my ‘game’ was up to. A quick download of Wireshark (formerly Ethereal) and an even quicker packet sniff and sure enough I could see where my ‘game’ was initiating connections and across what port.

After booting up wireshark, simply click on the “Capture” menu and select “Interfaces…” and from there it will show you a list of available ones to capture from. Select your active connection (the one with an IP thats NOT your localhost (127.0.0.1)), and click start. You should see something similar to this screenshot as Wireshark attempts to capture all the packets entering and leaving your machine.

If you’ve closed all your other connections (browsers, streaming music, etc.) you should now try to recreate the traffic you wish to sniff. In my case this involves launching the game I want to play and trying to connect to a LAN game, with which I am promptly kicked back for failing to ‘check out’ with the master server correctly. Now exit the game and pull up Wireshark to see what it caught.

In the interest of not angering anyone, I’ve obscured the specific IP and domain name that my machine is connecting to. But for these purposes, it shouldn’t matter. Notice there are numerous outbound and inbound packets originating from the IP 216.27.xx.xxx, and in the right hand column you can [almost] see that an actual domain name has also been found.

This is where the windows ‘hosts’ file comes into action. The hosts file is a pretty simple file to deal with, usually located at c:/windows/system32/drivers/etc/hosts on xp machines (On most linux distributions a similar file is located at /etc/hosts). Here is where you can redirect certain domains to other IPs for a variety of reasons. In our case we want to redirect the server xxxxx.server1.xxxxx.com to the localhost, to prevent the game from phoning home.

In the screenshot above you’ll notice I’ve added a line to my hosts file to redirect the offending domain. Now all outbound connections to xxxxx.server1.xxxxx.com will be redirected to the localhost, preventing any real connection from occurring between the two. But what if there’s no domain name listed? Then the hosts file will be fairly worthless to you, but there are a couple of possible alternatives.

First, try doing an ‘nslookup’ on the IP that looks suspect, and see if you get a domain name to return, in most cases you probably won’t. The next possible solution is to do a google search for the statistics, analytics or authentication server your program is trying to connect to. In many cases google will know the answer already for you. But if both of these methods fail, its time edit the routing table on your machine.

Bring up a [lame] windows command line, if you don’t know how simply click the ‘start’ menu, select ‘run…’ and type in ‘cmd.’ From here you can view and alter the routing table.

Type ‘route print’ at the command line and it should print out the routing table for you to like the screenshot above. If at any point you wish to learn more about route just type in ‘route’ by itself and it will print out detailed help. What we want to do now is create a route for the offensive IP to be sent to the localhost. In some cases this can be done by simply pointing the offending IP to 127.0.0.1, however in my case I had to point it to the actual local IP address of my machine (192.168.2.5) since there was already a route in place to direct traffic heading to 192.168.2.5 to the localhost at 127.0.0.1.

C:\Documents and Settings\Administrator>route print

IPv4 Route Table
===========================================================================
Interface List
0×1 ……………………… MS TCP Loopback interface
0×2 …00 01 29 d2 2c 2b …… NVIDIA nForce Networking Controller – Packet Sch
eduler Miniport
0×3 …00 01 29 d2 2c 2a …… Marvell Yukon 88E8001/8003/8010 PCI Gigabit Ethe
rnet Controller – Packet Scheduler Miniport
===========================================================================
===========================================================================
Active Routes:
Network Destination Netmask Gateway Interface Metric
0.0.0.0 0.0.0.0 192.168.2.1 192.168.2.5 20
127.0.0.0 255.0.0.0 127.0.0.1 127.0.0.1 1
192.168.2.0 255.255.255.0 192.168.2.5 192.168.2.5 20
192.168.2.5 255.255.255.255 127.0.0.1 127.0.0.1 20
192.168.2.255 255.255.255.255 192.168.2.5 192.168.2.5 20
224.0.0.0 240.0.0.0 192.168.2.5 192.168.2.5 20
255.255.255.255 255.255.255.255 192.168.2.5 192.168.2.5 1
255.255.255.255 255.255.255.255 192.168.2.5 2 1
Default Gateway: 192.168.2.1
===========================================================================
Persistent Routes:

C:\Documents and Settings\Administrator>

Use the ‘add’ parameter to add a new route to your table like this (change destination and source IP accordingly)

C:\Documents and Settings\Administrator>route add 216.27.xx.xxx 192.168.2.5
C:\Documents and Settings\Administrator>

You can also use the route command to change the route for entire subnets, but for my purposes its unnecessary, all I needed to do is redirect a specific IP.

Now launch a new session of Wireshark and begin capturing. Open up the offending game or application and test that it works (no longer phones home for any reason). In my case I can see that a bunch of traffic formerly headed to that rouge IP is now heading to 192.168.2.5, which then heads to 127.0.0.1, and effectively gets nowhere.

Congratulations! You’ve now stopped your game or application from ‘checking home.’ It should be noted that on many high end firewalls/routers, its possible to do similar things from within the router itself, but I’ve found that with most consumer level firewalls this still isn’t an option. For instance, on my cheap Belkin I can restrict specific port ranges by internal IP, which would actually work fine for this particular problem, but is a less than perfect solution since it would block ALL traffic outbound on that specific port (a less than optimal solution if the application is using a standard port).

In this day and age you can really never be too careful about privacy, more and more seemingly everyday games and applications religiously phone home your personal information about everything from your private browsing habits to your choice of music. In my case, I’d like to keep them from finding that type of information out.

The purpose of this project is to encode an image to a sound that can be viewed with a spectrogram. For some time I have known that musical artists have encoded pictures into their music. Most notable of these is artists is Aphex Twin. Luckily I had a copy of Windolicker and a great visualization program Sonic Visualiser. After looking at the images I decided it would be cool to try and encode my own images. I saw a few programs available, but decided it would be a better challenge to write my own program from scratch using Perl.

Spectrograms

A spectrogram is a graph representing the intensity or a frequency with relation to time. Normally the frequencies are along the Y axis, with the time on the X axis. The intensity of the frequency is represented by the brightness of the color. The frequency and color can use either a linear scale or a logarithmic scale. Below is an spectrogram of a few piano chords. The audio file used can be found on Wikipedia here.

Image encoding

The idea I had to encode the image was to simply create a sine wave at a corresponding frequency to represent the Y axis, a corresponding time to represent the X axis and a corresponding amplitude to represent the pixel color intensity.

Creating Sound

The first step to encoding an image was to learn how audio formats work. At first I tried writing a script that plays a frequency to the ‘/dev/dsp’ (Which is the sound card on Linux). When writing straight to /dev/dsp you are limited by a sample rate of 8000hz and a sample size of 8bits. Below simple Perl script that plays a concert A 440hz. To execute run ‘./sin.pl > /dev/dsp’.

#!/usr/bin/perl
use Math::Trig;
use strict;
use POSIX;

my $sample = 8000;
my $frequency = 440;
my $cycles = 6;
my $period = POSIX::floor($sample / $frequency * $cycles);

while (1) {
for(my $i=1;$i<=$period;$i++)
{
my $x = 128 + sin($cycles * 2 * pi * $i / $period) * 128;
$x = POSIX::floor($x);
my $char = pack(“C“,$x);
print “$char color=”#ff00ff”>”;
}
}

The DSP defaults do not offer much fidelity I needed at least the fidelity of an audio CD, which is 16bits at 44.1khz. I did some of searching on CPAN to find a library that allowed me write wave files. Most of the audio libraries had a too much overhead for what I wanted to do. Instead I looked up the file format for a ‘.wav’ and coded my own library. This library is limited to only producing a 16bit 44.1khz mono wave.

#!/usr/bin/perl
#Author Evan Salazar
#——————————————–
#
#Generate a .wav file for 16 bit mono PCM
#
#——————————————-
use strict;
package SimpleWave;

sub genWave {

#Get the reference to the data array

my ($audioData) = @_;

#This is the default sample rate
my $samplerate = 44100;
my $bits = 16;
my $samples = $#{$audioData} + 1;
my $channels = 1;

#Do Calculations for data wave headers
my $byterate = $samplerate * $channels * $bits / 8;
my $blockalign = $channels * $bits / 8;
my $filesize = $samples * ($bits/8) * $channels + 36;

#RIFF Chunk;
my $riff = pack(‘a4Va4‘,‘RIFF‘,$filesize,‘WAVE‘);

#Format Chunk
my $format = pack(‘a4VvvVVvv‘,
‘fmt ‘,
16,1,
$channels,
$samplerate,
$byterate,
$blockalign,
$bits);

#Data Chunk
my $dataChunk = pack(‘a4V‘,‘data‘,$blockalign * $samples);

#Read audoData array
my $data;
for(my $i=0;$i<$samples;$i++) {

$data .= pack(‘v‘,$audioData->[$i]);
}

#Return a byte string of the wave
return $riff . $format . $dataChunk. $data;
}
1;

Reading a Bitmap

Luckily I found a simple bitmap reader on CPAN called Image::BMP. This is a nice lightweight library that dose not depend on any external libraries or compiled code. Using this library I was able to easily load and read the bitmap data.

Encoding the Image

The first pass of my program disregarded the color data and only produced a frequency for the Y axis if the color intensity was less that half the sum of all colors. Below is an example. Note: I converted the WAV to an MP3 to conserve bandwidth, at 320kbps not much data is lost.

Audio File: ohmpie.mp3

I was really shocked to fist see the image! The only tweaking I needed to do was to use a linear scale for the frequency. Also if I selected too high an amplitude for the sin wave, clipping occurred in areas with too much black. For image above I used an amplitude of about 1000 on a scale of 0 to 32768.

The next step was to add amplitude scaling to match the color intensity. For this I summed all the color channels for a given pixel and scaled it to represent the max amplitude ‘(R + G + B) / 768 * max_amplitude’. Below is a picture of me after using the scaling.

Audio File: evan.mp3

By selecting a color scheme that goes from black to white and using a linear scale for the volume I get a very good black and white image. To prevent clipping on very dark images I added an inverse option that will invert the color producing a negative image.

Audo File: evanInv.mp3

You can reverse the color scheme to go from white to black to produce the regular image

Full Program

Below you can view and/or download the full code to this program. Currently performance is not optimized. So don’t write me telling me its slow. I currently have a few idea to speed it up. Also for best results use a small image around 100px tall.

Download: imageEncode-0.7.tar.gz

Serialization in Perl is the process of saving a class with multiple data types to a scalar (string of bytes). This can be used to save objects to a file or to transmit objects across the Internet. For this article I am going to describe the basics of creating a class in Perl and serialize it using the following packages: Data::Dumper, FreezeThaw, PHP::Serialization, and XML::Dumper.

Data types in Perl

Before we serialize anything we first need to learn a bit about the data types in Perl. There are only three data types in Perl, these are scalars, arrays and hash tables. Below is an example of each.

$myScalar = ‘This is a Scalar‘;
@myArray = (‘Element zero‘,‘Element one‘,‘Element Two‘);
%myHash = ( keyOne => ‘Data1‘, keyTwo => ‘Data2‘);

print “Scalar Data: “ . $myScalar . “\n“;
print “Array element at index 1: “ . @myArray[1] . “\n“;
print “Hash at KeyOne: “ . $myHash{‘keyOne‘} . “\n“;

Output:

Scalar Data: This is a Scalar
Array element at index 1: Element one
Hash at KeyOne: Data1

Like in C and C++, you can also have references to the data in each data type. The reference is not the data its self, but a location where the data can be found. By using special syntax the data can be retrieved from the reference itself.

$scalarReference = \$myScalar;
$arrayReference = \@myArray;
$hashReference = \%myHash;

print “Scalar Reference: $scalarReference \n“;
print “Array Reference: $arrayReference \n“;
print “Hash Reference: $hashReference \n“;

#Different ways to print the referenced data

print “Scalar Data: “ . ${$scalarReference} . “\n“; #Or
print “Scalar Data: “ . $$scalarReference . “\n“;

print “Array element at index 1: “ . @{$arrayReference}[1] . “\n“; #Or
print “Array element at index 1: “ . @$arrayReference[1] . “\n“;   #Or
print “Array element at index 1: “ . $arrayReference->[1] . “\n“;

print “Hash at KeyOne: “ . ${$hashReference}{‘keyOne‘} . “\n“;  #Or
print “Hash at KeyOne: “ . $hashReference->{‘keyOne‘} . “\n“;

Output:

Scalar Reference: SCALAR(0x8153600)
Array Reference:  ARRAY(0x8153630)
Hash Reference:   HASH(0x8153690)
Scalar Data: This is a Scalar
Scalar Data: This is a Scalar
Array element at index 1: Element one
Array element at index 1: Element one
Array element at index 1: Element one
Hash at KeyOne: Data1
Hash at KeyOne: Data1

Classes in Perl

Perl was not originally designed to be an object oriented language, although it is possible to use it as one by using the following techniques. A class in Perl is basically just a module that returns a reference to a hash containing the data that is accessible to the class. This referenced is then “blessed” which means that it is bounded to the module. Perl uses some syntactical sugar to make this processes easy. Below is a test class in Perl that uses each of the data types. This class was created to test the serialization of each package.

#!/usr/bin/perl
#####################################################
#Author:Evan Salazar
#This is a just a simple perl class that uses
#different data types to be used in serialization
#####################################################
package TestClass;
use strict; #Normally use to keep data clean

#The Constructor
sub new {
print “Creating the Class \n“;

my $obj = {
name => {firstName => ‘none‘, lastName => ‘none‘}, #Test Hash
email => ‘none@none.com‘, #Test Scalar
skills => undef,         #Test array
gpgKey => ” };                  #Binary Data
bless($obj);

return $obj;

}

#Set the Contact Name
sub setName {
my $self = shift;
$self->{‘name‘}->{‘firstName‘} = $_[0];
$self->{‘name‘}->{‘lastName‘} = $_[1];
}

#Set the E-Mail
sub setEmail {
my $self = shift;
$self->{‘email‘} = $_[0];
}

#Set the Skills
sub setSkills {
my $self = shift;
$self->{‘skills‘} = \@_;
}

#Set the GPG Key
sub setGpgKey {
my $self = shift;
$self->{‘gpgKey‘} = $_[0];
}

#Print all of the class Data
sub printAll {

my $self = shift;

#Print Full Name
print “Name: “ .
$self->{‘name‘}->{‘firstName‘} .
“ “ .
$self->{‘name‘}->{‘firstName‘} . “\n“;
#Print E-Mail
print “E-Mail: “ . $self->{‘email‘} . “\n“;

#Print Skills
print “Skills: “;
for(my $i=0;$i<=$#{$self->{‘skills‘}};$i++) {
print $self->{‘skills‘}[$i] . “ “;
}
print “\n“;
print “GPG Key: “ . unpack(‘H*‘,$self->{‘gpgKey‘}) . “\n“

}

1;

Perl Serialization Methods

There is no built in serialization in Perl, therefor serialization has to be done with an external package. After searching CPAN I found the following packages.

• Data::Dumper – Serialize data into Perl code that can then be unserialized using the eval() procedure.
• FreezeThaw – Converts objects to a string for data storage and retrieval.
• PHP::Serialization – Serialize using a method that is compatible with the serialize() method in PHP.
• XML::Dumper – Serialize to XML. Does not work with binary data.

These packages can be installed by downloading the source code and compiling or by using the following ‘cpan’ commands.

sudo cpan install Data::Dumper
sudo cpan install FreezeThaw
sudo cpan install PHP::Serialization
sudo cpan install XML::Dumper

Serializing TestClass

Below is a program that will serialize TestClass initialized with some sample data. The data will be serialized using all 4 classes.

#!/usr/bin/perl
#####################################################
#Author: Evan Salazar
#Serialize The data in TestClass
#####################################################
use strict;
use Storable;
use PHP::Serialization;
use FreezeThaw;
use TestClass;
use XML::Dumper;
use Data::Dumper;

#Create the New Test Class
my $myclass = TestClass::new();

#Fill the Test Class with data
$myclass->setName(‘Evan‘,‘Salazar‘);
$myclass->setEmail(‘esalazar1981@gmail.com‘);
$myclass->setSkills(‘Perl‘,‘PHP‘,‘Java‘,‘C‘,‘C++‘);
#—–Comment out to use XML::Dumper————–#
$myclass->setGpgKey(pack(‘H*‘,‘11061398fe828dcd83a4b9a79594c399‘)); #Not really my key but 128bits of random data

#Open File for wrting Serialized Data
open(PHPSER,    “>phpser“);
open(FREEZETHAW, “>freezeThaw“);
open(XMLDUMPER, “>xmldumper.xml“);
open(DATADUMPER, “>dataDumper.pl“);

#Serialize Using Data::Dumper
print “Data::Dumper\n“;
print DATADUMPER Data::Dumper::Dumper($myclass);

#Serialize Using FreezeThaw
print “FreezeThaw\n“;
print FREEZETHAW FreezeThaw::freeze($myclass);

#Serialize Using PHP::Serialization
print “PHP::Serializatoin\n“;
print PHPSER PHP::Serialization::serialize($myclass);

#Serialize Using XML::Dumper
print “XML::Dumper\n“;
my $dump = new XML::Dumper;
print XMLDUMPER $dump->pl2xml($myclass);

This is the output from each method:

dataDumper.pl

<br /> $VAR1 = bless( {<br /> ‘email’ => ‘esalazar1981@gmail.com’,<br /> ‘skills’ => [<br /> 'Perl',<br /> 'PHP',<br /> 'Java',<br /> 'C',<br /> 'C++'<br /> ],<br /> ‘name’ => {<br /> ‘firstName’ => ‘Evan’,<br /> ‘lastName’ => ‘Salazar’<br /> },<br /> ‘gpgKey’ => ‘���������Ù’<br /> }, ‘TestClass’ );<br />

FreezeThaw

<br /> FrT;@1|>>0|$9|TestClass%8|$5|email$6|gpgKey$4|name$6|skills$22|esalazar1981@gmail.com$16|���������Ù%4|$9|firstName$8|lastName$4|Evan$7|Salazar@5|$4|Perl$3|PHP$4|Java$1|C$3|C++<br />

phpser

<br /> O:9:”TestClass”:4:{s:5:”email”;s:22:”esalazar1981@gmail.com”;s:6:”skills”;a:5:{i:0;s:4:”Perl”;i:1;s:3:”PHP”;i:2;s:4:”Java”;i:3;s:1:”C”;i:4;s:3:”C++”;}s:4:”name”;a:2:{s:9:”firstName”;s:4:”Evan”;s:8:”lastName”;s:7:”Salazar”;}s:6:”gpgKey”;s:16:”���������Ù”;}<br />

xmldumper.xml

</p> <perldata> <hashref blessed_package=”TestClass” memory_address=”0x8314de4″><br /> <item key=”email”>esalazar1981@gmail.com</item><br /> <item key=”gpgKey”>���������Ù</item><br /> <item key=”name”><br /> <hashref memory_address=”0x8152c28″><br /> <item key=”firstName”>Evan</item><br /> <item key=”lastName”>Salazar</item><br /> </hashref><br /> </item><br /> <item key=”skills”><br /> <arrayref memory_address=”0x823bcf0″><br /> <item key=”0″>Perl</item><br /> <item key=”1″>PHP</item><br /> <item key=”2″>Java</item><br /> <item key=”3″>C</item><br /> <item key=”4″>C++</item><br /> </arrayref><br /> </item><br /> </hashref> </perldata>

Unserializing the Data

Below is the program that will unseralize the data from the previous program. Note that any binary data will not be unseralized using XML::Dumper. If you need to serialize binary data with this package, consider first encoding it using UUencode or base64 encode.

#!/usr/bin/perl
#####################################################
#Author: Evan Salazar
#Unserialize the data in TestClass
#####################################################
use strict;
use Storable;
use PHP::Serialization;
use FreezeThaw;
use TestClass;
use XML::Dumper;
use Data::Dumper;

#Set Slurp mode for reading
local($/) = undef;

#Open File for reading  Serialized Data
open(PHPSER,    “phpser“);
open(FREEZETHAW, “freezeThaw“);
open(XMLDUMPER, “xmldumper.xml“);
open(DATADUMPER, “dataDumper.pl“);

#Unserialize Using Data::Dumper
print “Data::Dumper\n“;
my $dataDumper = <DATADUMPER>;
#print $dataDumper
my $VAR1;
eval($dataDumper); #Data is stored into variable $VAR1
$VAR1->printAll;
print “\n“;

#Unserialize Using FreezeThaw
print “FreezeThaw\n“;
my $freezeThaw = <FREEZETHAW>;
#print $freezeThaw;
my ($classFreeze) = FreezeThaw::thaw($freezeThaw);
$classFreeze->printAll;
print “\n“;

#Unserialize Using PHP::Serialization
print “PHP::Serializatoin\n“;
my $phpser = <PHPSER>;
#print $phpser;
my $classPHP = PHP::Serialization::unserialize($phpser);
bless($classPHP,‘TestClass‘);
$classPHP->printAll;
print “\n“;

#Unserialize Using XML::Dumper
print “XML::Dumper\n“;
my $xmlDumper = <XMLDUMPER>;
my $dump = new XML::Dumper;
my $xmlClass = $dump->xml2pl($xmlDumper);
$xmlClass->printAll;

Program Output

Data::Dumper
Name: Evan Evan
E-Mail: esalazar1981@gmail.com
Skills: Perl PHP Java C C++
GPG Key: 11061398fe828dcd83a4b9a79594c399

FreezeThaw
Name: Evan Evan
E-Mail: esalazar1981@gmail.com
Skills: Perl PHP Java C C++
GPG Key: 11061398fe828dcd83a4b9a79594c399

PHP::Serializatoin
Name: Evan Evan
E-Mail: esalazar1981@gmail.com
Skills: Perl PHP Java C C++
GPG Key: 11061398fe828dcd83a4b9a79594c399

XML::Dumper

not well-formed (invalid token) at line 4, column 21, byte 148 at /usr/lib/perl5/XML/Parser.pm line 187

If you remove the binary data you will get

Data::Dumper
Name: Evan Evan
E-Mail: esalazar1981@gmail.com
Skills: Perl PHP Java C C++
GPG Key:

FreezeThaw
Name: Evan Evan
E-Mail: esalazar1981@gmail.com
Skills: Perl PHP Java C C++
GPG Key:

PHP::Serializatoin
Name: Evan Evan
E-Mail: esalazar1981@gmail.com
Skills: Perl PHP Java C C++
GPG Key:

XML::Dumper
Name: Evan Evan
E-Mail: esalazar1981@gmail.com
Skills: Perl PHP Java C C++
GPG Key:

Conclusion

All of these methods worked well for the given class, although binary to ASCII encoding is necessary for XML serialization. I personally prefer XML serialization because the data can be used with a wide variety of languages. Also XML serialization is human readable.

Personal data security is often overlooked by many computer users today. As people use their computers more, they never stop to think about how much personal data is accessible on their hard drive. I have been looking for a safe and convenient way to deploy cryptology in Linux. So far Truecrypt has been the best choice. It is very convenient and cross platform. This story will show how to use it on Ubuntu Linux along with some basic data safety principals.

A quick word about data in Linux
One of the first things that fascinated me about Linux is devices are treated as files. For example if you have an IDE hard drive, it is located at /dev/hda or a SCSI hard drive is located at /dev/sda. This is true about all devices in Linux including serial ports /dev/ttyS0 and sound cards /dev/dsp.

You could output the data from these devices as they where any other file, for example you could redirect the data from your hard drive to the standard output using

cat /dev/sda

On most computers this will generate garbage to the screen. It is better to pipe this data to a utility called ‘hexdump’ to see the data in hexadecimal format. Note the -C command will also display the ASCII output

cat /dev/sda | hexdump -C

Using this command will output all of your data to the screen. It is probably not usefully to try to read all the data at once. It is better to use the ‘dd’ utility so you can control how much data you read and write. The parameter ‘if=’ is the device your copying from, ‘bs=’ is the block size and ‘count=’ is the number of blocks to copy.

dd if=/dev/sda bs=512 count=1 | hexdump -C

In this example you can clearly see my boot record. Notice that the copy stops at line 200 where 200 is hexadecimal for 512.

Random data
Two important devices on any Linux system are /dev/random and /dev/urandom. These are both pseudo random number generators. The difference between /dev/random and /dev/urandom is that the second is known as a non-blocking random number generator. To see this we have the following example. Try typing the following into your console.

cat /dev/random | hexdump -C

You will notice that not much data is coming out. If you move your mouse or start opening programs, you will see more output. This is because /dev/random listens to hardware for a good source of true random data. If you try the same example with /dev/urandom you will instantly see lots of data being outputted. This is because urandom will not wait for fresh random data and generate pseudo random filler when needed. This makes it much faster.

Preparing a hard dive for security
Having random data is very important to format ones hard drive. A normal format and even operating re-install will not destroy old data. For example the following pictures are from an old hard drive I installed a fresh copy of Slackware Linux on.


I never did any personal work on this installation. It was was only used once in a hardware experiment. If I pipe the raw data do a program called ‘strings’ which only shows ASCII data then grep my name, I see old e-mails and other personal data from when this hard drive was in my computer running windows XP.

esalazar@manchester:~$ cat /dev/sdb | strings | grep evan | less

For most people this could be very frightening. But yet most people sell or give their old computers away doing nothing but a simple format and re-installation. It is very important to copy random data to the entire hard drive before using. This will ensure that any previous data will be completely erased. It is important to use random data because copying zeros will not be sufficient. In a forensic analysis some bytes will be more “zero” than others leaving all the data available. Some would suggest that the following procedure be carried out 7 times on a drive for maximum security.

dd if=/dev/urandom of=/dev/sdb

On my computer this ran at about 4.3MB (Megabytes) a second. For larger drives you may want to create a simple script to run this 7 times while you sleep. If this is a new drive, one pass should be sufficient.

Installing Truecrypt
Although Truecrypt is open source, there is not yet an available package for Ubuntu in the regular repositories. Therefor true crypt has to be installed manually from the source code (Actually a .deb package was recently released for 7.10). As of this writing the current version is 4.3a and can be downloaded from http://www.truecrypt.org/downloads.php.

Once the source code is downloaded un-tar it in your home folder

tar xvzf truecrypt-4.3a-source-code.tar.gz

If you do not have the kernel source code and compiler packages you can download them with the following command.

sudo apt-get install build-essential build-common
sudo apt-get install linux-source-2.6.22

Where 2.6.20 is your current version, you can use ‘uname -a’ to see your kernel version
Once you finish downloading the packages go to the Linux source folder and un-tar the kernel.

cd /usr/src/linux
sudo tar xvjf linux-source-2.6.22.tar.bz2

Now go to the Trucrypt build folder and type the following to build and install Truecrypt

cd ~/truecrypt-4.3a-source-code/Linux
sudo ./build.sh
sudo ./install.sh

At this point the install of Truecrypt should be complete. You can verify by running ‘truecrypt –help’.

Drive Encryption
Now that Truecrypt is installed and we have a properly formated hard drive we can now encrypt it. I will first start by running in interactive mode with the quick flag. The quick flag disables the copying of random data to the drive. This is not needed in this case because the drive I am using already has random data.

esalazar@manchester:~$ sudo truecrypt –quick -c
Volume type:
1) Normal
2) Hidden
Select [1]:

The first prompt will ask what volume type we are using. For this I am going to create a Normal type. The next prompt ask for the path to the volume. In my case I am going to use /dev/sdb

Enter file or device path for new volume: /dev/sdb
WARNING: Data on device will be lost. Continue? [y/N]: y

For the file type I am going to select none. This is because I plan on using ext3 instead of FAT.

Filesystem:
1) FAT
2) None
Select [1]: 2

Next is the Hash algorithm. I normally go with RIPEMD-160 From my research this looks like the most secure.

Now for the encryption algorithm. Truecrypt gives you the option to chain several algorithms for maximum security. In this example I am going to choose Serpent-Twofish-AES

Encryption algorithm:
1) AES
2) Blowfish
3) CAST5
4) Serpent
5) Triple DES
6) Twofish
7) AES-Twofish
AES-Twofish-Serpent
9) Serpent-AES
10) Serpent-Twofish-AES
11) Twofish-Serpent
Select [1]: 10

Now for the password. You can use a password, key file or both for your security. If you are only using a password make sure to pick a very strong one. More than likely the easiest way to crack your volume will be through a dictionary attack.

Enter password for new volume ‘/dev/sdb’:
Re-enter password:

Enter keyfile path [none]:

Last Truecrypt will need random data to build its internal key. If you are running Truecrypt as root or sudo you can enter random data by moving the mouse.

Please move the mouse randomly until the required amount of data is captured…
Mouse data captured: 100%

Now the drive is complete

Done: 38172.75 MB Speed: 38170.54 MB/s Left: 0:00:00
Volume created.

Filesystem creation
Now that the drive is setup for encryption, we need to put a file system on it. For this example I am going to use ext3. First step is to map the device

esalazar@manchester:~$ truecrypt -i
Enter esalazar’s or root’s system password:
Enter volume path: /dev/sdb
Enter mount directory [none]:
Protect hidden volume? [y/N]:
Enter keyfile path [none]:
Enter password for ‘/dev/sdb’:

Now the hard drive is mapped to ‘/dev/mapper/truecrypt0′ you can verify this by typing ‘truecrypt -l’. This means that any plantext or un-encrypted data that is sent to /dev/mapper/truecrypt0 will be encrypted and written to /dev/sdb. At this point I can create a the ext3 filesystem on /dev/mapper/truecrypt0

esalazar@manchester:~$ sudo mkfs.ext3 /dev/mapper/truecrypt0
mke2fs 1.40.2 (12-Jul-2007)
Filesystem label=
OS type: Linux
Block size=4096 (log=2)
Fragment size=4096 (log=2)
4889248 inodes, 9772224 blocks
488611 blocks (5.00%) reserved for the super user
First data block=0
Maximum filesystem blocks=0
299 block groups
32768 blocks per group, 32768 fragments per group
16352 inodes per group
Superblock backups stored on blocks:
32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632, 2654208,
4096000, 7962624

Writing inode tables: done
Creating journal (32768 blocks): done
Writing superblocks and filesystem accounting information: done

This filesystem will be automatically checked every 25 mounts or
180 days, whichever comes first. Use tune2fs -c or -i to override.

Now that a filesystem is on the drive I can mount it like any other drive.

esalazar@manchester:~$ cd /media
esalazar@manchester:/media$ sudo mkdir mydrive
esalazar@manchester:/media$ sudo mount /dev/mapper/truecrypt0 mydrive/

Now that the drive is mounted I will create home folder for myself that I have access to.

esalazar@manchester:~$ cd /media/mydrive/
esalazar@manchester:/media/mydrive$ sudo mkdir esalazar
esalazar@manchester:/media/mydrive$ sudo chown esalazar:esalazar esalazar/

Now I can access my drive like any other drive.

Un-Mounting / Un-Mapping
Remember that the drive is still vulnerable while mapped. Therefor it is very important to un-map and un-mount when not in use.

esalazar@manchester:~$ sudo umount /dev/mapper/truecrypt0
esalazar@manchester:~$ truecrypt -d

Remember you can verify the drive is un-mapped with ‘truecrypt -l’.

esalazar@manchester:~$ truecrypt -l
No volumes mapped

Headers backup
Since hard drives are prone to failure it is important to backup the Truecrypt header. The header is the key that the entire hard drive is encrypted with along with some meta-data. This key is then encrypted using your password hash as its key. So if one bit gets corrupted in your header none of your data will ever be able to be restored (Not very easily at least). It is also important to remember that the backup of your header will also have to be kept secure because if it is cracked, it can be used to decrypt your data. Use your best judgment on how you want to save your header.

esalazar@manchester:~$ truecrypt –backup-headers mybackup /dev/sdb

Conclusion
Unfortunately I have barely scratched the surface of cryptology. The cryptology Wiki has some excellent information for those who wish to know more. Much of my interest in cryptology came from Neal Stephenson’s book Cryptonomicon. It is a great book with many technical details along with an epic plot. Fell free to send me any suggestions or comments.

For those of you who aren’t familiar with the Basic Stamp, its a small microcontroller available from Parallax. It runs at a whopping 20Mhz and has a full 2K of storage on board for instructions. Although it may not sound like much, its more than enough to program the stamp to do some interesting things. The Basic Stamp is programmed in PBASIC, parallax’s version of BASIC the stamp interprets.

Rather than waste your time explaining the coolness of the Basic Stamp, (if you’ve found this page you’re probably already interested) I want to focus on how it can be utilized under linux. Currently, Parallax has a very nice PBASIC IDE but its available for windows only. It can however be run under Wine, and with the proper font settings it doesn’t look too horrible and is quite functional. But what is the fun in that?

If you’re more of a ‘vim’ guy like me, there’s a better alternative. A quick visit over to sourceforge and you’ll find a set of command line tools available for download that make it easy to tokenize code and send it to the stamp without needing to reboot into windows.

After downloading the tarball, unpack it and move into the directory. All you need to do now is build it, and it shouldn’t require much more than a simple ‘make’.

unpack…

tdavis@tdavis-64:~$ tar xvzf bstamp-2006.05.31.tar.gz
bstamp/
bstamp/bstamp_run.cpp
bstamp/tokenizer.h
bstamp/PBASIC_Tokenizer_Software_Distribution_License.txt
bstamp/pbasic_examples/
bstamp/pbasic_examples/hello.bs2
bstamp/pbasic_examples/Makefile
bstamp/pbasic_examples/touch.bs2
bstamp/Makefile
bstamp/PBASIC_Tokenizer_Software_Distribution_License.pdf
bstamp/TODO.txt
bstamp/GPL.txt
bstamp/README.txt
bstamp/CHANGES.txt
bstamp/COPYING.txt
bstamp/bstamp_tokenize.cpp
bstamp/tokenizer.so
bstamp/error_handling.cpp
tdavis@tdavis-64:~$

move into the directory where you unpacked the tarball…

tdavis@tdavis-64:~$ cd bstamp/
tdavis@tdavis-64:~/bstamp$

and build it…

tdavis@tdavis-64:~/bstamp$ make
tdavis@tdavis-64:~/bstamp$ make install

The last step is to make a symbolic link to whatever serial port your stamp is hooked up to. In my case it was /dev/ttyUSB0 because I’m using a serial to usb converter, but for a regular serial connection its likely to be /dev/ttyS0 or /dev/ttyS1. The symlink needs to point the serial device to a new location, /dev/bstamp. If at any point you encounter any problems, don’t forget to check out the README.txt that comes with the program.

tdavis@tdavis-64:~/bstamp$ sudo ln -s /dev/ttyUSB0 /dev/bstamp

Now you just need some code to tokenize, as an example here’s a simple program I wrote that does nothing more than monitor the light levels off a photo resistor and produce output accordingly. (It beeps and blinks!) Its certainly not the most beautiful code, but it does the trick.

'for Basic Stamp 2
'basic light meter that shows on 7 segment display
'and controls LEDs related to the amount
'of light detected; can also produce
'audio output through a piezo electric
'speaker based on the amount of light detected
'@ Tyler Davis 2007
' {$STAMP BS2}
' {$PBASIC 2.5}
DEBUG "program running!"
index VAR Nib
time VAR Word
dark CON 25
OUTH = %00000000
DIRH = %11111111
'FREQOUT 2, 2000, 4500 'test spk on p2

DO
GOSUB Get_RC 'grab light level info
GOSUB Delay 'delay between refreshes
GOSUB Update_Display
GOSUB sound 'play sound that changes as light
'measurments do
LOOP

Get_RC:
HIGH 0 '0 pin
PAUSE 3
RCTIME 0, 1, time
DEBUG HOME, "time = ", DEC5 time
IF (time > 200) THEN HIGH 6 'for green and
IF (time < 200) THEN LOW 6 'red lights
IF (time < 200) THEN HIGH 4
IF (time > 200) THEN LOW 4
IF (time < 35) THEN HIGH 5
IF (time > 35) THEN LOW 5
IF (time > 400) THEN HIGH 3
IF (time < 400) THEN LOW 3
RETURN
Delay:
PAUSE time
RETURN

sound: 'to create audible sounds related to
'detected illumination levels
FREQOUT 1, 50, time + 4000
RETURN

Now I’m gonna assume you’re using your own code since my code is kind of worthless without a corresponding schematic, but I guess it could be figured out. Since I don’t feel like drawing up one I’ll just post a picture and if someone wants to try and figure it out they’re welcome to. (Sorry but they’re terrible pictures, I’ll try and get better ones up as soon as I get a chance).

Otherwise the process of tokenizing the code and writing it to the stamp is quite straightforward.

tdavis@tdavis-64:~/bstamp$ ./bstamp_tokenize lightmeter.bs2 lightmeter.tokenized
: Success
PBASIC Tokenizer Library version 1.23

tdavis@tdavis-64:~/bstamp$

tdavis@tdavis-64:~/bstamp$ cat lightmeter.tokenized | bstamp_run

If you run into any problems, be sure to verify you’re working with the correct serial device. Try a ‘dmesg | grep ttyS’ and see what it brings up. Or replace ‘ttyS’ with ‘ttyU’ if you have a USB connection.

This project started one night while I was lying in bed trying to visualize how an AC motor worked. I knew that it was different from a DC motor as in it did not require brushes and the speed was controlled by frequency instead of voltage. After some research I came up with this project to better my understanding of AC motors.

AC Theory:
AC Current is different from DC in that the polarity is constantly inverting in a given period. For example: Lets say you have a standard battery hooked up to a volt meter. Normally you would connect the positive lead to the positive terminal of the battery as well as the negative lead to the negative terminal. If you wish to generate an AC current you would connect the leads normally for half a second and then invert them (where the positive terminal is connected to the negative lead and the negative terminal is connected to the positive lead) for another half second. If you constantly repeat this process you will have an AC current operating at one hertz (1hz). Where a hertz is 1 / Period. The period is the time the current is positive plus the time it is negative in one cycle, so in our case 0.5s + 0.5s = 1s per period. In America AC voltage to your home is typically 110 Volts at 60hz in a smooth sine wave.

Quick Magnet Theory:
A more in depth theory about magnets can be found here. For our practical purposes all we need to know is that a magnet has two poles, north and south. Poles attract each other when placed from north to south and repel when placed north to north or south to south.

Quick Electromagnet Theory:
An electromagnet is a magnet that is created with a coil. When current passes through the coil a magnetic flux is created. Conversely when a magnetic field passes through the coil a current is created. More information can be found here.

AC Motor/Generator theory
Most of the information I used to design this motor came from this page. I placed six magnets on the rotor with alternating poles and placed 6 coils in the housing with the polarities also alternating. When an AC current is run through the coils the polarity will switch the magnets poles from north to south at the given frequency. Therefor the rotor will turn so that the poles on the magnets will always line up.

Construction:

After I had a good idea of how I was going to build this motor I needed to collect parts. I already had some bolts that I can use for coils along with copper magnet wire. So off to Hobby Lobby. There I found some ultra strong magnets along with construction Styrofoam.

The base for the motor

Dividing the rotor into 6 sections

The completed measurements

Coil winding:
At this stage I had to determine how strong of an electromagnet I needed for the magnets I bought. Since the magnets are rated at “10” in strength, I had to create a electromagnet with enough magnetic flux to successfully repel the magnet.

Along with determining the proper coil windings, I also had to label the polarity of each magnet. I used a +5V DC power supply to test the coil. After experimenting I decided to use 350 turns with 30 gauge wire.

Once the polarity was determined for the magnets, I placed them in the rotor with hot glue.
The base fully assembled

The base with coils.

After the unit was fully assembled it was time to test it out. First I tested to see if spinning the rotor would generate an AC current. I wired all of the coils in series and hooked them up to the oscilloscope. Spinning the rotor by hand produced a rough sine wave at a about 100mv. Now it is time to try powering the motor. To generate a AC current I used a HP 200A audio oscillator at around 50hz. This device cannot supply much current so I ran it at high voltage (70v) through a step down transformer (110V to 12.6-0-12.6). After playing with lining up the coils I was able to successfully power the motor.

A Video of the Motor running can be found here