I started working on the italian translations of the KDE-PIM programs many years ago, that was my first contribute to the open source software (before I became a professional developer) and of course KDE and the PIM package were my beloved choice for every-day email and addressbook/calendar activities.

The pain started when KDE4 introduced akonadi and all the DB-backed stuff (virtuoso and its companions), let aside the endless configuration and installation problems, kmail it’s now completely unusable: for example I couldn’t make filters work anymore and it suddenly started asking for account’s passwords at reandom.

I’m a bit sad about leaving KMail, it has been a good pal and I liked its rich features and nice UI.

Goodbye KMail, it’s a real pity that KDE it’s slowly committing suicide.

BTW switching to thunderbird was not straight, consider using the utility described in the following link to convert your email folders: Migrating from KMail to Thunderbird

I’ve been recently fascinated by the V-USB project and its interesting applications to the ATtiny85 MCU. There are a couple of articles about its implementation on this tiny MCU but I’ve encountered many problems with the code and this is why I’m writing this notes.

Most notable materials/projects I’ve found on the net are:

• V-USB project website, not specific to Attiny85
• usb tiny project
• I2C tiny USB
• EasyLogger
• Attiny45 V-USB projects , applies to Attiny45
• Code and Life V-USB articles
• Fun-with-attiny-and-v-usb
• how-to-use-v-usb-on-an-attiny85

May  5 10:23:48 darkstar kernel: [ 5060.340336] input: obdev.at EasyLogger as /devices/pci0000:00/0000:00:1d.0/usb6/6-1/6-1:1.0/input/input36
May  5 10:23:48 darkstar kernel: [ 5060.341108] generic-usb 0003:4242:E131.0018: input,hidraw1: USB HID v1.01 Keyboard [obdev.at EasyLogger] on usb-0000:00:1d.0-1/input0
May  5 10:23:49 darkstar kernel: [ 5060.592176] hub 6-0:1.0: port 1 disabled by hub (EMI?), re-enabling...
May  5 10:23:49 darkstar kernel: [ 5060.592190] usb 6-1: USB disconnect, device number 23
May  5 10:23:49 darkstar kernel: [ 5060.852121] usb 6-1: new low-speed USB device number 24 using uhci_hcd
May  5 10:23:49 darkstar kernel: [ 5060.976057] usb 6-1: device descriptor read/64, error -71
May  5 10:23:49 darkstar kernel: [ 5061.204082] usb 6-1: device descriptor read/64, error -71
May  5 10:23:49 darkstar kernel: [ 5061.420119] usb 6-1: new low-speed USB device number 25 using uhci_hcd
May  5 10:23:50 darkstar kernel: [ 5061.544134] usb 6-1: device descriptor read/64, error -71
May  5 10:23:50 darkstar kernel: [ 5061.810138] usb 6-1: unable to read config index 0 descriptor/all
May  5 10:23:50 darkstar kernel: [ 5061.810151] usb 6-1: can't read configurations, error -71
May  5 10:23:50 darkstar kernel: [ 5061.924102] usb 6-1: new low-speed USB device number 26 using uhci_hcd
May  5 10:23:50 darkstar kernel: [ 5062.340078] usb 6-1: device not accepting address 26, error -71
May  5 10:23:50 darkstar kernel: [ 5062.452149] usb 6-1: new low-speed USB device number 27 using uhci_hcd
May  5 10:23:51 darkstar kernel: [ 5062.868115] usb 6-1: device not accepting address 27, error -71
May  5 10:23:51 darkstar kernel: [ 5062.868156] hub 6-0:1.0: unable to enumerate USB device on port 1
May  5 10:23:54 darkstar kernel: [ 5065.648077] hub 2-0:1.0: connect-debounce failed, port 1 disabled

Have fun with Attiny85 and V-USB!

I was simply tired of all that wires on my breadboard and I had a small chunk of a stripboard left from another project.

This small shield (a bit forced since Arduino has a wierd holes matrix and it’s not compatible with a standard  stripboard or protoboard) speeds up the development integrating the hearthbeat led for Arduino ISP when using Arduino as the programmer for the Attiny. I also added the capacitor needed by my Arduino UNO rev. 2 and a spare led for Pin 0 (Pin 5 on the chip) so that I can quick test with a blink if the sketch is running fine.

Today I’ve also adapted my Makefile to work with the Attiny and got rid o that silly IDE.

I’ve just started to explore the Attiny 85 small Arduino’s brother.

To program the chip I’ve successfully followed the guide Programming an ATtiny w/ Arduino 1.0  , just a few quick notes:

• you can use Arduino IDE 1.0, after uploading Attiny Arduino libs into your sketchbook/hardware folder
• in the Arduino IDE: load Arduino as ISP sketch from examples and change in the heartbeat function the delay(40) to delay(20), then upload the sketch on your Arduino board
• prepare the breadboard to flash the Attiny chip
• if you have an Arduino UNO rev.2 you now MUST put a 10uF capacitor between reset and gnd pins on the Arduino board (not sure about other boards)
• in the Arduino IDE: set the board to Attiny 85 (or to your chip type, if differs)
• in the Arduino IDE: set the clock of the Attiny to 8MHz (or whatever you choose), this must be done only the first time you use the chip
• in the Arduino IDE:open the blink sketch, change the pin from 13 to 0
• click the upload upload (if you get errors, see below)

avrdude: stk500_initialize(): programmer not in sync, resp=0x15
avrdude: stk500_initialize(): programmer not in sync, resp=0x15
avrdude: please define PAGEL and BS2 signals in the configuration file for part ATtiny85
avrdude: stk500_program_enable(): protocol error, expect=0x14, resp=0x12
avrdude: initialization failed, rc=-1
         Double check connections and try again, or use -F to override
         this check.

The jungle breadboard

Last night I had an hard time wiring a coupful of connectors to drive an 8×8 led matrix, my breadbord is now really a jungle of wires!

Given that I had no datasheet for the led matrix, I tried several combinations of wiring schemes until I found the right one on http://arduino.cc/playground/Main/DirectDriveLEDMatrix.

Wiring that beast is tedious and making mistakes is really easy, but after a few tries I could successfully run the test sketch.

Second question was what (possibly useless) object to make with the matrix, I saw some cool projects on the net, the most exciting being  a ping-pong clone at http://blog.bsoares.com.br/arduino/ping-pong-with-8×8-led-matrix-on-arduino.

Since I just have one potentiometer I choose a simpler variant, and I tried to implement the whole game from the ground up without looking at someone else’s code.

To drive the matrix I used a MAX7219 chip which only takes three Arduino pins, it has a nice library: http://arduino.cc/playground/Main/LedControl which allows to light single leds, rows and columns independently.

I also used the great http://arduino.cc/playground/Code/Timer library to adjust the ball speed.

This video shows the results of my efforts.

The code still needs some polishing, but it’s basically working.

 
/**
*  Play pong on an 8x8 matrix
*
*    0 1 2 3 4 5 6 7
*  0
*  1
*  2      7 0 1
*  3      6 X 2 (directions)
*  4      5 4 3
*  5
*  6
*  7    [pad]         
*
*
*
*
*/
 
 
#include "LedControl.h"
#include "Timer.h"
 
 
#define POTPIN A5 // Potentiometer
#define PADSIZE 3
#define BALL_DELAY 200
#define GAME_DELAY 10
#define BOUNCE_VERTICAL 1
#define BOUNCE_HORIZONTAL -1
#define NEW_GAME_ANIMATION_SPEED 50
#define HIT_NONE 0
#define HIT_CENTER 1
#define HIT_LEFT 2
#define HIT_RIGHT 3
 
 
//#define DEBUG 1
 
byte sad[] = {
B00000000,
B01000100,
B00010000,
B00010000,
B00000000,
B00111000,
B01000100,
B00000000
};
 
byte smile[] = {
B00000000,
B01000100,
B00010000,
B00010000,
B00010000,
B01000100,
B00111000,
B00000000
};
 
 
Timer timer;
 
LedControl lc = LedControl(4,3,2,1);
 
byte direction; // Wind rose, 0 is north
int xball;
int yball;
int yball_prev;
byte xpad;
int ball_timer;
 
void setSprite(byte *sprite){
    for(int r = 0; r < 8; r++){
        lc.setRow(0, r, sprite[r]);
    }
}
 
void newGame() {
    lc.clearDisplay(0);
    // initial position
    xball = random(1, 7);
    yball = 1;
    direction = random(3, 6); // Go south
    for(int r = 0; r < 8; r++){
        for(int c = 0; c < 8; c++){
            lc.setLed(0, r, c, HIGH);
            delay(NEW_GAME_ANIMATION_SPEED);
        }
    }
    setSprite(smile);
    delay(1500);
    lc.clearDisplay(0);
}
 
void setPad() {
    xpad = map(analogRead(POTPIN), 0, 1020, 8 - PADSIZE, 0);
}
 
void debug(const char* desc){
#ifdef DEBUG
    Serial.print(desc);
    Serial.print(" XY: ");
    Serial.print(xball);
    Serial.print(", ");
    Serial.print(yball);
    Serial.print(" XPAD: ");
    Serial.print(xpad);
    Serial.print(" DIR: ");
    Serial.println(direction);
#endif
}
 
int checkBounce() {
    if(!xball || !yball || xball == 7 || yball == 6){
        int bounce = (yball == 0 || yball == 6) ? BOUNCE_HORIZONTAL : BOUNCE_VERTICAL;
#ifdef DEBUG
        debug(bounce == BOUNCE_HORIZONTAL ? "HORIZONTAL" : "VERTICAL");
#endif
        return bounce;
    }
    return 0;
}
 
int getHit() {
    if(yball != 6 || xball < xpad || xball > xpad + PADSIZE){
        return HIT_NONE;
    }
    if(xball == xpad + PADSIZE / 2){
        return HIT_CENTER;
    }
    return xball < xpad + PADSIZE / 2 ? HIT_LEFT : HIT_RIGHT;
}
 
bool checkLoose() {
    return yball == 6 && getHit() == HIT_NONE;
}
 
void moveBall() {
    debug("MOVE");
    int bounce = checkBounce();
    if(bounce) {
        switch(direction){
            case 0:
                direction = 4;
            break;
            case 1:
                direction = (bounce == BOUNCE_VERTICAL) ? 7 : 3;
            break;
            case 2:
                direction = 6;
            break;
            case 6:
                direction = 2;
            break;
            case 7:
                direction = (bounce == BOUNCE_VERTICAL) ? 1 : 5;
            break;
            case 5:
                direction = (bounce == BOUNCE_VERTICAL) ? 3 : 7;
            break;
            case 3:
                direction = (bounce == BOUNCE_VERTICAL) ? 5 : 1;
            break;
            case 4:
                direction = 0;
            break;
        }
        debug("->");
    }
 
    // Check hit: modify direction is left or right
    switch(getHit()){
        case HIT_LEFT:
            if(direction == 0){
                direction =  7;
            } else if (direction == 1){
                direction = 0;
            }
        break;
        case HIT_RIGHT:
            if(direction == 0){
                direction = 1;
            } else if(direction == 7){
                direction = 0;
            }
        break;
    }
 
    // Check orthogonal directions and borders ...
    if((direction == 0 && xball == 0) || (direction == 4 && xball == 7)){
        direction++;
    }
    if(direction == 0 && xball == 7){
        direction = 7;
    }
    if(direction == 4 && xball == 0){
        direction = 3;
    }
    if(direction == 2 && yball == 0){
        direction = 3;
    }
    if(direction == 2 && yball == 6){
        direction = 1;
    }
    if(direction == 6 && yball == 0){
        direction = 5;
    }
    if(direction == 6 && yball == 6){
        direction = 7;
    }
 
    // "Corner" case
    if(xball == 0 && yball == 0){
        direction = 3;
    }
    if(xball == 0 && yball == 6){
        direction = 1;
    }
    if(xball == 7 && yball == 6){
        direction = 7;
    }
    if(xball == 7 && yball == 0){
        direction = 5;
    }
 
    yball_prev = yball;
    if(2 < direction && direction < 6) {
        yball++;
    } else if(direction != 6 && direction != 2) {
        yball--;
    }
    if(0 < direction && direction < 4) {
        xball++;
    } else if(direction != 0 && direction != 4) {
        xball--;
    }
    xball = max(0, min(7, xball));
    yball = max(0, min(6, yball));
    debug("AFTER MOVE");
}
 
void gameOver() {
    setSprite(sad);
    delay(1500);
    lc.clearDisplay(0);
}
 
void drawGame() {
    if(yball_prev != yball){
        lc.setRow(0, yball_prev, 0);
    }
    lc.setRow(0, yball, byte(1 << (xball)));
    byte padmap = byte(0xFF >> (8 - PADSIZE) << xpad) ;
#ifdef DEBUG
    //Serial.println(padmap, BIN);
#endif
    lc.setRow(0, 7, padmap);
}
 
void setup() {
  // The MAX72XX is in power-saving mode on startup,
  // we have to do a wakeup call
  pinMode(POTPIN, INPUT);
 
  lc.shutdown(0,false);
  // Set the brightness to a medium values
  lc.setIntensity(0, 8);
  // and clear the display
  lc.clearDisplay(0);
  randomSeed(analogRead(0));
#ifdef DEBUG
  Serial.begin(9600);
  Serial.println("Pong");
#endif
  newGame();
  ball_timer = timer.every(BALL_DELAY, moveBall);
}
 
 
void loop() {
    timer.update();
    // Move pad
    setPad();
#ifdef DEBUG
    Serial.println(xpad);
#endif
    // Update screen
    drawGame();
    if(checkLoose()) {
        debug("LOOSE");
        gameOver();
        newGame();
    }
    delay(GAME_DELAY);
}

Driving a 7-segments LED display with Arduino and a DC4511

This IC is basically a BCD (Binary Coded Decimal) to 7-segments driver, you feed it with a 4-bit array and it lights up corresponding segments on the display, additional pins on the IC allow you to switch on and off all leds and to “freeze” (store) the display.

The advantage of using the 4511 is that you can consume just 4 arduino pins instead of the 7 that you would need when controlling the individual display segments one-by-one (set aside the decimal point, which would count to 8).

Note that the 4511 has 7 outputs only, this means that you cannot use it to control the DP (Decimal Point)  rounded led in the display.

I’m using firmata and pyfirmata (see my previous article about firmata: http://www.itopen.it/2012/02/21/arduino-pyfirmata-ldr-semaphore/ )  because I wanted to interactively control what was going on issuing commands on my favourite python shell (http://ipython.org/) .

The code is quite self explanatory, the wiring is listed at the top (see also the picture attached to this article), this script basically counts up and down from 0 to 9 and blinks when reaches 0 and 9.

"""
driving 7 segments led display with a CD4511 IC
 
Wiring:
 
    CD4511    Connection
    1   A1    arduino pin 9
    2   A2    arduino pin 10
    3   LT    arduino pin 3 (lamp test)
    4   BL    arduino pin 2 (blink)
    5   LE    GND
    6   A3    arduino pin 11
    7   A7    arduino pin 8
    8   GND   GND
    9   e     \
    10  d     |     AA
    11  c     |    F  B
    12  b      >    GG
    13  a     |    E  C
    14  g     |     DD
    15  f     /
    16  +5V   +5V
 
"""
import time
from pyfirmata import Arduino, util
board = Arduino('/dev/ttyACM0')
 
# Assign data pins
pins = [board.get_pin('d:'+str(i)+':o') for i in [8, 9, 10, 11]]
# BLank pin
bl = board.get_pin('d:2:o')
# Light Test pin
lt = board.get_pin('d:3:o')
 
def blink():
    """Blink active leds"""
    print "blinking..."
    for i in range(1, 4):
        bl.write(0)
        time.sleep(0.5)
        bl.write(1)
        time.sleep(0.5)
    bl.write(1)
 
def show_digit(num):
    """Shows a digit on the display"""
    print "showing digit %s" % num
    for p in range(0, 4):
        pins[p].write(num % 2)
        num /= 2
 
# Test lamp
print "Testing lamp..."
lt.write(0)
time.sleep(1)
lt.write(1)
bl.write(1)
print "...done"
print "start counting..."
 
cycle = 0
while cycle > 100:
    for d in range(0, 10):
        show_digit(d)
        time.sleep(0.25)
    blink()
    for d in range(9, -1, -1):
        show_digit(d)
        time.sleep(0.25)
    blink()

Firmata is a software library which implements the firmata protocol, better described in the website http://firmata.org/wiki/Main_Page :

Firmata is a generic protocol for communicating with microcontrollers from software on a host computer.

Basically, it allows to send commands on a serial link to an Arduino board from a host PC.

Of course you could open a serial terminal and issue the commands typing on the keyboard, luckily enough libraries that “speaks firmata” are available for all the main programming languages, here I will use pyfirmata, which is a firmata library for python.

To reproduce this experiment, you will need to:

• install firmata binary on Arduino board
• installa pyfirmata on the host
• assemble the circuit on the breadboard
• start sending commands from the host

Part list for the circuit:

• 3 x leds: green red and yellow (it’s a semaphore, after all)
• 3 x 330 ohm resistors to limit current in the leds
• 1 x LDR (light dependent resistor)

Install firmata on Arduino

You should find Firmata on you standard Arduino examples, fire your IDE or search for Firmata on the example folder and load it on the board, here is where I found it on my dev machine:

./arduino-1.0/libraries/Firmata/examples/StandardFirmata/StandardFirmata.ino

You can install it as you would do for an ordinary sketch.

Install pyfirmata on your host PC

You can get the sources from the repository below:

cd
hg clone https://bitbucket.org/tino/pyfirmata
cd pyfirmata
sudo python manage.py install

Now you can connect your board and test the library with a simple LED 13 blink program which turns on and off the on-board LED connected on pin 13:

from pyfirmata import Arduino, util
board=Arduino('/dev/ttyACM0')  # adapt to your device address
ledpin = board.get_pin('d:13:o') # d=digital 13=pin number o=output
ledpin.write(1)
ledpin.write(0)

Green light to go!

Here is the semaphore script, see the picture for the circuit details.

The idea is to control the semaphore through a LDR, when you darken the sensor, the semaphore goes green (after two cycles the program ends).

import time
from pyfirmata import Arduino, util
 
board = Arduino('/dev/ttyACM0')
 
"""
rosso: pin D 8  -> red
giallo: pin D 11 -> yellow
verde: pin D 13 -> green
light pin A 0 -> LDR
 
"""
DELAY=1
GREEN=7
 
# GYR 13 11 8
g = board.get_pin('d:13:o')
y = board.get_pin('d:11:o')
r = board.get_pin('d:8:o')
 
l = board.get_pin('a:0:i')
 
iterator = util.Iterator(board)
iterator.start()
 
r.write(1)
 
def go_green():
	y.write(1)
        time.sleep(DELAY)
	r.write(0)
	g.write(1)
	y.write(0)
	time.sleep(GREEN)
	y.write(1)
	time.sleep(DELAY)
	g.write(0)
	y.write(0)
	r.write(1)
 
cycles = 0
 
while cycles < 2: 	
       val = l.read() 	
       print "Val %s" % val 	
       time.sleep(1) 	
       if val < 0.8:
		cycles+=1
		go_green()
 
board.exit()

egrep -r '#[a-fA-F0-9]{3,6}+(\s|;)' *.css|perl -ne 'if (m/(#[a-fA-F0-9]{3,6}+)(\s|;)/){print "$1\n";}'|sort|uniq

Suggestions and improvements are welcome!

A few months ago I started playing with an Arduino UNO R2 board (yes, the flawed one, I had to solder a diode to convince the board to load sketches…). One of the machines I use for development is ARM based, so I couldn’t use the newest Arduino versions which are downloadable from the website, because  they are available only for 32 and 64 bit architectures.

But the main reason for not using Arduino IDE is that I prefer vim or other IDEs to the one provided with Arduino package.

Finding a working Makefile was not an easy job: I tried first to adapt the old Makefile I was using with the older Arduino codebase but it was clearly not compatibile, after having tried to adapt some other makefiles, finally I discovered a mostly working and very well written Makefile from http://ed.am/dev/make/arduino-mk, I had to patch it to support more configuration overrides and to fix the missing compilation of “c” source utilities from the Wire library.

Meanwhile, I contacted Tim and he was independently fixing the same issues, after a few emails and tests we now have a wonderfull arduino Makefile: thanks Tim!

Advantages of the Makefile approach

Arduino IDE sucks. Ok, I admit it’s nice for beginners and for the click-and-forget kind of programmers, but it needs the full Java stack and hides to the user the fundamental steps involved in compiling and uploading programs to the arduino board.

I (an many other programmers) prefer to understand what I’m doing and running a Makefile from the command line is the way to see the individual steps and choose which to run and when. Finally, I’m not going to drop my favourite editor just to write arduino programs.

If your editor is vim, you will find this syntax highlighter useful: http://www.vim.org/scripts/script.php?script_id=2654.

Prepare your environment

There is nothing particular to do here, what you need is basically:

1. the arduino libraries (source code)
2. the Makefile
3. the avr gcc compiler toolchain (the compiler and linker)
4. avrdude (the program to speak with the MCU and upload the binaries)

Install arduino libraries

You can install the libraries with:

sudo apt-get install arduino

or dowload the latest version from here:

http://arduino.cc/en/Main/Software (follow the source Luke: download the source tarball for Linux)

cd
wget http://arduino.googlecode.com/files/arduino-1.0-src.tar.gz
tar -xzvf arduino-1.0-src.tar.gz

Get the Makefile

then grab the latest Makefile, put it in your sketchbook folder (the folder where your arduino programs are kept, create one if it does not exists, the folder name can be changed if you like):

cd
mkdir sketchbook
cd sketchbook
wget http://ed.am/dev/make/arduino-mk/arduino.mk
ln -s arduino.mk Makefile

The Makefile configuration is normally very limited, you just tell the Makefile which board type you are using (e.g. “uno”) and, in a few cases, where are installed your arduino libraries.

Except for the board type which cannot be guessed in any way,  the Makefile is smart enough to guess all other configuration parameters, which can be overriden setting environment variables for the need.

In the case of manual source installation above, additional configuration would be:

echo "export ARDUINODIR=~/arduino-1.0" >> ~/.bashrc
echo "export BOARD=uno" >> ~/.bashrc
source ~/.bashrc

An important convention is that the program you are going to compile resides in a folder with the same name, see the examples below.

Install the gcc AVR compiler and avrdude

If you have installed arduino with apt-get you have already installed the compiler and avrdude, if you have downloaded the sources, you need to install the compiler and avrdude with:

sudo apt-get install avrdude binutils-avr gcc-avr avr-libc gdb-avr

Test sketch

The steps are:

• create a directory with the same name of the sketch, this must be a subdirectory of the the sketchbook directory you have created above
• create the sketch with your favourite editor and save into the directory, the name must be the same, file extension  can be “.ino” or “.pde”
• connect your board to the USB plug
• compile and upload (in one step)

cd ~/sketchbook
mkdir blink
cd blink
echo "void setup(){pinMode(13,OUTPUT);}void loop(){digitalWrite(13,HIGH);delay(1000);digitalWrite(13,LOW);delay(1000);}" > blink.ino
make -f ../Makefile

That’s all!

I had to patch the plugin to store spl_autoload_functions before registering its own functions, the library method hit a PHP issue which prevents re-registering of spl abstract methods which were registerd by a private constructor of a child class: this definitely makes sense but in this case it’s just an idle complication.

The patched plugin is available for download from my github project page, please report any issue on the tracker.