venerdì 6 dicembre 2013

Speech To Text in Android

La funzione SpeechToText e' compresa nelle API di Android e permette di parlare al microfono del telefono e ricevere in risposta la stringa di quanto e' stato detto. Possono essere quindi implementati dei comandi vocali associati all'evento ed alla stringa pronunciata



Per provare questo sistema e' stata creata, sulla base una semplice applicazione basata sull'esempio a questo link

L'implementazione e' molto semplice ma ci sono un paio di dettagli non trascurabili
1) Non tutti i telefoni sono abilitati al SpeechToText (per esempio il Samsung Next Turbo GT-5570i non ha questa funzione mentre il Nexus S si'...francamente non riesco a capire il motivo della differenza)

2) La funzione Speech To Text ricalca il modo di lavorare di Siri per Apple. L'elaborazione non avviene in locale ma il file audio viene mandato ai server di Google che lo elaborano e rimandano indietro la stringa del risultato


di seguito il codice

MainActivity.java
---------------------------------------------------------
package com.luca.innocenti.texttospeech;

import java.util.ArrayList;

import android.os.Bundle;
import android.app.Activity;
import android.content.ActivityNotFoundException;
import android.content.Intent;
import android.speech.RecognizerIntent;
import android.view.Menu;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;


public class MainActivity extends Activity {

protected static final int RESULT_SPEECH = 1;
private TextView testo;
private Button pulsante;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

testo = (TextView) findViewById(R.id.textView1);
pulsante = (Button) findViewById(R.id.button1);

pulsante.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View v) {

                Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);

                intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL,       RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);
                intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, "it-IT");

                try {
                    startActivityForResult(intent, RESULT_SPEECH);
                    testo.setText("-------");
                } catch (ActivityNotFoundException a) {
                    Toast t = Toast.makeText(getApplicationContext(),"Speech to Text non disponibile su questo telefono",
                            Toast.LENGTH_SHORT);
                    t.show();
                }
            }
        });
}


@Override
   protected void onActivityResult(int requestCode, int resultCode, Intent data) {
       super.onActivityResult(requestCode, resultCode, data);
 
       switch (requestCode) {
       case RESULT_SPEECH: {
           if (resultCode == RESULT_OK && null != data) {
 
               ArrayList<String> text = data
                       .getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS);
 
               testo.setText(text.get(0));
           }
           break;
       }
 
       }
   }

@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.main, menu);
return true;
}

}
---------------------------------------------------------
activity_main.xml
---------------------------------------------------------
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context=".MainActivity" >

    <Button
        android:id="@+id/button1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentTop="true"
        android:layout_centerHorizontal="true"
        android:layout_marginTop="28dp"
        android:text="Push to Talk" />

    <TextView
        android:id="@+id/textView1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@+id/button1"
        android:layout_centerHorizontal="true"
        android:layout_marginTop="80dp"
        android:text="--------" />

</RelativeLayout>

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

Plotly

update : https://debiaonoldcomputers.blogspot.com/2024/11/update-plotly-dash-csv.html

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

IBook 12.2 A1054

Un nuovo arrivato nella collezione di computer, un IBook A1054 da 12.2 pollici.
Definirlo obsoleto  riduttivo (anche se di fatto e' una macchina con almeno 8 anni di vita perche' la commercializzazione e' finita nel giugno 2005) in quanto dopo 670 cicli di ricarica ha ancora una autonomia di oltre 1 ora di lavoro e la dotazione di oltre 1Gb di ram lo rende idoneo anche per l'ultima Mac Os X che supporta i processori G4 ovvero 10.5.8
Il portatile e' dotato di scheda Airport ma non di Bluetooth (era opzionale su questo modello)
Considerando che e' costato 40 euro, compresa la second skin della Tucano, direi che e' stato un affare
Per la scheda tecnica di dettaglio di questa macchina seguire questo link



MacOs X 10.3 venduto in budle con il computer


giovedì 5 dicembre 2013

IBeacon su Linux, IPhone ed Android

Grazie ad un amico che ha un IPhone ho provato ad usare IBeacon, la tecnologia portata avanti da Apple come anti-RFid, che e' fondamentalmente un sistema di posizionamento indoor (anche se poi puo' essere usato per altri scopi) e di prossimita'

Per prima cosa, per poter utilizzare questo sistema non avendo prodotti recenti Apple, ci si deve dotare un dongle Bluetooth LE (dove LE sta per Low Energy), altrimenti detto Bluetooth 4. In commercio non ne esistono ancora molti e sono ancora meno quelli compatibili con Linux.
La scelta e' caduta su un dongle dotato di chip Broadcom BCM20702 (il costo e' di una quindicina di euro, piu' caro dei normali dongle BT a causa del supporto alle specifiche 4.0)



Questo il log su Linux su come viene riconosciuto il device

-----------------------------------------------------------
Dec  5 08:01:52 debian-T61 kernel: [ 1296.024095] usb 5-2: new full-speed USB device number 3 using uhci_hcd
Dec  5 08:01:52 debian-T61 kernel: [ 1296.194138] usb 5-2: New USB device found, idVendor=0a5c, idProduct=21e8
Dec  5 08:01:52 debian-T61 kernel: [ 1296.194144] usb 5-2: New USB device strings: Mfr=1, Product=2, SerialNumber=3
Dec  5 08:01:52 debian-T61 kernel: [ 1296.194148] usb 5-2: Product: BCM20702A0
Dec  5 08:01:52 debian-T61 kernel: [ 1296.194151] usb 5-2: Manufacturer: Broadcom Corp
Dec  5 08:01:52 debian-T61 kernel: [ 1296.194155] usb 5-2: SerialNumber: 000272C5DC40
Dec  5 08:01:52 debian-T61 mtp-probe: checking bus 5, device 3: "/sys/devices/pci0000:00/0000:00:1d.0/usb5/5-2"
Dec  5 08:01:52 debian-T61 mtp-probe: bus: 5, device: 3 was not an MTP device
-----------------------------------------------------------
Per rendere operativo questo dongle c'e' da fare una piccola modifica
copiando i valori di IdVendor e IdProduct mostrati dal log si deve lanciare il seguente comando

modprobe btusb 
echo "0a5c 21e8" >> /sys/bus/usb/drivers/btusb/new_id
Per poter usare Bluetooth 4 si devono avere le librerie piu' recenti. E' quindi necessario aggiornare il proprio sistema compilando diretttamente da sorgente

apt-get install libusb-dev libdbus-1-dev libglib2.0-dev libudev-dev libical-dev libreadline-dev
wget www.kernel.org/pub/linux/bluetooth/bluez-5.8.tar.xz
unxz bluez-5.11.tar.xz

entrare nella directory 

./configure --disable-systemd
make 
make install

a questo punto le librerie sono installate e si puo' iniziare ad attivare l'IBeacon (ripreso da qui

hcitool -i hci0 cmd 0x08 0x0008 1e 02 01 1a 1a ff 4c 00 02 15 e2 c5 6d b5 df fb 48 d2 b0 60 d0 f5 a7 10 96 e0 00 00 00 00 c5 00 00 00 00 00 00 00 00 00 00 00 00 00

dove UUID e' UUID E2C56DB5-DFFB-48D2-B060-D0F5A71096E0 ovviamente da cambiare tra i vari dispositivi

hciconfig hci0 leadv 0

Impiegando un IPhone 5 IOs7 e l'applicazione LightBlue si puo' osservare i beacon nelle immediate vicinanze del telefono (in questo caso sono presenti due...il secondo e' il dongle attaccato alla Linux Box)



Per essere onesti durante le prove ogni tanto il segnale del Beacon spariva dal cellulare ed era necessario riconfigurarlo su Linux

Impressioni di uso
Il sistema puo' essere interessante ma e' un po' limitato.
Di fatto l'IBeacon non trasporta informazioni al di la' di quella del proprio UUID e la stringa del device.
Non si possono mandare messagi di Push e non si possono gestire eventi su dispositivi mobili.
Per fare in modo che il device mobile interagisca con l'IBeacon e' necessario scrivere una propria applicazione che, per esempio, quando il segnale del beacon e' sufficientemente prossimo (ovvero l'utente e' vicino al beacon) genera un evento come mostrare le informazioni di cio' a cui siamo prossimi (per esempio un quadro in un museo od le caratteristiche di un prodotto in una vetrina)

Fluttuazione dei valori ADC su Arduino 2009

Dopo aver effettuato le misure della cella di carico con un multimetro (vedi questo post) quest'ultimo e' stato sostituito da una Arduino con lettura diretta sulla porta analogica su A0

Nel corso delle misure per la calibrazione della cella di carico e' stato osservato che, anche se i dati del multimetro indicavano una tensione costante, le misure effettuate la lettura di una porta analogica di una Arduino 2009 erano fluttuanti

Nel grafico sottostante si puo' vedere il comportamento di una misura reale di tensione costante (nei limiti dei millivolt) derivante dalla cella di carico

come si osserva le misure oscillano attorno al valore medio di 82 unita' con picchi di +/- 6 unita'

Considerando tutta la curva di taratura si evidenzia che

Curva di taratura cella di carico amplificata INA125p con Arduino

Curva di taratura cella di carico amplificata INA125p con multimetro

Come si vede chiaramente leggere i dati con Arduino degrada in modo sensibile il coefficiente di correlazione (anche se poi per gli scopi previsti non e' cosi' importante)

Dalla scheda tecnica del ATMega328 si ricava che l'errore sull'ADC e' +/- 2.5 unita' sulla lettura.
Da dove viene il rimanente errore??

Leggendo su Internet le fonti di errore possono essere:
1) fluttuazioni sull'alimentazione del circuito: suggerimento consigliato mettere un condensatore tra VCC e GND (gia' fatto nel circuito quindi questo fattore e' da non considerarsi

2) fluttuazione sull'alimentazione dell'Arduino mediante USB: questo sito indica un errore sull'alimentazione pari al 3-5% con alimentazione dell'Arduino via USB. Visto che il riferimento per l'ACD e' data dall'alimentazione e' chiaro quanto possa essere influente questo aspetto.

Per verificare questo aspetto ho costruito molto semplice basato su  un potenziometro usando la stessa scheda impiegata per calibrare la cella di carico

La tensione misurata sul cavo giallo era di 907 mV
Le misure sono state effettuate alimentando l'Arduino sempre via USB una volta connettendo l'alimentatore del portatile ed una volta usando la sola batteria del portatile

Da questa prova si vede chiaramente che l'alimentazione via USB della scheda puo' influire sulle misure ma non in modo cosi' netto come nella prova con la cella di carico (non si vede una chiara periodicita' dei dati e la differenza picco-picco delle misure e' compresa in una unita' e non in 12 come nel caso della cella di carico)

Una possibilita' di valutare e' una interferenza esterna: le misure con il potenziometro sono state fatte a casa mentre le misure con la cella di carico sono state effettuate ad Arcetri presso il laboratorio di geotecnica. Quando facevo il laboratorio di misure elettromagnetiche a Fisica (sempre ad Arcetri) si notavano delle interferenze a causa del ponte radio della vicina stazione di polizia...e' comunque da studiare meglio e verificare



mercoledì 4 dicembre 2013

Instrumentation Amplifier (AD623) per Arduino e cella di carico

Per confronto con il precedente post e' stato provato ad usare un Instrumentation Amplifier differente ovvero l'AD623

Le differenze sono relative ad un minor numero di connessione ed all'uso di una resistenza Rg dell'ordine del KOhm (nel caso in esame il valore di Rg e' stato settato a 158 Ohm)



Nel dettaglio i collegamenti sono i seguente

Pin 1 : a potenzionemetro da 4.7 KOhm settato a 1 KOhm. Collegato a Pin 8
Pin 2 : Segnale ingresso negativo
Pin 3 : Segnale ingresso positivo
Pin 4 : GND
Pin 5 : GND
Pin 6 : Segnale uscita amplificato
Pin 7 : VCC
Pin 8 : vedi Pin 1




Ed ecco il circuito reale. Come nel caso precendete la foto e' stata fatta con il circuito e Arduino alimentate esternamente mediante i canali della breadboard. Il circuito realizzato con Fritzing e' da intendersi con l'Arduino alimentata via USB che a sua volta alimenta AD623


La curva di calibrazione della cella di carico e' sintetizzato nel grafico sotto riportato
I pesi sono variati da circa 250 gr a 21 Kg


la retta riporta una sensibilita' di 6gr/mV con una buona linearita'


Instrumentation Amplifier (INA125P) per Arduino e cella di carico

Partendo dalla sfortunata esperienza dell'uso di LM358 per amplificare il segnale della cella di carico e' stato ripensato e sostituito il componente di amplificazione utilizzando un integrato INA125P che fa parte della classe degli Instrumentation Amplifier (da Wikipedia si puo' vedere nel dettaglio come sono fatti all'interno questi componenti)



Piu' nel dettaglio

Pin 1 INA125P : VCC
Pin 2  INA125P : VCC
Pin 3  INA125P : GND
Pin 4  INA125P : collegato con con Pin 15
Pin 5  INA125P : GND
Pin6  INA125P : Segnale ingresso +
Pin7  INA125P : Segnale ingresso -
Pin8  INA125P : Collegato con una resistenza di 10 Ohm (potenziometro da 100 Ohm) a Pin 9
Pin9  INA125P : Vedi Pin 8
Pin10  INA125P : Collegato con Pin11
Pin11  INA125P : Segnale amplificato in uscita


ed ecco la foto del circuito su breadboard (c'e' una piccola differenza tra lo schema Fritzing e quello della foto: l'alimentazione nel primo caso e' presa da Arduino mentre nel secondo sia Arduino che il circuito sono alimentazioni esternamente tramite batteria a 9 V mediante breadboard....nella calibrazione sottostante e' la stata usata la prima configurazione)
Nel caso in esame il valore di Rg e' stato settato a 45 Ohm



Il tavolo di laboratorio. La cella di carico e' coperta dai pesi da geotecnica all'estrema destra


Ed alla fine la curva di calibrazione con plottati il peso contro i volt


La curva e' stata eseguita in entrambi i sensi (carico e scarico) ma dato che i dati erano identici e' stata riportata solo la fase di carico. Si osserva la netta linearita' della risposta e una ottima stabilita' delle misure
Di fatto il gradiente e' circa 1mV ogni 5gr



venerdì 29 novembre 2013

Calibrazione di Force Gauge con Arduino

Dopo aver completato il circuito di amplificazione visto in questo post ed in questo post  e' arrivato il momento di portarlo in laboratorio per la calibrazione e per verificare che la risposta del sensore alle sollecitazioni fosse corretta

La prova e' stata del tutto insoddisfacente ed il sistema di lettura ha mostrato molti difetti.
E' stato quindi necessario rimettere tutto a posto e verificare dove fosse l'errore.

Per semplicita', prima di prendere in mano il saldatore ho voluto effettuare una simulazione con LTSpice, un software open per la modellizzazione di circuiti elettrici

Il primo passo e' stato cercare il modello di LM358 (il vero modello e non l'operazionale teorico) che si puo' scaricare presso questo link (LTSPiceOpAmp3.zip)
Si copia i file nelle rispettivi directory di LTSpice (vedi pdf allegato nello zip)
Si seleziona quindi il componente Opamps, opamp3
Dopo aver posizionato il componente sullo schema si fa clic destro sul triangolo e si aprono le proprieta'
Doppio Clic su UA741 e si seleziona LM358


Costruito il circuito con le resistenze previste ed e' stata lanciata una simulazione con una tensione variabile da -0.7mV a 0.8mV (il range tipico della cella di carico)
Dal grafico sopra riportato (linea in blu) si vede chiaramente che la risposta del sensore e' del tutto non lineare. Anche dal punto di vista della simulazione il circuito con LM358 non e' adatto allo scopo previsto

Dove sono i limiti del circuito e dell'LM358 per l'uso previsto
Provando una simulazione con un segnale sinusoidale da 200 mV si ha qualche idea in piu'


1) l'integrato funziona in amplificazione soltanto per tensioni negative (studiando un po' di piu' gli operazionali avrei dovuto capirlo da solo ed e' questo il motivo per cui LM741 ha una alimentazione VCC+/VCC- e non VCC+/GND)
2) Forse la corrente da amplificare e' troppo bassa (anche con tensioni con tensioni sempre negative non si ha linearita'

in conclusione il futuro vedra' un paio di test passando da un amplificatore operazionale a quelli che si chiamano "instrumentation  amplifier" con l'uso di un INA126p ed un AD623

giovedì 28 novembre 2013

Fotodiodo TEMT6000 su Arduino

Questo progettino e' vecchio di 4 anni ed e' relativo ad una attivita' durante il dottorato di ricerca. Lo pubblico adesso perche' ho ritrovato le immagini originali

Si tratta di un semplice misuratore di intensita' di luce mediante un fotodiodo TEMT6000. Il collegamento e' semplicemente a tre cavi (alimentazione + 1 collegamento dati verso la porta A0 dell'Arduino)

Attenzione : il componente deve saldato con attenzione. Come da scheda tecnica non puo' essere superata la temperatura di 200°C per piu' di 3 secondi


Come si puo' vedere e' stata utilizzata una Arduino Bluetooth perche' il sensore doveva essere privo di cavo di collegamento che interferissero durante la misura
----------------------------------------------------
int val; 

void setup() 

  Serial.begin(115200);          


void loop() 

  val = analogRead(0);          
  Serial.println(val, DEC);       
  delay(1000);           

mercoledì 27 novembre 2013

Android JellyBean su Samsung GT-5570i (Samsung Next Turbo)

Era da un po' di tempo che aspettavo la possibilita' di aggiornare Android nel mio Galaxy Next Turbo.
A differenza del suo fratello minore Galaxy Next, per lungo tempo non e' stato possibile fare una custom rom non derivante da quella stock a causa dei driver proprietari di alcuni componenti del telefono

Oggi ho trovato (forse con un po' di ritardo) la JellyPlus v.3 , una Rom che permette di installare Android 4.2.2 al posto dell'originale Gingerbread.
La procedure e' piuttosto semplice e lineare.
1) scaricare i file pop_plus_CWM, JellyPlus3_turbo e Gapps_for_Jellyplus_3
2) spengere il telefono ed avviarlo mediante la combinazione On, Vol + e Home
3) selezionare Apply Update/CWM
4) Wipe data/cache
5) Install zip from sd e selezionare JellyPlus3
6) Reboot

in seguito, dall'interno della CWM si puo' effettuare update per installare anche le applicazione Google


L'installazione e' molto lenta ...pazientare


Al termine si puo' vedere il nuovo Android
Le prime impressioni d'uso sono buone ed il sistema funziona meglio che con la stock.

Virus su Android

Questo e' uno dei motivi per cui sarebbe bene ritornare al Nokia 3310

Oggi stavo facendo una scansione del telefono con inserita una vecchia SD card in cui erano presenti degli apk di backup sono stati individuati come Malware/Virus

Penetho.A
Rootcage.B

se l'origine del secondo e' piuttosto spiegabile (praticamente tutti i telefoni che ho sono stati o sono con permessi di root) il secondo e' decisamente piu' preoccupante perche' e' recente (e' stato isolato nel giugno 2013 e non puo' essere una eredita' del mio vecchio Huawei)

Da una ricerca su Internet, Penetho.A e' classificato solo come indesiderabile (nessun furto di informazioni, tracciamento della posizione, spedizione SMS od altri fastidi simili) ma il rischio di incappare in qualcosa di piu' malevolo e' sicuramente presente


C'e' da dire che gli antivirus mobile sono piuttosto permalosi. Sul Nexus S sono state segnalate come criticita' il fatto di avere attivato il Debug Mode, la possibilita' di installare applicazioni da Origini sconosciute e la presenza del root....dato che ogni tanto lo uso per sviluppare non mi sembra che questi siano motivi di allarme

martedì 26 novembre 2013

Clone di Samsung S3

Un amico e' tornato dalla Thailandia con un telefono clone del Samsung S3 pagato circa 70 euro
Quando per mail mi ha parlato del clone pensavo che fosse un telefono con caratteristiche simili ma quando ho avuto modo di vederlo direttamente la parola clone assume un altro significato...il telefono riporta i loghi Samsung su molta componentistica (batteria interna compresa) ed anche nelle stringhe interne ad Android ma ovviamente non e' l'originale. Sono presenti le App ufficiali di Samsung compreso Kies

Notare che l'immagine di Home e' la stessa del vero S4

Il logo Samsung ha iniziato a deteriorarsi

A cover rimossa

Da una breve indagine risulta che:
CPU : DualCore ARMv7 (VFPv3 NEON) Dual Core 1.9 GHz (originale Quad Core)
GPU : PowerVR SGX 531
Risoluzione : 480x800 (originale 1920x1080 Full HD)
Camera principale : 12.8 MPixels
Camera frontale : 1,9 MPixels
Memoria : 503 Mb
RAM : 1800 Mb
Internal SD : 2 Gb (originale minimo 16 Gb)
Sensori di direzione,prossimita',luce, bussola e distanza (l'originale ne ha molti di piu')

Il punteggio del benchmark di AnTuTu e' di 8004.
Per confronto il vero Samsung S4 ha un punteggio di 27435, il mio vetusto Nexus S si attesta a 4944 mentre il mio Nexus 7 2012 a circa 12000.

Una scansione con AVG rileva un malware nell'applicazione (non disinstallabile) UCWeb che non compare nell'elenco delle applicazioni. UCWeb e' un browser molto diffuso in estremo oriente ma e' strano che non compaia nella lista delle app...forse una applicazione malevola che si identifica con un nome conosciuto per nascondersi

In buona sostanza il telefono e' stato pagato per quello che vale (leggendo su Internet viene assimilato ad un Samsung Galaxy S4 Mini ma credo che il paragone sia esagerato)

piccola nota finale: probabilmente il suo codice reale e' MTK6577

Firenze Marathon 2013

Anche quest'anno servizio alla partenza della Firenze Marathon ed anche quest'anno su Repubblica





Certo che l'anno prima l'inquadratura era decisamente migliore
Nel 2012 al cordone di partenza




lunedì 25 novembre 2013

Play Store e SkyGo

E' un po' di tempo che attendo sul mio Nexus 7 2012 attendo l'aggiornamento di Android KitKat e non vedevo arrivare niente
Un po' infastidito sono andato sul PlayStore per vedere se c'era qualche notifica (in realta' dovrebbe comparire nella barra delle notifiche) e con sorpresa c'era un persistente errore di "Connessione Scaduta"


Visto che l'ultima modifica che avevo apportato nell'arco di un mese era quella di installare SkyGo (un amico mi aveva chiesto di provarla sul Nexus7) ho disinstallato l'applicazione, riavviato e come per magia e' ripartito il Play Store.

venerdì 22 novembre 2013

Calibrazione sensore di allungamento

Grazie ad un micrometro e' stato potuto calibrare con precisione il sensore di allungamentopresentato in questo post



Nella tabella sono riportate a sinistra i valori letti sul micrometro ed a destra il corrispondente valore letto direttamente sull'Arduino (i valori a sinistra sono in mm, a destra la lettura del canale analogico dell'Arduino)
Si deve precisare che i valori di lettura analogici sull'Arduino non erano molto stabili e quindi il dato  e' stato letto  come media di 5 misure consecutive


Riportando in grafico in grafico si evidenzia come la retta di taratura sia ottima come coefficiente di correlazione. Dai dati si potrebbe pensare di poter spingere la precisione fino a 5 centesimi di millimetro ma a causa della fluttazione del dato letto dall'Arduino e' piu' ragionevole impostare la sensibilita' della misura a circa il decimo di millimetro




mercoledì 20 novembre 2013

Software per progetto Force Gauge

Il progetto Force Guage sta arrivando al suo termine
L'hardware finale e' stato montato nella sua versione finale
-Arduino Due
-Ethernet Shield
-Amplifier Shield (autoprodotto)

adesso si passa al codice


per Arduino e' stato riutilizzato quasi tutto il codice di questo post
C'e' da annotare che (evindenziato in giallo)
1) per usare il comando itoa in Arduino Due si deve aggiungere  #include "itoa.h"
2) per far funzionare il convertitore analogico digitale di Arduino due a 12 bit lo si deve richiedere esplicitamente con il comando analogReadResolution

Codice Arduino
------------------------------------------
#include <SPI.h>         // needed for Arduino versions later than 0018
#include <Ethernet.h>
#include "itoa.h"

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

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

int sensorPin = A3;    
int sensorValue = 0;  

EthernetUDP Udp;

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

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

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

per il frontend di rappresentazione realtime dei dati e' stato scritto un programmino in Qt che implementa un server UDP e mostra i dati mediante la libreria QCustomplot

Codice Qt (4.8.5)
file .pro (le modifiche sono in giallo)
------------------------------------------
QT      += core gui network

greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

TARGET = geolab
TEMPLATE = app


SOURCES += main.cpp\
        mainwindow.cpp \
    qcustomplot.cpp

HEADERS  += mainwindow.h \
    qcustomplot.h

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

in azzurro le righe di codice relative al server UDP mentre in giallo quelle relative alla visualizzazione del grafico

mainwindow.h
------------------------------------------
#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QtNetwork>
#include <QVector>
#include "qcustomplot.h"


namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT
    
public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();
    
private slots:
    void on_pushButton_clicked();
    void ricevi();

private:
    Ui::MainWindow *ui;
    QUdpSocket *udpSocket;

 };

#endif // MAINWINDOW_H
------------------------------------------
mainwindow.cpp
-------------------------------------------
#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <QtNetwork>
#include <QUdpSocket>
#include <QDebug>

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)

{
    ui->setupUi(this);

    ui->widget->addGraph();
    ui->widget->xAxis->setLabel("x");
    ui->widget->yAxis->setLabel("y");
    ui->widget->xAxis->setRange(0, 10);
    ui->widget->yAxis->setRange(0, 10);
    ui->widget->replot();
}

MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::on_pushButton_clicked()
{
    udpSocket = new QUdpSocket(this);
    QString ip = "192.168.0.1";
    udpSocket->bind(QHostAddress("192.168.0.1"), 7755);
    connect(udpSocket, SIGNAL(readyRead()),
               this, SLOT(ricevi()));

}


void MainWindow::ricevi(){
    while (udpSocket->hasPendingDatagrams()) {
           QByteArray datagram;
           datagram.resize(udpSocket->pendingDatagramSize());
           QHostAddress sender;
           quint16 senderPort;

           udpSocket->readDatagram(datagram.data(), datagram.size(),
                                   &sender, &senderPort);

           qDebug() <<datagram;
           ui->widget->graph(0)->addData(i,datagram.toDouble());
           ui->widget->graph(0)->rescaleValueAxis(true);
           ui->widget->graph(0)->rescaleKeyAxis(true);

           ui->widget->replot();
           QString valore = datagram;
           ui->label->setText("Lettura istantanea : "+valore);

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


Telerilevamento con Beam

Alla ricerca di un software non coperto da licenza per il telerilevamento di dati Landsat ho provato Beam, un software sponsorizzato da ESA

Il programma e' scritto in Java ed eredita da questa scelta una sostanziale lentezza di calcolo e di gestione dei dati in memoria


Fra i pregi, oltre ad essere gratuito, vi e' la possibilita' di aprire una grande quantita' di formati compreso il recente Landsat 8 (sono esclusi i satelliti iperspettrali) ed una serie di algoritmi avanzati (solo per Meris)

Per poterlo utilizzare al momento attuale per i dati Landsat si deve effettuare un aggiornamento mediante Module Manager (Module Updates) del modulo Landsat perche' in agosto 2013 la Nasa, come spesso accade, ha modificato gli header delle immagini

Interessante da aggiungere a posteriori e' il modulo Envi Reader per le immagini salvate in .hdr


lunedì 18 novembre 2013

DIY: riparare un registratore ad audiocassette

Puo' sembrare strano ma c'e' ancora qualcuno che oggi i registratori ad audiocassette e me li porta a riparare dato che non sono piu' acquistabili

Di solito i registratori sono oggetti piuttosto solidi e basta un minimo di assistenza per farli ripartire.
Il modello sotto riportato ha una ventina di anni ed all'accensione si udiva il motore sotto sforzo ma nessun movimento


E' stato sufficiente aprirlo, sostituire le due cinghie di trasmissione oramai non piu' in tensione con due elastici (frecce in rosso) e lubrificare il meccanismo sottostante il volano (il cerchio tra le due frecce) per fare ripartire il registratore

In altri modelli, piu' vecchi, dove il problema e' di tipo elettrico spesso si risolve sostituendo il fusibile nascosto all'interno della scocca


Attaccare una WIFi/WPA mediante WPS e Reaver


Come ex amministratore di rete presso l'universita' e come ex white hat conosco un po' di trucchetti per attaccare una rete WiFi
Con l'arrivo del protezione WPA pero' pensavo che non fosse possibile entrare in una rete Wireless a meno di un colpo di fortuna (l'attacco WPA si basa sulla forza bruta) o stupidita' nella configurazione dell'access point (mi e' capitato di vedere degli access point con la password wpa che coincideva con l'SSID)

Frugando su Internet mi  sono imbattuto in Reaver, un software che sfrutta una vulnerabilita' sull'autenticazione automatica WPS, ed ho voluto provare sulla mia attrezzatura

Ho a disposizione un solo router wireless con capacita' Wps ed e' un access point portatile PN51T.
Per usare Reaver e' inoltre necessario avere a disposizione una scheda di rete che possa entrare in Monitor Mode..con mia grande sorpresa una scheda wifi Alfa AWUS036H su porta USB e dotata di chipset Realtek 8087 supporta questa modalita' in modo eccellente aggiungendo anche una antenna ad alto guadagno



Per usare Reaver conviene usare la distribuzione Back Track in modo da avere gia' tutto configurato

L'attacco e' piuttosto semplice perche si deve mandare prima la scheda in Monitor Mode
airmon-ng start wlan1

dopo si individuano gli access point visibili con capacita' wps mediante wash
wash -i mon0

guardando alla colonna WPS Locked si puo' vedere come alcuni access point siano protetti da questo tipo di attacco (Yes)

Selezionato l'obbiettivo di iniziare l'attacco (che rientra nella categoria di forza bruta perche' prova tutte le combinazioni di wps pin code) 
reaver -b mac_access_point -i mon0 -v


con un po' di disappunto la chiave wpa del mio access point e' stata trovata in meno di 30 secondi.
Il motivo della rapidita' e' che l'access point e' configurato con il pin code di default (12345670) che e' il primo che reaver prova

Un paio di controindicazioni:
1) l'attacco e' molto rumoroso perche' genera traffico per tutto il tempo in cui vengono provati i pin code (possono occorrere anche ore) e quindi e' facile da identificare. Alcuni access point prevedono un numero limitato di tentativi nell'unita' di tempo od addirittura disabilitano il wps dopo un certo numero di tentativi falliti

2) l'access point bersaglio deve essere piuttosto vicino all'attaccante perche' il traffico e' basato su una sequenza precisa di pacchetti che non devono essere persi (nel mio caso questo era sicuramente soddisfatto  perche' trra l'antenna e l'access point c'erano circa 20 cm)

PS: ovviamente questi esperimenti si fanno sulle reti che si amministrano....no su quelle dei vicini anche perche' e' reato 

venerdì 15 novembre 2013

Utilizzo di IP Camera Maygion su Linux

aggiornamento 20 maggio 2016
---------------------------------------
se si collega la camera con il cavo 192.168.1.111
per resettare il firmware si seguono le istruzioni a questa pagina
le istruzioni sul movimento della ptz del codice Python non sono esattamente corrette. Debuggando
la pagina web dell'amministrazione della camera le istruzioni corrette sono



html=urlopen(ur+"moveptz.xml?dir="+direzione+"&user=admin&password=admin")
time.sleep(0.1)
html=urlopen(ur+"moveptz.xml?dir=stop&user=admin&password=admin"

in pratica si fa movimento in una direzione, si attende e poi si stoppa, altrimenti il movimento va a fine corsa
---------------------------------------


Per cercare un sostituto a basso costo della IP Camera Samsung PTZ vista in questo post mi sono per una trentina di euro questa Ip Camera non marcata su un e-commerce cinese

La cosa divertente dell'acquistare prodotti cinesi e' che arrivano totalmente privi di istruzioni e sostanzialmente privi di marca per cui la prima sfida e' stata quella di capire cosa avevo davanti. Il cd incluso con i driver recava un directory denominata asw-380 ed un manuale in inglese ma senza indicazioni di marca e modello.


Guardando in una immagine relativa all'uso del software Android IP Cam Viewer viene riportato che deve essere selezionata l'opzione MayGion IP Camera V3 e questa e' stata l'indicazione fondamentale per individuare il modello.
Per quanto riportato dal manuale la camera e' pilotabile via browser mediante un OCX..quindi non solo sarei stato costretto ad usarlo sotto Windows ma sarei stato costretto ad usare Internet Explorer...la presenza di un programma per Android comunque mi lasciava speranze

La configurazione della rete wireless e' stata semplice perche' sul retro della camera e' disponibile il pulsante WPS per cui il WiFi e' stato autoconfigurato senza l'utilizzo di un computer esterno

Frugando su Internet vi sono frammentarie e scarse informazioni ma sono riuscito a trovare un paio di Pdf in cinese che mostrano la possibilita' di pilotare il dispositivo mediante delle URL (attenzione: esistono due versioni del software della IP Camera MayGion che differiscono sensibilmente, si deve individuare quindi il corretto set di URL)

Per visualizzare lo stream video si puo' utilizzare VLC usando come sorgente del flusso di rete questa URL
http://ipcamera:81/videostream.asf?usr=admin&pwd=admin

Per quanto riguarda il movimento PTZ ho scritto invece un semplice programmino in Python che sfrutta un joystick per muovere la camera

----------------------------------------------
import pygame,time

try:
    from urllib.request import urlopen
except ImportError:
    from urllib2 import urlopen

pygame.init()
j = pygame.joystick.Joystick(0)
j.init()
conta = 0
tick = 100

try:
    while True:
conta=conta+1
        pygame.event.pump()
        if j.get_button(0) == 1:
print "Pulsante 1 : "+str(j.get_button(0))
html=urlopen("http://192.168.0.102:81/cmd.xml?cmd=moveptz&tick="+str(tick)+"&nPtzTimes="+str(conta)+"&dir=up&user=admin&password=admin")
html=urlopen("http://192.168.0.102:81/cmd.xml?cmd=moveptz&nPtzTimes="+str(conta)+"&dir=none&user=admin&password=admin")

        if j.get_button(1) == 1:
print "Pulsante 2 : "+str(j.get_button(1))
html=urlopen("http://192.168.0.102:81/cmd.xml?cmd=moveptz&tick="+str(tick)+"&nPtzTimes="+str(conta)+"&dir=right&user=admin&password=admin")
html=urlopen("http://192.168.0.102:81/cmd.xml?cmd=moveptz&nPtzTimes="+str(conta)+"&dir=none&user=admin&password=admin")

        if j.get_button(2) == 1:
print "Pulsante 3 : "+str(j.get_button(2))
html=urlopen("http://192.168.0.102:81/cmd.xml?cmd=moveptz&tick="+str(tick)+"&nPtzTimes="+str(conta)+"&dir=down&user=admin&password=admin")
html=urlopen("http://192.168.0.102:81/cmd.xml?cmd=moveptz&nPtzTimes="+str(conta)+"&dir=none&user=admin&password=admin")

        if j.get_button(3) == 1:
print "Pulsante 4 : "+str(j.get_button(3))
html=urlopen("http://192.168.0.102:81/cmd.xml?cmd=moveptz&tick="+str(tick)+"&nPtzTimes="+str(conta)+"&dir=left&user=admin&password=admin")
html=urlopen("http://192.168.0.102:81/cmd.xml?cmd=moveptz&nPtzTimes="+str(conta)+"&dir=none&user=admin&password=admin")


        if j.get_button(4) == 1:
print "Pulsante 4 : "+str(j.get_button(4))
tick = tick+25
if tick > 200:
tick = 200

        if j.get_button(5) == 1:
print "Pulsante 5 : "+str(j.get_button(4))
tick = tick-25
if tick < 50:
tick = 25


time.sleep(0.1)

except KeyboardInterrupt:
    j.quit()

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


LLama3 Anita

A seguito di questo post ho provato a vedere ho provato a vedere cosa accadeva ad utilizzare un modello specifico per la lingua italiana in...