A team at UNC Charlotte has been working on an autonomous vehicle to drag a cart that has sensing equipment. Starting with a stock Honda ATV, different systems were added to give a Renesas processor control of the ATV.  A model airplane receiver was attached to the Renesas to give remote control for Phase 1 of the project. Basically they’ve turned the ATV into a giant remote controlled car.

Later revisions will incorporate LIDAR, cameras, and multiple GPS units so the ATV can autonomously traverse most terrain with a high level of accuracy. Path planning will become a large part of the project at that point.

In a two-part series called “PS3 Fab-to-lab” on IBM’s awesome developerWorks website, [Lewin] explains how to use the Cell Broadband Engine in a PS3 to create an audio-bandwidth spectrum analyzer and function generator. The set up consists of Yellow Dog Linux, an NTSC television, and an external USB sound card to provide the inputs of the spectrum analyzer and the outputs of the function generator. The sound card driver is written to simply capture or send the info in question (audio range only) and the NTSC television as the graphical interface. This hack involves a lot of coding with hardly any example code provided. The article is more of a guide than anything. If anyone gets this working, let us know!

[via Digg]

[photo: Malcom Tredinnick]

GpsPasSion forum member [Ospray] has released a new version of MioPocket. For those of you that don’t know, MioPocket is a great unlock kit for GPS units. It basically unlocks the hidden potential of your GPS so you can access the built-in functionality of a PDA as well as retaining the GPS software. This means you can play music, watch video, play games, read and write office documents, and many other things with the once single-purpose device.

Originally written for Mio brand devices, it has been successfully used on a couple other brands. We’ve seen it on a Navigon 2100 using a modified install. This software can run directly off the SD card, so it can easily be updated or removed.

The fun part is fiddling with the scripts to get the newest releases to work on the Navigon and Magellan devices.

When a baby too small for the regular dialysis machine (similar to the one pictured above) needed help after her kidneys failed, the kind doctor designed and built a smaller version of the machine in his garage, then used it to save six-pound baby Millie Kelly’s life. Since then the machine has continued to be used in similar emergency situations.

[Photo: NomadicEntrepreneur]

We’ll begin by building the solder fume hood. Yes, we said “hood”, not just “extractor”. While there have been some nice fume extractors hacked together, this system integrates all of your soldering tools into and around the fume hood.

The purpose of a fume hood is to draw solder fumes away from the person soldering. Besides the health risks, these fumes are really annoying as they follow that pesky law of the universe: “No matter where you happen to be sitting, solder fumes will float directly towards your face.”

To start, let’s gather materials:

Once all the materials are gathered, we can begin cutting the plastic of the Rubbermaid container. To cut this material, use a plastic scoring tool. When you make your cuts, make sure to repeatedly score the line you want to cut until the blade goes all the way through the plastic. Do not try to score it and snap it like acrylic. This material has a bad tendency to crack in places you didn’t intend. If your plastic cracks, all is not lost. Since the plastic is soft, you can weld the cracks back together by touching it with the tip of a high temperature hot glue gun.

First, we need to cut a hole for the fan in the top of the hood. Take off the cover of the fan and use it to make a hole slightly smaller than the inside diameter of the fan cover in the top center of the hood. The fan is actually going to hang from the top of the hood and pull the fumes out of the hood when turned on.

Once the big hole is made, drill smaller holes for the screws used to hold the fan together. With the nuts on the outside, screw the fan assembly to the top of the hood.

To reattach the top cover of the fan, use some scrap solid core wire or twist-ties to connect the spars on the top cover to the spars on the bottom fan assembly. We used only three twist ties as this is plenty to keep the fan cover in place.

Now we are ready to mount the light. Mark a good place to attach the light in the back top of the hood. It is likely that the mounting screws that came with the lamp are too long. Additionally, the lamp might get too hot. To prevent the lamp from melting the plastic, we cut about five half-inch spacers out of some of the plastic cut off earlier. To make life easier, pre-drill holes in the center of each of the spacers. Use a couple of the spacers on the inside to lower the lamp away from the top of the hood, and then use a few on the outside to cover the sharp points of the protruding screws. Alternatively, encapsulating the screw points on the outside of the hood with hot glue works just as well.

Next, cut the main window of the fume hood. Ours goes all the way across the front and is about 7 inches high. It’s a good idea to start with a smaller hole and expand it to see what feel comfortable for you to use. Make sure it is easy to reach the top back wall of the hood. This is where the controls will go later.

At this point, you can use zip ties to attach the active carbon filter to the top of the fan.

Plug the fan and the light into a powerstrip. Make sure the fan and the light are turned on so you can turn the entire hood on and off from the strip. Plug in the soldering iron and you are ready to go. The adjustable base of the fan is used here to hold the excess wire from the soldering iron; keeping it out of the way.

A slightly more advanced option for the front is to cut another smaller window (about 6.5 by 13.5 inches) just above the first one and add a piece of acrylic. This greatly improves visibility. Make sure to cut the acrylic about a half inch larger than the window to give yourself a surface to glue. Attach the acrylic on the inside of the fume hood with hot glue.

To improve your soldering iron set-up, you can get a professional soldering station. But why spend $50 on a temperature controlled soldering station when you can build your own for cheaper! Afrotechmods has a rough guide to building a great adjustable temperature soldering station.

To install this soldering station into the fume hood, simply cut a hole in the back of the hood large enough to stuff the dimmer and the socket through it from the front side and small enough to make sure the mounting holes still have some plastic to mount to. The box will be attached to the back of the hood, but the faceplate needs to be on the inside.

You’ll notice that there is a different knob on the dimmer switch. We used a scrap knob with a flat bottom (comes complete with cool numbers) on the dimmer switch instead of the stock knob.

Regardless of what soldering station you use, if it doesn’t have auto turn off (which is good for fire prevention), put a grounded AC appliance timer inline with the iron. These timers allow you to automatically turn on or off any AC appliance at any time you want within a 24 hour period, but don’t rely on it to keep your iron turned off, as it will turn it back one every 24 hours. It’s better than nothing and is a cheap option, as they run between 5 and 10 bucks at local hardware and super stores. The one we use has increments of about 15 minutes. Setting it for 30-45 minutes works well.

For some reason, the designers of these timers want to take up all the plug space they can by placing the plug practically in the center on the back of the timer. Luckily, the scrap dimmer knob we found has a low profile, and allows the timer to plug in with little interference to the dimmer. A better option is to get an aquarium timer. These are designed with a better form factor and generally only cover one socket.

Many cheap soldering irons come with a sponge to clean the tip. If you think about it, it’s not really the best idea to use a sponge to clean your soldering iron; it works, but it also cools down the tip of the iron every time you clean it. If you are doing delicate work and clean your tip once every couple of soldering points, this can lead to cold solder joints and bad connections.

Professionals use a flux covered wire mesh to clean the tip. This method draws off the solder and uses flux to clean the tip. Every now and then, you just kind of stab the mesh with your iron a couple of times to clean it off. The problem is that this method costs around $10.

Instead of buying some job specific wire mesh, just use a copper coated scourer to clean your soldering iron tip. Usually used for cleaning pots and pans, these little guys can be picked up at your local grocery store for $1 or so a pack. The copper mesh isn’t coated with flux, but the copper itself will draw the excess solder from the tip of the iron. Do not get the steel scourers, as they are only good for cleaning dishes.

A great addition to our ti
p cleaner is the use of a simple $1 “locker organizer” picked up from the dollar aisle of the local super store. Just shove the scourer into the organizer to keep it from sticking to the iron. The magnet on the bottom will also weigh it down enough to keep it on the table when you make spastic stabs at the scourer in frenzied hacking sessions.

Surface mount soldering is becoming more common amongstl hackers and hobbyists. This work is notorious for being one of the most tedious and annoying practices known to man. Of course, having the right tools for the job helps. The cheapest surface mount rework stations cost upwards of $100. In the past, our own [Will O'Brien] showed how to make your own surface mount reflow iron.

A reflow iron or pen isn’t the only tool you need for surface mount soldering. Sometimes you’ll need a hot plate or oven.

For smaller jobs we’ve found that using a candle warmer can be useful. We got ours for $5 from a super store. The plate might not get completely hot enough to melt the solder by itself, but it does help a lot when you use a soldering iron or a reflow iron by decreasing the time and effort it takes to warm the joints. The sweet spot on these warmers is usually directly in the middle of the black steel plate.

Simply place a PCB in the center of the candle warmer and allow it to raise the temp of the solder joints. Use a reflow pen or soldering iron to heat the particular joint you want the rest of the way. It will take a lot less time to melt the solder this way. This is especially useful when placing surface mount parts, but can also be useful when taking them off of a PCB.

Placing all of these components together inside the fume hood, the Hacker’s Soldering Station is complete. With this project we set out to make a simple, cheap solder fume hood complete with a time and temperature soldering station. We ended up with a great soldering station and fume extractor set up. In fact, this has now replaced one of the WLC100 soldering stations we usually use.

By no means is this a new idea. There have been a lot of magnetic stripe projects and software. This project in particular references the 1992 Phrack article “A Day in the Life of a Flux reversal” by [Count Zero].

[via Hackszine]

The basic design for the RGB keypad came from [JMG]‘s Arduino based Monome clone. He used an Arduino, and multiplexed RGB LEDs with some digital potentiometers to create a color mixing keypad. Since we couldn’t fit the complete 4×4 keypad into a standard 2 gang wall box, we chopped the design down to a 2×4 matrix. This cuts down significantly on the cost to build the keypad and makes the code that much easier to digest.

To build your own RGB keypad, you’ll need the following:

• An electric door strike (Smarthome.com)
• A locking door handle (Any hardware store)
• An Arduino or compatible clone (Sparkfun, adafruit and others)
• 1 TIP120 transistor
• 1 1N4001 diode
• 10 1N4148 diodes
• 4 2n2222 transistors
• 1 Monome style keypad (Sparkfun Electronics)
• 1 Keypad PC board (Sparkfun Electronics)
• 8 RGB LEDs (Sparkfun Electronics)
• 1 7805 voltage regulator
• 4 100 ohm resistors
• 2 150 ohm resistors
• 8 1 kohm resistors

To reliably lock and unlock the door, we ordered an electric door strike. We scored this one as an open box item from Smarthome.com. It’s a 12 Volt DC unit designed just for Schlage commercial door locks. The edge of the strike is slightly recessed from the mounting plate, so it might not work with certain locks. It features a thinner body than the non-recessed version, which will allow us to cut a smaller but deeper hole in the door frame. Without power, the strike stays locked, keeping the locking door shut. When 12 volts is applied to the coil, the strike releases, allowing the door to be pulled open. For the prototype build, you don’t have to purchase a strike just yet; you can use a LED and a resistor to indicate the door lock state for testing your code.

The keypad is actually built from two separate circuits that physically overlap. The input circuit is a simple keypad matrix. To read each button push, the Arduino brings one keypad input line high and checks the voltage of the four output lines in order. The diodes on the PC board prevent feedback across the rows and columns.

The RGB LEDs are lit via a completely separate set of circuits. Each row of like colored LEDs is brightness controlled by a digital potentiometer. The digital pot works just like a normal pot, but it’s digitally controlled by the Arduino. Meanwhile, each column of LEDs is activated by a separate transistor. By quickly changing the resistance and stepping through the columns, each LED will appear to be individually controlled.

The door strike circuit is pretty simple. Since it contains a coil, we’ll treat it like the coil of a stepper motor and use a TIP120 transistor to supply the power. When power is removed from a coil, the collapsing magnetic field creates a current within the coil. To keep the TIP120 from burning out, we’ll add a diode to handle the surge created by the field breakdown.

update: [Triffid] pointed out that the diode is better placed in parallel with the coil to handle the transient surge. He’s correct, but the circuit here has operated perfectly for several months, so you’ll be fine either way.

The traces for the buttons looked a bit challenging to etch at home, so we ordered this PC board that Sparkfun produces for their keypads. Sparkfun helpfully provides the layout for these keys in their eagle library, so you can make your own PCB if you prefer. For reliability, you’ll probably want to have it commercially produced. The board wasn’t really designed to break apart, but after a review of the traces and vias we decided that we could get away with trimming a couple of rows from the board.

We carefully split the board down the middle with a band saw. If you look closely, you can see where some of the vias were actually cut in half. (A paper cutter might work in a pinch) Don’t forget to put on a mask to keep the dust out of your lungs.

Cutting the button pad is much easier. The pads have pre-scored lines that just need a quick swipe of a sharp knife or scissors to separate them.

The new shorter PCB only needs a few parts: some 1N4148 diodes and the RGB LEDs. The silkscreen on the board indicates the direction and position of diodes and LEDs.

Once you solder on the 1n4148 diodes, cut them as close to the PC board as you can. Flat head cutters like these work extremely well. The keypad will sit on this side of the board and we want to make sure that it can sit as flat as possible.

Install the LEDs in the orientation indicated by the silk screen. Carefully push them down into the board until they’re inserted just like this. If you let them stick up too high, they’ll interfere with the keypad buttons being pushed.

Once you’ve soldered all the LEDs in place, clip them flush as well. Then you’ll need to add some cable to jumper from the keypad to the interface board we’ll build. We used some old CAT-5 wiring. Since each axis of the board has eight pins, it’s perfect for the application.

Each RGB LED has three LEDs inside the package. They share a common terminal and have a single separate lead coming out. Because they have different characteristics – that is brightness, current and voltage requirements, we spent some time testing out various combinations. We even murdered a couple of innocent $2 LEDs just for you. Hey, the other two colors are still usable…

After some experimentation, we managed to find the right combination to create some fairly white light. The requirements will vary between manufacturers, but for the Sparkfun LEDs we found that a pair of 100 ohm resistors and a single 150 ohm resistor blended the red, green and blue fairly well.

The color combination was hard on the eyes until we put the keypad over the LED to double check our findings. In real life, you can see some blending lines from the offset of each LED, but it still looks great.

The circuit has plenty of components, but it’s pretty easy to build. We’ll break everything up by section to keep things easy. You can download the all of the schematics, Eagle project files, and code for the Arduino here.

The digital pot has six outputs. Each of these will power a row of red, green or blue LEDs, via a color matching resistor. The digital potentiometer wiring comes directly from this how-to. You can read it if you need more information, or use our quick version:

• Connect AD5206 pins 3, 6, 10, 13, 16, 21 and 24 to 5v.
• Connect pins 1, 4, 9, 12, 15, 18, 19, and 22 to ground.
• Connect pot pin 5 to Arduino pin 10
• Connect pot pin 7 to Arduino pin 11
• Connect pot pin 8 to Arduino pin 13

Grab four 100 ohm resistors and two 150 ohm resistors. Place them in the breadboard in a row with each end in a separate bus. (Across the center of the board is easiest) Connect the six LED leads from the keypad to one end of each resistor – reds get the 150′s and blue and green into the 100′s. Here’s the connection order we used.

• RED3 to a 150 ohm resistor to pot pin 14
• GREEN3 to a 100 ohm resistor to pot pin 11
• BLUE3 to a 100 ohm resistor to pot pin 2
• RED4 to a 150 ohm resistor to pot pin 23
• GREEN4 to a 100 ohm resistor to pot pin 20
• BLUE4 to a 100 ohm resistor to pot pin 17

To ground the LED busses, we’ll be using four 2N2222 transistors. The Arduino will trigger each transistor individually through a 1Kohm resistor. The collector of each transistor connects to a ground line from the keypad. The emitter of each transistor is connected to the ground. The four transistor select lines connect to Arduino pins 0, 1, 2, and 3. Yes, they’re marked Analog in, but it doesn’t matter.

The keypad switch matrix is connected in four columns and two rows. Each of the four columns gets a pull-down resistor. We used 1Kohm resistors for R11, R12, R13, and R14; one lead connects to the columns and the other is grounded.

Arduino pins 2 and 3 should connect to the two ungrounded lines, which are marked SWITCH3 and SWITCH4 on the PC board (5 and 6 on the schematic).

Arduino pins 6, 7, 8, and 9 should connect to the four output lines marked SWT-GND1, SWT-GND2, SWT-GND3, and SWT-GND4 (1-4 on the schematic).

The final version of the board takes a 12VDC input to drive the door lock. We added a 7805 to drop the 12V down to 5V for the Arduino. You don’t need it for the prototype version unless you want to test the striker. The Arduino has an on-board regulator, but 7805′s are cheap and it helps reduce the load on the Arduino’s built in regulator. For code development, we just connected an LED with a resistor to the output line that will control the door lock.

With everything wired in the prototyping board, it’s time to test things out. With any luck, you’ll soon be rewarded by the pulsing, glowing sight of several RGB LEDs under your tender digits.

Programming the Arduino is a snap. Just download the software for your OS here. Now follow the Getting Started guide to get the Arduino software talking to the Arduino board. Once you’ve enjoyed the blinking LED demo, come back here and get your keypad rolling.

Once you’ve set up and tested your Arduino, it’s time to test out your prototype. Download the button_test code from here. Paste it into a new sketch and upload it to the Arduino. Click the serial console button and you should start seeing dots accumulating in the window. If you press a button on the pad, the Arduino should print a message to the console and toggle the lock output state.

Once your buttons are tested, you’ll probably want to try out your LEDs. Grab the RGB_light_fade routine from the same page and upload it to your Arduino. You should get treated to a nice little light show. This is our favorite demo because it really shows off the color mixing capabilities of the digital potentiometer.

With your LEDs and buttons working, you can grab the row_entry_pad_meffect lock code from the same place and upload it. Now the keypad should start flashing blue buttons while it’s idle. On key presses, the keys will change colors. By entering the correct color code, the pad will flash green and unlock the door for 10 seconds. If you go over the limit counter, it will flash red for 30 seconds.

Next time we’ll show you how to make the permanent version of the keypad, walk through the code for the Arduino, make the PC board, cut a custom wall plate, and install the lock strike.

This hack shows how to make a dumb terminal out of a keyboard, LCD screen, and an 8-bit microcontroller. From time to time, a portable dumb terminal can be handy for when you have to rescue a headless server that’s acting up or if you are building a minicomputer out of a WRT, or if you just want to learn how to run a keyboard and LCD screen with a microcontroller. This super simple serial terminal will use RS-232 to control a headless linux system. Additionally, you might want to check into some of the command line interface programs that allow web browsing, AIM and IRC chatting and more directly from the terminal, but nothing beats being able to track your pizzas with this device.

The Linux system in question here will be Linux Mint. It’s a young distro based on Ubuntu that’s gaining a lot of attention lately, though the principles can be used for other Linux distros.

The Hardware:
For this How-To we’ll be using an ATMEGA128 running at 16MHz. Since this device will be communicating through RS-232, we’re going to need a level shifter. RS-232 uses 12 volt signals which will fry our 5V microcontroller. To fix this problem, we’re going to use a MAX233 chip.

This is the schematic of the level shifter circuit.

This is an example layout.

I’m using the ET-AVR stamp module with the stamp board for this project. This dev board is cheap and has the essentials built in. I’ll be using the on board power supply and the MAX232 RS-232 level converter.

The LCD chosen for this project is a very common 4×20 character LCD. These LCDs are really easy to control with a microcontroller(PDF), and even without one(PDF). The HD44780 chip allows for several bit widths for parallel programming, as well as commands, and even custom characters. This LCD has nice software library, which makes it even easier to use.

A more attractive choice would have been to go with a graphical LCD, which are also supported by our library, however, we only had the character LCD on hand.

A common AT keyboard will be used for character input, again these aren’t hard to find, you probably have an extra one laying around somewhere .

If you don’t want to buy the ET-AVR, you can build the circuit for this hack yourself. (Click for larger pic).

A full parts list of above circuit: :

If you would like to use the ET-AVR or some other dev board, you can use this parts list:

The Software:
We used WinAVR with AVRlib installed. AVRlib is a set of libraries that can run servos, set up A/D conversions, etc. It can do pretty much anything else you need it to do. To install WinAVR, get the newest version here and follow the directions on the installer. We generally don’t follow the directions here for installing AVRlib and place it into the include folder of WinAVR installation found at C:/WinAVR/avr/include/AVRlib. This way your included headers are easier to see and find.

eg. #include <AVRlib/servo.h>

Once this is done, you can open up Programmer’s Notepad and begin coding. We’ve already written the code for this project (with room left over for some adventurous readers to modify).

The Keyboard Protocol:
Keyboards use a simple serial communication setup. There are only 2 lines, the DATA and the CLOCK. Generally, nothing is happening on these lines (both the CLOCK and DATA lines are high) until you hit a key. Once a key is pressed, the DATA line goes low. Shortly thereafter, the CLOCK falls. The clock will go for a total of 11 cycles. As this happens, data must be read form the DATA line on the falling edge of the clock. The data is sent from the keyboard in reverse (least significant bit first) with a parity and a stop bit.

The overall data package is:

The Start bit, Parity bit, and Stop bits are going to be ignored in this simple hack.

After the keyboard sends a key’s scancode, it also sends a 0xF0 when the key has been released.

Looking at an example, it is easier to understand. Imagine the ‘m’ key has been hit on the keyboard. The data line goes low to make a start bit, then the scancode is sent with the LSB first, then the parity (odd parity) and a stop bit. Since the scancode for ‘m’ is 0x3A, we should get that value in the data portion of the package. Again, the keyboard sends data LSB first, so since we are expecting 0x3A (binary 00111010) we will actually get the reverse of that (binary 010111100). Just remember to read the data bits from right to left to make it easier to see the scancode. After the data, we’ll receive a 1 in the parity bit to make the package odd parity, then the stop bit. After the scan code has been sent, the keyboard will send another scancode when the button has been released. This release code is always 0xF0 and can be ignored, and it gets handled in the code.

So when ‘m’ is hit, the keyboard sends :

A more advanced explanation on how this works can be found elsewhere.

We must only read the data line as the clock falls to make sure we get good data. We attempted to do this using an external interrupt on the ATMEGA128 and AVRlib’s external interrupts routines. This proved more complicated than it needed to be. We then remembered that not too long ago Sparkfun had posted about some kind of keyboard widget on their site that used an AVR. The code for their keyboard reading routine was really simple and didn’t use external interrupts at all. We modified the “getkey” routine from the one [Nathan] at Sparkfun wrote for their key-counter widget.

Once the scancodes have been read, they must be converted into something useful. As far as we could tell, keyboard scancodes have no mathematical relation to ASCII code so we set up two ASCII lists. Each list is actually an array of ASCII characters. One list has all the values for shifted characters, and another list has the values for unshifted characters. We looked up the ASCII value for each scancode and placed them in the array in order. This allows for a simple way to return the ASCII value of a given scancode.

When you hit the ‘h’ key for instance, the program catches the scancode 0×33 and goes to the 0×33 rd value in that array, which happens to be 0×68, the ASCII value of ‘h’. The resulting ASCII character is sent to the LCD and to the UART, both being controlled by AVRlib to make them easier to deal with.

There are a lot of 0s used as placeholders in the arrays. This is because AVRlib automatically loads the LCD’s CG RAM address 0×00 (the ASCII code for NULL) with a character. Basically, if those codes are send to the LCD, it will just look like garbled mess. We used ’0′ so we could tell what was going in if that were the case.

Extended keys are not currently supported. The Function keys (F1-F12) have been given normal functions used in Linux, but not supported by the rest of the program. For example, pressing F1 sends the same command as “Ctrl+X” in Linux. See the code for the other function keys. Not all the keys are used (purposely) so if you want to add custom functions to the terminal, there’s plenty of space to.

The UART:
The ATMEGA128 has two UART ports. Using the first one (UART0) characters can be sent from the AVR to the terminal, and vice versa. The UART is initialized and set to 9600 baud, 8-bits, no parity, one stop bit. Make sure to set the terminal program to the same settings. We’ll modify Linux later to make sure the settings match.

With AVRlib, using the UART is a breeze. Simply initialize it, give it a baud rate, and you can start sending and receiving data.

Fiddling with Linux:
You’ll either need a monitor and keyboard on the Linux machine, or SSH into the machine and set this up.

There are several good guides on the internet for setting up a Linux machine to use a serial console. However, Linux Mint is based off of Ubuntu, which is a bit different than most OSs when it comes to setting up serial access at boot. This guide explains the basics, but we’ll need to tweak that a little to make it work for us.

First you need to find out if you even have a serial port on your machine. Look at the back and try to find a DB9 connector.

Now you will need to figure out what that serial port is referenced on your machine. Open a terminal window on the machine and enter the following command:

======================================
$ dmesg | grep tty
======================================

The output will be something like this:
======================================
[ 35.742036] serial8250: ttyS0 at I/O 0x3f8 (irq = 4) is a 16550A
[ 35.742435] 00:08: ttyS0 at I/O 0x3f8 (irq = 4) is a 16550A
======================================
This shows that we have 1 serial port on this particular machine. And it is called “ttyS0″.

Now we must set up a way of logging into the serial console. This is handled by the getty process. This process will open the tty port you specify and send a login prompt.

To set this up, we need to create a file in /etc/event.d called ttyS0. Open up your favorite text editor and type in the following:

======================================
start on runlevel 2
start on runlevel 3
start on runlevel 4
start on runlevel 5

stop on runlevel 0
stop on runlevel 1
stop on runlevel 6

respawn
exec /sbin/getty -L 115200 ttyS0 vt102
======================================

Now save this file as /etc/event.d/ttyS0.

Now, that’s fine for the regular users on the machine, but to do things as root, there will have to be a pass in the /etc/securetty file. Go to /etc and use a text editor to open the securetty file. (That’s “securetty”, not “security” ).In this file, type “ttyS0″. This allows that port to have root access. Save the file and close the editor.
Now the final step is to have the console available when the machine boots. To do this, we must modify the grub bootloader. You have to go to /boot/grub and edit the menu.lst file. First go there and make a clean copy of the menu.lst file:

======================================
cp /boot/grub/menu.lst /boot/grub/menu_orig.lst
======================================

Now open menu.lst in a text editor and type the following

======================================
serial --unit=0 --speed=9600 --word=8 --parity=no --stop=1
terminal --timeout=10 serial console
======================================

This first line tells grub that you want ttyS0 to be used (–unit=0) with a baud rate of 9600 (–speed=9600) using 8n1 (–word =8–parity=no –stop=1)

The second line says to display the terminal on both the serial console as well as the screen, if there is one.

If you want to watch the boot messages on the serial console, you can add the following line to the end of the “kernel” line in this file:

======================================
console=ttyS0,9600n8 console=tty0
======================================

Save this file.

Now you should have access to the serial console when you boot, but the default shell is bash. This is bad because bash sends a lot of extra characters when it executes commands. On many terminals, these characters are stripped from displaying, however, it is hard to do that on an LCD, and with only 80 characters, we don’t have much room to spare on our screen. We need to use something a little simpler.

[Fabienne] suggested using sh as the shell to get rid of bash’s weird characters. This worked during tests, so we made it the default shell on the machine. This allows it to automatically load during the boot, making it much easier to use with the device we’ve just made.To do this, simply open a terminal window and type:

======================================
chsh
======================================

This will ask you for your password. Once you enter it, you will see a screen like this:

======================================
Changing the login shell for <username>
Enter the new value, or press ENTER for the default.
Login shell [/bin/bash]
======================================

At this point you need to type the following:

======================================
/bin/sh
======================================

Hitting ENTER again will save this new setting.

Now you are ready to connect the device and see it in action!

Connecting the device:
You can play with this on a windows machine, but its real power is with a Linux machine. If you have a Windows machine, you can now communicate to the device through hyperterminal or some other terminal program. Just plug in a serial cable to the DB9 plug and set the terminal to 8n1 as mentioned above. Typing on the keyboard will display on the terminal and on the LCD.

To use it with the Linux machine, plug in the DB9 to the serial port on the computer, and turn the machine on. The first that that should happen is that the system will ask you to “Press any key to continue”. Hit anything on the keyboard to begin loading the OS. After pressing the key, you should see all the boot information scrolling on the screen. Once this stops, hit “enter”. This will bring up the logon screen (remember setting up the getty?).

Type your login name, and hit enter, then your password. As with most Linux systems, typing in the password field will NOT print to the screen. Go ahead and get an “ls” of your home directory. Notice that the screen isn’t large enough to show all the files and folders. We’ve written in a simple single screen buffer that will show the previous 4 lines displayed on the screen. So this kind of emulates a “Page Up” function.

Now you have the code, and the hardware lists, lets see what you can do with it.

[chris] sent in his own round up of his personal projects.

[Chris Coleman] let me know about hacktherazr. They’ve got some decent guides on customizing just about everything on the things.

[Ben Heck] got sick of emails, so he’s offering to build one more xbox 360 laptop, if you give him a pile of money.

Staring sunday, I’ll be ripping the hell out of my new house (and re-doing most of the upstairs). Do me a favor and keep the tips line brimming over.

[David] has some interesting ideas involving wireless AP antennas and wireless keyboards. How about a cantenna…

Macmod released some of the first entries for their contest. James and Mick submitted their M3 Mobile Mac Mini. That’s a touchscreen lcd mounted in the rear, Up front it’s equipped with video halogen lights and IR range sensors. The chassis is interfaced through a PIC 16F877A controller. You might want to check out the rest of the mods here.