Since my last post, I’ve been busy with coding the routines for handling the user input and projecting the construction of the controller. The coding involved a simple bash script that reads the input from the controller. The script determines its action depending on the context of the input and will eventually carry out that action. The user later on reads – in some cases also hears – the result. This is of course, only possible when there is a controller to begin with. The controller’s task is to read input (by reading the state of four buttons and a variable potentiometer), sending this data to the router over a USB connection and sending translated input from the router to an LCD.

Both elements are not finished yet. I’ve ordered all the components necessary and created a schematic of the controller.

The controller

The Arduino I mentioned in my previous post was intended as a controller since I decided to add it to the project. I now have decided that the Arduino is way too functional to be locked in a wooden box, never to be heard from again. After reading several articles and how-to’s on the subject, I found that programming a new Atmel micro controller with the Arduino and using this instead will be cheaper and more interesting than using the Arduino as an easy way out.

And so I’ve gathered the required details and began projecting this new course. There is a practical how-to available that explains how the microcontroller can be integrated into a circuit without blowing it up. It basically describes how to set up the power supply and the crystals in order to make this work. It even covers including a USB break-out adapter to the circuit!

Of course I do not need a power supply as described in the article, since I use the power supply provided by the USB adapter.

The parts I will use:

• 1 x 10k resistor
• 4 x 1k resistor
• 2 x 22pf capacitor
• 4 x strategic push button
• 1 x variable potentiometer
• 1 x Atmel atmega168 microcontroller
• 1 x 16MHZ timer crystal
• 1 x USB to Serial adapter

I’m soldering this on 2 print boards (buttons and variable potentiometer; microcontroller and USB adapter).

Here I want to take a brief moment to talk about software, circuit design software that is. I stumbled on several options, varying from easy-to-use educational software as Yenka (wine!) to professional software (Eagle, Geda, Oregano). I would like to take this opportunity to mention Kicad here. Kicad is simple, well documented and conveys neat 3d modeling. I would say that simpleness is by far the most important reason to go for Kicad, other software solutions out there are simply not simple.

When it comes to designing and simulating basic circuits, Yenka is your friend.

I have used Kicad as a mean to designing the circuit of the controller. The schematic:

Note: the LCD is not included in the bill of materials

This schematic includes the USB to serial adapter, which I made from scratch (other software solutions didn’t provide it either, I’ve checked). Here is the library file which you can import in the library editor in Kicad. The following schematic covers the buttons and the variable potentiometer, pretty basic, but a schematic nonetheless.

I’ve mentioned earlier that I didn’t finish both the script and the controller. I did, however, put some time in designing the end-product in Google’s SketchUp. It is still in ‘beta’ but I believe it is in the right direction. See these images below for an inner and outer view of the wifi internet radio. I’ve added an Arduino Duemillenove to illustrate the controller.

So far so good, my next post will be a somewhat in-depth how-to about building the controller. This will also be added to Circuits For Beginners, a source for other circuit plans and tutorials explaining how to build them.

This post is meant to describe the steps taken in the process of making a Wifi Internet Radio, based upon an idea of Jeff (at mightyohm.com). The project’s goal is to create a stand-alone player for internet music streams over a WiFi-connection. This is done by the help of an Asus wl500GU router combined with a minimal set of input components to support a user in configuring the WiFi-connection (all common encryptions should be supported), adjusting the volume or choosing a radio station. While I was working on this project, I deviated in some extend (some things turned out not to work, or just seemed more satisfying when done differently) of Jeff’s approach in reaching this goal. Because of this, I’m keeping track of my work for my own review later on and for any other person interested.

Current state of the project

So far I’ve managed to:

1. re-flash the router with a self-compiled Open-WRT distribution (Kamikaze 8.09 – following the steps provided by Jeff);
2. successfully made the router play an internet stream (Jeff, also);
3. successfully made an Arduino Duemillanove write to a LCD (What is the title of the song currently playing?);
4. send data from the router to the Arduino (although it is arguable whether the current approach will suffice)

For the first two steps I will advise you to read the posts written by Jeff here. I will try to cover the following two steps, making the current state of the project replicable.

3. Writing “blah” to the LCD

For now, the arduino is loaded with a sketch capable of reading the serial buffer and writing any valid chars to the LCD. The arduino DK comes with a library called ‘LiquidCrystal’, dealing with the communication to the LCD. It pretty much covers a simple 4-bit connection that transmits pre-set character codes. This sketch should handle any input components later on in the project as well.

LCDArduino schema (arduino.nu)

! If you use the schema provided by arduino.nu, don’t forget to connect the E(nable) pin: it’s quite important as I found out.

After everything is set up it’s time to upload the sketch to the Arduino via an usb connection. I’ve written this sketch to let the Arduino receive serial input and send it to the LCD. I figured that a 16 (screen width) x 2 (lines) x 2 (`screens`) configuration provides the best readability.  The script basically scrolls to a ‘new’ set of two lines when the input is higher than 16×2=32 chars, provided that there is no `return` character (numbero 10 in the Arduino ASCII table). The LCD’s buffer didn’t allow any more of these screens so I’ll just see if this suits practical use. I’m thinking of controlling the serial input when this gets too big, before outputting anything from the router.

4. Transmitting ‘Title: Let It Be’ to Arduino

And headaches begin. Apparently, open-wrt on a wl500GU (thus, Kamikaze 8.09 on a broadcom device) is not handling serial transmission correctly. So far I wasn’t able to send a, what would look like, title whatsoever following preached approaches present online. These approaches consist of setting the baud speed to 9600 bps and redirecting an echo to the device brought to light when plugging in the Arduino (open-wrt says /dev/usb/tts/0, my desktop /dev/ttyUSB0). Attempts on my desktop proved this approach being worthy, but the router was not showing any changes other than a short flickering of the display. I could have tried avoiding all, speculated, problems by updating the current 2.4 kernel to 2.6. I haven’t done this however for the simple reason that the router’s wifi capability is not – completely – supported in 2.6. For example, it doesn’t support the WEP encryption method (yet, it seems there is some progress here) – let alone the somewhat unstable state it is in now, considering WiFi. 

This was, of course, not what I wanted so I had to try something else (or dive into the world of drivers: I don’t think I want to be there already). Further experimenting showed that {cat > /dev/usb/tts/0} did work after entering some characters and commiting them with return. Making it possible to show you this:

It may be arguable, as I stated earlier, whether such an approach suffices in a later stage. Mainly because the cat command isn’t really open for input when implementing it in a script. Still, after some struggling with the driver involved (the ftdi one), it seems I am forced – for now- to try reaching the stdin of a process running the cat command. Luckily, this is easily done by redirecting the first-intended {echo} to /proc/#process-id here#/fd/1 (not sure about the number 1, but {ls -al} showed this file was linked with the device involved. Edit (26/10/2009): I’ve learned that the stty command did the job when given the right flags. For a wl500GU router with open-wrt the following command will succeed in communicating with an Arduino: stty -F /dev/ttyUSB0 9600 raw -parenb -parodd cs8 -hupcl -cstopb clocal

Soon, I will describe any further steps taken in building myself an internet radio player.

There is another post! Click here for part two.