lunedì 15 luglio 2013

NOOBS Raspberry

Un metodo per provare (e solo per provare dato che viene rubato spazio sulla SD da immagini che poi non verranno utilizzate) i vari sistemi operativi supportati da Raspberry si puo' utilizzare il pacchetto NOOBS

Una volta  scaricato NOOBS si deve scompattare l'archivio su una SD Card formattata FAT32 vuota di almeno 4 Gb

Al primo avvio si osserva la schermata sottostante che permette di scegliere quale SO provare

Selezione SO

in questo caso e' stato selezionato Pidora che viene installato in automati

Installazione Pidora
ed dopo un paio di riavvi compare Pidora con XFCE


Nel caso si voglia cambiare SO per qualche frazione di secondo ad ogni reboot compare questa schermata che invita a premere il tasto Shift...in questo modo si ritorna alla selezione del SO


Megatools

Attenzione:
al momento di scrivere di questo post sul sito dello sviluppatore e' comparso un messaggio in cui lo sviluppo di questo tool e' sospeso a causa di una modifica alle API di Mega e sono stati rimossi i link per il download degli eseguibili. Risulta tuttora disponibile il link a GitHub per i sorgenti. Per adesso il tool funziona ma non e' chiaro fino a quando le API continueranno a funzionare come adesso


Finalmente iniziano ad essere disponibili i clienti per il servizio Cloud di Mega in particolar modo quello ufficiale per Android e quello non ufficiale per Linux/Windows offerto da Megatools
E' infatti sostanzialemente inutile avere 50 Giga di spazio e dover effettuare tutte le operazioni da interfaccia Web senza la possibilita' di automatizzare l'upload



In Linux, una volta scompattato l'archivio e compilato i sorgenti mediante ./configure make, si hanno a disposizione i seguenti principali comandi (ne ho omessi alcuni di uso meno frequente)

megadf       come df mostra lo spazio disco a disposizione
megals       come ls (Linux)
megamkdir    come mkdir (Linux)
megarm       come rm (Linux)
megamv       come mv (Linux)
megaput      effettua l'upload di un file
megaget      effettua il download di un file
megasync     sincronizza una directory remota con una directory locale

in generale i comandi hanno tutti uno switch
-u nomeutente
-p password

una tipica sessione puo' essere

megadf -u lucainnoc@gmail.com -p password
megamkdir -u lucainnoc@gmail.com -p password Immagini
magesync -u lucainnoc@gmail.com -p password --local /home/luca/Immagini --remote /Root/Immagini

La directory di root del Cloud e' sempre Root 

Le velocita' di upload sono piuttosto modeste e popolare i 50 Gb sara' veramente un'impresa

venerdì 12 luglio 2013

Shutdown Raspberry via pulsante

Questo progetto e' stato copiato da questo link per evitare uno dei problemi piu' fastidiosi della Raspberry (ovvero di Linux) ovvero la corruzione del file system in caso di arresto brutale dell'elaboratore

In questo esempio viene implementato un pulsante fisico che permetta di eseguire (ove possibile) uno shutdown corretto della macchina

Sono possibili due schemi elettrici



Io ho usato il metodo del secondo schema perche' nel primo la porta GPIO e' sempre sottotensione (stato logico 1) mentre nel secondo esempio lo stato logico e' 0

il programma per gestire il pulsante e' il seguente: se il pin 17 acquisisce uno stato logico 1 viene lanciato il comando di shell per lo shtdown. Le resistenze, come nello schema, sono da 1 e 10 KOhm

------------------------------------------------------
import RPi.GPIO as GPIO
import time
import os
GPIO.setmode(GPIO.BCM)
GPIO.setup(17, GPIO.IN)
while True:
if (GPIO.input(17)):
os.system("sudo shutdown -h now")
break
time.sleep(1)
------------------------------------------------------

Nella foto il cavo rosso e' collegato al pin di 3.3 V, il cavo nero al GND mentre il cavo giallo e' collegato alla porta 17


vistodall'alto



Ed ecco un breve video


mercoledì 10 luglio 2013

GPIO su Raspberry (Led Blink)

In Raspberry e' presente una porta una porta GPIO (General Purpose Input Output) che puo' essere utilizzata come in Arduino per interfacciare la scheda con il mondo esterno (attenzione: ci sono controlli digitali e non analogici)

La prima fondamentale differenza rispetto al mondo Arduino e' che i pin sono spesso indicati con un doppio nome; il primo e' il numero ordinale  (da 1 a 26) mentre il secondo prende in considerazione a quale collegamento rispetto alla CPU siano associati

GPIO Pin Rev.1

ad aggiungere confuzione tra la prima e seconda revisione della Raspberry alcuni pin sono stati modificati per cui alcuni progetti girano su una versione e non sull'altra

GPIO Pin Rev.2
Attenzione : la tensione di riferimento della Raspberry e' di 3.3 V sui pin digitali (ad esclusione di una alimentazione a 5 V sul pin 2)

Per programmare in modo semplice l'accesso i/o ai pin e' disponibile una libreria Python (gia' installata di default nelle versioni attuali di Raspbian). Tutti i programmi che usano le porte devono essere eseguiti come super-utente (script python compresi)


Lo script seguente accende e spenge un led connesso al pin 11 (nome GPIO17)
-------------------------------------------------
import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)

# Set up #17 as an output
print "Setup #17"
GPIO.setup(17, GPIO.OUT)

var=1
print "Start loop"
while var==1:
 print "Set Output False"
 GPIO.output(17, False)
 time.sleep(1)
 print "Set Output True"
 GPIO.output(17, True)
 time.sleep(1)
-------------------------------------------------




Stringhe su Nokia 5110 da Raspberry

In questo esempio viene mostrato come scrivere stringhe sul display Nokia 5110 utilizzando Raspberry

Nel caso specifico la stringa viene ripresa dal primo parametro della linea di comando
Per la compilazione e maggiori dettagli si rimanda  a questo post




-------------------------------------------------
#include <wiringPi.h>
#include <stdio.h>
#include <stdlib.h>
#include "../PCD8544.h"

// pin setup
int _din = 1;
int _sclk = 0;
int _dc = 2;
int _rst = 4;
int _cs = 3;
  
// lcd contrast 
int contrast = 50;
int i;
  
int main (int argc, char *argv[])
{
  if (wiringPiSetup() == -1)
  {
printf("wiringPi-Error\n");
    exit(1);
  }
  
  LCDInit(_sclk, _din, _dc, _cs, _rst, contrast);
  LCDclear();
  LCDdrawstring(1, 1, argv[1]);
  LCDdisplay();
  delay(2000);

  LCDclear();
  
  return 0;
}

Mandelbrot in Raspberry con display Nokia 5110

Mettendo insieme i precedenti post Display Nokia 5110 su RaspberryArduino Uno + Display Nokia 5110 = Mandelbrot 48x84 ho provato a ripetere la stessa cosa su Raspberry

il codice per generare l'immagine e' sempre il solito (che fortunatamente si ricicla in mille modi) e si compila con la seguente linea

cc -o mandel mandel.c ../PCD8544.c -L/usr/local/lib -lwiringPi


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

#include <wiringPi.h>
#include <stdio.h>
#include <stdlib.h>
#include "../PCD8544.h"

#define SCREEN_WIDTH 84
#define SCREEN_HEIGHT 48

// pin setup
int _din = 1;
int _sclk = 0;
int _dc = 2;
int _rst = 4;
int _cs = 3;
// lcd contrast 
int contrast = 50;
  

float re_min = -2.0;
float im_min = -1.2;
float re_max = 1.0;
float im_max = 1.2;
int iterazioni = 1024;
float a,b;
float x,y,x_new,y_new;
int k,j,i;


int main (void)
{
  // check wiringPi setup
  if (wiringPiSetup() == -1)
  {
printf("wiringPi-Error\n");
    exit(1);
  }
  
  // init and clear lcd
  LCDInit(_sclk, _din, _dc, _cs, _rst, contrast);
  LCDclear();

  
  float re_factor = (re_max-re_min);
  float im_factor = (im_max-im_min);
    

for (i=0;i<SCREEN_HEIGHT;i++)
{
for (j=0;j<SCREEN_WIDTH;j++)
 {
 a = re_min+(j*re_factor/SCREEN_WIDTH); 
 b = im_min+(i*im_factor/SCREEN_HEIGHT);
 
 x = 0;
 y = 0;

 
 for (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)
{
test = k;
if (k%2 == 0)  LCDsetPixel(j, i, BLACK);
// LCDdisplay();    
break;
}
  x = x_new;
  y = y_new;
  }
 
 }

}
  
  
  LCDdisplay();
  delay(2000);
  return 0;

}

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

L'aspetto piu' interessante e' la differenza di velocita', su Raspberry l'immagine appare in modo praticamente istantaneo mentre su Arduino era necessario circa un minuto



Un riassunto di PlayStore (dopo oltre un anno)

Un piccolo riassunto sulle applicazioni che ho pubblicato sul Play Store

Di queste Geocompass, Soil Color Chart e Well Drawdown Test non sono state pubblicizzate in nessun modo ma in ogni caso sono state individuate dagli utenti e sono anche (diciamo) gradite

Nel periodo di maggior interesse il rapporto tra numero di installazioni e numero di download era di circa il 40-50% ovvero circa la meta' degli utenti che la aveva provata continuava ad utilizzarla. Con il tempo, dato che le applicazioni non sono mantenute ed aggiornate, sono arrivate nuove app piu' interessanti e gli utenti si sono spostati su altri sviluppatori



martedì 9 luglio 2013

Mandelbrot in Go

Era da un po' di tempo che mi stuzzicava l'idea di provare il linguaggio Go di Google (vedi precedente post) e questa volta ci ho riprovato scrivendo il codice per Mandelbrot da solo senza utilizzare script gia' fatti

Come si puo' vedere ci sono riuscito ma ci sono un paio di considerazioni


al di la' del fatto se Go sia destinato all'oblio (come alcuni progetti di Google) o diventera' lo standard del futuro (personalmente propendo per la prima ipotesi .. ma di solito sbaglio) il linguaggio e' particolarmente ostico per un principiante


  • non si possono eseguire operazioni tra tipi di variabile differenti (pena un errore  mismatched types int float32 invalid operation) a meno di un esplicito cast
  • l'assegnazione di un valore ad una variale mediante il segno "=" e' differente da ":=". In pratica usando := non solo si assegna ma si definisce anche una variabile. Se non si comprende questo meccanisco e si dichiara per esempio var s = "Luca" e subito dopo  s:="Luca" si avra' l'errore variable declared and not used a causa di una doppia dichiarazione della variabile s
  • il linguaggio non e' a formattazione libera e la posizione della parentesi graffa (per esempio) deve essere posizionato in posti precisi pena un errore di compilazione
  • in generale la filosofia del compilatore e': tutti warnings sono errori. Il che puo' essere fastidioso ma mi ha permesso di eliminare una variabile che di fatto non utilizzavo mai (e' la variabile test dei precedenti esempi). In questo senso se si importa una libreria che non viene utilizzata il compilatore genera un errore e non esegue il programma

---------------------------------------------------------------
package main

import (
 "image"
 "image/png"
 "image/color"
 "log"
 "os"
)

func main() {

var SCREEN_WIDTH int = 400
var SCREEN_HEIGHT int =  400

var re_min float32  = -2.0
var im_min float32  = -1.2
var re_max float32  = 1.0
var im_max float32  = 1.2

var iterazioni int = 1024

var a,b float32 
var x,y,x_new,y_new,somma float32
var k,i,j int

var re_factor float32 = (re_max-re_min)
var im_factor float32 = (im_max-im_min)

m := image.NewRGBA(image.Rect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT)) 

for i=0;i<SCREEN_HEIGHT;i++ {
for j=0;j<SCREEN_WIDTH;j++ {
a = re_min+(float32(j)*re_factor/float32(SCREEN_WIDTH))
      b = im_min+(float32(i)*im_factor/float32(SCREEN_HEIGHT))
x = 0
      y = 0
     
for k=0;k<iterazioni;k++ {
        x_new = (float32(x)*float32(x))-(float32(y)*float32(y))+float32(a)
y_new = (float32(2)*float32(x)*float32(y))+float32(b)
somma = (x_new*x_new)+(y_new*y_new)
        if somma > 4   {
if k%2 == 0 {
m.Set(j, i, color.RGBA{0, 0, 0, 255})
} else {
m.Set(j, i, color.RGBA{255, 255, 255, 255})
}
break
}
        x = x_new;
        y = y_new;
    }
}
}

 f, err := os.OpenFile("mandelbrot.png", os.O_CREATE | os.O_WRONLY, 0666)
 if(err != nil) {
  log.Fatal(err)
  }
 if err = png.Encode(f, m); err != nil {
  log.Fatal(err)
  }
}

lunedì 8 luglio 2013

Raspberry Rev.1 e Rev.2

Mi e'  stata gentilmente prestata una Raspberry Ver.2 da affiancare alla Rev.1

Le differenze, ad esclusione del case in plastica che e' stato aggiunto successivamente e si acquista a parte, sono a colpo d'occhio:

  1. la presenza dei fori di montaggio nella Rev.2 non presenti nel precedente modello
  2. l'assenza dei connettori alla sinistra (in foto) al connettore (giallo) del segnale video composito nella Rev.2 (ci sono i fori nella basetta ma non i pin di connessione)
  3. Piccoli spostamenti sulla circuiteria per fare posto a fori di montaggio


In alto Rev.1, in basso Rev.2



Display Nokia 5110 su Raspberry

Per utilizzare il display Nokia 5110 su Raspberry la via piu' semplice e' quella di utilizzare la libreria PCD8544 presente a questo sito
Prima pero' deve essere soddisfatta la dipendenza dalla libreria WiringPi che si puo' scaricare da questo sito

La compilazione di WiringPi e' semplice in quanto, dopo aver spacchettato l'archivio. e' sufficiente da root digitare ./build

A questo punto si puo' spacchettare la libreria PCD8544 e procedere alla sua compilazione.
Una volta spacchettato l'archivio se si tenta di lanciare la compilazione con i comandi proposti dal sito


cc -o pcd8544_test pcd8544_test.c ../PCD8544.c -L/usr/local/lib -lwiringPi
cc -o pcd8544_test2 pcd8544_test2.c ../PCD8544.c -L/usr/local/lib -lwiringPi
cc -o pcd8544_rpi pcd8544_rpi.c ../PCD8544.c -L/usr/local/lib -lwiringPi

questa fallisce

La cosa da fare e' modificare leggermente i file contenuti nella cartella samples modificando la riga dell'include da
#include "PCD8544.h"

a
#include "../PCD8544.h"

a questo punto si puo' compilare con successo

Attenzione: i collegamenti sono validi solo per la Raspberry Ver.2. Nei commenti del sito originario e' presente lo schema di collegamento per la Raspberry Ver.1 a cui devono essere accoppiate anche delle leggere modifiche al codice

Le connessione sono le seguenti
LCD pins      Raspberry Pi
---------------------------------------
LCD1 - GND    P06  - GND
LCD2 - VCC    P01 - 3.3V
LCD3 - CLK    P11 - GPIO0
LCD4 - Din    P12 - GPIO1
LCD5 - D/C    P13 - GPIO2
LCD6 - CS     P15 - GPIO3
LCD7 - RST    P16 - GPIO4
LCD8 - LED    P01 - 3.3V

in piu' per avere il led della retroilluminazione acceso si puo' collegare il pin BL del display all'alimentazione a 3.3 V della Raspberry

Dettaglio dei collegamenti


L'esempio test2 in esecuzione


Quadro completo




Backup SD Card Raspbian

Una delle cose piu' fastidiose della Raspberry e' la necessita' di effettuare uno shutdown corretto pena la compromissione della SD Card ed il non riavvio del sistema operativo (abituati alle Arduino questo e' decisamente un problema)


Una soluzione puo' essere quella di creare una copia della SD Card in  modo da salvare le impostazione e le personalizzazioni alla Raspbian

Per fare cio' in Linux,avendo la SD Card montata su sdb, si puo' digitare (da root)

dd if=/dev/sdb of=./copia.img
tar cvfj copia.tgz copia.img

venerdì 5 luglio 2013

Easter Egg su Amministrazione Google AdSense

Stavo consultando l'amministrazione di AdSense di questo blog (come si puo' vedere in un anno ha fatto 2.9 euro di guadagno..) quando ho lasciato il mouse sull'immagine in basso a destra, il numero 10 che festeggia il compleanno di questa piattaforma


In maniera non prevedibile e' apparsa un barra verde che progressivamente aumentava
Al termine e' comparso il gioco di Pong


La cosa divertente e' che non sapevo della presenza dell'Easter Egg ed e' stato abbastanza sorprendente...per la cronaca e' piuttosto facile vincere

Porta seriale in Qt

Per leggere e scrivere i valori per la porta seriale si possono utilizzare varie librerie. In questo caso viene presentato un esempio relativo alla libreria Qt Serial Port che si trova sul sito ufficiale Qt

La libreria e' valida sia per Qt4 che Qt5

Una volta scaricato il pacchetto si entra nella directory e si digita
qmake
make 
make install

a questo punto si puo' creare un nuovo progetto Qt4
la prima cosa da modificare e' il file .pro aggiungendo la serialport
--------------------------------
QT       += core gui
CONFIG += serialport

greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

TARGET = seri
TEMPLATE = app


SOURCES += main.cpp\
        mainwindow.cpp

HEADERS  += mainwindow.h


FORMS    += mainwindow.ui
--------------------------------

dopo di cio' si modifica il file header aggiungendo l'include all'header della libreria, uno slot privato per la funzione di lettura della porta ed una nuova variabile che identifica la porta seriale
--------------------------------
#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QtSerialPort/QSerialPort>

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT
    
public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();

private slots:
    void readData();

    
private:
    Ui::MainWindow *ui;
    QSerialPort *serial;

};

#endif // MAINWINDOW_H

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

il programma vero e proprio puo' essere cosi' scritto
In questo caso viene letta la porta /dev/ttyUSB0 con parametri 2400 8N1

--------------------------------
#include "mainwindow.h"
#include "ui_mainwindow.h"

#include <QtSerialPort/QSerialPort>
#include <QDebug>

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    serial = new QSerialPort(this);
    serial->setPortName("/dev/ttyUSB0");

    if (serial->open((QIODevice::ReadWrite)))
    {
    serial->setBaudRate(QSerialPort::Baud2400);
    serial->setDataBits(QSerialPort::Data8);
    serial->setParity(QSerialPort::NoParity);
    serial->setStopBits(QSerialPort::OneStop);
    }

    connect(serial,SIGNAL(readyRead()),this,SLOT(readData()));
}

void MainWindow::readData()
{
    QByteArray data = serial->readAll();

    qDebug() << data;

}

MainWindow::~MainWindow()
{
    delete ui;

}
--------------------------------

giovedì 4 luglio 2013

VLC e Proxy Server

Impostare il proxy server su VLC e' tutto fuorche' banale anche per colpa del menu' nascosto

Si parte da Strumenti/Preferenze
si seleziona Mostra le Impostazioni/Tutto


Ingresso/Codifica-Moduli di Accesso-HTTP


Sensore di allungamento su Arduino + Shield Ethernet

Questo sensore e' di comune utilizzo nei laboratori di geotecnica per misurare le variazioni di lunghezza.
Il sensore ha 4 cavi che corrispondono a

rosso = positivo alimentazione
bianco = negativo alimentazione
giallo = positivo segnale
verde = negativo segnale

nella posizione di riposo (ovvero con la molla a riposo) e con alimentazione a 9 V il segnale e' di circa 780 mV, via via che la testa rientra nel corpo cilindrico azzurro la tensione scende fino a 0 mV

La corsa della testa va da 35 mm (corrispondente a 780 mV) fino a 22. mm (0 mV), per valori di accorciamento superiori il valore e' sempre 0 mV. Si ha quindi una corsa utile di circa 13 mm


Per automatizzare la lettura e permettere la lettura in remoto (all'esterno del laboratorio di geotecnica) la sonda e' stata collegata ad un ingresso analogico della Arduino.
Il valore letto a riposo e' 165 per scendere a 0 a fine corsa. Considerando che la risoluzione di una unita' del convertitore ADC dell'Arduino coincide con circa 4.8 mV si ha una buona corrispondenza con i 780 mV misurati con il tester.
Inoltre visto che la corsa e' di circa 13 mm ed i livelli risultano essere 165 la precisione di campionamento dell'Arduino dovrebbe essere corrispondete al decimo di millimetro

Per permettere la lettura in remoto dei dati la scheda Arduino e' stata programmata come un client UDP che invia le letture ad un server UDP scritto in Python su una Debian Box



La rete e' cosi' configurata
Server : 192.168.0.1
Porta UDP : 5555

Arduino : 192.168.0.2

Lo sketch Arduino utilizzato e' il seguente
-----------------------------------------------
#include <SPI.h>         // needed for Arduino versions later than 0018
#include <Ethernet.h>

byte ardmac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ardip(192, 168, 0, 2);

byte Server[]  = { 192,168,0,1 };  
unsigned int porta = 5555;    
unsigned int localPort = 8888;      // local port to listen on

int sensorPin = A0;    
int sensorValue = 0;  

EthernetUDP Udp;

char buf[12]; // "-2147483648\0"

void setup() {
  Ethernet.begin(ardmac,ardip);
  Udp.begin(localPort);
}

void loop() {
    sensorValue = analogRead(sensorPin);    
    Udp.beginPacket(Server, porta);
    Udp.write(itoa(sensorValue, buf, 10));
    Udp.endPacket();
    delay(1000);
}

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

mentre il server UDP (molto stupido e da implementare con il salvataggio dei dati)
-----------------------------------------------
import socket
UDPSock = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

listen_addr = ("",5555)
UDPSock.bind(listen_addr)
contatore = 0

while True:
        data,addr = UDPSock.recvfrom(1024)
        print data.strip(),contatore
contatore = contatore + 1
-----------------------------------------------
modificando leggermente lo sketch e' possibile utilizzare una Arduino Uno per monitorare fino a 5 sensori

Arduino Uno ed Ethernet Shield

Invece di acquistare una Arduino Ethernet ho preferito provare ad utilizzare un Ethernet Shield per aggiungere le funzionalita' di rete ad una Arduino Uno.
Da un punto di vista di costo non ha molto senso comprare uno shield in quanto l'accoppiata Uno+Ethernet Shield costa piu' o meno quanto una Arduino Ethernet...diciamo che questa soluzione e' piu' flessibile


Shield Ethernet

Per accoppiare le due l'orientamento e' quello indicato nella foto sottostante


Si sovrappongono e si connettono come nella foto successiva. A seconda dei modelli di Arduino non tutti i connettori dello shield trovano un corrispondente header dell'Arduino ma il tutto funziona ugualmente



dal punto di vista della programmazione nell'Arduino IDE deve essere comunque scelta come board l'Arduino Uno anche se poi si possono caricare gli sketch con le funzionalita' di rete

mercoledì 3 luglio 2013

Villa di Rusciano 20 anni dopo

Sono tornato dopo piu' di 20 anni all'interno della Villa Rusciano attuale sede dell'Ufficio Ambiente del Comune di Firenze (motivo della visita) e prima sede del Liceo Gobetti
Il giardino e' decisamente piu' curato e l'edificio risulta essere attualmente  in vendita da parte del  Comune






Mappa frane da news on line

Correva l'anno 2008 ed il mio direttore di Dipartimento mi aveva chiesto di lavorare sui Big Data per estrarre dati di geolocalizzazione...