Processing ed Android

Con Processing e' possibile sviluppare applicazioni per Android senza la necessita' di utilizzare il metodo tradizionale in Java

Per settare Processing ad compilare per Android si deve prima di tutto avere un SDK Android funzionante ed avere installato installate le API 10 (le altre, sia superiori che inferiori vengono ignorate)

a questo punto si puo' installare Processing 2.0 dal sito di riferimento. Una volta installato si deve cliccare sul menu a discesa nell'angolo in alto a sinistra (dove nell'immagine sottostante si legge Android). Si sceglie quindi Add Mode e si sceglie Android

Al termine dell'installazione viene richiesta la directory di installazione di Android SDK.
Fatto.
A questo punto si puo' collegare il telefono Android via cavo (ovviamente gia' settato in Debuggin Mode come si solito si fa per lo sviluppo) e lanciando gli skecth il risultato sara' visibile sullo schermo del telefono

Xively su Linux/Raspberry

Quanto visto per l'Arduino puo' essere ripetuto anche per un calcolatore che monta Linux (come per esempio Raspberry)

In questo caso verra' impiegato Python per dialogare con Xively come descritto a questo tutorial
Prima di lanciare lo script si devono eseguire i seguenti comandi che impostano Python e scaricano la libreria Xively per Python

$ sudo apt-get install git
$ sudo apt-get install python-setuptools 

$ sudo easy_install pip 

$ sudo pip install virtualenv
$ mkdir xively_tutorial 

$ cd xively_tutorial
$ virtualenv .envs/venv
$ source .envs/venv/bin/activate
$ pip install xively-python
terminata la configurazione si puo' lanciare il seguente script in Python che invia Xively i dati sul carico di lavoro. Come nel caso precedente si devono eseguire delle personalizzazione sulla base delle propri settaggi del device su Xively inserendo la chiave, il feed_id ed il nome del feed (vedi righe evidenziate in giallo)
--------------------------------------------------------------
#!/usr/bin/env python

import os
import xively
import subprocess
import time
import datetime
import requests

# extract feed_id and api_key from environment variables
FEED_ID = 302563049
API_KEY = "KPpjdurjzx9jVhp8PwpMCd6byMSatfcKuOu1CHJbdDkxXrI4"
DEBUG = "true"

# initialize api client
api = xively.XivelyAPIClient(API_KEY)

# function to read 1 minute load average from system uptime command
def read_loadavg():
  if DEBUG:
    print "Reading load average"
  return subprocess.check_output(["awk '{print $1}' /proc/loadavg"], shell=True)

# function to return a datastream object. This either creates a new datastream,
# or returns an existing one
def get_datastream(feed):
  try:
    datastream = feed.datastreams.get("load_avg")
    if DEBUG:
      print "Found existing datastream"
    return datastream
  except:
    if DEBUG:
      print "Creating new datastream"
    datastream = feed.datastreams.create("load_avg", tags="load_01")
    return datastream

# main program entry point - runs continuously updating our datastream with the
# current 1 minute load average
def run():
  print "Starting Xively tutorial script"

  feed = api.feeds.get(FEED_ID)

  datastream = get_datastream(feed)
  datastream.max_value = None
  datastream.min_value = None

  while True:
    load_avg = read_loadavg()

    if DEBUG:
      print "Updating Xively feed with value: %s" % load_avg

    datastream.current_value = load_avg
    datastream.at = datetime.datetime.utcnow()
    try:
      datastream.update()
    except requests.HTTPError as e:
      print "HTTPError({0}): {1}".format(e.errno, e.strerror)

    time.sleep(10)

run()

Xively su Arduino

Per sviluppare il progetto presentato in questo precedente post ho provato ad inviare i dati del sensore non ad un server udp ma ad un servizio internet denominato Xively (ex Cosm, ex Pachube) che permette la registrazione di dati (principalmente da sensori) e la visualizzazione direttamente su grafico

Una volta effettua la registrazione si deve andare nel menu di Develop e si deve creare un nuovo Device

una volta creato il device si entra nella configurazione e si devono annotare i valori delle Api Keys

i valori importanti sono il feed_id (in questo caso 302563049) e la chiave (KP........)

A questo punto si puo' iniziare a programmare l'Arduino. Sempre dal sito di Xively si sceglie il menu Developer Center/ Libraries e si sceglie di scaricare la libreria per Arduino a questo link. Per soddisfare si deve scaricare ed installare anche la liberia HttpClient 

Si puo' quindi caricare il seguente sketch su Arduino che semplicemente manda sul sito i valori progressivi di un contatore. Ovviamente questo e' lo schema base e nell'uso reale si devono inviare gli output del proprio sensore.

Oltre ad impostare la Key ed il feed_id si deve anche impostare un nome per il sensore. Importante: tale stringa non deve contenere caratteri speciali o spazi

Attenzione: questo semplice sketch occupa circa 20 Kb dei 32Kb disponibili sull'Arduino Uno. Per rendere il tutto piu' snello si puo' impostare un indirizzo fisso alla scheda dell'Arduino e non usare il DHCP come nell'esempio
-------------------------------------------------------
#include <SPI.h>
#include <Ethernet.h>
#include <HttpClient.h>
#include <Xively.h>

// MAC address for your Ethernet shield
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

// Xively key
char xivelyKey[] = "KPpjdurjzx9jVhp8PwpMCd6byMSatfcKuOu1CHJbdDkxXrI4";
//il sensorId deve essere una stringa senza spazi e caratteri speciali
char sensorId[] = "Contatore_test";
long unsigned int feed_id = 302563049;

XivelyDatastream datastreams[] = {
  XivelyDatastream(sensorId, strlen(sensorId), DATASTREAM_FLOAT),
};

XivelyFeed feed(feed_id, datastreams, 1 /* number of datastreams */);

EthernetClient client;
XivelyClient xivelyclient(client);

float contatore;

void setup() {
  contatore = 0.0;
  Serial.begin(9600);
  while (Ethernet.begin(mac) != 1)
  {
    Serial.println("Error getting IP address via DHCP, trying again...");
    delay(5000);
  }
}

void loop() {
  contatore = contatore + 1;
  datastreams[0].setFloat(contatore);
  int ret = xivelyclient.put(feed, xivelyKey);
  Serial.println(ret);
  delay(5000);
}
---------------------------------------------------------------------

Una nota finale: se si collega la scheda ad un router Fastweb il programma non funziona ritornando come codice di errore -405. Cio' e' ragionevolmente dovuto alla peculiare configurazione della rete ADSL casalinga di Fastweb

Debian Hurd su VirtualBox

Giusto per curiosita' ho provato ad installare Debian/Hurd...ovviamente in una macchina virtuale per non fare troppi danni

La storia dello sviluppo di Hurd e' decennale e dopo aver letto che era uscita la nuova Debian Hurd ho voluto provarlo. So bene che non e' consigliato l'uso di produzione e che solo 2/3 dei pacchetti Debian sono disponibili....e' solo una prova con una prima incredibile sorpresa

Dopo aver configurato la macchina virtuale con un disco da 3Gb (come piu' o meno sono solito fare) ho lanciato il cd di installazione ed al momento di effettuare il partizionamento del disco fisso mi sono accorto che "semplicemente" non era elencato

Dopo una buona mezz'ora di riavvi mi sono messo alla ricerca su Internet di qualche indizio ed ho trovato che uno dei limiti attuali di Hurd e' quello di non gestire i dischi SATA ma di gestire solo in controller IDE

A questo punto sono ritornato in Virtualbox, ho cancellato il disco fisso ed il controller (di default sono SATA) ed ho creato un disco virtuale IDE

a questo punto l'installazione e' partita

Comunque una volta arrivati, dopo il riavvio, al login le impressioni di utilizzo sono pessime. Al di la' dei comandi che sono (ovviamente) differenti da Linux anche le operazioni piu' banali pongono problemi e vi sono molti errori. Il sistema e' sostanzialmente non usabile

Esempio GUI con QtQuick 2.0

Riprendendo la serie di esempi di GUI stavolta e' la volta di QtQuick (Qt 5.1)
Da notare che la release 5.1 i problemi all'editor visuale di QtQuick all'interno di QtCreator sembrano essere risolti per cui per progettare la pagina e' sufficiente fare doppio clic sul file .qml della colonna Progetti

Editor Visuale di QtQuick in QtCreator

------------------------------------------

import QtQuick 2.1

import QtQuick.Controls 1.0

import QtQuick.Window 2.0

ApplicationWindow {

    title: qsTr("Esempio")

    width: 250

    height: 160

    menuBar: MenuBar {

        Menu {

            title: qsTr("File")

            MenuItem {

                text: qsTr("Exit")

                onTriggered: Qt.quit();

            }

        }

    }

    TextField {

        id: text_field1

        x: 21

        y: 17

        width: 200

        height: 20

        text: ""

        placeholderText: ""

    }

    ProgressBar {

        id: progress_bar1

        x: 21

        y: 54

    }

    Slider {

        id: slider__horizontal_1

        x: 21

        y: 101

        value: 0.5

        onValueChanged: aggiorna();

        function aggiorna()

            {

            text_field1.text = slider__horizontal_1.value.toFixed(2).toString();

            progress_bar1.setValue(slider__horizontal_1.value);

        }

    }

}

Mandelbrot in QtQuick 2

Visto che oramai sembra che nell'immediato futuro un po' di sistemi mobili useranno le QtQuick (Ubuntu Touch ed Android) e visto che e' uscito l'SDK Qt 5.1 ho voluto riaprire l'argomento per vedere se e' la volta buona

Come risulta chiaro dal confronto con questo post QtQuick eredita molta della struttura del codice da Javascript anche se vi sono comunque differenze. Per esempio la stampa con il comando

context.fillRect(j,i,1,1);
in QtQuick e' dovuta diventare

ctx.moveTo(j,i);

ctx.lineTo(j+1,i+1);

----------------------------------------------------

import QtQuick 2.0

Canvas {

    id : canvas

    width : 640

    height : 640

    MouseArea {

             anchors.fill: parent

             onClicked: { }

         }

    onPaint: {

        var re_min = -2.0;

        var im_min = -1.2;

        var re_max = 1.0;

        var im_max = 1.2;

        var iterazioni = 255;

        var r;

        var a,b;

        var x,y,x_new,y_new;

        var k,j,i;

        var SCREEN_HEIGHT = 640;

        var SCREEN_WIDTH = 640;

        var re_factor = (re_max-re_min);

        var im_factor = (im_max-im_min);

        var ctx = canvas.getContext('2d');

        ctx.fillRect(0,0,SCREEN_WIDTH,SCREEN_HEIGHT);

        ctx.save();

        ctx.strokeStyle = "#FFFFFF";

        for (var i=0;i<SCREEN_WIDTH;i++) {

            for (var j=0;j<SCREEN_HEIGHT;j++) {

                a = re_min+(j*re_factor/SCREEN_WIDTH);

                b = im_min+(i*im_factor/SCREEN_HEIGHT);

                x = 0;

                y = 0;

                for (var k=0;k<iterazioni;k++)

                                      {

                                      x_new = (x*x)-(y*y)+a;

                                      y_new = (2*x*y)+b;

                                      if (((x_new*x_new)+(y_new*y_new))>4)

                                       {

                                       r = k%2;

                                       if (r == 1)

                                           {

                                           ctx.beginPath();

                                           ctx.moveTo(j,i);

                                           ctx.lineTo(j+1,i+1);

                                           ctx.stroke();

                                           }

                                       break;

                                       }

                                      x = x_new;

                                      y = y_new;

                                    }

                }

            }

         }

}

----------------------------------------------------

Real Time Clock DS1302 su Raspberry

Di questo componente esistono molti tutorial su Internet e, cosa abbastanza incredibile, sono spesso molto differenti tra di loro. In alcuni casi viene proposto di rimuovere delle resistenza della schedina dell'RTC, in altri casi l'alimentazione deve essere collegata ai 5 Volts...in questo caso viene presentato l'esempio riportato da questo sito che per il mio caso ha funzionato

La pedinatura e' la seguente

Raspberry     ->  RTC
VCC 3 Volt -> VCC
GND -> GND
GPIO #21/27 -> CLK
GPIO #18 -> DAT
GPIO #17 -> RST

(il sito originale indica di inserire delle resistenze da 10 KOhm su DAT e VCC .. nel mio caso ha funzionato senza necessita' di questi componenti)

per usare questo componente si deve utilizzare il programma rtc-pi.c che si scarica da questo link 

Dato che utilizzo la Raspberry 2 devono essere modificato il file rtc-pi.c come segue
si devono commentare (o cancellare alcune righe) ed inserirne altre; vedi righe evidenziate

---------------------------------------------

#define IO_INPUT    *(gpio+GPIO_SEL1) &= 0xF8FFFFFFL

#define IO_OUTPUT   *(gpio+GPIO_SEL1) &= 0xF8FFFFFFL; *(gpio+GPIO_SEL1) |= 0x01000000L 

//#define SCLK_OUTPUT *(gpio+GPIO_SEL2) &= 0xFFFFFFC7L; *(gpio+GPIO_SEL2) |= 0x00000008L

#define CE_OUTPUT   *(gpio+GPIO_SEL1) &= 0xFF1FFFFFL; *(gpio+GPIO_SEL1) |= 0x00200000L

#define IO_HIGH     *(gpio+GPIO_SET) = 0x00040000L

#define IO_LOW      *(gpio+GPIO_CLR) = 0x00040000L

//#define SCLK_HIGH   *(gpio+GPIO_SET) = 0x00200000L

//#define SCLK_LOW    *(gpio+GPIO_CLR) = 0x00200000L

#define CE_HIGH     *(gpio+GPIO_SET) = 0x00020000L  

#define CE_LOW      *(gpio+GPIO_CLR) = 0x00020000L

#define IO_LEVEL    *(gpio+GPIO_INP) & 0x00040000L

#define SCLK_OUTPUT *(gpio+GPIO_SEL2) &= 0xFF1FFFFFL; *(gpio+GPIO_SEL2) |= 0x00200000L
#define SCLK_HIGH *(gpio+GPIO_SET) = 0x08000000L
#define SCLK_LOW *(gpio+GPIO_CLR) = 0x08000000L---------------------------------------------
il programma si puo' compilare come

cc -o rtc-pi.c rtc-pi.c
chmod +x rtc-pi

per impostare la data sull' RTC si puo' procedere come (da sudo)
./rtc-pi 20130713173002 (ora 17:30:02 del 13 luglio 2013)

per impostare l'ora del Raspberry riprendendola dall' RTC e' sufficiente
./rtc-pi 

per rendere il sistema funzionante si deve infine mandare in esecuzione automatica il programma ./rtc-pi ad ogni avvio del sistema