This is my second experiment with Energia LaunchPad boards. This time I wanted to see how difficult could be to adapt for the LaunchPad a program which I originally developed for Arduino.

If are interested in how I did setup my Linux box for working with the LaunchPad and the Energia libraries, I’ve described the whole process in this post.

It turned out to be quite easy and the program needed only a few pin configuration changes.

Here is a link to the breadboard schema:

http://www.softwareliberopinerolo.org/images/arduino/D14-N_3_Display_7seg_.jpg

The code:

/**
Display 7 segmenti per corso arduino.

segmenti:    
a   3   P2_4
b   4  P1_1
c   5  P1_2
d   6  P1_3
e   7  P1_4
dp  8  P1_5
f   9  P2_0
g   10 P2_1
Q1  2 transistor unità P2_2
Q2  11 transistor decine P1_7
SW1 12 P2_3
SW2 13 P2_5
*/

#define SW1 P2_3
#define SW2 P2_5

#define DECINE P1_7
#define UNITA  P2_2

#define DEBOUNCE 200

byte valore = 0;
byte decine_attivo = 0;
byte seven_seg_digits[11][7] = {
                                { 0,0,0,0,0,0,0 },  // = blank
                                { 1,1,1,1,1,1,0 },  // = 0
                                { 0,1,1,0,0,0,0 },  // = 1
                                { 1,1,0,1,1,0,1 },  // = 2
                                { 1,1,1,1,0,0,1 },  // = 3
                                { 0,1,1,0,0,1,1 },  // = 4
                                { 1,0,1,1,0,1,1 },  // = 5
                                { 1,0,1,1,1,1,1 },  // = 6
                                { 1,1,1,0,0,0,0 },  // = 7
                                { 1,1,1,1,1,1,1 },  // = 8
                                { 1,1,1,0,0,1,1 }   // = 9
                                };

byte segment_to_pin[8] = {P2_4, P1_1, P1_2, P1_3, P1_4, P2_0, P2_1, P1_5};
unsigned long last_read;
byte led = 0;

void write_digit(byte cifra, bool dp){
    for(int i=0; i<7; i++){
        digitalWrite(segment_to_pin[i], seven_seg_digits[cifra+1][i]);
    }
    digitalWrite(segment_to_pin[7], dp);
}

void setup(){
    for(int p=0; p<8; p++){
        pinMode(segment_to_pin[p], OUTPUT);
        digitalWrite(segment_to_pin[p], HIGH);
    }
    pinMode(DECINE, OUTPUT);
    pinMode(UNITA, OUTPUT);
    pinMode(P1_0, OUTPUT);
    pinMode(P1_6, OUTPUT);
    digitalWrite(P1_0, LOW);
    digitalWrite(P1_6, LOW);
    pinMode(SW1, INPUT);
    pinMode(SW2, INPUT);
    digitalWrite(SW1, HIGH);
    digitalWrite(SW2, HIGH);
    last_read = millis();
}

void blank_digit(){
    for(int i=0; i<7; i++){         
        digitalWrite(segment_to_pin[i], 0);     
    }
    digitalWrite(segment_to_pin[7], 0); 
} 

void loop(){     
    if(digitalRead(SW1) == LOW){         
        if(millis() - last_read > DEBOUNCE){
            valore--;
            digitalWrite(P1_0, led);
            led = ! led;
            last_read = millis();
        }
    }
    if(digitalRead(SW2) == LOW){
        if(millis() - last_read > DEBOUNCE){
            valore++;
            digitalWrite(P1_6, led);
            led = ! led;
            last_read = millis();
        }
    }
    valore = constrain(valore, 0, 99);
    decine_attivo = !decine_attivo;
    if(decine_attivo){
        digitalWrite(UNITA, LOW);
        if(valore/10){
            write_digit(valore/10, 0);
        } else {
            blank_digit();
        }
        digitalWrite(DECINE, HIGH);
    } else {
        digitalWrite(DECINE, LOW);
        write_digit(valore%10, 0);
        digitalWrite(UNITA, HIGH);
    }
    delay(1);
}

A new baby is sitting on my desktop: yesterday arrived the MSP430 powered Launchpad development board.  These few notes describe the steps I did to setup a development environment for this board on Ubuntu Linux 12.04 LTS 64bit.

The launchpad board

Update: at the beginning of March 2012 TI raised the price of LaunchPad board to 10 $ shipping included.

The launchpad board is a low-cost (less than 5 € shipping included) development board based on Texas Instruments MSP430 family microcontrollers, it ships in a nice retail box with two different MCUs, an USB cable and a tiny 32KHz smd crystal ready to be soldered onto the board (you don’t normally need it for the basic operations), the software stack is a gcc backend and a clone of the Arduino IDE and libraries. This stack makes the switch from Arduino environment very easy.

The Arduino-like libraries are named Energia and can be downloaded as pre-packaged binaries from http://energia.nu/download/ or from the GitHub repository: https://github.com/energia/Energia

The community is still smaller than the huge Arduino community but it is growing fast, you can find a couple of useful links at the end of this article.

Some “shields” compatible with LaunchPad are also available on TI store, particularly interesting the capacitive and audio shields, that add a touch interface and MP3 recording/playback capabilities to the device. For an overview of the available LaunchPads, see http://www.ti.com/ww/en/launchpad/overview_head.html

Comparison with Arduino

The intent of TI when they launched their development board was clearly to follow and exploit the huge success of Arduino, this paragraph will attempt to shed some light on similarities and differences of Arduino and LaunchPad+Energia.

Hardware

The Launchpad board is  shipped with two different MCUSs: MSP430G2553 and MSP430G2452, they are both 20 pin devices but the 452 has half the flash and RAM of the 5523.

Comparing MSP430 and Atmega328P is just like comparing apples and oranges but we can try to summarize tha main differences:

What we can tell for sure it that Atmega328P beats MSP430G2553 in Flash and RAM size, but where MSP430 is clearly superior is:

• when used in low power modes
• CPU speed thanks to 16bit architecture
• MCU price: it costs about one third of the Atmega328P
• development board price: ~ 5 $ vs. ~ 25 $ of an Arduino UNO

On the contrary, Arduino compatible shields,  community and software libraries are far ahead of MSP430/Energia.

Installing the software

First you need to install the compiler packages:

binutils-msp430 - Binary utilities supporting TI's MSP430 targets
gcc-msp430 - GNU C compiler (cross compiler for MSP430)
gdb-msp430 - The GNU debugger for MSP430
msp430-libc - Standard C library for TI MSP430 development
msp430mcu - Spec files, headers and linker scripts for TI's MSP430 targets
mspdebug - debugging tool for MSP430 microcontrollers

If you plan to use the Energia libraries which provide an Arduino-like environment, you should download the package from http://energia.nu/download/ and install them in a subfolder of your home directory, I installed them in a folder named “energia”.

To hold my sketches and libraries, I also created a folder named “energia_sketchbook”.

To summarize the steps:

$ sudo apt-get install binutils-msp430 gcc-msp430 gdb-msp430 msp430-libc msp430mcu mspdebug
$ cd
$ mkdir energia_sketchbook
$ wget -O energia.tgz http://energia.nu/download/download.php?file=energia-0101E0009-linux.tgz
$ tar -xzvf energia.tgz
$ mv energia-0101E0009 energia

An additional step is required if you are on a 64bit architecture:

$ cd energia/lib
$ mv librxtxSerial.so librxtxSerial32.so
$ ln -s librxtxSerial64.so librxtxSerial.so

After doing this, you should be able to launch the Energia IDE with

$ cd 
$ energia/energia

Development using a Makefile

I’m the kind of programmer that hates complicated IDEs, moreover I can’t suffer Java(TM), for this reason I tend to use Makefiles to compile MCU code and the first thing I did was to setup a development environment using a Makefile to do all the compilation, linking and upload stuff.

This Makefile is freely adapted from the good job done by Tim Marston at http://ed.am/dev/make/arduino-mk

You can download the latest version of the Makefile from my repository: https://github.com/elpaso/energia-makefile

$ cd
$ cd energia_sketchbook
$ wget https://github.com/elpaso/energia-makefile/raw/master/energia.mk
$ ln -s energia.mk Makefile

The Make must be launched from within the directory containing the sketch you want to compile, the name of the directory must be the same name of the main sketch file which has the Arduino “.ino” file extension.

A couple of environment variables are used to instruct the Makefile where the libraries are located and to build code for the correct MCU (for a complete list of config vars, please refer to the Makefile itself, they are described in details in the header), you can set them once for all using .bashrc:

$ echo 'export ENERGIABOARD=lpmsp430g2553' >> ~/.bashrc
$ echo 'export ENERGIADIR=/home/your_username/energia' >> ~/.bashrc
$ . ~/.bashrc

Hello world!

You are now ready to test your new Launchpad, the “Hello World” program for MCUs is the classic Blink program, which just blinks one of the two leds available on the board, you can just copy the example provided with the Energia IDE:

$ cd
$ cd energia_sketchbook
$ cp -r ../energia/examples/1.Basics/Blink .
$ cd Blink
$ make -f ../Makefile target

You now need to connect the board to your PC with the provided USB cable.

$ make -f ../Makefile upload

If everything went fine, you will see a nice blinking led at 1Hz on your Launchpad board.

The serial nightmare

The board has onboard USB-to-serial logic, but I had a really hard time before I could use it, and it’s still somewhat unstable.

Basically, there are some problems with the acm_cdc driver provided with latest Ubuntu kernels, I could make it work following the instructions on https://github.com/energia/Energia/wiki/Linux-Serial-Communication

More info in this post (and previous pages):
http://e2e.ti.com/support/low_power_rf/f/156/t/53610.aspx?pi239031349=3

You will need to compile a patched kernel module named cdcacm (the stock module is called cdc_acm), and you mileage may vary, after compiling and loading the patched module I was able to read from serial just doing:

$ cat /dev/ttyACM1

Sometimes I still need to unload and reload the module with:

$ sudo rmmod cdc_acm
$ sudo modprobe cdcacm

Conclusions

Arduino and Energia differs too much, but I think they are both interesting devices, given the very low price of MSP430 and the Arduino-like development environment I feel that I will be using this MCUs wherever I can as long as I don’t need much flash and RAM.

Flash, RAM, community, libraries and examples are what make Arduino great, let’s see if Energia community will grow  fast and if TI will release more powerful MCUs for this interesting development board.

Useful links

• http://www.ti.com/ww/en/launchpad/overview_head.html
• http://processors.wiki.ti.com/index.php/Open_Source_Projects_-_MSP430
• http://energia.nu/
• https://github.com/energia/Energia
• https://github.com/elpaso/energia-makefile
• http://forum.43oh.com/forum/28-energia/

Happy hacking!

See also my new article about MSP430:

http://www.itopen.it/2013/03/18/driving-a-pair-of-7-segments-display-with-msp430-energia-libraries/

Recently we have upgraded our multi-site Django-based platform (see: MapSlow) to support OpenStreetMap routing with OSRM.

OSRM is a lightning fast routing server that uses OpenStreetMap data to calculate routes based on different routing profiles, the system is very flexible and configurable, you can setup profiles for car, foot, and bicycle and decide every detail about where the different users (pedestrian, cyclists etc.) can pass trough or cross.

The process of preparing OSM data  for routing requires high CPU and RAM resources and quite a lot of time, we are using a 16 cores and 32 GB RAM virtual instance and the full update takes about 90′ for each profile (for Italy only!!), of course we are running this process (weekly) in the background, at night while server load is typically low.

Since we are using three different profiles, we need three independant OSRM server instances, each running instance requires a huge amount or RAM, for this reason we chose such a powerful server.

We are really satisfied with OSRM, the performances are very good and response is ligthning fast, allowing for a richful UX: while the user drags a waypoint the routes are immediately updated on the screen.

The only missing piece is the ability to use altitude data, this can be a problem when calculating routes for bicycle and foot profiles because they should really take altitude into account to calculate the shortest paths in terms of time.

The viewer

The map interface is developed with GeoEXT (an EXTJs and OpenLayers wrapper or as stated in the project’s page: a JavaScript Toolkit for Rich Web Mapping Applications), we managed to write an adapter to query the OSRM server and parse the JSON response to display vector data into the map canvas.

Driving directions are also processed to build a road-book composed by detailed maps and waypoints, with  turn-by-turn routing instructions.

Conclusions

OSRM is a very good and robust project, well suited for fast routing applications. It has fully configurable profiles but each server instance support only one profile at a time, leading to increasing resources requirements as the number of needed profiles grows up.

The only important missing feature is the ability to use a DTM (Digital Terrain Model) to ajust driving speeds in not-flat areas, this obviously leads to wrong shortest (timewise and lengthwise) path calculations in most mountain and hill areas.

This little project was born to build a present for my son’s birthday, I had a couple of components laying around and I decided to make something new.

Goals

• build an easy-to-use alarm clock with a personal touch
• use only components I already had in stock
• use as few components as possible
• low power consumption
• learn to solder some SOIC components

Design decisions

• project a 3.3V circuit
• use a 64 led matrix for the display…
• a rotary encoder with integrated pushbutton for the controls
• an RGB led to change the clock color while the time passes (60′ cicle)
• sometimes print some random messages addressed to my son
• play a small song once every hour at his birthday
• play a custom alarm music
• an LDR sensor to adjust display and RGB brightness in the dark

The project ended up using:

• ATMEGA328P-PU for the MCU, clocked @ 8MHz using internal oscillator and running @ 3.3V
• DS1388 SOIC for the RTC (unfortunately DS1307 doesn’t run @ 3.3V)
• an 8OHM speaker for the sound
• an AS1107  SOIC to drive the matrix (MAX7219 does not officialy run @ 3.3V even if it seemed ok to me when I tested it on the breadboard)

Here is the scheme:

And my beloved jungle-breadboard

Building the board

Placing components was the most difficult and tedious work, I had to keep the board small and I only had 100x70mm boards available.

This was my first project using soic components, initially I was a bit scared about that, but it wasn’t too hard after all.

I used the toner-transfer technique to prepare the PCB:

… and HCL + H2O2 to etch the board:

And finally: some more photos on Flickr and a short and ugly video showing the clock running.

Follow the source Luke! (The code)

The code is very patchy but Just Works (TM) , I used a couple of Arduino libraries and I merged the Pong game I’ve already written as a standalone sketch.

/**
* Matrix Clock
*/

#define DEBUG_CLOCK 0
#define ENABLE_RGB  1 /* rgb led */


// Pins
#define ENCODER_PIN_1   2 // INT0
#define ENCODER_PIN_2   3 // INT1
#define SET_PIN         4 // digital pull up, connected to ENCODER push button
#define LC_PIN_1        8
#define LC_PIN_2        7
#define LC_PIN_3        6
#define ALM_SWITCH_PIN  A3
#define BUZZER_PIN      5 // digital (PWM?) -> BUZZER -> GND
#define RED_PIN         9
#define GREEN_PIN       10
#define BLUE_PIN        11
#define LDR_PIN         A2

// Includes
#include "LedControl.h"
#include "8x8Font.h"
#include "3x5Font.h"
#include <EEPROM.h>
#include "EEPROMAnything.h"
#include <Wire.h>
#include "RTClib.h"
#include "Timer.h"
#include <Encoder.h>
#include "note.h"
#include "messages.h"

#define NO_PORTB_PINCHANGES // to indicate that port b will not be used for pin change interrupts
#define NO_PORTC_PINCHANGES // to indicate that port c will not be used for pin change interrupts
// if there is only one PCInt vector in use the code can be inlined
// reducing latency and code size
// define DISABLE_PCINT_MULTI_SERVICE below to limit the handler to servicing a single interrupt per invocation.
#define       DISABLE_PCINT_MULTI_SERVICE
#include <PinChangeInt.h>

// FSM status
#define CLK_IDLE        0
#define CLK_PLAY        1
#define CLK_SET_ALM_H   2
#define CLK_SET_ALM_M   3
#define CLK_SET_TIM_H   4
#define CLK_SET_TIM_M   5
#define CLK_SET_TIM_S   6
#define CLK_SET_DAT_D   7
#define CLK_SET_DAT_M   8
#define CLK_SET_DAT_Y   9
#define CLK_SET_SPEED   10
#define CLK_SET_LAST    10 // Must be the last: check main code for status changes.

#define POS_CENTER      1
#define POS_LEFT        0
#define POS_RIGHT       2
#define SYM_ALM         0
#define SYM_DATE        1
#define SYM_TIME        2
#define SYM_SETUP       3

// Config
#define BIRTHDAY_M      4
#define BIRTHDAY_D      12
#define CHAR_SPEED      20

// Random message every
#define RANDOM_MSG_EVERY 6 * 60 * 1000 // 13 minutes
#define PRINT_DATE_EVERY_CICLES 5

// Alarm FSM
#define ALM_PLAY        1
#define ALM_STOP        0
#define ALM_CLEARED     2

// Pong
#define PADSIZE 3
#define BALL_DELAY 100
#define GAME_DELAY 9
#define BOUNCE_VERTICAL 1
#define BOUNCE_HORIZONTAL -1

#define HIT_NONE 0
#define HIT_CENTER 1
#define HIT_LEFT 2
#define HIT_RIGHT 3


// Timers
#define TIMEOUT         5000 // millis
#define DELAYED_TIMEOUT 20000 // millis
#define DEBOUNCE        200 // millis between pulses
#define ALM_RESET_AFTER_MINUTES     2 // timer for alarm reset


// Ugly globals...
uint8_t timeH;
uint8_t timeM;
volatile uint8_t timeS;
uint8_t dateD;
uint8_t dateM;
uint8_t dateY;
uint8_t dateW;
uint8_t almH;
uint8_t almM;
//int almDays;
uint8_t brightness = 8;
const uint8_t eeprom_id = 0x99;
DateTime now;
uint8_t print_date;
uint8_t char_speed = CHAR_SPEED;

// store clock status
int clockStatus = CLK_IDLE;


// Used in ISR, keep one-byte-long to avoid disabling INTs

byte alarmStatus = ALM_STOP;
volatile boolean setButtonPressed = false;
volatile unsigned long setButtonBounceTime=0; // variable to hold ms count to debounce a pressed switch

int oldStatus = CLK_IDLE;

// Timers
Timer timer;
volatile int idleTimer = 1000; // set to out of range value
volatile int alarmTimer = 1000;
volatile int storeConfigTimer = 1000;
volatile int ballTimer = 1000;

// Pong
byte direction; // Wind rose, 0 is north
int xball;
int yball;
int yball_prev;
int xpad;


// Sound
//char noteNames[] =     {'C','D','E','F','G','a','b'};
//unsigned int frequencies[] = {262,294,330,349,392,440,494};
//const byte noteCount = sizeof(noteNames); // the number of notes
                                          // (7 in this example)

//notes, a space represents a rest
// char song[] PROGMEM = "CCGGaaGFFEEDDC GGFFEEDGGFFEED CCGGaaGFFEEDDC ";
unsigned int alarm_song[] PROGMEM = {NOTE_C4, NOTE_C4, NOTE_G4, NOTE_G4, NOTE_A4, NOTE_A4, NOTE_G4, SILENCE, NOTE_F4, NOTE_F4, NOTE_E4, NOTE_E4, NOTE_D4, NOTE_D4, NOTE_C4, SILENCE, SILENCE, NOTE_G4, NOTE_G4, NOTE_F4, NOTE_F4, NOTE_E4, NOTE_E4,  NOTE_D4, SILENCE, NOTE_G4, NOTE_G4, NOTE_F4, NOTE_F4, NOTE_E4, NOTE_E4, NOTE_D4, SILENCE, SILENCE, NOTE_C4, NOTE_C4, NOTE_G4, NOTE_G4, NOTE_A4, NOTE_A4, NOTE_G4, SILENCE, NOTE_F4, NOTE_F4, NOTE_E4, NOTE_E4, NOTE_D4, NOTE_D4, NOTE_C4, SILENCE, END_SONG};

//do do re do fa mi   do do re do sol fa  do do do# la fa mi re   do do re do fa mi
// # G G A G C B | G G A G D C | G G + G E C B A | F F E C D C
unsigned int birthday_song[] PROGMEM = {NOTE_G4, NOTE_A4, NOTE_G4, NOTE_C5, NOTE_B4, SILENCE, NOTE_G4, NOTE_A4, NOTE_G4, NOTE_D5, NOTE_C5, SILENCE, NOTE_G4, NOTE_G5, NOTE_E5, NOTE_C5, NOTE_B4, NOTE_A4, SILENCE, NOTE_F4, NOTE_E4, NOTE_C4, NOTE_D4, NOTE_C4, SILENCE, END_SONG};

// Encoder
int encoderCount = 0;
Encoder myEnc(ENCODER_PIN_2, ENCODER_PIN_1);


#if DEBUG_CLOCK

RTC_DS1307 RTC;


// variables created by the build process when compiling the sketch
extern int __bss_end;
extern void *__brkval;
// function to return the amount of free RAM
int memoryFree()  {
    int freeValue;
    if((int)__brkval == 0)
        freeValue = ((int)&freeValue) - ((int)&__bss_end);
    else
        freeValue = ((int)&freeValue) - ((int)__brkval);
    return freeValue;
}
#else

RTC_DS1388 RTC;

#endif


LedControl lc = LedControl(LC_PIN_1, LC_PIN_2, LC_PIN_3,1);

char char_buffer[8];
char char_buffer2[8];
char buf[64];

#if ENABLE_RGB

void setColor(int red, int green, int blue)
{
    analogWrite(RED_PIN, 255-red);
    analogWrite(GREEN_PIN, 255-green);
    analogWrite(BLUE_PIN, 255-blue);
}

//Convert a given HSV (Hue Saturation Value) to RGB(Red Green Blue) and set the led to the color
//  h is hue value, integer between 0 and 360
//  s is saturation value, double between 0 and 1
//  v is value, double between 0 and 1
//http://splinter.com.au/blog/?p=29
void setColorHsv(int h, double s, double v)
{
    byte rgb[3];

    // Make sure our arguments stay in-range
    h = max(0, min(360, h));
    s = max(0, min(1.0, s));
    v = max(0, min(1.0, v));
    if(s == 0)
    {
        // Achromatic (grey)
        rgb[0] = rgb[1] = rgb[2] = round(v * 255);
    } else {
        double hs = h / 60.0; // sector 0 to 5
        int i = floor(hs);
        double f = hs - i; // factorial part of h
        double p = v * (1 - s);
        double q = v * (1 - s * f);
        double t = v * (1 - s * (1 - f));
        double r, g, b;
        switch(i)
        {
                case 0:
                        r = v;
                        g = t;
                        b = p;
                        break;
                case 1:
                        r = q;
                        g = v;
                        b = p;
                        break;
                case 2:
                        r = p;
                        g = v;
                        b = t;
                        break;
                case 3:
                        r = p;
                        g = q;
                        b = v;
                        break;
                case 4:
                        r = t;
                        g = p;
                        b = v;
                        break;
                default: // case 5:
                        r = v;
                        g = p;
                        b = q;
        }
        rgb[0] = round(r * 255.0);
        rgb[1] = round(g * 255.0);
        rgb[2] = round(b * 255.0);
    }
    setColor(rgb[0], rgb[1], rgb[2]);
}



void setColorHueValue(int hueValue, uint8_t brightness)
{
    setColorHsv(hueValue, 1, constrain((double)brightness/15, 0.1, 1));
}

#endif


/*
* Play a note for a given time
*
*
void playNote(char note, int duration)
{
  // play the tone corresponding to the note name
  for (int i = 0; i < noteCount; i++)
  {
    // try and find a match for the noteName to get the index to the note
    if (noteNames[i] == note) // find a matching note name in the array
      //  play the note using the frequency:
      tone(BUZZER_PIN, frequencies[i], duration);
  }
  // if there is no match then the note is a rest, so just do the delay
  delay(duration);
}
*/

/**
* Play a note for a given time
*
*/
void playFrequency(unsigned int note, int duration)
{
    if(note != SILENCE){
        tone(BUZZER_PIN, note, duration);
    }
    delay(duration);
}


/**
* Set IDLE status
*/
void setIdle()
{
    clockStatus = CLK_IDLE;
}


/**
 * Get encoder move
 */
void readEncoder(){
    encoderCount = myEnc.read()/4;
    if(encoderCount){
        myEnc.write(0);
    }
}


/**
 * String message handling
 */


char reverseByte(char b) {
   b = (b & 0xF0) >> 4 | (b & 0x0F) << 4;
   b = (b & 0xCC) >> 2 | (b & 0x33) << 2;
   b = (b & 0xAA) >> 1 | (b & 0x55) << 1;
   return b;
}

void setSprite(char* font){
    for(int r = 0; r < 8; r++){
        lc.setRow(0, r, reverseByte(*(font + r)));
    }
}

void load_char(char i, char* c){
    for(int r = 0; r < 8; r++){
        c[r] = pgm_read_byte((char*)font_data + (i * 8) + r);
    }
}

void merge_char(char* c1, char* c2, char pos){
    for(int r = 0; r < 8; r++){
        c1[r] = (c1[r] << 1) | (c2[r] >> (8 - pos)) ;
    }
}

void print_string(char* s){
    load_char(32, char_buffer);
    bool valid = 1;
    while (valid){
        setSprite(char_buffer);
        load_char(*s ? *s : 32, char_buffer2);
        for(int r = 1; r <= 8; r++){
            if(setButtonPressed){
                return;
            }
            merge_char(char_buffer, char_buffer2, r);
            setSprite(char_buffer);
            delay(char_speed);
        }
        valid = (char) *s;
        s++;
    }
}

void load_digits(char* c, uint8_t digits, uint8_t pos, uint8_t sym){
    for(uint8_t i=0; i<5; i++){
        c[i] = pgm_read_byte((char*)small_font_data + digits / 10 * 5 + i) << 4 | pgm_read_byte((char*)small_font_data + digits % 10 * 5 + i);
    }
    c[5] = 0;
    uint8_t shift = constrain(6 - 3 * pos, 0, 5);
    switch(sym){
        case SYM_ALM:
            c[6] = B00000010 << shift;
            c[7] = B00000101 << shift;
        break;
        case SYM_TIME:
            c[6] = B00000111 << shift;
            c[7] = B00000010 << shift;
        break;
        case SYM_DATE:
            c[6] = B00000111 << shift;
            c[7] = B00000101 << shift;
        break;
        case SYM_SETUP:
            c[6] = 0;
            c[7] = B00000111 << shift;
        break;
    }
}

/**
 * Pong game
 */
void newGame() {
    lc.clearDisplay(0);
    // initial position
    xball = random(1, 7);
    yball = 1;
    direction = random(3, 6); // Go south
    load_char(1, char_buffer);
    setSprite(char_buffer);
    delay(700);
    lc.clearDisplay(0);
}


void setPad() {
    readEncoder();
    xpad = constrain(xpad + encoderCount, 0, 8 - PADSIZE);
}


/**
* Checks if the ball is in contact with the walls
*/
int checkBounce() {
    if(!xball || !yball || xball == 7 || yball == 6){
        int bounce = (yball == 0 || yball == 6) ? BOUNCE_HORIZONTAL : BOUNCE_VERTICAL;
        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 hitSound(){
    playFrequency(NOTE_B4, 2);
}

void moveBall() {
    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;
        }
    }

    // Check hit
    switch(getHit()){
        case HIT_LEFT:
            if(direction == 0){
                direction =  7;
            } else if (direction == 1){
                direction = 0;
            }
            hitSound();
        break;
        case HIT_RIGHT:
            if(direction == 0){
                direction = 1;
            } else if(direction == 7){
                direction = 0;
            }
            hitSound();
        break;
        case HIT_CENTER:
            hitSound();
        break;
    }

    // Check orthogonal directions and borders ...
    // should never happen
    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));
}

void gameOver() {
    load_char(33, char_buffer);
    setSprite(char_buffer);
    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) ;
    lc.setRow(0, 7, padmap);
}

void initGame(){
  randomSeed(analogRead(0));
  newGame();
  ballTimer = timer.every(BALL_DELAY, moveBall);

}

void playGame(){
    while(!setButtonPressed){
        timer.update();
        setPad();
        drawGame();
        if(checkLoose()) {
            gameOver();
            newGame();
        }
        delay(GAME_DELAY);
    }
    timer.stop(ballTimer);
}




/**
* Wake up effect, this is not returning
* check for status from button ISR
*
*/
void wakeUp(const unsigned int* song)
{
    while (pgm_read_word(song) != END_SONG)
    {
        if(alarmStatus != ALM_PLAY || setButtonPressed){
            alarmStatus = ALM_CLEARED;
            setButtonPressed = false;
            return;
        }
        playFrequency(pgm_read_word(song++), 333); // play the note
    }
    delay(4000); // wait four seconds before repeating the song
}


/**
 * Birthday
 */
void check_birthday(){
    unsigned int *song;
    song = birthday_song;
    if(dateD == BIRTHDAY_D && dateM == BIRTHDAY_M && timeH > 9 && timeH < 21){
        load_char(3, char_buffer);
        setSprite(char_buffer);
        while (pgm_read_word(song) != END_SONG)
        {
            playFrequency(pgm_read_word(song++), 333); // play the note
        }
        delay(4000);
    }
}

/**
* Turn off alarm
*/
void stopAlarm(){
    alarmStatus = ALM_CLEARED;
    //digitalWrite(BUZZER_PIN, LOW);
    //digitalWrite(ALM_LED_PIN, LOW);
}


/**
* ISR on FALLING push button
*/
void setSetButtonPressed(){
    // this is the interrupt handler for button presses
    // it ignores presses that occur in intervals less then the bounce time
    if (abs(millis() - setButtonBounceTime) > DEBOUNCE)
    {
        setButtonPressed = true;
        setButtonBounceTime = millis();  // set whatever bounce time in ms is appropriate
    }
}


/**
* Changes clock status
*/
void changeStatus()
{
    clockStatus++;
    if(clockStatus > CLK_SET_LAST){
        setIdle();
    }
    // Start timer
    timer.stop(idleTimer);
    idleTimer = timer.after(TIMEOUT, setIdle);
    setButtonPressed = false;
}

/**
 * Store config to EEPROM
 */
void store_config(){
    // Read EEPROM
    int write = 0;
    write += EEPROM_writeAnything(write, eeprom_id);
    write += EEPROM_writeAnything(write, char_speed);
    write += EEPROM_writeAnything(write, almH);
    EEPROM_writeAnything(write, almM);
}

/**
 * Delayed store config
 */
void store_config_delayed(){
    timer.stop(storeConfigTimer);
    storeConfigTimer = timer.after(DELAYED_TIMEOUT, store_config);
}

/**
 * Adjust clock
 */
void storeDateTime(){
    RTC.adjust(DateTime(dateY, dateM, dateD, timeH, timeM, timeS));
}

/**
 * Adjust brightness
 */
void adjustBrightness(){
    brightness = map(analogRead(LDR_PIN), 0, 1023, 0, 15);
    lc.setIntensity(0, brightness);
#if ENABLE_RGB
    setColorHueValue((uint16_t)timeM * 6, brightness);
#endif

}

/**
 *  Random message
 */
void randomMessage(){
    if(clockStatus == CLK_IDLE){
        strcpy_P(buf, (char*)pgm_read_word(&(messages[random(0, sizeof(messages)/sizeof(char *))])));
        print_string(buf);
    }
}

/**
 * Setup
 */
void setup() {

    // Read Alm from EEPROM
    // Read EEPROM
    if(EEPROM.read(0) == eeprom_id){
        int read = 1;
        read += EEPROM_readAnything(read, char_speed);
        read += EEPROM_readAnything(read, almH);
        EEPROM_readAnything(read, almM);
    } else {
        store_config();
    }

    pinMode(LDR_PIN, INPUT);
    adjustBrightness();

    // LCD
    // The MAX72XX is in power-saving mode on startup,
    // we have to do a wakeup call
    lc.shutdown(0,false);
    /* Set the brightness to a medium values range (0-15) */
    lc.setIntensity(0, brightness);
    /* and clear the display */
    lc.clearDisplay(0);

    // RTC
    Wire.begin();
    RTC.begin();
    if (! RTC.isrunning()) {
        // following line sets the RTC to the date & time this sketch was compiled
        RTC.adjust(DateTime(__DATE__, __TIME__));
    }

    // Encoder & push
    pinMode(SET_PIN, INPUT);
    digitalWrite(SET_PIN, HIGH);
    PCintPort::attachInterrupt(SET_PIN, &setSetButtonPressed, FALLING);

    // Alm enable pin
    pinMode(ALM_SWITCH_PIN, INPUT);
    digitalWrite(ALM_SWITCH_PIN, HIGH); // pull up
    pinMode(BUZZER_PIN, OUTPUT);

    timer.every(1000, adjustBrightness);
    timer.every(RANDOM_MSG_EVERY, randomMessage);

    print_date = 0;
}


/**
 * Loop
 */
void loop() {
    if(setButtonPressed && alarmStatus != ALM_PLAY){
        changeStatus();
    }

    // Read encoder
    readEncoder();

    // Read clock
    now = RTC.now();
    timeH = now.hour();
    timeM = now.minute();
    timeS = now.second();
    dateD = now.day();
    dateM = now.month();
    dateY = now.yoff();

    boolean alarmSwitchClosed;

    alarmSwitchClosed = (digitalRead(ALM_SWITCH_PIN) == LOW); // pull-up, closed is low

    // Check alarm, buttons pressed stop alarm
    int minutes_after_alarm;
    minutes_after_alarm = ((int)timeH * 60 + (int)timeM) - ((int)almH * 60 + (int)almM);


    if(clockStatus == CLK_IDLE && alarmSwitchClosed && alarmStatus == ALM_STOP && minutes_after_alarm == 0){
        alarmStatus = ALM_PLAY;
    }

    if(alarmStatus == ALM_PLAY){
        if(clockStatus == CLK_IDLE && alarmSwitchClosed && !setButtonPressed){
            load_char(13, char_buffer);
            setSprite(char_buffer);
            wakeUp(alarm_song);
        } else {
            stopAlarm();
        }
    }

    if(clockStatus == CLK_PLAY){
        timer.stop(idleTimer);
        initGame();
        playGame();
        idleTimer = timer.after(TIMEOUT, setIdle);
    }

    if(clockStatus > CLK_PLAY){
        uint8_t digits;
        uint8_t pos;
        uint8_t sym;
        switch(clockStatus) {
            case CLK_SET_ALM_H:
                pos = POS_LEFT;
                sym = SYM_ALM;
                digits = almH;
            break;
            case CLK_SET_ALM_M:
                pos = POS_CENTER;
                sym = SYM_ALM;
                digits = almM;
            break;
            case CLK_SET_TIM_H:
                pos = POS_LEFT;
                sym = SYM_TIME;
                digits = timeH;
            break;
            case CLK_SET_TIM_M:
                pos = POS_CENTER;
                sym = SYM_TIME;
                digits = timeM;
            break;
            case CLK_SET_TIM_S:
                pos = POS_RIGHT;
                sym = SYM_TIME;
                digits = timeS;
            break;
            case CLK_SET_DAT_D:
                pos = POS_LEFT;
                sym = SYM_DATE;
                digits = dateD;
            break;
            case CLK_SET_DAT_M:
                pos = POS_CENTER;
                sym = SYM_DATE;
                digits = dateM;
            break;
            case CLK_SET_DAT_Y:
                pos = POS_RIGHT;
                sym = SYM_DATE;
                pos = 2;
                digits = dateY;
            break;
            case CLK_SET_SPEED:
                digits = char_speed;
                pos = POS_CENTER;
                sym = SYM_SETUP;
            break;
        }
        if(encoderCount){
            // reset timeout
            timer.stop(idleTimer);
            idleTimer = timer.after(TIMEOUT, setIdle);
            // Update...
            switch(clockStatus) {
                case CLK_SET_ALM_H:
                    almH += encoderCount;
                    if(almH > 23) almH = 0;
                    store_config_delayed();
                break;
                case CLK_SET_ALM_M:
                    almM += encoderCount;
                    if(almM > 59) almM = 0;
                    store_config_delayed();
                break;
                case CLK_SET_TIM_H:
                    timeH  += encoderCount;
                    if(timeH > 23) timeH = 0;
                    storeDateTime();
                break;
                case CLK_SET_TIM_M:
                    timeM += encoderCount;
                    if(timeM > 59) timeM = 0;
                    storeDateTime();
                break;
                case CLK_SET_TIM_S:
                    timeS += encoderCount;
                    if(timeS > 59) timeS = 0;
                    storeDateTime();
                break;
                case CLK_SET_DAT_D:
                    dateD += encoderCount;
                    if(dateD > 31)dateD = 1;
                    storeDateTime();
                break;
                case CLK_SET_DAT_M:
                    dateM += encoderCount;
                    if(dateM > 12) dateM= 1;
                    storeDateTime();
                break;
                case CLK_SET_DAT_Y:
                    dateY += encoderCount;
                    if(dateY > 99) dateY = 0;
                    storeDateTime();
                break;
                case CLK_SET_SPEED:
                    char_speed+= encoderCount;
                    if(char_speed > 30) char_speed = 10;
                    if(char_speed < 10) char_speed = 30;
                    store_config_delayed();
                break;
           }
        }
        load_digits(char_buffer, digits, pos, sym);
        setSprite(char_buffer);
    } else {
        //strcpy_P(buf, PSTR("Ciao Leo... sono le"));
        //print_string((char*) buf);
#if DEBUG_CLOCK
        //sprintf(buf, "E: %d S: %d", encoderCount, clockStatus);
        //print_string(buf);
        //sprintf_P(buf, PSTR("F:%d"), memoryFree());
        //print_string(buf);
        sprintf_P(buf, PSTR("B:%d"), brightness);
        print_string(buf);
#endif
        sprintf_P(buf, PSTR("%02d:%02d:%02d"), now.hour(), now.minute(), now.second());
        print_string(buf);

        if(print_date++ == PRINT_DATE_EVERY_CICLES){
            print_date = 0;
            sprintf_P(buf, PSTR("%02d-%02d-%d"), now.day(), now.month(), now.year());
            print_string(buf);
        }

        // Show alarm
        if(alarmSwitchClosed && alarmStatus == ALM_STOP){
            sprintf_P(buf, PSTR("%c %02d:%02d"), 13, almH, almM);
            print_string(buf);
        }
    }

    if(timeM == 0){
        check_birthday();
    }

    // Hand timer
    if(alarmStatus != ALM_STOP && minutes_after_alarm >= ALM_RESET_AFTER_MINUTES){
        alarmStatus = ALM_STOP;
    }

     timer.update();

}

An AVR programmer based on LittleWire

Recently I’ve built a small clone of LittleWire Attiny85 based AVR programmer.

A few notes to make it work with my toolchain follows:

Avoid permission errors on Ubuntu 12.10

Due to permissions on USB you can get the following error:

usbtiny_transmit: error sending control message: Operation not permitted

to fix it:

$ cat  /etc/udev/rules.d/10-usbtinyisp.rules
# USBTiny
ATTR{idVendor}=="1781", ATTR{idProduct}=="0c9f", GROUP="plugdev", MODE="0666"
<em id="__mceDel">$ sudo restart udev</em>

unplug and plug the programmer to see the changes.

Burn a bootloader on a factory new Atmega 328P-PU

avrdude -b 19200 -c usbtiny -p m328p -v -e -U efuse:w:0x05:m -U hfuse:w:0xD6:m -U lfuse:w:0xFF:m
avrdude -b 19200 -c usbtiny -p m328p -v -e -U flash:w:optiboot_atmega328.hex -U lock:w:0x0F:m

PwerTags for Joomla! logo

Browse PowerTags documentation!

PowerTags demo site

Key features

Tags can be used to freely organize Joomla! content items (Tagged Items) in a more simple manner, you can attach multiple Tags to a single item and build a menu-like structure with the Tags using the dedicated Modules. Another module can be used to show a tag-cloud and another one can be used to show related items (items that share the same Tags).

Adding tags to item is super-simple: Ajax powered live-search alllows you to scan the existing Tags while you type and to select matching Tags from a list, to reduce the risk of typos and duplicated Tags.

Attaching and detching tags to an Article

Items can be tagged from the Back-End (control panel) and even from the Front-End (public site) (if a view is available for that component).

Style is important, you can associate a different icon to every Tag to style them differently.

What makes this component unique among other tagging tools in the Joomla! galaxy is the level of assistance (this is really what people pays for), its ease of use, its configurability and its rich set of features.

Download

PowerTags for Joomla! is open source software, distributed under AGPL software license and it is also free software, where “free” means that you can do (almost) whatever you want with this software but it does not mean that it costs nothing. We distribute the component only in bundle with paid 12 month support service that costs  15 €.

To receive a copy of PowerTags you are kindly requested to pay us  15 €, using the buttons located at the top or at the bottom of this page. You will receive a regular invoice at the end of the month. After a successful payment,  an email with the download link will be automatically sent to you PayPal’s account email address.

The money you give us will be used to further develop PowerTags and to provide professional assistance and support to those that will need it.

Together with 12 months support you will receive software updates for the same period of time, that means that you can pay just once and use the software forever in how many Joomla installations you like.

Please use the PayPal link at the top of this page, after a successful payment a download link will be sent you automatically.

Thank you for supporting PowerTags project!

Refund policy

We provide a 7 days refund policy (one week), if you are not satisfied with PowerTags you can ask for a refund within 7 days from the purchase and you will get a full refund (we will only keep the small transaction fees and only in case PayPal charge us for those).

Recently I had an error message while migrating and old Joomla! 1.5 site to the new Joomla! 2.5, jupgrade failed with “Migrating undefined” error.

After digging in the code I found a solution:

You have to edit two files:

jupgrade/installation/models/configuration.php
jupgrade/installation/models/database.php

and insert the following line near the top of the script:

require_once JPATH_ROOT.'/jupgrade/libraries/cms/model/legacy.php';

When done (after the failed upgrade), you can retry the migration checking the following options in Jupgrade configuration:

Jupgrade options

3D css view

I’ve just discovered that the latest versions of web developer FF extension supports 3D view of the web pages: super cool!

Look at how nice is the  OpenLayers vector layer stacked on to the background map  layers.

I’ve closed a lot of tickets concerning the python plugin website and added a couple of new features, like the rating/voting system for plugins.

Everybody was really satisfied for the very good organization and liked to come back here for one of the next hackfests.

QGIS is growing fast and demonstrates the pover of free software, thanks to everybody who participated and made this possible!

Here are some pictures of the location and the event:

http://www.flickr.com/photos/45502883@N06/sets/72157631719309094/with/8066288380/

È stato un piacere partecipare a questo evento e incontrare Alexred, Ste e tutti i partecipanti.

Ho caricato la mia presentazione su slideshare:

Il video dell’intervento: