Selezionando per esempio nell'SDK Manager il Galaxy Tab (attenzione, e' presente solo nella versione Android 2.2)
si avra' la possibilita' di creare una nuova macchina virtuale
mercoledì 29 febbraio 2012
Un aspetto carino e poco conosciuto dell'emulatore Android e' quello di poter simulare non solo telefoni generici ma anche anche modelli specifici ed in alcuni casi anche tablet.
Selezionando per esempio nell'SDK Manager il Galaxy Tab (attenzione, e' presente solo nella versione Android 2.2)
si avra' la possibilita' di creare una nuova macchina virtuale
con una emulazione dotata di risoluzione pari all'orginale
Selezionando per esempio nell'SDK Manager il Galaxy Tab (attenzione, e' presente solo nella versione Android 2.2)
si avra' la possibilita' di creare una nuova macchina virtuale
Syntax Highligthing su Blogger
Avevo voglia di rendere piu' carino il codice scritto sul blog sulla falsariga di phpBB..peccato che su Blogger questa funzione non e' presente.
Seguendo questo esempio si puo' impostare un comodo syntax highlighter
per prima cosa si deve modificare il layout di blogger introducendo le righe
per prima cosa si deve modificare il layout di blogger introducendo le righe
<link href="http://google-code-prettify.googlecode.com/svn/trunk/src/prettify.css" type="text/css" rel="stylesheet" />
<script type="text/javascript" src="http://google-code-prettify.googlecode.com/svn/trunk/src/prettify.js"> </script>
Successivamente si deve modificare il tag body aggiungendo<body onload='prettyPrint()'>Il codice deve essere inserito tra due pre
<pre class="prettyprint"> ...import android.media.AudioRecord; import android.media.MediaRecorder.AudioSource; import android.media.AudioFormat; class recorderThread extends Thread { public boolean recording; //variable to start or stop recording public int frequency; //the public variable that contains the frequency value "heard", it is updated continually while the thread is running. public recorderThread () { </pre>
giovedì 23 febbraio 2012
Html link in AlertDialog
Creare dei link all'interno di un AlertDialog non e' banale
Nell'esempio sottostante sono riportate in grassetto le modifiche rispetto al codice non Html; in particolare l'ultima riga deve essere necessariamente presente e dopo .show altrimenti i link saranno evidenziati ma inutilizzabili
--------------------------------------------------
AlertDialog.Builder conferma_canc = new AlertDialog.Builder(this);
conferma_canc.setTitle("Credits");
conferma_canc.setMessage(Html.fromHtml("App developed by Luca Innocenti (lucainnoc@gmail.com).<a href=\"http://github.com/c1p81\">Source Code Link</a>. "));
conferma_canc.setPositiveButton("Ok", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int id) {
}
});
AlertDialog alert = conferma_canc.create();
alert.show();
((TextView) lert.findViewById(android.R.id.message)).setMovementMethod(LinkMovementMethod.getInstance());
--------------------------------------------------
Dimensioni dello schermo
Uno dei problemi di Android e' che, al contrario di IOs, puo' essere eseguito da una molteplicita' di hardware con caratteristiche differenti in particolar modo per quanto riguarda la risoluzione dello schermo.
Per gestire l'interfaccia visuale e' quindi necessario conoscere le dimensioni dello schermo che sono riportate in
-------------------------------------------------------------------
Display display = getWindowManager().getDefaultDisplay();
int width = display.getWidth();
int height = display.getHeight();
--------------------------------------------------------------------
Per gestire l'interfaccia visuale e' quindi necessario conoscere le dimensioni dello schermo che sono riportate in
-------------------------------------------------------------------
Display display = getWindowManager().getDefaultDisplay();
int width = display.getWidth();
int height = display.getHeight();
--------------------------------------------------------------------
Un programma, due Activity
Il concetto di Activity in Android e' piu' o meno quello di Form in Visual Basic ovvero un gestore di una finestra legata ad un ben preciso compito. Per creare piu' finestre all'interno della stessa attivita' si devono preparare diversi file di layout (nell'esempio sono grid1.xml e main.xml)
Dopo cio' si deve modificare il file Manifest per includere oltre alla schermata principale (main) anche la sottoschermata grid1.
------------------------------------------------------------
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.geo.munsell"
android:versionCode="2"
android:versionName="0.99" android:installLocation="preferExternal">
<uses-sdk android:minSdkVersion="8" />
<application
android:icon="@drawable/icon"
android:label="@string/app_name" >
<activity
android:name=".MunsellActivity"
android:label="@string/app_name"
android:screenOrientation="portrait">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity android:name=".grid1" android:label="@string/app_name"></activity>
</application>
</manifest>
------------------------------------------------------------
da main per aprire la schermata grid1 si esegue la chiamata
------------------------------------------------------------
Intent myIntent = new Intent(MunsellActivity.this, grid1.class);
startActivityForResult(myIntent, 0);
------------------------------------------------------------
Dove MunsellActivity e' l'Activity di main mentre grid1 e' la classe di grid1
Dopo cio' si deve modificare il file Manifest per includere oltre alla schermata principale (main) anche la sottoschermata grid1.
------------------------------------------------------------
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.geo.munsell"
android:versionCode="2"
android:versionName="0.99" android:installLocation="preferExternal">
<uses-sdk android:minSdkVersion="8" />
<application
android:icon="@drawable/icon"
android:label="@string/app_name" >
<activity
android:name=".MunsellActivity"
android:label="@string/app_name"
android:screenOrientation="portrait">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity android:name=".grid1" android:label="@string/app_name"></activity>
</application>
</manifest>
------------------------------------------------------------
da main per aprire la schermata grid1 si esegue la chiamata
------------------------------------------------------------
Intent myIntent = new Intent(MunsellActivity.this, grid1.class);
startActivityForResult(myIntent, 0);
------------------------------------------------------------
Dove MunsellActivity e' l'Activity di main mentre grid1 e' la classe di grid1
Soil Color Chart pubblicata su Android Market
Il programma Soil Color Chart e' stato sviluppato come ausilio per il geologo rilevatore per classificare il colore di un suolo senza la necessita' di portarsi in campagna il libro dei colori di riferimento.
Sono disponibili 115 colori con relativi codici definiti come rappresentativi di tutte le possibili combinazione di colore di rocce e suoli.
All'avvio il programma mostra una galleria di colori con sottostante codice. Si puo' navigare la galleria sia facendo scivolare a destra e sinistra il dito sui rettangoli di colore sia usando la barra in basso allo schermo.
Altrimenti e' possibile avere una differente visione usando l'Option Menu e selezionando la modalita' Grid View
In questo modo si ha una comparazione piu' immediata delle differenze cromatiche
cliccando su un colore si ha il relativo codice e nome
Per tornare alla finestra precedente e' sufficiente cliccare sul menu Escape
Sono disponibili 115 colori con relativi codici definiti come rappresentativi di tutte le possibili combinazione di colore di rocce e suoli.
All'avvio il programma mostra una galleria di colori con sottostante codice. Si puo' navigare la galleria sia facendo scivolare a destra e sinistra il dito sui rettangoli di colore sia usando la barra in basso allo schermo.
Altrimenti e' possibile avere una differente visione usando l'Option Menu e selezionando la modalita' Grid View
In questo modo si ha una comparazione piu' immediata delle differenze cromatiche
cliccando su un colore si ha il relativo codice e nome
Per tornare alla finestra precedente e' sufficiente cliccare sul menu Escape
mercoledì 22 febbraio 2012
Passare variabili globali
Passare il valore di una variabile tra differenti classi non e' esattamente una operazione banale in quanto ci si deve affidare ad una apposita classe. Nella classe devono essere contenute le variabili che si desiderano essere globali ed i metodi per settare e richiamare il valore della variabile
-------------------------------------------------------------------------
class MyApp extends Application {
int width;
int height;
public int getwidth(){
return width;
}
public void setwidth(int s){
width = s;
}
public int getheight(){
return height;
}
public void setheight(int s){
height = s;
}
private int myVar = 0;
private static MyApp instance;
static {
instance = new MyApp();
}
private MyApp() {
}
public static MyApp getInstance() {
return MyApp.instance;
}
}
-------------------------------------------------------------------------
per settare il valore delle variabili si procede cosi'
-------------------------------------------------------------------------
MyApp.getInstance().setheight(height);
MyApp.getInstance().setwidth(width);
-------------------------------------------------------------------------
mentre per richiamare il valore...
-------------------------------------------------------------------------
int w = (int) (MyApp.getInstance().getwidth()*0.9);
int h = (int) ((int) (MyApp.getInstance().getheight())*0.7);
-------------------------------------------------------------------------
-------------------------------------------------------------------------
class MyApp extends Application {
int width;
int height;
public int getwidth(){
return width;
}
public void setwidth(int s){
width = s;
}
public int getheight(){
return height;
}
public void setheight(int s){
height = s;
}
private int myVar = 0;
private static MyApp instance;
static {
instance = new MyApp();
}
private MyApp() {
}
public static MyApp getInstance() {
return MyApp.instance;
}
}
-------------------------------------------------------------------------
per settare il valore delle variabili si procede cosi'
-------------------------------------------------------------------------
MyApp.getInstance().setheight(height);
MyApp.getInstance().setwidth(width);
-------------------------------------------------------------------------
mentre per richiamare il valore...
-------------------------------------------------------------------------
int w = (int) (MyApp.getInstance().getwidth()*0.9);
int h = (int) ((int) (MyApp.getInstance().getheight())*0.7);
-------------------------------------------------------------------------
martedì 21 febbraio 2012
Android Screenshot
per salvare la schermata di un programma qualsiasi ed al di fuori di Eclipse si puo' usare nella directory tools dell'SDK il comando DDMS,selezionare il device nella finestra Name e poi scegliere il menu Device/Screen Capture o piu' semplicemente premendo CTRL-S
Reverse USB Tethering
Detto in italiano, come sfruttare la connessione Internet del PC per navigare con il telefono Android usando il cavo dati USB
Per prima cosa si deve mettere il telefono in modalita' Aereo e poi come root sulla Linux Box lanciare il seguente script (dove 192.168.1.7 e' l'IP del computer che deve essere modificato secondo le necessita')
--------------------------------------------------------------------------
# Linux <-> Android Reverse Tethering Script
# This script tether the internet from your PC *to* the phone
# Some apps will not recognize the connection
# See http://ajasmin.wordpress.com/2011/07/24/android-usb-tethering-with-a-linux-pc/
# Path to ADB
export ADB=/home/luca/android_sdk/platform-tools/adb
if [ $USER != "root" ]; then
echo "Please run this script as root"
exit
fi
echo "Enabling NAT on `hostname`..."
echo 1 > /proc/sys/net/ipv4/ip_forward
iptables -t nat -F
iptables -t nat -A POSTROUTING -j MASQUERADE
echo "Connecting to the phone via 'adb ppp'..."
$ADB ppp "shell:pppd nodetach noauth noipdefault defaultroute /dev/tty" nodetach noauth noipdefault notty 192.168.1.7:10.0.0.2
echo "Done."
Per prima cosa si deve mettere il telefono in modalita' Aereo e poi come root sulla Linux Box lanciare il seguente script (dove 192.168.1.7 e' l'IP del computer che deve essere modificato secondo le necessita')
--------------------------------------------------------------------------
# Linux <-> Android Reverse Tethering Script
# This script tether the internet from your PC *to* the phone
# Some apps will not recognize the connection
# See http://ajasmin.wordpress.com/2011/07/24/android-usb-tethering-with-a-linux-pc/
# Path to ADB
export ADB=/home/luca/android_sdk/platform-tools/adb
if [ $USER != "root" ]; then
echo "Please run this script as root"
exit
fi
echo "Enabling NAT on `hostname`..."
echo 1 > /proc/sys/net/ipv4/ip_forward
iptables -t nat -F
iptables -t nat -A POSTROUTING -j MASQUERADE
echo "Connecting to the phone via 'adb ppp'..."
$ADB ppp "shell:pppd nodetach noauth noipdefault defaultroute /dev/tty" nodetach noauth noipdefault notty 192.168.1.7:10.0.0.2
echo "Done."
--------------------------------------------------------------------------
successivamente si lancia da utente normale il comando adb shell e si digita
--------------------------------------------------------------------------
sh-3.2# setprop net.dns1 151.99.125.2
--------------------------------------------------------------------------------------------
dove 151.99.125.2 e' il DNS di riferimento
A questo punto si puo' navigare nel market o su Internet
 |
| Notare l'icona dell'aeroplano |
lunedì 20 febbraio 2012
Centra TextView su un layout
Centrare una TextView rispetto al Layout non e' banale
<TextView
android:id="@+id/textView1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerInParent="true"
android:layout_gravity="center"
android:text="Large Text"
android:textAppearance="?android:attr/textAppearanceLarge" />
<TextView
android:id="@+id/textView1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerInParent="true"
android:layout_gravity="center"
android:text="Large Text"
android:textAppearance="?android:attr/textAppearanceLarge" />
Nomi delle risorse drawable
Le convenzioni dei nomi delle risorse in Android sono curiose.
I file grafici vengono indicati senza l'estensione (per esempio R.drawable.icon puo' fare riferimento sia ad una jpg che ad una png) ma e' obbligatorio che il nome inizia per una lettera minuscola e che non vi siano caratteri speciali...di fatto il nome delle risorse grafiche deve essere del tipo [a-z][0-9]
I file grafici vengono indicati senza l'estensione (per esempio R.drawable.icon puo' fare riferimento sia ad una jpg che ad una png) ma e' obbligatorio che il nome inizia per una lettera minuscola e che non vi siano caratteri speciali...di fatto il nome delle risorse grafiche deve essere del tipo [a-z][0-9]
Terminare applicazione in Android
Il ciclo di vita di una applicazione Android non e' uguale a quella delle applicazioni Desktop in quanto e' il sistema operativo, in relazione al carico di lavoro ed alla gestione della memoria, che si occupa di come allocare la memoria e quando effettivamente chiudere una applicazione.
Di fatto ogni applicazione si comporta con un utente Linux differente con un proprio ID e con i propri permessi, ogni applicazione viene eseguita all'interno di una propria macchina virtuale con completa separazione rispetto alle altre applicazioni in esecuzione
Detto cio' per far scomparire una Activity dallo schermo e' sufficiente chiamare il comando
finish()
Di fatto ogni applicazione si comporta con un utente Linux differente con un proprio ID e con i propri permessi, ogni applicazione viene eseguita all'interno di una propria macchina virtuale con completa separazione rispetto alle altre applicazioni in esecuzione
Detto cio' per far scomparire una Activity dallo schermo e' sufficiente chiamare il comando
finish()
domenica 19 febbraio 2012
Strip HTML tags in Android
Per rimuovere i tag HTML da una stringa in Android e' sufficiente il comando
String stringa = android.text.Html.fromHtml(stringa_html).toString();
String stringa = android.text.Html.fromHtml(stringa_html).toString();
venerdì 17 febbraio 2012
Screencast con RecordMyDesktop
Un utile programma su Linux per realizzare degli Screencast ovvero dei video del desktop con un commento audio risulta essere RecordMyDesktop.
Per prima si deve selezionate l'area di schermo da catturare (Tutto lo schermo/Finestra), il nome e la qualita' della registrazione
Cliccando su Registra la finestra scompare ed appare una icona nella toolbar (in Gnome in alto) caratterizzata da un quadratino grigio che simula il pulsante di Pausa. Per terminare la registrazione si deve premere questa icona che cambia diventando un puntino rosso per ricominciare a registrare
Il file viene salvato in formato .ogv (che praticamente non viene letto da quasi niente al mondo, Youtube compreso).
Per effettuare la conversione in AVI si puo' procedere da linea di comando con
mencoder screencast.ogv -ovc xvid -oac mp3lame -xvidencopts pass=1 -o screencast.avi
dove screencast.ogv e' il file di input mentre screencast.avi e' quello di output. Il filmato e' quindi pronto per essere postato su Yotube
Per prima si deve selezionate l'area di schermo da catturare (Tutto lo schermo/Finestra), il nome e la qualita' della registrazione
Cliccando su Registra la finestra scompare ed appare una icona nella toolbar (in Gnome in alto) caratterizzata da un quadratino grigio che simula il pulsante di Pausa. Per terminare la registrazione si deve premere questa icona che cambia diventando un puntino rosso per ricominciare a registrare
Il file viene salvato in formato .ogv (che praticamente non viene letto da quasi niente al mondo, Youtube compreso).
Per effettuare la conversione in AVI si puo' procedere da linea di comando con
mencoder screencast.ogv -ovc xvid -oac mp3lame -xvidencopts pass=1 -o screencast.avi
dove screencast.ogv e' il file di input mentre screencast.avi e' quello di output. Il filmato e' quindi pronto per essere postato su Yotube
Importare progetti Android in Eclipse
Importare un progetto Eclipse/Android nella propria Linux Box non e' esattamente banale perche' non e' sufficiente copiare i file a causa di alcuni file di configurazione (.classpath e .project) che sono tipici di ogni installazione Eclipse/Android. Si puo' ovviare con la seguente procedura.
Come esempio si scarichino gli esempi da
svn checkout http://krvarma-android-samples.googlecode.com/svn/trunk/ krvarma-android-samples-read-only
Come esempio si scarichino gli esempi da
svn checkout http://krvarma-android-samples.googlecode.com/svn/trunk/ krvarma-android-samples-read-only
si tratta di diversi esempi di funzioni di Android.
Nel caso in cui si voglia importare il progetto RssReader creare un nuovo progetto Android e selezionare Create project from existing source indicano la cartella dove e' stato scompattato il codice di esempio
Next,selezionare la versione del Build Target e terminare.
Il progetto e' stato importato e puo' essere eseguito
SVN e Proxy HTTP
Per eseguire un comando del tipo
svn checkout http://krvarma-android-samples.googlecode.com/svn/trunk/ krvarma-android-samples-read-only
svn checkout http://krvarma-android-samples.googlecode.com/svn/trunk/ krvarma-android-samples-read-only
stando dietro ad un server proxy si deve andare nella propria home, entrare nella directory nascosta ./.subversion ed editare il file servers nella sezione [global] (circa verso la fine del file) togliendo il segno di nota (#) dati a http-proxy-host e http-proxy-port e modificando i valori a destra del segno uguale con le impostazioni della propria rete
Dalvik
Ripreso e sintetizzato da Wikipedia.
Le applicazioni Android girano all'interno di una macchina virtuale denominata Dalvik che fa parte integrante del sistema operativo Android. I programmi sono di fatto compilati solo come bytecode (differente da quello di Java) e vengono convertiti dal formato .class di Java al formato .dex di Dalvik quando vengono installati sul telefono. Per questo motivo non sono supportate le librerie grafiche AWT e Swing di Java.
Di fatto quindi
In alcuni casi puo' accadere che in fase di compilazione si generi l'errore
Conversion to Dalvik format failed: Unable to execute dex: null
 |
| Immagine ripresa da www.learncomputer.com/what-is-dalvik |
Le applicazioni Android girano all'interno di una macchina virtuale denominata Dalvik che fa parte integrante del sistema operativo Android. I programmi sono di fatto compilati solo come bytecode (differente da quello di Java) e vengono convertiti dal formato .class di Java al formato .dex di Dalvik quando vengono installati sul telefono. Per questo motivo non sono supportate le librerie grafiche AWT e Swing di Java.
Di fatto quindi
- Android ha un sintassi Java
- Effettua una prima compilazione in bytecode Java
- Il codice che effettivamente gira nella macchina virtuale (non Java) e' Dalvik e non Java
In alcuni casi puo' accadere che in fase di compilazione si generi l'errore
Conversion to Dalvik format failed: Unable to execute dex: null
In pratica non e' stata effettuata la conversione in .dex
Alla mia esperienza un Clean sul progetto risolve il problema mentre per altre persone e' necessario aumentare la memoria di Eclipse con un add -Xmx1024m (per i dettagli link)
Aggiungere una libreria esterna ad un progetto Android
Nel caso in cui un comando non esista nel linguaggio di Android si puo' ricorrere alle librerie esterne disponibili....ma come inserirle in un progetto Eclipse??
L'esempio che segue prende come esempio AndroidPlot, una libreria gratuita per creare grafici su Android (link).
Una volta scaricato il file della libreria dal sito si puo' creare un nuovo progetto in Eclipse, cliccando destro sul progetto si deve selezionare New/Folder e si inserisce per esempio il nome lib.
L'esempio che segue prende come esempio AndroidPlot, una libreria gratuita per creare grafici su Android (link).
Una volta scaricato il file della libreria dal sito si puo' creare un nuovo progetto in Eclipse, cliccando destro sul progetto si deve selezionare New/Folder e si inserisce per esempio il nome lib.
 |
| Crea nuova directory nel progetto |
giovedì 16 febbraio 2012
Option Menu
Per creare un Option menu, ovvero il menu che appare in basso allo schermo, si puo' procedere per due vie.
Prima di tutto si deve segnalare che non esiste un sistema unico per aprire un Option Menu. Sull'emulatore si deve premere il tasto Menu
Prima di tutto si deve segnalare che non esiste un sistema unico per aprire un Option Menu. Sull'emulatore si deve premere il tasto Menu
 |
| Cerchiato in rosso il tasto di Option Menu |
Localizzare una applicazione
Creare una versione localizzata, ovvero con le scritte tradotte nella lingua dell'utente, e' un processo piuttosto immediato in Android.
In generale e' buona abitudine non inserire le stringhe relative all'interfaccia grafica ed ai messaggi nel codice ma e' piu' conveniente scriverle nel file di default strings.xml che si trova nella cartella /res/values del progetto Android
In generale e' buona abitudine non inserire le stringhe relative all'interfaccia grafica ed ai messaggi nel codice ma e' piu' conveniente scriverle nel file di default strings.xml che si trova nella cartella /res/values del progetto Android
un esempio di come vengono riferite le stringhe nel file strings.xml si puo' trovare nel codice sottostante
-----------------------------------------------------------------------------------------------
<string name="hello">Hello World, GeocompassActivity!</string>
<string name="app_name">Geocompass</string>
------------------------------------------------------------------------------------------------
per usare la stringa all'interno del codice del programma si puo' referenziare, per esempio, mediante R.strings.hello; in questo modo sara' stampata la stringa Hello World, GeocompassActivity!
Nel file strings.xml si puo' mettere il testo scritto nel linguaggio di default. Se si vuole effettuare una personalizzazione, per esempio in italiano, si deve creare sotto la directory /res/ una nuova cartella /values-it/ in cui copiare il file strings.xml che sara' poi editato per effettuare la traduzione delle stringhe.
Sara' il telefono, in base alle impostazioni contenute in Impostazioni/Impostazioni Lingua e Tastiera a scegliere quale elenco di stringhe utilizzare in modo del tutto trasparente
martedì 14 febbraio 2012
lunedì 13 febbraio 2012
Geocompass released on Android Market
Today the first release of Geocompass, a free and simple Geological Compass (Clinometer).
Il programma e' in fase di beta test su piattaforma Android 2.2 telefono Huawei Vodafone Ideos U8150 con firmware modificato (Dronix 0.4) e schermo 320x240
Uso
Il telefono Android deve essere posto sulla superficie piana dello strato con qualunque orientazione.
Se lo strato da misurare e' rovescio e' necessario cliccare sulla apposita checkbox. Si puo' anche selezionare la formazione su cui viene effettuata la misura (il controllo per la gestire le litologie e la formazioni e' configurabile; di default viene presentato un elenco di litologie ma puo' essere modificato creando sulla SD Card un file formazioni.txt con un elenco continuo di stringhe separate da punto e virgola senza ritorni a capo)
---------------------------------------- Esempio del file formazioni.txt -----------------------------
F.Monte Morello;A. Cervarola;A. Castel Guerino;A. Falterona;Marne Vicchio;Marne Pievepelago;Marne S.Polo;Macigno;A.Modino;Calcari Angulati;Rosso Ammonitico;C.Selc.Limano;Marne Posidonomya;C.Selc.Lima;Diaspri;Calcari Aptici;Maiolica
---------------------------------------- Esempio del file formazioni.txt -----------------------------
La misura viene salvata cliccando sul pulsante "Salva" ed i dati sono inseriti in un file testo posto in /SdCard/geocompass.txt in un formato compatibile con l'importazione in Excel; sono registrati data ed ora dell'acquisizione, punto GPS (se disponibile), Strike, Dip, orientazione dello strato (N=Normale, R=Rovescia) e indicazione della formazione litologica misurata. Il telefono emette un suono per confermare l'avvenuta misura
Le misure sono nettamente piu' speditive in quanto, al contrario dell'impiego di una bussola in cui si deve mettere in bolla, misurare lo Strike, inclinare la bussola e misurare il Dip con Geocompass non e' necessario orientare lo strumento e le due misure vengono effettuate istantaneamente.
-----------------------Esempio file delle misure /sdcard/geocompass.txt------------------
14:07:00 15/02/2012;0;0;293;40;N;A. Castel Guerino
14:07:10 15/02/2012;0;0;175;45;R;Marne Vicchio
14:07:18 15/02/2012;0;0;Dir: 197-17;90;R;Marne Vicchio
14:08:52 15/02/2012;43.7193124;10.95045389;19;37;N;F.Monte Morello
14:08:59 15/02/2012;43.71932407;10.95045727;117;54;N;Calcari Aptici
----------------------------------------------------------------------------------------------------------------------------------
I campi sono delimitati dal carattere ; (punto e virgola)
campo 1 : data e ora dell'acquisizione (hh:mm:ss dd/mm/yyyy)
campo 2 : latitudine punto GPS (gradi decimali punto come separatore decimale)
campo 3 : longitudine punto GPS (gradi decimali punto come separatore decimale)
campo 4 : strike (intero)
campo 5 : dip (intero)
campo 6 : orientamento N/R (normale/rovescia)
campo 6 : formazione (stringa)
Per gli angoli di inclinazioni vengono considerate come orizzontali tutte le misure inferiori a 5° di inclinazione e come verticali tutte le misure superiori a 80°. Nel caso di misura verticale non viene indicato lo strike ma la direzione
Se viene abilitato il sensore GPS del telefono viene inserita anche l'informazione per la georeferenziazione (disponibile solo se e' disponibile il fix gps indicato dalla scritta GPS in colore verde). Il programma funziona correttamente anche senza questa funzione abilitata
Il programma e' in fase di beta test su piattaforma Android 2.2 telefono Huawei Vodafone Ideos U8150 con firmware modificato (Dronix 0.4) e schermo 320x240
Uso
Il telefono Android deve essere posto sulla superficie piana dello strato con qualunque orientazione.
Se lo strato da misurare e' rovescio e' necessario cliccare sulla apposita checkbox. Si puo' anche selezionare la formazione su cui viene effettuata la misura (il controllo per la gestire le litologie e la formazioni e' configurabile; di default viene presentato un elenco di litologie ma puo' essere modificato creando sulla SD Card un file formazioni.txt con un elenco continuo di stringhe separate da punto e virgola senza ritorni a capo)
---------------------------------------- Esempio del file formazioni.txt -----------------------------
F.Monte Morello;A. Cervarola;A. Castel Guerino;A. Falterona;Marne Vicchio;Marne Pievepelago;Marne S.Polo;Macigno;A.Modino;Calcari Angulati;Rosso Ammonitico;C.Selc.Limano;Marne Posidonomya;C.Selc.Lima;Diaspri;Calcari Aptici;Maiolica
---------------------------------------- Esempio del file formazioni.txt -----------------------------
 |
| Misura orizzontale |
La misura viene salvata cliccando sul pulsante "Salva" ed i dati sono inseriti in un file testo posto in /SdCard/geocompass.txt in un formato compatibile con l'importazione in Excel; sono registrati data ed ora dell'acquisizione, punto GPS (se disponibile), Strike, Dip, orientazione dello strato (N=Normale, R=Rovescia) e indicazione della formazione litologica misurata. Il telefono emette un suono per confermare l'avvenuta misura
 |
| Field Test |
-----------------------Esempio file delle misure /sdcard/geocompass.txt------------------
14:07:00 15/02/2012;0;0;293;40;N;A. Castel Guerino
14:07:10 15/02/2012;0;0;175;45;R;Marne Vicchio
14:07:18 15/02/2012;0;0;Dir: 197-17;90;R;Marne Vicchio
14:08:52 15/02/2012;43.7193124;10.95045389;19;37;N;F.Monte Morello
14:08:59 15/02/2012;43.71932407;10.95045727;117;54;N;Calcari Aptici
----------------------------------------------------------------------------------------------------------------------------------
I campi sono delimitati dal carattere ; (punto e virgola)
campo 1 : data e ora dell'acquisizione (hh:mm:ss dd/mm/yyyy)
campo 2 : latitudine punto GPS (gradi decimali punto come separatore decimale)
campo 3 : longitudine punto GPS (gradi decimali punto come separatore decimale)
campo 4 : strike (intero)
campo 5 : dip (intero)
campo 6 : orientamento N/R (normale/rovescia)
campo 6 : formazione (stringa)
Per gli angoli di inclinazioni vengono considerate come orizzontali tutte le misure inferiori a 5° di inclinazione e come verticali tutte le misure superiori a 80°. Nel caso di misura verticale non viene indicato lo strike ma la direzione
Se viene abilitato il sensore GPS del telefono viene inserita anche l'informazione per la georeferenziazione (disponibile solo se e' disponibile il fix gps indicato dalla scritta GPS in colore verde). Il programma funziona correttamente anche senza questa funzione abilitata
domenica 12 febbraio 2012
Geocompass su GitHub
Il progetto della bussola geologica e' stato pubblicato su GitHub
git@github.com:c1p81/Geocompass.git
al momento non e' funzionante
git@github.com:c1p81/Geocompass.git
al momento non e' funzionante
Log su Android (2)
In fase di debugging puo' essere utile non tracciare il programma con il DDMS ma anche inviando i dati al file di log da leggere in diretta mediante Logcat
Per stampare sul file di log il contenuto delle variabili da esaminare si deve aggiungere al programma la chiamata
if (Config.LOGD) Log.d("Nome_programma","Variabile 1 :"+variabile1);
In questo caso viene stampato il valore della variabile1. La prima stringa "Nome_programma" serve ad effettuare un filtro sul comando logcat come per esempio
adb logcat -s Nome_programma:*
In questo modo si vedono solo le parti del log relative al programma in debugging. Il log puo' essere stampato su un file del computer mediante piping
adb logcat -s Nome_programma:* > file_log.txt
Le stesse cose possono essere fatte, con maggiore semplicita' da dentro Eclipse, usando la finestra Logcat in basso nello schermo selezionando l'apposito tab ed impiegando il filtro
Per stampare sul file di log il contenuto delle variabili da esaminare si deve aggiungere al programma la chiamata
if (Config.LOGD) Log.d("Nome_programma","Variabile 1 :"+variabile1);
In questo caso viene stampato il valore della variabile1. La prima stringa "Nome_programma" serve ad effettuare un filtro sul comando logcat come per esempio
adb logcat -s Nome_programma:*
In questo modo si vedono solo le parti del log relative al programma in debugging. Il log puo' essere stampato su un file del computer mediante piping
adb logcat -s Nome_programma:* > file_log.txt
Le stesse cose possono essere fatte, con maggiore semplicita' da dentro Eclipse, usando la finestra Logcat in basso nello schermo selezionando l'apposito tab ed impiegando il filtro
sabato 11 febbraio 2012
Screenshot su Android
per effettuare uno screenshot di una applicazione di propria scrittura in esecuzione sul telefono si puo' andare nel mene DDMS (in alto a destra in Eclipse insieme a Java e Debug)
si apre la finestra in cui si deve scegliere l'icona della macchina fotografica
Un esempio di cattura di schermo di una applicazione su cui sto lavorando adesso la potete trovare nella immagine sottoriportata
Un esempio di cattura di schermo di una applicazione su cui sto lavorando adesso la potete trovare nella immagine sottoriportata
Force portrait
Per impostare lo schermo dell'applicazione in modo che non ruoti muovendo il telefono si deve impostare nel Manifest.xml il comando
<activity
android:name=".GeocompassActivity"
android:label="@string/app_name"
android:screenOrientation="portrait">
<activity
android:name=".GeocompassActivity"
android:label="@string/app_name"
android:screenOrientation="portrait">
venerdì 10 febbraio 2012
Applet Wireless Netowork su Gnome
nel caso si cancellasse erroneamente l'applet che gestisce le connessioni Wi-Fi nella barra di Gnome, questa puo' essere ripristinata cliccando destro sulla barra/Aggiungi al Pannello/Area di Notifica
mercoledì 8 febbraio 2012
Bussola Geologica - Geological Compass
Un utilizzo dei sensori del telefono Android per creare una bussola da rilevamento geologico
Al contrario del normale metodo per orientare la bussola con questo programma basta appoggiare il telefono sulla superficie piana da misurare e si ha direttamente la misura di strike/dip
-------------------------------------------------------------------------------------------
import android, time,math
droid = android.Android()
droid.startSensingTimed(1,1000)
time.sleep(2)
while True:
azimuth = droid.sensorsReadOrientation().result[0]
pitch = droid.sensorsReadOrientation().result[1]
roll = droid.sensorsReadOrientation().result[2]
pimezzi = math.pi/2
cosalfa = math.cos(roll-pimezzi)
cosbeta = math.cos(pitch-pimezzi)
dir_maxpendenza = math.degrees(math.atan(cosalfa/cosbeta))
if (pitch < 0):
dir_maxpendenza = dir_maxpendenza + 180
if ((pitch > 0) and (roll < 0)):
dir_maxpendenza = dir_maxpendenza + 360
dir_maxpendenza = (math.degrees(azimuth)+dir_maxpendenza)% 360
print "Strike : " + str(dir_maxpendenza)
ang_maxpendenza = 90-math.degrees(math.acos(math.sqrt((cosalfa*cosalfa)+(cosbeta*cosbeta))))
print "Dip: "+ str(ang_maxpendenza)
droid.stopSensing()
-------------------------------------------------------------------------------------------
 |
| da http://portal.tugraz.at/portal/page/portal/i_2720/Projects/diggc |
-------------------------------------------------------------------------------------------
import android, time,math
droid = android.Android()
droid.startSensingTimed(1,1000)
time.sleep(2)
while True:
azimuth = droid.sensorsReadOrientation().result[0]
pitch = droid.sensorsReadOrientation().result[1]
roll = droid.sensorsReadOrientation().result[2]
pimezzi = math.pi/2
cosalfa = math.cos(roll-pimezzi)
cosbeta = math.cos(pitch-pimezzi)
dir_maxpendenza = math.degrees(math.atan(cosalfa/cosbeta))
if (pitch < 0):
dir_maxpendenza = dir_maxpendenza + 180
if ((pitch > 0) and (roll < 0)):
dir_maxpendenza = dir_maxpendenza + 360
dir_maxpendenza = (math.degrees(azimuth)+dir_maxpendenza)% 360
print "Strike : " + str(dir_maxpendenza)
ang_maxpendenza = 90-math.degrees(math.acos(math.sqrt((cosalfa*cosalfa)+(cosbeta*cosbeta))))
print "Dip: "+ str(ang_maxpendenza)
droid.stopSensing()
-------------------------------------------------------------------------------------------
martedì 7 febbraio 2012
Git e GitHub
ho spostato il progetto su Git Hub e riporto di seguito un breve tutorial
prima di registrarsi su GitHub e' necessario configurare la propria Linux Box creando le proprie chiavi ssh con il comando
ssh-keygen -t rsa -C "your_email@youremail.com"
formulando la passphrase
successivo passo importante e' quello di definire l'utente che usa Git
git config --global user.name "Firstname Lastname"
git config --global user.email "your_email@youremail.com"
la mail deve essere la stessa con cui e' stata firmata la chiave RSA
successivamete dall'interfaccia del sito si deve creare un repository
per iniziare ad usare il repository ci si deve poi porre nella root del progetto sul disco locale e scrivere
git init
questo comando crea una directory nascosta in cui vengono inseriti i file di configurazione di Git
Dopo di cio' per popolare il server remoto si deve
git add .
git commit -m 'commento al commit'
git remote add origin git@github.com:username/nome_repository.git
git push origin master
prima di registrarsi su GitHub e' necessario configurare la propria Linux Box creando le proprie chiavi ssh con il comando
ssh-keygen -t rsa -C "your_email@youremail.com"
formulando la passphrase
successivamente ci si registra su GitHub e nel menu "Account Settings” > Click “SSH Public Keys” > Click “Add another public key” si deve inserire il contenuto del file rsa.pub contenuto nella directory .ssh della propria home.
Si puo' testare il corretto inserimento digitando ssh -T git@github.comsuccessivo passo importante e' quello di definire l'utente che usa Git
git config --global user.name "Firstname Lastname"
git config --global user.email "your_email@youremail.com"
la mail deve essere la stessa con cui e' stata firmata la chiave RSA
successivamete dall'interfaccia del sito si deve creare un repository
per iniziare ad usare il repository ci si deve poi porre nella root del progetto sul disco locale e scrivere
git init
questo comando crea una directory nascosta in cui vengono inseriti i file di configurazione di Git
Dopo di cio' per popolare il server remoto si deve
git add .
git commit -m 'commento al commit'
git remote add origin git@github.com:username/nome_repository.git
git push origin master
per effettuare gli aggiornamenti si puo' procedere,ponendosi nella directory di radice del progetto sottoposto a Git con
git diff per vedere le differenze con il progetto precedente
git commit -m "stringa" per preparare l'aggiornamento del progetto su GitHub. Fino ad ora comunque non sono state fatte modifiche al sistema di GitHub e tutto rimane in locale. Nella stringa si puo' riassumere in modo stringato le modifiche effettuate
git push -u origin master effettua l'invio e la sincronizzazione con il database remoto
Attenzione: se si sono aggiunti dei file rispetto al commit precedente si deve in modo esplicito digitare il comando
git add nomefile per includere il file nel progetto Git
per aggiungere invece in un colpo solo tutti i file che sono stati creati nel progetto si digita invece
git add . (attenzione al punto finale..e' importante)
con git status si ha un elenco della situazione della sincronia del progetto
se si vuole invece copiare un progetto da git e creare una copia locale (clone) si puo' digitare
git clone git@github.com:c1p81/GpsTest.git
git diff per vedere le differenze con il progetto precedente
git commit -m "stringa" per preparare l'aggiornamento del progetto su GitHub. Fino ad ora comunque non sono state fatte modifiche al sistema di GitHub e tutto rimane in locale. Nella stringa si puo' riassumere in modo stringato le modifiche effettuate
git push -u origin master effettua l'invio e la sincronizzazione con il database remoto
Attenzione: se si sono aggiunti dei file rispetto al commit precedente si deve in modo esplicito digitare il comando
git add nomefile per includere il file nel progetto Git
per aggiungere invece in un colpo solo tutti i file che sono stati creati nel progetto si digita invece
git add . (attenzione al punto finale..e' importante)
con git status si ha un elenco della situazione della sincronia del progetto
se si vuole invece copiare un progetto da git e creare una copia locale (clone) si puo' digitare
git clone git@github.com:c1p81/GpsTest.git
domenica 5 febbraio 2012
DGPS su GitHub
il codice del progetto per il GPS Differenziale e' stato pubblicato su GitHub
al link https://github.com/c1p81/GpsTest
per scaricare il codice si puo' utilizzare il link git@github.com:c1p81/GpsTest.git
al link https://github.com/c1p81/GpsTest
per scaricare il codice si puo' utilizzare il link git@github.com:c1p81/GpsTest.git
Move app su SDCard
Per poter spostare, una volta installata, una applicazione sulla SD e' aggiungere nel file Manifest la scritta installLocation="auto"
-------------------------------------------------------------------------------------------------------------
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.test.gpstest"
android:versionCode="1"
android:versionName="1.0" android:installLocation="auto">
-------------------------------------------------------------------------------------------------------------
altrimenti in modo automatico da dentro Eclipse si puo' usare il menu
-------------------------------------------------------------------------------------------------------------
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.test.gpstest"
android:versionCode="1"
android:versionName="1.0" android:installLocation="auto">
-------------------------------------------------------------------------------------------------------------
altrimenti in modo automatico da dentro Eclipse si puo' usare il menu
giovedì 2 febbraio 2012
Magnetometro come misuratore di distanza
Ho provato ad usare il magnetometro contenuto nel telefono come sensore di distanza. Il sistema prevede l'impiego di una calamita, del telefono Android e dello script riportato di seguito
-----------------------------------------------------------------------------------------
import android, time
droid = android.Android()
droid.startSensingTimed(1, 250)
time.sleep(1)
f = open('/sdcard/magnete00.txt','w')
while True:
s5 = droid.sensorsReadMagnetometer().result
f.write(str(s5[0])+";"+str(s5[1])+";"+str(s5[2])+"\n")
print str(s5[0])+" "+str(s5[1])+" "+str(s5[2])
droid.stopSensing()
-----------------------------------------------------------------------------------------
Il sistema puo' avere impieghi piu' disparati dal realizzare un sistema di allarme (mettendo il magnete su uno stipite di una porta ed il sensore dall'altra) a misuratori di distanza a corto raggio.
La prova e' stata effettuando allontanando il magnete dal telefono e registrando il valore medio ad ogni distanza
Come si puo' vedere dal grafico sottostante
il comportamento del sensore e' ottimale nonostante lo scarso campionamento del convertitore ADC con un errore pari a circa qualche punto percentuale. Con questo sistema e' quindi possibile sicuramente misurare spostamenti dell'ordine di 2mm ma credo sia possibile scendere anche a sensibilita' pari ad 1mm di spostamento
Da notare che le unita' di misura del magnetometro non sembrano essere unita' fisiche. A seguito di una calibrazione con la app Stato GPS i valori sono passati da circa 30 unita' a 15 unita'
-----------------------------------------------------------------------------------------
import android, time
droid = android.Android()
droid.startSensingTimed(1, 250)
time.sleep(1)
f = open('/sdcard/magnete00.txt','w')
while True:
s5 = droid.sensorsReadMagnetometer().result
f.write(str(s5[0])+";"+str(s5[1])+";"+str(s5[2])+"\n")
print str(s5[0])+" "+str(s5[1])+" "+str(s5[2])
droid.stopSensing()
-----------------------------------------------------------------------------------------
Il sistema puo' avere impieghi piu' disparati dal realizzare un sistema di allarme (mettendo il magnete su uno stipite di una porta ed il sensore dall'altra) a misuratori di distanza a corto raggio.
La prova e' stata effettuando allontanando il magnete dal telefono e registrando il valore medio ad ogni distanza
Come si puo' vedere dal grafico sottostante
 |
| Misure magnetometro Distanza-Intensita' |
Da notare che le unita' di misura del magnetometro non sembrano essere unita' fisiche. A seguito di una calibrazione con la app Stato GPS i valori sono passati da circa 30 unita' a 15 unita'
DGPS Test 2
Il metodo del GPS Differenziale prevede una correzione basato sul cacolo delle effemeridi dei satelliti e degli errori degli orologi atomici. L'idea sarebbe quella di effettuare un sistema DGPS usando due GPS di due telefoni senza la pretesa di scendere alla precisione del centimetro ma quanto meno di migliore l'errore di posizionamento di un singolo telefono.
Se i due telefoni sono ragionevolmente vicini (nel raggio di qualche chilometro l'uno dall'altro) e condividono la stessa elettronica saranno ragionevolmente affetti dagli stessi errori sistematici che si possono annullare mantenendone uno fisso
Per il secondo test di GPS differenziale mi sono dotato di due telefoni identici (due Huawei 8150 Ideos Vodafone) con montato il medesimo programma utilizzato per il primo test. I due telefoni sono stati posti uno vicino all'altro (pochi centimetri) fissato il punto in modo simultaneo e messi in registrazione in simultanea
Lo script del test 1 e' stato leggermente modificato in modo da scrivere anche il tempo e data ripresi dall'orologio del telefono ed tempo ripreso dal satellite GPS (loc.getTime())
In particolare e' interessante il secondo valore (espresso in millisecondi a partire dalla data del 1 gennaio 1970 00:00:00) perche' puo' essere utilizzato come sincronizzatore tra le due serie di misure. Questa funzione e' quella impiegata dalla app GPS Time (Market Android). Per passare dallo Unix time in millisecondi al formato data/ora in formato leggibile da un umano si puo' usare in Openoffice Calc la formula
A1/86400000+DATA(1970;1;1) e poi formattando la cella come data/ora (supponendo che il dato da convertire sia nella cella A1)
--------------------------------------------------------------------------------------------------------
package com.test.gpstest;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import android.app.Activity;
import android.os.Bundle;
import android.os.Environment;
import android.content.Context;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.widget.Toast;
public class GpsTestActivity extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
/* Use the LocationManager class to obtain GPS locations */
LocationManager mlocManager = (LocationManager)getSystemService(Context.LOCATION_SERVICE);
LocationListener mlocListener = new MyLocationListener();
mlocManager.requestLocationUpdates( LocationManager.GPS_PROVIDER, 0, 0, mlocListener);
}
public class MyLocationListener implements LocationListener
{
@Override
public void onLocationChanged(Location loc)
{
loc.getLatitude();
loc.getLongitude();
loc.getAccuracy();
String Text = "My current location is: " + "Latitud = " + loc.getLatitude() +"Longitud = " + loc.getLongitude()+" Accuracy = " + loc.getAccuracy();
Toast.makeText( getApplicationContext(),Text,Toast.LENGTH_SHORT).show();
// scrive i dati sul file
try {
File root = Environment.getExternalStorageDirectory();
if (root.canWrite()){
File gpxfile = new File(root, "dati_gps.txt");
FileWriter gpxwriter = new FileWriter(gpxfile,true);
BufferedWriter out = new BufferedWriter(gpxwriter);
//String currentDateTimeString = DateFormat.getDateInstance().format(new Date());
String currentTimeString = new SimpleDateFormat("HH:mm:ss").format(new Date());
out.write(currentTimeString+";"+loc.getTime()+";"+loc.getLatitude()+";"+loc.getLongitude()+";"+loc.getAccuracy()+"\n");
out.close();
}
} catch (IOException e) {
}
}
@Override
public void onProviderDisabled(String provider)
{
Toast.makeText( getApplicationContext(),"Gps Disabled",Toast.LENGTH_SHORT ).show();
}
@Override
public void onProviderEnabled(String provider)
{
Toast.makeText( getApplicationContext(),"Gps Enabled",Toast.LENGTH_SHORT).show();
}
@Override
public void onStatusChanged(String provider, int status, Bundle extras)
{
}
}/* End of Class MyLocationListener */
}
--------------------------------------------------------------------------------------------------------
Come si osserva nei primi istanti l'errore di posizionamento e' alto ma decresce rapidamente fino a 2 metri dichiarati. La distanza relativa tra i due punti e' stata calcolata usando il valore medio di latitudine e longitudine (eliminando i primi punti con HDOP troppo elevata) ed e' risultata di circa 1.2 m
Calcolando la differenza di ogni latitudine e longitudine rispetto al valore medio per i due GPS si osserva una certa correlazione sulla longitudine ma non sulla latitudine
Effettuando una correzione utilizzando i delta di differenza tra i due GPS non si hanno significativi miglioramenti della distanza reciproca tra i sensori
Se i due telefoni sono ragionevolmente vicini (nel raggio di qualche chilometro l'uno dall'altro) e condividono la stessa elettronica saranno ragionevolmente affetti dagli stessi errori sistematici che si possono annullare mantenendone uno fisso
Per il secondo test di GPS differenziale mi sono dotato di due telefoni identici (due Huawei 8150 Ideos Vodafone) con montato il medesimo programma utilizzato per il primo test. I due telefoni sono stati posti uno vicino all'altro (pochi centimetri) fissato il punto in modo simultaneo e messi in registrazione in simultanea
Lo script del test 1 e' stato leggermente modificato in modo da scrivere anche il tempo e data ripresi dall'orologio del telefono ed tempo ripreso dal satellite GPS (loc.getTime())
In particolare e' interessante il secondo valore (espresso in millisecondi a partire dalla data del 1 gennaio 1970 00:00:00) perche' puo' essere utilizzato come sincronizzatore tra le due serie di misure. Questa funzione e' quella impiegata dalla app GPS Time (Market Android). Per passare dallo Unix time in millisecondi al formato data/ora in formato leggibile da un umano si puo' usare in Openoffice Calc la formula
A1/86400000+DATA(1970;1;1) e poi formattando la cella come data/ora (supponendo che il dato da convertire sia nella cella A1)
--------------------------------------------------------------------------------------------------------
package com.test.gpstest;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import android.app.Activity;
import android.os.Bundle;
import android.os.Environment;
import android.content.Context;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.widget.Toast;
public class GpsTestActivity extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
/* Use the LocationManager class to obtain GPS locations */
LocationManager mlocManager = (LocationManager)getSystemService(Context.LOCATION_SERVICE);
LocationListener mlocListener = new MyLocationListener();
mlocManager.requestLocationUpdates( LocationManager.GPS_PROVIDER, 0, 0, mlocListener);
}
public class MyLocationListener implements LocationListener
{
@Override
public void onLocationChanged(Location loc)
{
loc.getLatitude();
loc.getLongitude();
loc.getAccuracy();
String Text = "My current location is: " + "Latitud = " + loc.getLatitude() +"Longitud = " + loc.getLongitude()+" Accuracy = " + loc.getAccuracy();
Toast.makeText( getApplicationContext(),Text,Toast.LENGTH_SHORT).show();
// scrive i dati sul file
try {
File root = Environment.getExternalStorageDirectory();
if (root.canWrite()){
File gpxfile = new File(root, "dati_gps.txt");
FileWriter gpxwriter = new FileWriter(gpxfile,true);
BufferedWriter out = new BufferedWriter(gpxwriter);
//String currentDateTimeString = DateFormat.getDateInstance().format(new Date());
String currentTimeString = new SimpleDateFormat("HH:mm:ss").format(new Date());
out.write(currentTimeString+";"+loc.getTime()+";"+loc.getLatitude()+";"+loc.getLongitude()+";"+loc.getAccuracy()+"\n");
out.close();
}
} catch (IOException e) {
}
}
@Override
public void onProviderDisabled(String provider)
{
Toast.makeText( getApplicationContext(),"Gps Disabled",Toast.LENGTH_SHORT ).show();
}
@Override
public void onProviderEnabled(String provider)
{
Toast.makeText( getApplicationContext(),"Gps Enabled",Toast.LENGTH_SHORT).show();
}
@Override
public void onStatusChanged(String provider, int status, Bundle extras)
{
}
}/* End of Class MyLocationListener */
}
--------------------------------------------------------------------------------------------------------
 |
| Dati non elaborati |
Calcolando la differenza di ogni latitudine e longitudine rispetto al valore medio per i due GPS si osserva una certa correlazione sulla longitudine ma non sulla latitudine
 |
| Differenze di longitudine rispetto alla media |
 |
| Differenze di latitudine rispetto alla media |
 |
| Distanza tra sensori con valori corretti sulla base del valore medio |
Usando un altro approccio ovvero correlando a coppie le varie posizioni GPS allo stesso tempo si osserva una correlazione decisamente piu' stringente
Utilizzando le correlazioni precedenti per correggere i valori delle posizioni GPS le nuove tracce GPS sono le seguenti. Si osserva chiaramente il miglioramento e la sostanziale coincidenza dei dati misurati
 |
| Dati corretti da retta di calibrazione |
 |
| Calcolo della distanza corretta |
La distanza tra i due GPS e' calcolata con il metodo correlatao in circa 4 cm che e' sostanzialmente la reale distanza presente tra i due sensori al momento delle acquisizioni
Questa prova si e' rivelata sostanzialmente un successo che ha comunque necessita' di conferme
Questa prova si e' rivelata sostanzialmente un successo che ha comunque necessita' di conferme
Iscriviti a:
Post (Atom)
Debugger integrato ESP32S3
Aggiornamento In realta' il Jtag USB funziona anche sui moduli cinesi Il problema risiede nell'ID USB della porta Jtag. Nel modulo...
-
In questo post viene indicato come creare uno scatterplot dinamico basato da dati ripresi da un file csv (nel dettaglio il file csv e' c... -
La scheda ESP32-2432S028R monta un Esp Dev Module con uno schermo TFT a driver ILI9341 di 320x240 pixels 16 bit colore.Il sito di riferiment... -
Questo post e' a seguito di quanto gia' visto nella precedente prova Lo scopo e' sempre il solito: creare un sistema che permet...