You can use the USB cable it comes with the get tty access, but I couldn’t be bothered, I’m happy enough to use the provided OS filesystems etc. Just plugged it in, waited a couple of minutes and use the standard root password.

The device was called UBUNTU on my routers config.

The forum at NewIt recommends regerating keys.

As I want to use it for a storage I attached my usb hard drive, typed in ls /dev/ expecting to see an entry for a hdd something like sda1. The drive was lighting up; I could hear it spinning up repeatedly.

Nothing there, so I swapped it for a memory stick, which seems to work fine. I’m guessing that the drive is drawing more than the 500ma that USB are supposed to draw. I installed lsusb and checked for the device, which didn’t appear. I added a hub, with external power supply, and attached the USB drive via that and it worked fine. Now its easy to mount the drive (my drive happens to be a WD Passport:

mkdir /media/WDPassport/
sudo mount /dev/disk/by-label/WD\\x20Passport /media/WDPassport/

Added a new user so that I don’t have to log in as root.

adduser daveh

and add to sudoers list to stop me from making stupid mistakes

visudo

annoyingly it uses vi, add the line with i

daveh ALL=(ALL) ALL

then :wq to write the file and exit

Do an apt-get update so that apt has the correct locations to get packages from.

I changed the MOTD for so I know I’m definitely booting from the SD card.

I’d also like to use it to serve my music up, so I’ve installed mt-daap. This was pretty straight forward.

Create new rule for udev

sudo emacs /etc/udev/rules.d/60-objdev.rules

Edit new rule in emacs and add following:

SUBSYSTEM!=”usb_device”, ACTION!=”add”, GOTO=”objdev_rules_end”

SYSFS{idVendor}==”16c0″, SYSFS{idProduct}==”05df”, GROUP=”users”, MODE=”666″
LABEL=”objdev_rules_end”

For other devices replace the vendor and product id with values you can get from lsusb. For example:

daveh@mbp:~$ lsusb

Bus 001 Device 005: ID 16c0:05df VOTI

Restart udev

sudo /etc/init.d/udev restart

Plug in the cube, and try the command.

In the mean time several of the forum members on eeeuser.com have been attempting to build a mail notifier inspired the LED cube that I’ve built. They’ve put their progress in this thread. Forum member posted some pictures to that thread. They’ve gone a bit further than I have by etching their own PCBs and using SMT components.

Here is the completed circuit controlling a mini lava lamp from forum member AlphaCentauri whom has also adapted with Twitter/ICQ/Mail notifier software, dBird to control the cube.

Here is a tool that will help calculate the correct values for l/h/e fues.

It is possible to turn off the reset pin. When this happens the only option is to use the HV programmer. When the device is dead you might be able to recover them with this HV Rescue Arduino shield. I’m not planning to buy as I’d like to be able to use it with ATTiny45 which it does not support.

I have loads of 3mm red LEDs and I’m going to use 25 of them to make this LED strip. I want each LED to be independently addressable so I have decided to configure the LEDs in a matrix. I’ve previously discussed how to use an LED matrix with an Arduino. If you were to wire the LEDs individually you would need 25 pins, one to control each LEDs. Using a matrix can reduce this.

I begin by wiring up the LED matrix. I decided to use 5 groups of 5 Leds

For each group, of LEDs, solder all the cathodes together. I have attached a black wire to this group and this will be used to connect to the MCU.

Close up of the back of the LED strip

The group’s anodes are then wired together with the corresponding anode from the other groups; the first LED’s anode, from the first group, is wired to the anode of the first LED in each of the other groups. This gives ten wires to control all the LEDs. I’ve soldered each wire to a pin on some PCB header so I should be able to plug it into breadboard, or alternatively a female header when I have made the PCB.

Wiring completed

The LEDs are mounted in a bent strip of acrylic. I bent this over my kitchen hob but I didn’t get particularly good quality results.

The finished LED strip from the front

As usual I first prototype the design on my Arduino. I’ve connected the ground pins to digital pins 2 to 6 and the positive pins to 7 to 11. I’ve again used Port Manipulation for the Arduino. The Arduino wiki advises against using it because it makes things more complicated, but I feel that it actually makes things simpler in this case. 

Here is the Arduino source. The ‘anim’ array contains the display information. Each byte is used to represent the five LED group. You should be able to see the pattern, 1′s mean LED on 0′s mean LED off.

char anim[][5] = {
	{ B00000, B00000, B11111, B00000, B00000},
	{ B00000, B00000, B00111, B11000, B00000},
	{ B00000, B00000, B00011, B11100, B00000},
	{ B00000, B00000, B00000, B11111, B00000},
	{ B00000, B00000, B00000, B01111, B10000},
	{ B00000, B00000, B00000, B00111, B11000},
	{ B00000, B00000, B00000, B00001, B11110},
	{ B00000, B00000, B00000, B00000, B11111},
	{ B00000, B00000, B00000, B00000, B01111},
	{ B00000, B00000, B00000, B00000, B01111},
	{ B00000, B00000, B00000, B00000, B00111},
	{ B00000, B00000, B00000, B00000, B00111},
	{ B00000, B00000, B00000, B00000, B00111},
	{ B00000, B00000, B00000, B00000, B00111},
	{ B00000, B00000, B00000, B00000, B00111},
	{ B00000, B00000, B00000, B00000, B00111},
	{ B00000, B00000, B00000, B00000, B01111},
	{ B00000, B00000, B00000, B00000, B01111},
	{ B00000, B00000, B00000, B00000, B11111},
	{ B00000, B00000, B00000, B00001, B11110},
	{ B00000, B00000, B00000, B00111, B11000},
	{ B00000, B00000, B00000, B01111, B10000},
	{ B00000, B00000, B00000, B11111, B00000},
	{ B00000, B00000, B00011, B11100, B00000},
	{ B00000, B00000, B00111, B11000, B00000},
	{ B00000, B00000, B11111, B00000, B00000},
	{ B00000, B00011, B11100, B00000, B00000},
	{ B00000, B00111, B11000, B00000, B00000},
	{ B00000, B11111, B00000, B00000, B00000},
	{ B00001, B11110, B00000, B00000, B00000},
	{ B00011, B11100, B00000, B00000, B00000},
	{ B01111, B10000, B00000, B00000, B00000},
	{ B11111, B00000, B00000, B00000, B00000},
	{ B11110, B00000, B00000, B00000, B00000},
	{ B11110, B00000, B00000, B00000, B00000},
	{ B11100, B00000, B00000, B00000, B00000},
	{ B11100, B00000, B00000, B00000, B00000},
	{ B11100, B00000, B00000, B00000, B00000},
	{ B11100, B00000, B00000, B00000, B00000},
	{ B11100, B00000, B00000, B00000, B00000},
	{ B11100, B00000, B00000, B00000, B00000},
	{ B11110, B00000, B00000, B00000, B00000},
	{ B11110, B00000, B00000, B00000, B00000},
	{ B11111, B00000, B00000, B00000, B00000},
	{ B01111, B10000, B00000, B00000, B00000},
	{ B00011, B11100, B00000, B00000, B00000},
	{ B00001, B11110, B00000, B00000, B00000},
	{ B00000, B11111, B00000, B00000, B00000},
	{ B00000, B00111, B11000, B00000, B00000},
	{ B00000, B00011, B11100, B00000, B00000},

};

void setGnd(int i)
{
  PORTD &= B10000011;
  PORTD |= (~(1 << (i+2))) & B01111100;
}

void clearGnd()
{
  PORTD |= B01111100;
}

void setLeds(unsigned int frame, unsigned int block)
{
  PORTD &= B01111111;
  PORTD |= B10000000 & (anim[frame][4 - block] <> 1);
}

void setup()
{
  DDRD |= B11111100;
  DDRB = B00001111;
}

void loop()
{
  int frames = sizeof(anim) / (5 * sizeof(char));
  unsigned int t = millis();
  unsigned int f = (t / 40) % frames;
  for (int i = 0; i < 5; ++i)
  {
    setGnd(i);
    setLeds(f, i);
    delay(1);
    clearGnd();
  }
}

As Arduino has much much than I need  I want to simplify the design. Here is a simple circuit using an ATTiny2313 to control the LEDs. The capacitors and the chip on the right are a voltage regulator. The orange LED is a power indicator. This is the first circuit I’ve made using this chip, so I’ve yet to figure it out how to properly program it. I’ve manage to brick two chips so far, so I’m going to investigate fixing them before I continue with the next stage of this project.

Breadboard ATTiny2312 LED controller

Here are the previous posts with the information so far:

• Initial prototype and bread board version
• Firmware and Software
• Schematic and final build

Questions

What toolchain did you use? 

I use Crosspack tool chain (formerly AVR MacPack) 
I also use V-USB (formerly AVR-USB) by the same author as Crosspack. This is a software USB implementation that works great in this scenario when only a small amount of information needs to be transferred.

How do you flash the chip?

I’ve created a small board powered by USB which I can insert the ATTiny into and attach an Atmel ISP mkII. Flashing the program is as simple as typing ‘make program’ from the firmware directory in the code.

Atmel AVR ISP mkII

How much did the components cost?

• ATTiny45 £1.26
• USB Connector £0.29 
• LEDs approx £0.60
• Resistors, Diodes, strip board approx £0.60

The cube itself was a freebie and I could have salvaged the LEDs. I’ve deliberately aimed to keep things simple with as few components as possible. It has cost less than £3 (~$5).

Is it fast enough to do colour fading?

Yes. It uses software PWM to create 24-bit colours. That means the LEDs are turning on and off really quickly to give the impression that they’re either bright or dim and mix in different proportions to create all the shades.

At the moment I just run the executable (in the commandline directory in the code) many times to create the fade. It wouldn’t be too complicated to extend the firmware to add smooth fading or alternatively to the command line tool.

How fast can you change the colours?

Pretty much instantly. However, it depends what you mean by ‘change’. As I mentioned before the LEDs are turning on and off constantly. You are limited by the transfer rate of the USB, but you could add colour fading in the firmware reducing he number of instructions required to change. 

Can I see more pictures?

I probably won’t revisit this project, but I promise to add more to future posts.

My cube is a bit dim how can I make it brighter?

It depends, I have build one board where I have removed the resistors protecting the LEDs as they are rated at approximately 3v. It is also possible to run LEDs at a higher voltage than their max rating if you reduce the duty cycle as described in this article.

The hardware required is very similar to the email notified I built. It is actually possible with a reprogram of the chip to use the same device. However I want to make this small enough to be hidden.

As with all my projects I’m trying to avoid making PCBs or using surface mount devices. I’m sticking with stripboard and normal sized devices. I used the same vertical mount of inline components.

I have removed the USB connector from an old memory stick and, although this is surface mount, the pins are spaced far enough apart to sit on a track each.

When all the parts a soldered and the chip is flashed I tested the device. It doesn’t seem to work on OS X, but fortunately it does on Windows.

Caps locker fob

As for Simon, he was perplexed for about 40 minutes, but saw the funny side when he figured it out

To select each we need use a digital output for both the rows and columns. This means we need we need a total of 12 outputs. It might be possible to reduce this number further, but this will be fine as a first pass as we are not short on IO on the arduino.

The arduino has 13 digital outputs, but two are used for serial communication and I generally avoid using them as we might need them to help debug any problems. Instead I’m going to use the analog pins, which are referred to by using pin 14 to 20.

The arduino’s digital outputs deliver 5v, which is higher than the 2v required for each LED. As we are only going to drive one LED, per output, at a time the circuit decomposes to a standard series LED-resistor. I’ve calculated the value required using a web form using the information from the datasheet.

The column pins connect first to a resistor and then to the normal digital pins of the arduino. The row pins connect directly to the analog pins of the arduino.

The arduino sketch is simple to write, but care must be taken to ensure that the LEDs are on for similar durations, otherwise the will be different brightnesses. It is possible to write directly to the ports but for simplicity I’m going to just use digital write.

Here is the Arduino code, the pins (apins, cpins) need to be specified depending on how you have wired it up.

int ledPin = 13;  
int cpins[] = {15,17,18,16,19,0};
int apins[] = {6,8,7,2,5,3,4,0};
 
int pic0[] = {
  B00010000,
  B01010000,
  B00010000,
  B01010000,
  B00010000
};
 
int pic1[] = {
  B00010000,
  B01011000,
  B00011000,
  B01011000,
  B00010000
};
 
 
int pic2[] = {
  B00011000,
  B01010100,
  B00010100,
  B01010100,
  B00011000
};
 
int pic3[] = {
  B00011100,
  B01010010,
  B00010010,
  B01010010,
  B00011100
};
 
int *anim[] = { pic0, pic1, pic2, pic3, pic2, pic1, NULL };
 
void setup() 
{
  for (int i =0; apins[i]; ++i)
    pinMode(apins[i], OUTPUT); 
    
  for (int i =0; cpins[i]; ++i)
    pinMode(cpins[i], OUTPUT); 
  
}
 
int frame = 0;
unsigned long next_frame = 0;
void loop() 
{
  unsigned long time = millis();
  if (next_frame < time)
  {
    frame += 1;
    next_frame = time + 50;
    if (anim[frame] == NULL)
      frame = 0;
  }
  
  for (int j =0; cpins[j]; ++j)
  {
    for (int i =0; apins[i]; ++i)
    {
      digitalWrite(apins[i], LOW);
    }
    digitalWrite(cpins[j], LOW);
    for (int i =0; apins[i]; ++i)
    {
      digitalWrite(apins[i], anim[frame][j] & (1<<i));
    }
    digitalWrite(cpins[j], HIGH);
  }
}

LED Matrix and Arduino

schematic

NB: 2 is D+ 3 is D- 

When laying out circuits, it is a good idea to, start with the largest component first, in this case, the ATTiny45. I want to program the chip first so I am using a DIL socket. This also has the advantage of protecting the chip from excessive heat when soldering. I’d also like to use as small a board as possible so I am limiting the width to six tracks. Place all the components on the board before soldering so you can get an idea of how large the board needs to be. I followed the layout of the breadboard, however I want to make the circuit small so I have mounted the resistors and diodes vertically, with one leg bent back.

I also tried to avoid cutting tracks with the spot cutter and instead used a knife to allow components to be closer to each other. This requires a sharp knife and care must be taken to cut only one track. Soldering is also more challenging, solder sparingly, to avoid bridging across your cuts.

I cut the tracks under the chip; note that the reset pin is left disconnected. If you needed extra IO you can flash the chip to use it as such but after that you can no longer reprogram it so I avoid that as I may use the chips from previous devices in future things.

I soldered the LEDs at the end of their leads, towards the end of the PCB. This means they will be in the center of the difuser. They also have a series resistor to reduce the AVR output voltage from 3.6V to the approriate level. This resistor may not be required with some ultrabright LEDs.

To fit in the cube, I have removed the circuit, the coin cells and cover. The cube is going to be used as a cover for the new circuit so I have just cut a space using a sharp knife allowing space for the LEDs to fit into the diffuser. The circuit is slotted into the empty cube to complete the device. Plug it in and test it using the libusb command line tool, mentioned in a previous post.

The finished cube

There is a coresponding program using libusb which allows you to send the commands, it simply allows you to set the colour of the cube with an RGB tuple on the command line.

To get the code you need to check out using subversion. To flash the chip you probably want to use the makefile.