lunedì 12 agosto 2013

Autenticazione OAuth2 con Google

Mediante le API di Google e' possibile effettuare un sistema di autenticazione basato sulle credenziali di Google ovvero si puo' avere un sistema di verifica username/password basato su un account Google

Per fare cio' in Php per prima cosa si deve creare una applicazione andando su questa pagina https://code.google.com/apis/console/?api=plus&pli=1

Si crea una nuova applicazione

 e si ottengono le chiavi per l'utilizzo delle API


a questo punto si puo' scaricare da questo link la libreria Php per interfacciarsi con le API di Google
Attenzione: il redirect Url e' l'indirizzo dello script che gestisce l'autenticazione. Normalmente Google richiede che sia un indirizzo in https ma si puo' cambiare anche in http (non come per le API di Facebook)

Si puo' quindi inserire lo script in Php riportato alla fine di questo post per verificare l'uso delle API modificando i campi evidenziati in giallo con le proprie chiavi

A questo punto richiamando l'indirizzo dello script in un browser si avranno le seguenti schermate

Richiesta di login



Verifica dei permessi richiesti dall'applicazione (in questo caso minimali)




Conferma dell'avvenuta autenticazione




-----------------------------------------------------
<?php

require_once './api/src/Google_Client.php';
require_once './api/src/contrib/Google_Oauth2Service.php';
session_start();

$client = new Google_Client();
$client->setApplicationName("Google UserInfo PHP Starter Application");

$client->setClientId('30253xxxxxx.apps.googleusercontent.com');
$client->setClientSecret('Yq8K0SS-p28tjQxxxxxxxxxx');
$client->setRedirectUri('http://xxxxxx/luca/google/test.php');
$client->setDeveloperKey('AIzaSyDchpWdZDkRtCmdXRANkXjxxxxxxx');
$oauth2 = new Google_Oauth2Service($client);

if (isset($_GET['code'])) {
  $client->authenticate($_GET['code']);
  $_SESSION['token'] = $client->getAccessToken();
  $redirect = 'http://' . $_SERVER['HTTP_HOST'] . $_SERVER['PHP_SELF'];
  header('Location: ' . filter_var($redirect, FILTER_SANITIZE_URL));
  return;
}

if (isset($_SESSION['token'])) {
 $client->setAccessToken($_SESSION['token']);
}

if (isset($_REQUEST['logout'])) {
  unset($_SESSION['token']);
  $client->revokeToken();
}

if ($client->getAccessToken()) {
  $user = $oauth2->userinfo->get();

  // These fields are currently filtered through the PHP sanitize filters.
  // See http://www.php.net/manual/en/filter.filters.sanitize.php
  $email = filter_var($user['email'], FILTER_SANITIZE_EMAIL);
  $img = filter_var($user['picture'], FILTER_VALIDATE_URL);
  $personMarkup = "$email<div><img src='$img?sz=50'></div>";

  // The access token may have been updated lazily.
  $_SESSION['token'] = $client->getAccessToken();
} else {
  $authUrl = $client->createAuthUrl();
}
?>
<!doctype html>
<html>
<head><meta charset="utf-8"></head>
<body>
<header><h1>Google UserInfo Sample App</h1></header>
<?php if(isset($personMarkup)): ?>
<?php print $personMarkup ?>
<?php endif ?>
<?php
  if(isset($authUrl)) {
    print "<a class='login' href='$authUrl'>Connect Me!</a>";
  } else {
   print "<a class='logout' href='?logout'>Logout</a>";
  }
?>
</body></html>

Tastiera Sony VGP-WKB1/1

Recentemente ho acquisito una tastiera Sony VGP-WBB1/1 destinata ad essere cestinata. Si tratta di una tastiera wireless che in origine era accoppiata ad un computer Sony Vaio Desktop All-in-one.
Oltre che essere un oggetto con un design carino (da notare la possibilita' di piegarla a libro per proteggere i tasti) il fatto di avere un trackpad la rende ideale per la Raspberry

Tastiera aperta

Tastiera ripiegata


Con mia grande ho scoperto che la tastiera e' si' wireless ma non bluetooth. Per farla funzionare e' necessario un ricevitore (proprietario) che era inglobato all'interno del case del computer All-in-one (sembra esistere un ricevitore esterno ma non saprei dove trovarlo) e quindi adesso la tastiera per quanto carina e' sostanzialmente un fermacarte di design...peccato

domenica 11 agosto 2013

Finless 1.7 su MK808

La chiavetta MK808 improvvisamente ha deciso di smettere di funzionare. Il difetto e' piuttosto curioso in quanto Android riusciva a caricarsi fino alla schermata di Home ma al momento di lanciare qualsiasi applicazione questa si chiude senza nessun messaggio di errore.

Visto che l'errore sembrava piu' di natura software che hardware ho provato flashando di nuovo il firmware

Frugando per Internet ho visto che e' disponibile una versione per Android 4.2 a questo link

La procedura di installazione prevede di mettere il dispositivo in flash mode e cio' si ottiene inserendo una graffetta nel buco del case come da foto sottostante

Attenzione alla graffetta !!

A questo punto, premendo sulla graffetta (si sente il click del pulsante nascosto sotto al buco) si inserisce un cavo standard USB tra il computer e la MK808 usando l'ingresso OTG (ovviamente deve essere rimosso l'accessorio OTG che permette di collegare le chiavi di memoria USB)

Windows riconosce il nuovo dispositivo ma non ha i driver per cui si deve scaricare il pacchetto RockusbDriver.rar. Al termine si avra' il nuovo device RK30Device


A questo punto tramite il software RKBatchTool e l'immagine scaricata si puo' flashare la MK808


Alla fine il sistema riparte con Android 4.2 ma con una sorpresa non gradita ovvero che la scheda Wifi non funziona...ho scoperto a posteriore a fronte di un case sempre uguale e nessun identificativo vengono prodotti diversi modelli di MK808 con hardware differente

A questo punto sono passato al firmware Finless 1.7 che si scarica da questo link
Flashare il dispositivo e' molto semplice perche' basta lanciare l'applicativo ROM Flash Tool, cliccare sul pulsante ed attendere

Rom Flash Tool in esecuzione

Alla fine si ha Android 4.1.1 gia' con i permessi di root e con pochissime applicazioni preinstallate in modo da personalizzare al massimo il dispositivo. C'e' anche un pulsante di shutdown in modo da spengere in modo non brutale l'MK808.




Il sistema adesso e' nuovamente funzionante al 100%

lunedì 5 agosto 2013

Da Debian Wheezy (stable) a Jessie (testing)

Qualche tempo fa, con il passaggio da Wheezy al ramo stable di Debian, tutte le mie installazioni sono passate da testing a stable. Il che va piu' che bene in quanto non ci sono particolari motivi per lamentarsi di Wheezy...in ogni caso ero comunque curioso di mantenere almeno un portatile in modalita' testing per cui ho provato a fare il passaggio

La prima cosa da fare e' modificare il file /etc/apt/sources.list modificando la parte evidenziata in giallo per farlo puntare ai repository testing e quindi a Jessie

----------------------------------------------
deb http://ftp.it.debian.org/debian/ testing main contrib non-free
deb-src http://ftp.it.debian.org/debian/ testing main contrib non-free

deb http://security.debian.org/ testing/updates main
deb-src http://security.debian.org/ testing/updates main
----------------------------------------------
Di seguito si eseguono i due comandi nell'ordine

apt-get update
apt-get dist-upgrade

Inizia un processo piuttosto lungo dipendente dal numero di pacchetti installati. E' praticamente tutto installato ad eccezione di una schermata in cui viene richiesta la rimozione del salvaschermo (da effettuare con un kill)


ed una richiesta di conferma di poter riavviare in automatico i servizi (a cui ho risposto di si)
Dopo circa due ore l'upgrade ha fine (ho avuto solo un piccolo problema su Java Oracle) e si puo' avere conferma digitando

cat /etc/issue

che deve rispondere
Debian GNU/Linux jessie/sid \n \l

in fin dei conti sostanzialmente indolore

per terminare
apt-get clean
apt-get autoremove
per cancellare il pacchetti .deb non piu' utili

martedì 30 luglio 2013

Itunes 11.0.4.4.e Proxy Server

Stavo cercando di andare sull'Apple Store da Itunes da una rete che non avevo utilizzato  mai per questo scopo quando mi sono imbattuto in un messaggio strano..ovviamente usando Windows perche' su Linux non si fa e basta


vista la presenza di un proxy nella rete ho cercato le impostazioni nei settaggi di ITunes senza successo...leggendo a giro la versione Windows di ITunes non ha queste impostazioni ma le prende direttamente da Internet Explorer

Breve controllo ed i settaggi di rete sono ok e si naviga dal browser di Microsoft.
Ancora un po' di lettura e trovo che ITunes non digerisce i file di configurazione .pac dei client del proxy server...niente male, metto le configurazioni a mano, controllo di essere in grado di navigare ma niente da fare.

A questo punto i casi sono due
1) il proxy mi filtra il traffico che va verso i server Apple di ITunes (sono piu' di uno leggendo i log di rete)
2) ITunes non ne vuole sapere di bucare un proxy server




Ipod Touch 2G e Debian

Un tentativo di utilizzare l'Ipod Touch 2G con Debian
Ho seguito le istruzioni riportate a questo link direttamente dal sito Debian http://wiki.debian.org/it/iPhone
Si parte da un Ipod con almeno un brano all'interno della libreria


In estrema sintesi su Wheezy si devono fare i seguenti passi
apt-get install install libimobiledevice-utils gvfs-backends gvfs-bin gvfs-fuse

poi si deve modificare /etc/fuse.conf togliendo il commento alla linea #user_allow_other
e si aggiunge il proprio utente al gruppo fuse
usermod -aG fuse luca 

Per sincronizzare a questo punto si puo' usare Rythmbox che si installa banalmente con
apt-get  install rhythmbox rhythmbox-plugins


La procedura e' stata sostanzialmente indolore ed il tutto funziona... non credo sia possibile con il nuovo connettore Lightning

Spedire mail da GMail via Python

Alla ricerca di un metodo per spedire le misure di un sensore attaccato a Raspberry ho trovato il codice di questo sito che permette di inviare mail in automatico mediante un account GMAIL


------------------------------------
#!/usr/bin/env python
import smtplib
from email.mime.text import MIMEText

USERNAME = "lucainnoc@gmail.com"
PASSWORD = "password"
MAILTO  = "rec@toscana.it"

msg = MIMEText('valore sensore')
msg['Subject'] = 'Sensore'
msg['From'] = USERNAME
msg['To'] = MAILTO

server = smtplib.SMTP('smtp.gmail.com:587')
server.ehlo_or_helo_if_needed()
server.starttls()
server.ehlo_or_helo_if_needed()
server.login(USERNAME,PASSWORD)
server.sendmail(USERNAME, MAILTO, msg.as_string())
server.quit()

lunedì 29 luglio 2013

Mediacom 850i e ROM

Ieri ho rimesso mano al Mediacom 850i (fino ad adesso in possesso esclusivo di mio figlio) ed ho cercato un metodo per renderlo un po' piu' reattivo cercando qualche ROM partendo da questo link

In particolare ero curioso della PASCAPEX che necessita' pero' di installare la Cloclworkmod .. e qui sono iniziati i guai. Le istruzioni per CWM su Mediacom 850i si trovano qui ma dopo aver eseguito i programma il tablet non mostrava segni di vita con schermo completamente nero.
In realta' qualche segno di vita era presente perche' connettendo il cavo USB a Windows si vedeva (e sentiva) che una nuova porta era aggiunta..in pratica era come se il tablet fosse in modalita' recovery permanente a schermo spento.

Preso dallo sconforto ho frugato ed ho trovato che e' possibile aggiornare il firmware non solo tramite recovery ma anche utilizzando il software Rockchip Backup Tool (attualmente alla versione 1.4) ed una immagine completa del sistema

Attenzione : per il Mediacom 850i esistono due tipi di driver differenti. Quello per adb che permette la programmazione e di montare le memorie interne del tablet e quello da utilizzare per gestire la recovery (29Rockusb)

Come immagine ho preso vanilla (sembrava essere quella meno pericolosa e buggata) e dopo aver lanciato Rktool il tablet e' ripartito


Forse va un po' meglio di prima per quanto riguarda la velocita' ma e' presente un fastidiosissimo bug sulla gestione della grafica che corrompe alcune schermate. In compenso frugando un po' si trova il market ufficiale (non presente nella precedente versione se non in versione widget)

In ogni caso si puo' scaricare il pacchetto originale di ripristino dove sono contenuti tutti i programmi e le immagini per riportare il sistema all'originale

Partizione GPT in Windows XP

Mi e' capitato di prendere un disco esterno da 500 Gb che non usavo da un po' di tempo e di non riuscire a montarlo su Windows Xp
Il sintomo e' che la periferica e' stata riconosciuta nella catena USB ma non veniva mostrata tra i dischi disponibili. Una verifica sugli strumenti di amministrazione/gestione dischi ha mostrato che il disco risultava integro ma con una partizione di protezione GPT...probabilmente avevo usato il disco su Windows 7.

Rimuovere la partizione GPT da Windows XP non e' banalissimo e comporta comunque la perdita dei dati.
Seguendo le istruzioni sul sito di Lacie si deve


entrare in shell (cmd), lanciare diskpart ed individuare il numero del disco (in questo caso 6)

ed effettuare
select disk 6
clean

a questo punto il disco di puo' formattare sotto Windows XP

venerdì 26 luglio 2013

Ext2/Ext3 su Windows

Dato che ho praticamente tutti i computer su Debian e' abbastanza ovvio che anche i dischi di backup siano formattati con filesytem Linux

Oggi pero' avevo la necessita' di scaricare i dati (e quindi di montare anche in sola lettura) i dischi di backup su un Windows Xp

La prima prova e' stata con Ext2Fsd. Questo metodo funziona ma ha dei grossi limiti, il piu' evidente e' quello di non riuscire a copiare dei file il cui nome includa caratteri speciali (spazi, accenti) il che e' abbastanza comune oggi

Il secondo tentativo e' stato con ExtFs, un prodotto commerciale che una licenza libera per uso personale

Il programma si comporta decisamente meglio del precedente (anche se non e' esente da difetti) e mi ha permesso di copiare oltre 10 Gb di dati con poche correzioni manuali


venerdì 19 luglio 2013

Web Radio con VLC




Controradio
Radio Due
Radio Tre
Radio Capital
Radio Virgin Classic

PiBang su Raspberry

fdsa
Mentre stavo cercando di sostituire LXDE con Openbox su Raspbian mi sono imbattuto in PiBang, una versione compilata per Arm di Crunchbang

A differenza di Raspbian, questa distribuzione si presenta come una versione desktop completa (sono preinstallati Gimp, VLC, Abiword e viene proposto in modo semplice di installare Libreoffice).
Per questo motivo e' necessario utilizzare almeno una SD Card da 4 Gb

Le impressioni di utilizzo sono buone nonostante l'hardware limitato ...fra le altre cose al primo avvio viene proposta di effettuare l'overclock fino ad oltre 1GHz (io mi sono fermato a 900 MHz senza troppi problemi)


L'altro aspetto carino e' la semplicita' di configurazione della rete sia cablata che WiFi



L'unico problema reale che ho riscontrato e' stato al momento di inserire (a sistema operativo avviato) il dongle USB della scheda di rete WiFi...il sistema ha crashato senza possibilita' di recupero ed al successivo riavvio il file system era (ovviamente) corrotto

giovedì 18 luglio 2013

Mandelbrot con Processing+Android

Per mettere alla prova quanto appreso dal post precedente un classico, Mandelbrot
Il programma e' eseguito interamente sul telefono Android dopo essere stato compilato con Processing

Screenshot di Android
Il tempo di esecuzione e' inferiore ai 3 secondi e mezzo sul Samsung Next Turbo

-----------------------------------------
int larghezza = 200;
int altezza = 200;

float re_min = -2.0;
float im_min = -1.2;
float re_max = 1.0;
float im_max = 1.2;
int iterazioni = 255;

float a,b,x,y,x_new,y_new;
int i,j,k;
  
float re_factor=(re_max-re_min);
float im_factor=(im_max-im_min);

void setup() {
  size(200,200);
  background(0,0,0);
  stroke(255);
}

void draw() {
   for (i=0;i<altezza;i++)
    {
      for(j=0;j<larghezza;j++)
      {
        a = re_min+(j*re_factor/larghezza); 
        b = im_min+(i*im_factor/altezza);
   
        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)
             {
             if (k%2 == 0)  point(i,j);
             break;
             }
           x = x_new;
           y = y_new;
           }
  
       }
    }
        
}

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

mercoledì 17 luglio 2013

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

martedì 16 luglio 2013

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


Fauna di mezza estate a Caldine


Nidiaceo di pipistrello

Scarabeo Rinoceronte

lunedì 15 luglio 2013

Usb Host Shield sun Arduino Uno

In questo post verra' descritto l'USB Host Shield Keynes che aggiunge la funzionalita' di utilizzare periferiche USB su una Arduino Uno.
Lo shield si monta come tutti gli altri dello stesso tipo e, oltre a replicare i pin della scheda ed il pulsante di reset, aggiunge una porta USB femmina tipo A
C'e' da specificare che esistono due release dell'USB Host shield...nel mio caso e' la versione 2 che necessita della libreria USB_HOST_Shield_2.0 che si recupera a questo link GitHub


Nella cartella esempi vi sono diversi programma ma nel mio caso mi interessava interfacciare solo HID (Human Interface Devices) ovvero mouse e tastiera
Prima di iniziare una precisazione. Gli esempi nella libreria settano la porta seriale alla velocita' di 115200 baud per cui il monitor seriale dovra' essere impostato di conseguenza (di default si apre a 9600 baud)

Il primo esempio e' USBHIDBootMouse



Questo e' l'output in cui sono riportati i movimenti relativi tra due acquisizioni
Output Mouse
Il secondo e' USBHIDBootKbd


con il relativo output
Output Tastiera



Arduino Uno su Windows

In generale uso veramente di rado Windows e cosi' mi sono accorto solo oggi che connettendo una Arduino Uno in una Windows Box il sistema operativo non riconosce la periferica


Il problema si risolve rapidamente andando installando i driver che si trovano nella directory drivers del software Arduino IDE

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...