• One Acme Systems Terra board or
• One Acme Systems Fox board with one Daisy-1 Daisy adapter for Fox board G20
• One Daisy-12 protoboard
• One 20cm flat cable with sockets for Acme Daisy Cabling System (FLAT-20CM)
• One Innovations ID-12 RFID reader
• One RFID TAG
• One Panasonic Schottky diode (or other similar diode)
• One 10K resistor

NOTE: if you use the new Innovations ID-12LA RFID reader you don’t need the schottky diode and the 10K resistor and you must connect your reader to a 3V3 pin.

Create your Daisy module

To read your tags in Node you must create a new simple Daisy module. To easy connect your Innovations RFID reader you can use a breadboard like this:

See below the simple schema:

NOTE: the diode represented has another package to simplify the drawing.

Now you can connect your custom Daisy module to your Terra board (of Fox G20 board) using a flat cable. You can use D10 or D13 connector on Terra board (or D17 in Terra board base) or also D1, D6 or D8 on Fox G20 board.

Install software on Terra board

Your Terra board must have Node.js installed: use this instructions for this task. Now install rfid Node module opening your terminal and typing:

mac: ~$ ssh root@debarm-ip

Linux debarm 2.6.39 #9 Sat May 7 10:19:20 UTC 2013 armv5tejl

The programs included with the Debian GNU/Linux system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.

Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
permitted by applicable law.

debarm:~# mkdir rfid
debarm:~# cd rfid
debarm:~/rfid# npm install rfid

Run your test program:

debarm:~rfid# node node_modules/example/example.js

After a few seconds you see in your terminal:

RFID info: using /dev/ttyS2 port on D13 connector
RFID debug: serial /dev/ttyS2 opened
init

and when you place your TAG near the ID-12, you can see:

RFID debug: read TAG 47007650A8C9
TAG 47007650A8C9
err: undefined

Well: now you can manage your TAGs as you want.

What you need

To accomplish this task you need this components:

• One Acme Systems Terra board
• Two IQRF modules (TR-52D)
• One IQRF programmer and debugger (CK-USB-04)
• One SIM card connector
• One Daisy-12 protoboard
• One 20cm flat cable with sockets for Acme Daisy Cabling System (FLAT-20CM)

Prepare your hardware

Before to start you must prepare a simple Daisy board to connect an RF module to your Terra board. This is a very easy step: follow the table and the figure below.

Install RF development environment

To load a firmware into an RF module you need the IQRF IDE: download from the official site and install in your PC.

NOTE: install IQRF IDE before connect your CK-USB-04 programmer.

Install firmware on RF module

The first RF module can be connected to the ttyS4 (or ttyS2) of the Terra board and must have a simple firmware that forward all data read from the serial port into RF buffer to transmit and viceversa. Microrisc provide an example with source code that implement this functionality (UART_LINK.c example). Edit this file as follow:

// *********************************************************************
//                            Aria UART Link
// *********************************************************************
//
// Intended for:
//   HW: - TR-52D
//   OS: - v3.02D
//
// Description:
//   This example works as UART (RS232) link. Received RF packet
//   is sent via UART and vice versa. UART receiving and transmiting use
//   MCU interrupt.
//   The bufferCOM is divided into two 32 B parts. First one works as a TX buffer
//   and second one as a circular RX buffer for UART data.
//   If the delay between RX UART data bytes is greater than 20 ms,
//   it it recognized as the end of the packet and then the packet is forwarded via RF.
//   This delay is measured by the Timer6. 
//
// File:     AriaUartLink.c
// Version:  v1.06                                   
// Revision: 20/04/2013
//
// Revision history:
//   v1.06: 20/04/2013  Added blinking led: the application is running
//   v1.05: 28/08/2012  Modified for OS 3.02D. Interrupt and Timer6 used.
//   v1.04: 19/06/2012  Comments slightly changed.
//   v1.03: 02/04/2012  Tested for baud rate 19200
//   v1.02: 26/03/2012  Modified for OS 3.01D, not tested for baud rate 19200
//   v1.01: 16/03/2011  Modified for OS 3.00.
//   v1.00: 02/06/2010  First release.
//
// *********************************************************************
#include "../../includes/template-basic.h"     // System header files

// *********************************************************************
                                            // Set UART baudrate
#define BD_19200                            // BD_19200, BD_9600, BD_4800
#define BUFFER_SIZE     32                  // DO NOT CHANGE! .. works only with 32

// *********************************************************************

// UART function prototypes
void openUART(void);
void closeUART(void);
void restartUART(void);
uns8 getTxStatusUART(void);
void sendDataUART(uns8 length);
uns8 getRxStatusUART(void);
uns8 getRxByteUART(void);
void copyRxDataUART(uns16 to, uns8 length);
void errorsRecoveryUART(void);
void userIntRoutine(void);
// *********************************************************************

// UART variables
uns8 TxData;                // Number of bytes to transmit
uns8 TxBytePtr;             // Pointer to the byte to be send
uns8 RxData;                // Number of received bytes
uns8 RxBufStartPtr;         // Circular buffer pointers
uns8 RxBufEndPtr;       
bit RxBufOverflow;          // RX buffer overflow flag
// *********************************************************************

void APPLICATION() {    
    openUART();
    
    startCapture();                 // Resets counter of ticks
    startDelay(50);                 // Start a delay (500ms in background)
    pulseLEDG();
    
    while(1) {
        if (!isDelay()) {
            pulseLEDG();
            startDelay(50);
        }
        
        toutRF = 5;

        if (TMR6IF) {                           // Gap between UART bytes was recognized
            TMR6ON = 0;                         // Timer off
            TMR6IF = 0;
            
            if (RxBufOverflow) {
                restartUART();
                continue;
            }
            
            DLEN = getRxStatusUART();
            copyRxDataUART(bufferRF, DLEN);
            pulseLEDR();
            PIN = 0;
            RFTXpacket();
        }
        
        if (checkRF(0)) {
            if (RFRXpacket()) {
                if (DLEN > BUFFER_SIZE)          // TX UART buffer has 32 B
                    DLEN = BUFFER_SIZE;
                    
                while (getTxStatusUART());      // Wait until previous packet is sent
                pulseLEDG();
                copyMemoryBlock(bufferRF, bufferCOM, DLEN);
                sendDataUART(DLEN);             // Send DLEN bytes from UART TX buffer
            }   
        }
    }    
}
// *************************************************************************

void openUART() {                       // Baudrate, 8N1
    TRISC.5 = 1;                        // Pin connected with RX
    TRISC.7 = 1;                        // RX input
    TRISC.6 = 0;                        // TX output
    BAUDCON = 0;                        // Baudrate control setup
                                        // Baudrate @ 8MHz, high speed
#ifdef BD_19200
    SPBRGL = 25;
#elif defined BD_9600
    SPBRGL = 51;
#elif defined BD_4800
    SPBRGL = 103;
#else
    SPBRGL = 51;                        // Default baudrate 9600 bd
#endif
    
    TXSTA = 0b00100100;                 // Async UART, high speed, 8 bit, TX enabled
    RCSTA = 0b10010000;                 // Continuous receiving, enable port, 8 bits
        
    RxData = 0;
    TxData = 0;
    TxBytePtr = 0;
    RxBufEndPtr = 0;
    RxBufStartPtr = 0;
    RxBufOverflow = 0;
                                        // Timer6 setting
    T6CON = 0x7B;                       // Prescaler: x64, Postscaler: x16, Timer: off
    PR6 = 39;                           // Period: cca 20ms for 8 MHz MCU clock
    TMR6IF = 0;
    
    RCIE = 1;                           // UART RX interrupt enable
    _enableUserInterrupt = 1;
}
//-------------------------------------------------------------------------

void closeUART(void) {                  
    _enableUserInterrupt = 0;
    TXEN = 0;
    CREN = 0;
    TXIE = 0;
    RCIE = 0;
}
//-------------------------------------------------------------------------

void restartUART(void) {
    _enableUserInterrupt = 0;
    CREN = 0;
    TXEN = 0;
    TXIE = 0;
    RCIE = 0;
    TxData = 0;
    RxData = 0;
    TxBytePtr = 0;
    RxBufEndPtr = 0;
    RxBufStartPtr = 0;
    RxBufOverflow = 0;
    CREN = 1;
    TXEN = 1;
    RCIE = 1;
    _enableUserInterrupt = 1;
}
//-----------------------------------------------------------------------------

void sendDataUART(uns8 length) {        // Starts sending data in background
    if (length > BUFFER_SIZE)
        length = BUFFER_SIZE;           // UART TX buffer has 32 B
    
    TxData = length;
    TxBytePtr = 0;
    TXIE = 1;                           // UART TX interrupt enable
}
//---------------------------------------------------------------------------

uns8 getTxStatusUART(void) {            // Returns number of bytes waiting to be send
    return TxData; 
}
//-------------------------------------------------------------------------

uns8 getRxStatusUART(void) {            // Returns number of received bytes
    return RxData; 
}
//-------------------------------------------------------------------------

uns8 getRxByteUART() {                  // Get first unread byte from circular RX buffer
    uns8 tmp;

    if (RxData) {
        GIE=0;
        tmp = readFromRAM(bufferCOM + RxBufStartPtr + BUFFER_SIZE);
        RxBufStartPtr = (RxBufStartPtr + 1) % BUFFER_SIZE;
        --RxData;
        RxBufOverflow = 0;
        GIE=1;
        return tmp;
    } else {
        return 0;
    }
}
//-------------------------------------------------------------------------

void copyRxDataUART(uns16 to, uns8 length) {
uns8 i, tmp;

    if (length > BUFFER_SIZE) {
        length = BUFFER_SIZE;
    }

    for (i = 0; i < length; i++) {
        tmp = getRxByteUART();
        writeToRAM(to + i, tmp);
    }
}
//-------------------------------------------------------------------------

void errorsRecoveryUART() {             // OERR and FERR bits recovery - see PIC datasheet
    if (OERR) {                         // Overrun recovery
        CREN = 0;
        CREN = 1;
    }

    if (FERR) {                         // Framing error recovery
        FERR = 0;
    }
}
// ***********************************************************************

#pragma origin 0x3F00                   // This address must not be changed
void userIntRoutine() {                 // User interrupt service routine
    if (RCIF) {                         // Something was received via UART
        errorsRecoveryUART();
        FSR0 = bufferCOM;
        FSR0 = FSR0 + (RxBufEndPtr + BUFFER_SIZE);
        setINDF0(RCREG);
        RxBufEndPtr = (RxBufEndPtr + 1) % BUFFER_SIZE;
        
        if (RxData < BUFFER_SIZE) {
            ++RxData;
        } else {                        // Buffer overflow
            RxBufStartPtr = (RxBufStartPtr + 1) % BUFFER_SIZE;
            RxBufOverflow = 1;
        }
        
        TMR6 = 0;                       // Timer reset
        TMR6ON = 1;                     // Timer on
    }   
    
    if (TXIF && TxData) {               // There is still data to send and UART peripheral is free
        FSR0 = bufferCOM + TxBytePtr;
        TXREG = getINDF0();             // Copies data from bufferCOM to TXREG
        ++TxBytePtr;
        
        if (--TxData == 0) {
            TXIE = 0;                   // No more data to send, clear interrupt flag
        }
    }
}
// *********************************************************************

Now put your first RF module into the programmer and connect it to your PC, open your IQRF IDE and follow the instruction below (see official IQRF help for a detailed instructions):

• create a new project
• edit the module settings according your module
• attach the file above
• compile
• upload

Now remove the RF module and put it into the homemade Daisy module and connect it to your Terra board using the D10 connector (remember to insert the RF module before connect Daisy module).

The second RF module must have a firmware that send an RF packet with desired data to the RF module connected to the Terra board and/or viceversa according your needs. To easy test the functionality, you can use another firmware example (E03-TR.c) and edit it as follow:

// *********************************************************************
// *                       Aria Remote Link                            *
// *                        RF transceiver                             *
// *********************************************************************
// Example of RF transmiter/receiver. Suitable for a PC link.
//
// Intended for:
//   HW: - TR-52D
//   OS: - v3.02D
//  
// Description:
//   - This program applied in two kits is a bidirectional RF-SPI interface.
//   - Received RF data is sent via SPI and vice versa. For sending and
//     receiving SPI data e.g. the IQRF IDE Terminal can be used
//     (See IQRF IDE Help).
//   - Received SPI data is sent via RF.
//   - PIN should be updated in case of bidirectional RF communication
//     before every RF transmission.
//
// File:    AriaRemoteLink.c
// Version: v1.03                                   Revision: 20/04/2013
//
// Revision history:
//   v1.03: 20/04/2013  Added blinking led: the application is running
//   v1.02: 28/08/2012  Tested for OS 3.02D
//   v1.01: 14/06/2012  Tested with TR-54D
//   v1.00: 07/03/2012  First release
//
// *********************************************************************
#include "../includes/template-basic.h"

// *********************************************************************
void APPLICATION() {
    enableSPI();                    
    toutRF = 5;

    startCapture();                 // Resets counter of ticks
    startDelay(200);                // Start a delay (2s in background)
    pulseLEDG();
    
    while (1) {                     // Main cycle (perpetually repeated)
        if (!isDelay()) {
            pulseLEDG();
            startDelay(200);
        }

        if (checkRF(5)) {           // RF signal detection (takes 1ms)
            if (RFRXpacket()) {     // If anything was received
                pulseLEDG();        // LED indication
                copyBufferRF2COM(); // Copy received RF data from bufferRF to bufferCOM
                startSPI(DLEN);     //  and send it via SPI
            }
        }
        
        if (getStatusSPI()) {       // Update SPIstatus, check SPI busy
                                    // SPIpacketLength: data length
             continue;              // Wait until message is picked up
        }
        
        if (_SPIRX) {               // Anything received?
                                    // Yes:
            if (_SPICRCok) {        // CRCM matched?
                                    // Yes:
                DLEN = SPIpacketLength;
                copyBufferCOM2RF(); // Copy received SPI data from bufferCOM to bufferRF
                PIN = 0;
                RFTXpacket();
                pulseLEDG();        // LED indication
            }

            startSPI(0);            // Restart SPI communication
        }
    }
}

// *********************************************************************

Now put this RF module into the programmer and connect it to your PC, open your IQRF IDE and follow the instruction below (see official IQRF help for a detailed instructions):

• create a new project
• edit the module settings according your module
• attach the file above
• compile
• upload

Leave this module plugged into the programmer and see the results into the terminal window.

Install software on Terra board

Last task: install Node.js using this instructions. Open your terminal and type:

mac: ~$ ssh root@debarm-ip

Linux debarm 2.6.39 #9 Sat Apr 13 09:59:50 UTC 2013 armv5tejl

The programs included with the Debian GNU/Linux system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.

Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
permitted by applicable law.

debarm:~# mkdir serial
debarm:~# cd serial
debarm:~/serial# touch serial.js
debarm:~/serial# npm install serialport

Edit the created serial.js file:

var SerialPort = require('serialport').SerialPort;
/**
 * /dev/ttyS4 -> Terra D10 connector
 * /dev/ttyS2 -> Terra D13 connector
 */
var serialPort = new SerialPort('/dev/ttyS4', {
    baudrate: 19200,
    databits: 8,
    stopbits: 1,
    parity: 'none'
});
serialPort.on('open', function() {
    console.log('open');
    serialPort.on('data', function(data) {
        console.log('data received: ' + data);
    });
    serialPort.write("Welcome Aria UART RF connected!", function(err, results) {
        console.log('total written bytes ' + results);
        console.log('err ' + err);
    });  
});

Run your test program:

debarm:~# node serial.js

After a few seconds you see in your terminal:

open
total written bytes 31
err undefined

and your IQRF IDE shows the sent message (Welcome Aria UART RF connected!).
Enjoy!

1. Update Debian

The first step is the Debian updating to use new gcc compiler: see my guide to upgrade Debian Squeeze to Wheeze on your Aria G25 board.

2. Install prerequisites

Follow the steps from 1 to 3 on my previous guide.

3. Customize nvm

Edit nvm.sh:

debarm:~# nano nvm.sh

if (
        [ ! -z $tarball ] && \
        mkdir -p "$NVM_DIR/src" && \
        cd "$NVM_DIR/src" && \
        curl --progress-bar $tarball -o "node-$VERSION.tar.gz" && \
        if [ "$sum" = "" ]; then : ; else nvm_checksum `${shasum} node-$VERSION.tar.gz | awk '{print $1}'` $sum; fi && \
        tar -xzf "node-$VERSION.tar.gz" && \
        cd "node-$VERSION" && \
        ./configure --prefix="$NVM_DIR/$VERSION" $ADDITIONAL_PARAMETERS && \
        make && \
        rm -f "$NVM_DIR/$VERSION" 2>/dev/null && \
        make install
        )
      then

adding the highlighted line:

if (
        [ ! -z $tarball ] && \
        mkdir -p "$NVM_DIR/src" && \
        cd "$NVM_DIR/src" && \
        curl --progress-bar $tarball -o "node-$VERSION.tar.gz" && \
        if [ "$sum" = "" ]; then : ; else nvm_checksum `${shasum} node-$VERSION.tar.gz | awk '{print $1}'` $sum; fi && \
        tar -xzf "node-$VERSION.tar.gz" && \
        read -p "Please customize $NVM_DIR/src/node-$VERSION/deps/v8/src/arm/macro-assembler-arm.cc and press [Enter]..." && \
        cd "node-$VERSION" && \
        ./configure --prefix="$NVM_DIR/$VERSION" $ADDITIONAL_PARAMETERS && \
        make && \
        rm -f "$NVM_DIR/$VERSION" 2>/dev/null && \
        make install
        )
      then

4. Install Node from source code

If you have customized your nvm.sh file open your terminal and type:

debarm:~# nvm install v0.10.1
######################################################################## 100.0%
Checksums do not match.
Binary download failed, trying source.
Additional options while compiling: 
######################################################################## 100.0%
Please customize /root/.nvm/src/node-v0.10.1/deps/v8/src/arm/macro-assembler-arm.cc and press [Enter]...

Customize now the macro-assembler-arm.cc file:

debarm:~# nano .nvm/src/node-v0.10.1/deps/v8/src/arm/macro-assembler-arm.cc

adding the highlighted lines:

// We always generate arm code, never thumb code, even if V8 is compiled to
// thumb, so we require inter-working support
#if defined(__thumb__) && !defined(USE_THUMB_INTERWORK)
#error "flag -mthumb-interwork missing"
#endif

#if !defined(CAN_USE_THUMB_INSTRUCTIONS)
# define CAN_USE_THUMB_INSTRUCTIONS 1
#endif

// We do not support thumb inter-working with an arm architecture not supporting
// the blx instruction (below v5t).  If you know what CPU you are compiling for
// you can use -march=armv7 or similar.
#if defined(USE_THUMB_INTERWORK) && !defined(CAN_USE_THUMB_INSTRUCTIONS)
# error "For thumb inter-working we require an architecture which supports blx"
#endif

Now press Enter and wait. After a few hours (be patient!) you have compiled the latest Node version and you must use it:

debarm:~# nvm use v0.10.1

Done! Now you can verify all:

debarm:~$ node -v
debarm:~$ npm -v

If all versions appear, you can install your desired Node packages using npm as you know:

debarm:~$ npm install express

You can also set the default Node version as follow:

debarm:~$ nvm alias default v0.10.1

Good programming with Node!

create and configure lightweight, reproducible, and portable development environments.

Vagrant works on Mac OS X, Linux and Windows using the power of virtualization provided by VirtualBox, VMware, AWS, or any other provider. Using Vagrant I’ve build a template (for VirtualBox) with all tools needed to cross-compile the Linux Kernel. To use this template follow this simple steps (I’ve used my Mac OS X Mountain Lion, but you can use your preferred operating system).

1. Install Vagrant

To install Vagrant simply follow the steps on the official Vagrant website.

2. Create your environment

sqeezecross32 is a development environment build on top of a Debian 6.0 Squeeze distribution and equipped with ARM9 cross toolchain (see this). To create your environment using this box simply open your terminal window and type:

Mac:~ Dev$ mkdir acme
Mac:~ Dev$ cd acme
Mac:~ Dev$ vagrant init squeezecross32 http://www.yoovant.com/downloads/squeezecross32.box

A `Vagrantfile` has been placed in this directory. You are now
ready to `vagrant up` your first virtual environment! Please read
the comments in the Vagrantfile as well as documentation on
`vagrantup.com` for more information on using Vagrant.

3. Start your VM

To start your VM simply type:

Mac:~ Dev$ vagrant up
Bringing machine 'default' up with 'virtualbox' provider...
[default] Box 'squeezecross32' was not found. Fetching box from specified URL for
the provider 'virtualbox'. Note that if the URL does not have
a box for this provider, you should interrupt Vagrant now and add
the box yourself. Otherwise Vagrant will attempt to download the
full box prior to discovering this error.
Downloading with Vagrant::Downloaders::HTTP...
Downloading box: http://www.yoovant.com/downloads/squeezecross32.box
Progress: 1% (22062944 / 1348847160)
...
Extracting box...
Cleaning up downloaded box...
Successfully added box 'squeezecross32' with provider 'virtualbox'!
[default] Importing base box 'squeezecross32'...
[default] No guest additions were detected on the base box for this VM! Guest
additions are required for forwarded ports, shared folders, host only
networking, and more. If SSH fails on this machine, please install
the guest additions and repackage the box to continue.

This is not an error message; everything may continue to work properly,
in which case you may ignore this message.
[default] Matching MAC address for NAT networking...
[default] Setting the name of the VM...
[default] Clearing any previously set forwarded ports...
[default] Creating shared folders metadata...
[default] Clearing any previously set network interfaces...
[default] Preparing network interfaces based on configuration...
[default] Forwarding ports...
[default] -- 22 => 2222 (adapter 1)
[default] Booting VM...
[default] Waiting for VM to boot. This can take a few minutes.
[default] VM booted and ready for use!
[default] Configuring and enabling network interfaces...
[default] Mounting shared folders...
[default] -- /vagrant
Mac:~ Dev$

NOTE: on the first boot the vbox is downloaded. The vbox is very large (~1.3 GB): be patient!

Now connect to console in SSH:

Mac:~ Dev$ vagrant ssh

Linux squeeze32 2.6.32-5-686 #1 SMP Mon Feb 25 01:04:36 UTC 2013 i686

The programs included with the Debian GNU/Linux system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.

Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
permitted by applicable law.
Last login: Fri Mar 22 11:33:16 2013 from 10.0.2.2

vagrant@squeeze32:~$

After running the above two commands, you’ll have a fully running virtual machine in VirtualBox and you can manage file in your host computer using the shared folder /vagrant: all file that you put in this folder is visible both in your host computer and your VM.

4. Compile Linux Kernel

As you can see in your /home/vagrant/ folder there is a folder named linux-2.6.39 (and also a fox20-linux-2.6.38 folder for Fox): now simple read the Build the bootable Linux Kernel image for Aria G25 section into the official Acme Systems guide.

5. Turn off your environment

When you have finished your work, you can turn off your VM typing:

Mac:~ Dev$ vagrant halt
[default] Attempting graceful shutdown of VM...

1. Enable swap

Connect to your Aria board console using a SSH connection and open the file /etc/fstab and remove the # char from this line:

#/dev/mmcblk0p4 none swap sw 0 0

Save and reboot the FOX by typing:

debarm:~# reboot

2. Set new repositories

Edit the file /etc/apt/sources.list and replace all the words squeeze in wheezy.

This is the old contents of /etc/apt/sources.list:

deb http://ftp.it.debian.org/debian squeeze main                                
deb-src http://ftp.it.debian.org/debian squeeze main                            
deb http://security.debian.org/ squeeze/updates main                            
deb-src http://security.debian.org/ squeeze/updates main

This is the new content:

deb http://ftp.it.debian.org/debian wheezy main                                
deb-src http://ftp.it.debian.org/debian wheezy main                            
deb http://security.debian.org/ wheezy/updates main                            
deb-src http://security.debian.org/ wheezy/updates main

Note that the .it. in the urls within the /etc/apt/sources.list file stand for Italy so it might change to your own country’s two letter abbreviation.

3. Launch the upgrading

In your console type:

debarm:~# apt-get update

and update python to new 2.7 version that is the default python interpreter in Wheezy:

debarm:~# apt-get install python

Now you can upgrade your distribution:

debarm:~# apt-get dist-upgrade --force-yes

Accept all the default option.
When finished (be patient!) remove the file /etc/udev/rules.d/70-persistent-net.rules and reboot the board:

debarm:~# rm /etc/udev/rules.d/70-persistent-net.rules
debarm:~# reboot

Connect again to your Aria console using SSH and type:

debarm:~# lsb_release -a

No LSB modules are available.
Distributor ID: Debian
Description:    Debian GNU/Linux 7.0 (wheezy)
Release:    7.0
Codename:   wheezy

Your brand new Debian Wheezy is ready on your Aria G25 board!

If you want to have a ready to use rootfs archive, you can download the archive below and use it as the substitute of the rootfs archive indicated in the official instruction to make bootable your microSD card with Debian Wheeze.

Remember to check MD5:

debarm:~# openssl md5 rootfs.tar.bz2

Now follow the official instructions to create your bootable microSD.

NOTE This archive is made using the official Acme System rootfs archive with Debian 6.0 Squeeze updated to Debian 7.0 Wheeze using the previous steps. Note also that the default language is set to en_US.

First you must install Node.js on your board following this instructions (tested with v0.8.14). Now you can install daisy_gpio as usual:

debarm:~# npm install daisy_gpio

Done! Now you can write a simple program to turn on a led when push a button using two prototype boards: Daisy5 and Daisy11. Assuming you connect Daisy5 to D5 connector and Daisy11 to D2 connector of your FoxBoard, your first program seems like this:

var daisy = require('daisy')({
    model: 'fox',   // set to aria if you have this board
    test: false,    // set true if you want use a fake gpio path.
                    // Note that the change, falling and rising events can't fires
    debug: false    // set true if you want see debug messages into terminal window
});
// create a new Daisy5 instance (8 buttons array)
var daisy5 = new daisy.Daisy5();
// attach the init event (fired when ALL buttons are ready)
daisy5.attach('init', function(event) {
    console.log('init daisy5');
});
// create a new Daisy11 instance (8 leds array)
var daisy11 = new daisy.Daisy11();
// attach the init event (fired when ALL leds are ready)
daisy11.attach('init', function(event) {
    console.log('init daisy11');
});
// attach the rising event fired for EVERY button when pressed
daisy5.attach('rising', function(event) {
    daisy11.instances[event.data.sender.index].setHigh();
});
// attach the falling event fired for EVERY button when released
daisy5.attach('falling', function(event) {
    daisy11.instances[event.data.sender.index].setLow();
});
// attach the rising event fired for EVERY led is turned on
daisy11.attach('rising', function(event) {
    console.log('turned on led #' + event.data.sender.index);
});
// attach the falling event fired for EVERY led is turned off
daisy11.attach('falling', function(event) {
    console.log('turned off led #' + event.data.sender.index);
});

Save your file as presstolight.js and run in your terminal:

debarm:~# node presstolight.js

Now if you push a button, the corresponding led is turned on. Easy, right? Note that the init and free events are fired only when ALL leds (buttons) of Daisy11 (Daisy5) are ready to use and available respectively, whereas the rising and falling events are fired by every led (button). Note also that all events have a data property that contains two properties:

• err: the error if occurred
• sender: the Gpio instance that has fired the event

The event.data for a change event has also a value property with the last value.

In general if you want manage your GPIO as input or output without a daisy prototype board, you can use the generic aria_fox_gpio module. Install it:

debarm:~# npm install aria_fox_gpio

and write a simple program:

// define the OutGpio class from the aria_fox_gpio module
var Led = require('aria_fox_gpio')({
    model: 'fox',
    debug: true
}).OutGpio;
// create a new Led instance
var led = new Led('D2', 2, function() {
    // use callback to handle the init
    console.log('init callback button #1');
    var isOn = false;
    setInterval(function(){
        isOn = !isOn;
        if (isOn) {
            led.setHigh();
        } else {
            led.setLow();
        }
    }, 500);
});
// attach the init event fired (after the callback) when the led is ready 
led.attach('init', function(event) {
    console.log('init event button #1');
});
// attach the rising event fired when the led is turned on
led.attach('rising', function(event) {
    console.log('led is turned on');
});
// attach the rising event fired when the led is turned off
led.attach('falling', function(event) {
    console.log('led is turned off');
});

Save your file as blinking.js and run in your terminal:

debarm:~# node blinking.js

Your led is blinking.

See full documentation online or into doc folder and some examples into test folder within the aria_fox_gpio package and daisy_gpio package