Plotly

Vista la pubblicita' di questi ultimi tempi ho voluto provare il servizio di grafici online Plotly come possibile alternativa a Xively

Vi sono API per numerosi linguaggi ma per semplicita' ho preferito usare Python

Prima di iniziare a scrivere il codice si deve importare la libreria Python per Plotly mediante il comando

pip install plotly
una volta autenticati con Plotly (anche mediante account Google o Facebook) si deve reperire la propria chiave entrando in Settings

si seguito lo script di esempio piu' semplice
Sono da modificare la parte in giallo (attenzione che il nome utente non coincide necessariamente con l'utente di Google... nel caso in cui ci si autentica in questo modo)
------------------------------------
import plotly
py = plotly.plotly(username='LucaInnocenti', key='ifntvfcaa9')

x1 = [1,2,3,10]
y1 = [4,5,6,10]

x2 = [1,2,3]
y2 = [2,10,12]

line1 = {"x": x1,"y": y1, "type":"scatter", "name":"Experiment",
"line":{"color":"rgb(3,78,123)", "width":6, "dash":"dot"},
"marker":{"opacity":1.0,"symbol":"square", "size":12,"color":"rgb(54,144,192)",
"line":{"width":3, "color":"darkblue"}}}

line2 = {"x":x2, "y":y2,"type":"scatter","name":"Control",
"line":{"color":"purple", "width":4, "dash":"dashdot"},
"marker":{"opacity":0.9,"symbol":"cross","size":16,"color":"fuchsia",
"line":{"color":"","width":0}}}

py.plot([line1, line2])
------------------------------------

Una volta che si lancia lo script viene generato un nuovo grafico. Non sembra possibile appendere dei dati ad un grafico gia' esistente creato da un altro script, questo pone dei limiti nel creare grafici incrementali con misure ogni tot secondi per esempio da letture di strumenti

In definitiva, per plottare dati da strumentazione considero superiore Xively

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