Oggi ho partecipato al Linux Day di Dalmine (BG), è stata un’esperienza davvero interessante.
Ho avuto modo di vedere in azione macchine con sistema operativo Ubuntu 9.10, la nuova versione non ancora ufficialmente rilasciata (verrà infatti rilasciata settimana prossima), soprattutto ho avuto modo di vedere la potenza del KMS (Kernel Mode Settings) e di constatare che la mia macchina non lo supporta XD.
E ho anche avuto modo di provare 2 HTC Dream, e mi è venuta una certa acquolina in bocca :p
Peccato che fossi il solo ad avere con me l’Openmoko Neo Freerunner, quest’anno
Purtroppo mi sono perso l’unica conferenza che realmente mi interessava (quella sui diritti digitali) in ogni caso è stato interessante, un’esperienza sempre bella, e ho imparato anche qualche nuova cosuccia (tipo come disattivare il KMS, visto che il mio pc non lo supporta XD).

OpenMoko, the company behind the FreeRunner open-source phone, released their latest product today: WikiReader. It’s a small mobile device for browsing Wikipedia. Rather than use a wireless network to pull data off of the web, it has local copy of the database on a 8GB microSD card. This approach has been used before, and it lets the WikiReader be compact and really cheap. It uses a Kindle-esque touch-screen display that allows it to run on 3 AAA’s for about a year. The device itself costs just $99, but you can choose to receive updates by snail mail for just $29/year. Alternatively, you can just download the +4GB file and dump it on the card.

Like the FreeRunner, this project is also open-source. The code isn’t available yet, but they say it will be released soon. With luck, the device will be really easy to hack.

Eine einfache und schnelle USB-Verbindung auf das Openmoko Freerunner (mit Android OS) wird durch ein kleines Skript erleichtert.

androidshell

Hinweis: Dieser Artikel erschien ursprünglich am 11.5.2009 und erfährt aus rein technischen Gründen eine überarbeitete Neuauflage. Danke für das positive feedback!

Nach der Installation von Android will man schnell Daten zwischen dem lokalen Rechner und dem Freerunner austauschen. Dazu nötig ist die korrekte Netzwerkkonfiguration der lokalen Schnittstelle (z.B. usb0, bei Ubuntu 9.04 eth1), eine bestehende USB-Verkabelung (muss zum Bootzeitpunkt des Freerunners bestehen), sowie eine funktionierende Verbindung via adb (Details: Android auf Freerunner: Einstieg und USB-Networking).

Nach der x-ten Verbindung war ich es Leid, dieselben Befehle immer wieder einzugeben. Ich beschloss also, dies durch ein Skript ein bisschen effektiver zu gestalten. Das Resultat in action sieht dann so aus:

androidshell

Ach ja: das schöne (eigentlich vollkommen unnötige Banner) wurde mit Hilfe von figlet erstellt.

Das Skript nun als “androidshell” umbenennen, ausführbar machen und in PATH ablegen.

#!/bin/sh
# Easily connect to Openmoko phones with Android OS.
# This script first configures your local interface.
# This script then utilizes Android Debug Bridge (adb) to connect.
# Possibly you have to change the variable INT.
# INT may vary on different systems (eth1, usb0, eth0 ...).
# All other variables should be fine.
######################### Configure local interface to connect to android by USB
INT="eth1"              # you might have to change this (eg usb0)
IPADDR="192.168.0.200"  # local IP: should be fine
NETMASK="255.255.255.0" # local netmask: should be fine
IPFREE="192.168.0.202"  # IP freerunner (default): fine
PROGNAME="androidshell" # name of program: no need to change
#########################
######################### make a nice banner
clear
echo "                 _                 _     _          _ _ " | grep --colour "."
echo "  __ _ _ __   __| |_ __ ___ (_) __| |___| |__   ___| | |" | grep --colour "."
echo " / _. | '_ \ / _. | '__/ _ \| |/ _. / __| '_ \ / _ \ | |" | grep --colour "."
echo "| (_| | | | | (_| | | | (_) | | (_| \__ \ | | |  __/ | |" | grep --colour "."
echo " \__,_|_| |_|\__,_|_|  \___/|_|\__,_|___/_| |_|\___|_|_|" | grep --colour "."
echo "      Android on Freerunner - adb connector via USB"      | grep --colour "."
echo "--------------------------------------------------------"
echo "2009 by linuxnetzer -GPLv3- www.linuxnetz.wordpress.com"
echo "--------------------------------------------------------"
echo "                 PLEASE MAKE SURE... " | grep --colour "."
echo "... adb is installed in PATH."
echo "... Freerunner was connected whilst booting."
echo "... $INT is your correct local USB interface."
echo "--------------------------------------------------------"
######################## configure local interface
echo "setting up $INT for connection (needs root privileges)"
sudo ifconfig $INT $IPADDR netmask $NETMASK
######################## prepare adb
echo "preparing adb..."
adb kill-server
ADBHOST="$IPFREE" adb devices 1> /dev/null
echo "If prompt has changed (#), connection was successful."    | grep --colour "\#"
echo "Type 'exit' to finish connection. Keep up the vibes!" | grep --colour "exit"
######################## start adb
adb shell
exit

# chmod +x /usr/local/bin/androidshell

Das Skript sollte – theoretisch – “out of the box ” funktionieren. Sollte die lokale Schnittstelle (im Skript: eth1) nicht erkannt werden, muss die Variable ‘INT’ gleich zu Beginn des Skripts entsprechend geändert werden. usb0 ist eine wahrscheinliche Alternative.

Wer solche Skripten wegen ihres “grafischen Overloads” meidet und die Dinge lieber einfach hält, für den tut es auch ein minimalistisches Skript. Zur Erinnerung: Per default hat Freerunner seiner Schnittstelle die IP Adresse 192.168.0.202 zugeteilt. Um mit ihm zu kommunizieren, müssen wir uns in dasselbe Netz begeben…

#!/bin/sh
sudo ifconfig eth1 192.168.0.200 netmask 255.255.255.0
adb kill-server
ADBHOST=192.168.0.202 adb devices
adb shell

Links:

http://linuxnetz.wordpress.com/2009/05/09/freerunner-android-sd-card-vorbereiten/
http://linuxnetz.wordpress.com/2009/05/05/android-auf-freerunner-einstieg-und-usb-networking/
http://wiki.openmoko.org/wiki/Android_on_Freerunner#On_Linux
http://wiki.openmoko.org/wiki/Android_on_Freerunner#Installing_Android_on_an_SD_card
http://www.freeyourphone.de/portal_v1/viewforum.php?f=18

Che io non sono un consumista, non sono mai stato uno di quei bambini odiosi che al supermercato “voglioquellovoglioquellovoglioquello!!”. Mi sono sempre accontentato, mi sono sempre adagiato e adattato.

Ma sono anche sempre stato uno di quelli pragmatici, se una cosa non mi viene facile o non mi si adatta bene, io non mi sento in ordine, finché non l’ho portata a termine, non l’ho sistemata o non ho chiesto aiuto per appianarla.

Che c’entra tutto questo con il titolo?!

Beh, che io possegga un fantastico NEO FreeRunner della Openmoko (grazie al generosissimo dono della mia ragazza), l’ho sbandierato a destra e a manca, ma che io sia così pirla da preferirgli un cacchio di telefono patacco di fascia bassa, magari può sembrare uno slancio di spocchia che annienterebbe in blocco tutti i miei buoni propositi e il mio predicare bene.

Ma è che io ho bisogno di una tastiera. Una qualsiasi. Sarà forse la mia cecità incipiente, sarà forse la mia abitudine a voler fare più cose contemporaneamente. Ma pur amando le possibilità offerte e le sorprese splendide che la mia saponetta ha in serbo per me, io ho bisogno di sentire di premere materialmente qualcosa, ogni volta che devo scrivere.

Dev’essere un po’ come una di quelle ricompense inutili di cui hanno bisogno i fedeli, quando vanno a confessarsi:
- ho ucciso il trans ebreo che avevo appena stuprato
- dieci pater ave gloria e lasciami in sagrestia il numero di chi te l’ha procurato …
Una di quelle sensazioni appaganti basate su poco. Perché in fondo, io mi trovo bene anche a scrivere su uno schermo più grande, mi trovo bene a cercare la tastiera che più mi aggrada, mi piace poter fare il copia-incolla, ma è proprio che mi devo sentir dire dalla tastiera “ego te absolvo, polpastrellum”.

C’è una sola cosa che mi consola, il fatto che una buona dose delle persone che possiedono il FreeRunner, lo tengano come giocattolo di sviluppo, mentre utilizzino un altro strumento come telefono di tutti i giorni. Sino ad oggi ho potuto constatare che la distribuzione QT Extended (come l’attuale QT moko) sono stabilissime e pienamente utilizzabili (pochi “crash” in 4 mesi e pochi problemi dovuti al fatto di non aver avuto il tempo di applicare alcune modifiche consigliate e già pienamente documentate).

Insomma, è giusto uno sfizio, quando devo scrivere, telefonare e gestire i contatti, ho bisogno di farlo con una tastiera solida, per tutto il resto, mi trovo lussuosamente bene con il mio schermo toccabile (che adesso è diventato la panacea universale, fra poco installeranno degli schermi touch anche sulle mammelle delle mucche, altrimenti i contadini ggggiovani non saprebbero da che parte cominciare).

Quindi mi sento un po’ traditore, ma spero non troppo.

Freerunning/Parkour

1. free runners) use the city and rural landscape to perform acrobatic movements in order to get from point A to point B. It borrows efficient movements from parkour, adds other acrobatics such as tricking and street stunts, creating an athletic and aesthetically pleasing/ (showoff) way of moving. It is commonly practiced at gymnasiums and in urban areas that are cluttered with buildings and obstacles.
2. Parkour can be thought of as being chased by someone. You want to get away as fast as possible, right? But lets say you begin running into rails or walls or other obstacles as such. If you go around them you’re only wasting time and energy.

   The trick of parkour is to use as little wasted movementt while going past an obstacle. This is why most consider tricking and flips “not parkour” as they simply aren’t necessary and will most likely slow you down in someway.

   To parkour is to be able to control your body and mind into one being, so that you can find a path quickly, and move your body in a way that the path can be followed into the next path you’re given. If you’re running towards and obstacle and start to slow down in order to maneuver around it, most likely you need to practice more.

Now think of that metaphorically. I see it as one who will use whatever is in front of him/her to get to their goals, someone doing whatever it takes to defeat any obstacles challenging them.

Dieser Beitrag befasst sich mit der verschlüsselten Datenübertragung zwischen entfernten Rechnern per scp.

Quelle: Wikimedia

Als Szenario dient die Datenübertragung von einem lokalen Rechner auf das Open Source Telefon Openmoko Freerunner. Um auf den Freerunner bequem vom Laptop zuzugreifen, ist ssh sicher eine gute Lösung. Wie in einem früheren Artikel beschrieben, können mit ssh sogar grafische Anwendungen per Fernverbindung ausgeführt werden. Voraussetzung für den Datentransfer ist, dass zwischen beiden Systemen grundsätzlich eine ssh-Verbindung stattfinden kann (Standard Port 22). In diesem Beispiel wird davon ausgegangen, dass beide Systeme im selben lokalen Netz 192.168.0.0 liegen und Nutzer von ssh sich mit Passwort identifizieren.

Das Programm scp (secure copy) basiert auf rcp und nutzt eine ssh-Verbindung, um verschlüsselt zwischen den Rechnern Dateien zu transferieren. Dazu werden die selben Authentifizierungsmechanismen wie bei ssh herangezogen. Im folgenden Beispiel sollen vom lokalen Rechner (192.168.0.20) alle 3 Bilder aus dem Ordner /media/pics/ in das Zielverzeichnis /media/card/pics/ auf die Erweiterungskarte des Freerunners (192.168.0.21; Benutzer: just) kopiert werden.

Dateien mit scp kopieren

/media/pics$ scp * just@192.168.0.21:/media/card/pics/
just@192.168.0.21’s password:

1.png    100% 1817     1.8KB/s   00:00
2.png    100%   82     0.1KB/s   00:00
3.png    100%    0     0.0KB/s   00:00

Dies funktioniert allerdings nur, wenn Verzeichnisse nicht rekursiv kopiert werden sollen. Sonst muss die Option -r an scp angehängt werden:

Verzeichnisse rekursiv kopieren:

scp -r wikinews just@192.168.0.21:/media/card/

Obiger Befehl kopiert den Ordner “wikinews” samt seiner Unterordner und aller Inhalte. Der komplette Ordner findet sich dann auf dem Freerunner unter /media/card/wikinews wieder.

Weitere nützliche Optionen:
-P    Portangabe
-v    verbose (ausführlich)
-q    quiet

Mehr Freerunner Artikel

As i said in my recent post, the sapwood issue with the freerunner have been solved. And the Mer project is ready to release a first tarball which contains the rootfs and the kenrel for the freerunner.

The tarball is hosted by eshopen.com, a freerunner reseller i work with, and can be downloded from here. You need at least a 512 MB microsd to install it. Your Freerunner must have qi installed, to install it just download qi, power on the freerunner pressing the AUX button, connect your freerunner with usb cable and run:

sudo dfu-util -d 0x1d50:0x5119 -a u-boot -R -D qi-s3c6410-andy_8589b40295653557.udfu

After that you can take a microsd, plug on your pc, mount it and do:

cd MOUNTPOINT

sudo tar -xvzf PATH/OF/THE/TARBALL/mer-freerunner-20090603-alpha.tar.gz

You can now plug the microsd and Mer should start.

Known Issues:

1. No phone stack ATM
2. Keyboard is not usable

From a recent talk in #mer on irc.freenode.net it seems that a keyboard engine has been found and we are working on layouts for this engine, you can find more specs at the mer forum.

I’m working to speed the development setting up a x86 virtual image of Mer having the same screen resolution and space of the Freerunner one, so there will be no need to have a Freerunner to develop anymore (and you can use hardware acceleration for tests and rapid development.)

The image will make you able to connect via ssh via the usb link. To do so just boot Mer and then do:

sudo ifconfig usb0 192.168.2.1

ssh root@192.168.2.2

Password is rootme. You will have a full ubuntu system in your hand afterwards…

To start surfing the web from Mer just do these commands in your linux box:

sudo sysctl -w net.ipv4.ip_forward=1

sudo iptables -A POSTROUTING -t nat -j MASQUERADE -s 192.168.2.0/24

And you will be able to share your network connection via the usb cable which connects the Freerunner with your pc.

Finally Maemo/Mer desktop screen on the Freerunner.

A huge milestone have been reached, the sapwood issue, that blocked the development of Mer into Freerunner until now seems to be fixed with recent updates.

The only opened issue is the keyboard. We are looking for a good gtk based virtual keyboard that renders good in the tiny Freerunner screen. If you know one, please tell me.

Soon we will publish some rootfs to test with, stay tuned!

ho rilasciato una nuova versione di bluespam.py, scaricabile da http://minucci.net/file/bluespam.py, con un sacco di funzionalità in piu’.

in pratica ora si puo’ specificare il file da inviare da linea di comando, dentro il sorgente ci sono due variabili da settare per la temporizzazione dell’invio dei file, inoltre salva l’elenco dei file inviati in un database, e scrit in output tutti dei log decenti.

tutte le varie modifiche le ho commentate e spiegate qua http://forum.telefoninux.org/index.php/topic,1373.0.html

questo coso mi servira’ ad un altro progetto che, forse, mi frutterà anche dei soldi

Dieser Artikel beschreibt, wie man auf Ubuntu 9.04 eine SD Card zur Installation von Android auf Freerunner erkennt, partitioniert und mit den korrekten Dateisystemen ausstattet.

Partitionieren für Android

Diese Anleitung sollte größtenteils auch für andere Betriebssysteme gültig sein und bezieht sich auf die Installation auf den internen Flash des Freerunner. Die zweite Möglichkeit, Android direkt auf die sd card zu installieren, wird hier im englischen Wiki beschrieben. Den Vorgang des Flashens an sich habe ich bereits in einem früheren Artikel beschrieben. (Bildquelle: Wikimedia – Lizenz:Creative Commons Attribution ShareAlike 2.0)

Einstieg
Anders als bei Open Moko images benötigt eine Installation von Android auf Freerunner zwei Partitionen: Die erste Partition (/dev/mmcblk0p1) muss im Format FAT sein. Auf dieser Partition (später als /sdcard gemountet) werden all die schönen Bildchen, mp3s und andere Daten landen. Android benötigt eine zweite Partition (/dev/mmcblk0p2, später als /data gemountet), um betriebssystemspezifische Android-Daten zu speichern (Format: ext3).

SD Card erkennen
Zunächst überprüfen wir ob die SD Card überhaupt von unserem Desktopsystem erkannt wird und wie sie bezeichnet wird. Wir müssen die SD Card also über irgendeine beliebige Schnittstelle (hier: SD Card Slot) für Jaunty zugänglich machen. Nach dem Einstecken in den SD Slot poppt bei meinem Jaunty ein Fenster auf, wodurch ich weiß, dass die Karte von Ubuntu erkannt wurde. Um mehr Infos zu erhalten nutze ich auf der Kommandozeile ein ` dmesg |tail ‘ :

# dmesg | tail
[ xxxx.xxxxxx] mmc0: new SDHC card at address 8fe4
[ xxxx.xxxxxx] mmcblk0: mmc0:8fe4 SU08G 7.40 GiB

Meine “8 GB” Karte trägt also die Gerätebezeichnung /dev/mmcblk0 und wird mit 7,4 GB Fassungsvermögen angegeben.

SD Card partitionieren
Mit fdisk kann man die SD Card partitionieren und eigentlich auch die entsprechenden Dateisysteme erstellen. Während auf meiner 2GB SD Card fdisk beide Aufgaben mit Bravour gelöst hat, funktionierte dies bei meiner 8GB Karte nicht. Die Dateisysteme wurden zwar scheinbar korrekt angelegt. Doch weder erkannte Android später das Dateisystem (Bootvorgang abgebrochen), noch erkannte 9.04 die Dateisysteme. Die Lösung war schließlich, mit fdisk zu partitionieren und mit mkfs die Dateisysteme anzulegen. Wir starten fdisk also mit:

sudo fdisk /dev/mmcblk0

Wir legen die erste Partition als FAT an, die zweite als ext3. In meinem Fall legte ich die erste Partition als FAT16 mit 3 GB an. Für die Android-Partition spendierte ich großzügige 312 MB. Hier einige fdisk Optionen:

m    zeigt alle Optionen an
d    löscht eine Partition
n    legt eine neue Partition an
t    ändert den Dateisystemtyp einer Partition
p    zeigt die Partitionstabelle an
q    beendet fdisk ohne zu speichern
w    beendet fdisk und speichert alle Änderungen unwiderruflich

Dateisysteme anlegen:
Nun wollen wir der ersten Partition ein FAT16 Dateisystem verpassen, welches zur späteren besseren Erkennung das label “fat_andr” (Bezeichnung frei wählbar) tragen soll. Wer FAT32 will, nimmt die Option “-F 32″: sudo mkfs.vfat -n fat_andr -F 16 /dev/mmcblk0p1 Analog dazu erstellen wir nun ein ext3 auf der zweiten Partition mit dem label “sys_andr”: sudo mkfs.ext3 -L sys_andr /dev/mmcblk0p2 Fertig!

Android installieren/flashen:
Nun können wir die SD Card an Freerunner übergeben und Android durch Flashen mit dfu-util installieren.  Sehr nützlich ist auch das englische Wiki (siehe links weiter unten), ohne das dieser Artikel sowieseo nie zustande gekommen wäre. Ein deutschsprachiges Forum zu Android auf Freerunner gibt es bei freeyourphone.de

http://linuxnetz.wordpress.com/2009/05/05/android-auf-freerunner-einstieg-und-usb-networking/
http://wiki.openmoko.org/wiki/Android_on_Freerunner#On_Linux
http://wiki.openmoko.org/wiki/Android_on_Freerunner#Installing_Android_on_an_SD_card
http://www.freeyourphone.de/portal_v1/viewforum.php?f=18

Nachdem ich mich in zwei früheren Artikeln mit dem Flashen des Freerunner sowie Zugang per OpenSSH (OM und FDOM) befasst habe, wende ich mich in diesem Artikel der Plattform Android auf dem Openmoko Freerunner zu.

Android auf Openmoko Freerunner

INSTALLATION:
Um Android auf Freerunner zu installieren, muss die SD Karte mit 2 Partitionen formatiert werden (eine FAT und eine EXT3). Außerdem habe ich den Qi Bootloader installiert. Die genauen Anleitungen zur Vorbereitung der Karte und der Installation durch Flashen des Freerunner sind im Wiki Android on Freerunner beschrieben. In meinem Fall kamen Michael Trimarchi`s Images zum Einsatz (http://panicking.kicks-ass.org/download/): freerunner-v14.6.jffs2 (als root fs) und uImage-v17.bin (als kernel image). Das Partitionieren erwies sich als die einfachere Übung. Mit der Ausnahme, dass die im Wiki beschriebene Formatierung der SD Card mit mkfs für die FAT-Partition fehlschlug. Stattdessen machte fdisk die FAT16 Partition ohne zu Murren. Das Flashen der Images per USB-Anschluss erfordert das Tool dfu-util. Auf Ubuntu 9.04 kann dies über die Paketquellen bezogen werden. Das Flashen erfolgte dann nahezu problemlos (bei Problemen der Erkennung von devices siehe auch: Flashen des Freerunner). Android bootete zwar, das Touchpad funktionierte jedoch erst nach der dritten Installation. Keine Ahnung warum.
[EDIT: Mehr Infos zur Installation auf die SDCard gibt es in einem später erschienenen Artikel: Freerunner (Android): SDCard für Installation vorbereiten]
ERSTE POSITIVE EINDRÜCKE:
Mein erster Eindruck von Android war durchaus positiv. Nach 2 Tagen Android kann ich sagen: Vom look and feel ist Android (im Vergleich zu den von mir bis dahin getesteten Distros) eine Klasse für sich. Optisch sehr ansprechend, fingerfreundlich und intuitiv zu bedienen. Es bootet relativ zügig (im Vergleich zu OM und FDOM) und läuft bis jetzt sehr stabil. Die vorinstallierte Menüauswahl und die Optionen zur Konfiguration sind groß. Sehr praktisch ist, dass man AUX und POWER zur Navigation verwenden kann. AUX schließt die zuletzt gestartete Anwendung, POWER öffnet ein Menü.

ERSTE NEGATIVE EINDRÜCKE:
Als erstes habe ich versucht, WLAN (über settings >> Wifi settings) aufzusetzen. Mein heimisches Netz wurde zwar erkannt und ich kam mühelos zum Dialog, um das Passwort einzugeben. Aber wie? Zwar kann man mit einem kurzen Druck auf POWER über ein Menü ein keyboard herzaubern, doch diese liegt später unter dem Wifi-dialog und kann nicht benutzt werden. Hier habe ich mich das erste Mal nach FDOM zurückgesehnt…
Dasselbe Problem gilt für die Eingabe der PIN der SIM-Card. Keine PIN-Eingabe ohne Tastatur. Damit ich erst mal erreichbar bleibe, habe ich die SIM-Card in mein altes Telefon gesteckt und die PIN einfach deaktiviert…
Ein allgemeines Problem bei Freerunner scheint die Lautstärke beim Empfang von Telefonaten zu sein. Auch bei Android hätte ich es gerne ein, zwei Stufen lauter.

USB-NETWORKING PER ADB (SHELL)
Für das Keyboardproblem scheint es zwar einen workaround zu geben, bei dem ein tool installiert wird, um Textinhalte per copy und paste einzufügen. Diesem habe ich mich aber noch nicht zugewendet (und habe auch den link des Forenthreads verloren). Ich versuche die Dinge lieber mit einer shell per USB-Networking zu lösen. Mag Android optisch noch so ansprechend gestaltet sein – ein Zugriff per shell auf das Dateisystem ist einfach unersetzlich zur Konfiguration. Sonst kann man sich gleich ein x-beliebiges Sony Ericsson kaufen (Oh! Nein!). Und so geht`s:

Für den Shellzugriff über einen PC nutzt man adb. Zunächst sollte man das binary von adb herunterladen und innerhalb von PATH ablegen. Shellzugriff erfordert einen reboot des Freerunner. Beim Neustart muss der Freerunner bereits per USB-Kabel mit dem Rechner verbunden sein. Im folgenden Beispiel wurde Ubuntu 9.04 genutzt. Sollte es Probleme geben, kann es helfen, WLAN abzuschalten. An Stelle der Schnittselle eth1 kann es durchaus sein, dass diese usb0 oder sonst irgendwie heißt. Freerunner hat als Standard IP-Konfiguration 192.168.0.202. Zunächst muss also die Schnittstelle so konfiguriert werden, das sie im selben Netzwerk liegt:

sudo ifconfig eth1 192.168.0.200 netmask 255.255.255.0

Dann müssen folgende Befehle ausgeführt werden:

adb kill-server
ADBHOST=192.168.0.202 adb devices

Es ist ein gutes Zeichen, wenn man darauf eine Ausgabe wie die folgende erhält:

* daemon not running. starting it now *
* daemon started successfully *
List of devices attached
emulator-5554    device

Nun kann die shell auf dem Freerunner gestartet werden

adb shell

Voila! Fernzugriff per Ubuntu-Desktop auf Freerunner (mit Android).

FAZIT:
Ob Android mein bevorzugtes System auf Freerunner wird, ist fraglich. Unter FDOM liefen WLAN und GPS, eine Tastatur war immer zur Verfügung. Schauen wir mal, wie es mit Android weitergeht. Schließlich stehe ich ja erst am Anfang meiner Android-Expedition. Dies ist nur mein persönlicher Erfahrungsbericht. Über Hinweise, Ergänzungen usw. würde ich mich freuen.

As you can see from the image, Maemo/Mer is running on a freerunner. You can see the blue Mer background, a window to set up username (it’s first boot ) and a keyboard that pops up when an editable field is touched. As you can see, the keyboard is not rendered correctly and it does not work but we didn’t touch any source of the GUI ATM and it’s very good that it worked without any modification.

Well, what’s supported until now? It runs a 2.6.28 linux kernel the same which is used in debian, so there is gps, gsm, wireless and bluetooth support but i’m not able to test them ATM until we will not solve the GUI issues. But the project looks ver promising from these early stages For now Mer is installed in a microsd and it boots thanks to qi. We (primary Carsten V. Munk) also devoped a imager script wich creates a rootfs. Ready rootfs will be available via mer website this website and eshopen when GUI will work too. In the meantime i’ll publish some snapshots of the working rootfs tree, so all the brave people can start playing with the rootfs

Eshopen, the company i work for, is sponsoring the porting giving a Freerunner to the developer team. In the next few months we will see a lot of changes in the GUI.

But why this project? Why porting Maemo/Mer on the freerunner?

Well, after that Openmoko CEO Sean Moss-Pultz in April 09 said that they will not develop the GTA03, the freerunner successor, due to budget problems, one thing was clear at eshopen: Openmoko will never delop a stable and full working operating system for freerunner. Om is the proof. Even being developed from 2007 it’s not stable enough to be used as an everyday phone. I also never felt confortable with the opkg package manager and i was missing the the wonderful apt-get which is available in debian based systems.

There are some alternatives to OM operating system, but most of them are based on OpenEmbedded (the same as OM) and others, like debian, seems to bring a full working desktop into a mobile phone. Android looks promising but it is not “open enough” (about it you can see the slides of my talk in Politecnico di Milano University for the Neomeeting), instead, the Openmoko community choose the Freerunner to have a 360° openness.

Maemo/Mer seems an answer to a full working and well supported operating system for any open mobile device. To understand more why Maemo/Mer is so open, more than any other operating system for mobile devices is this image:

As you can see it’s a full debian system with Hildon as GUI. It’s a key point cuz you have quite the same environment (if you use ubuntu) of your desktop pc in your mobile phone. You also have access to all the debian applications already packaged and ready to use. In this kind of environment developing an application will be very easy and you can share your applications via a debian repository.

But there is a field in which Maemo/Mer lacks and the Openmoko community developed a good solution: the phone stack. Maemo/Mer borns to be used into tablet pc like nokia n810, not phones, so it does not have any application to make calls. In the other hand the Openmoko community developed the fso framework (frameworkd and so on) which works thanks a standard, dbus, which is already in Maemo/Mer by default. The experimental applicazion to make calls via fso is called zhone and it’s already packaged for debian. As you can see it will be a good field in which Memo/Mer community and Openmoko community could join forces and help eachoter to develop the next generation free operating system for mobile devices.

What to do next?

1. Make GUI work
2. apt-get install fso-frameworkd zhone
3. Test that all works
4. Release stable image

Do you believe in this project and you want to help? Just contact me at vincenzo.ampolo[AT]gmail.com

ho rilasciato una versione embrionalissima, ma relativamente funzionante, di Coypu, una comoda utility per mandare file dall’openmoko verso altri device bluetooth.

Appena si lancia il programma lui ci chiede subito qual’e’ il file da inviare. questa soluzione un po’ posticcia l’ho adottata per fare prima, facendo cosi’ poi non devo impazzire ad aggiungere le funzioni per distruggere e ridisegnare le finestra. quando si seleziona il file e si preme “open”, il path del file viene inviato alla parte del programma per mandare i file. inoltre se si preme “cancel” lui crasha e non ho capito il perche’.

purtroppo lo schermo dell’openmoko e’ stretto e non ci sta tutta la finestrella per la selezione dei file, anche questo e’ un problema da risolvere.

Il programma poi fa la scansione dei device bluetooth, e ci impiega circa un minuto. non so che problemi succedano se i device bluetooth sono un sacco, se ci stanno tutti nella finestra o meno. un altro problema da risolvere.

il bottone sulla destra serve per inviare il file precedentemente selezionare ad un device piuttosto che ad un altro.

c’e’ un altro problema, appena si preme il bottone per inviare il file, il programma sta li senza dire nulla. poi alla fine compare questa finestra che il file e’ stato inviato… o forse no… non ho trovato ancora il modo di verificare che il file sia arrivato o meno, o che sia stato accettato dal ricevente o meno.

tra l’altro ho scoperto che esistono due metodi per inviare i file, uno si chiama obexftp e l’altro obexpush. le differenze non le so, io ho usato obexpush perche’, a quanto pare e’ quello che e’ supportato da piu’ dispositivi diversi. per abilitare le ricezione dei file sull’openmoko bisogna lanciare obexftpd -b a quel punto l’openmoko e’ in grado di ricevere i file col protocollo obexpush (altrimenti tocca usare obexftp) pero’ riceve i file senza chiedere conferma o altro.

insomma… e’ tutto un po’ cosi’… senza certezze

pero’ la funzione principale, ovvero inviare i file, funziona

I’ve published a rootfs of the Maemo/Mer operating system for the freerunner. This is a very experimental version, with NO GUI and with a lot of bug still opened. Ssh access is available, so it’s easy to login and do changes to the system. If you work on this image and you make some changes that you want to share, please consider to mail me with the changes you do. It runs with the qi bootloader and a sd card. To install just do:

cd /tmp

wget http://data.vincenzo-ampolo.net/Projects/Mer/mer-freerunner-09-04-26.tar.gz

sudo tar-xzf mer-freerunner-09-04-26.tar.gz

Mount your sd card on your pc

sudo rsync -aHx freerunner * /mountpoint

Where mountpoint is the mountpoint of your sd card.

Just plug your microsd card into the freerunner and load it. Your freerunner has a default address of 192.168.2.2 and a gateway of 192.168.2.1. So you need to setup your usb0 device in your pc which is connected to the freerunner as 192.168.2.1 like this:

sudo ifconfig usb0 192.168.2.1

If you do:

ping 192.168.2.2

You will be able to ping the frerunner. to login via ssh do:

ssh root@192.168.2.2

Password is rootme.

Please feel free to mail me or comment this post for any suggestion.

Il post sul telefono che avevo dichiarato qualche giorno fa, poi, non l’ho più scritto. Non so perché.

Oggi scrivo questo che, magari non avrà lo stesso effetto o lo stesso valore, ma mi andava di chiarire anche questo aspetto di ciò che faccio, mi capita e in cui credo.

Ho un nuovo telefono, come qualcuno già sa; e mi diverto un mondo ad arrabbiarmici su. È un telefono per smanettoni, viene venduto con quest’avvertenza, ma, forse, non è sufficiente per chi lo considera un prodotto pronto all’uso. La crisi imperante e, probabilmente, l’errata gestione di troppi progetti, ha portato la casa produttrice a decidere di non proseguire nello sviluppo di un successore (il GTA03), ma di convogliare le forze in un “piano B”, di cui non si sa molto. Il post avrebbe dovuto parlare di questo e aiutare la comunità a chiarire questa questione, sorta per colpa di una disinformazione presa sottogamba da troppe testate. Questo paragrafo non sarà poi così efficace, ma io ce l’ho messo ugualmente.

Quello che, invece, vorrei chiarire qui, è un altro punto. Io questo telefono l’ho preso perché ci credo: credo nella possibilità di una concertazione di sforzi gratuitamente infusi per un bene comune; credo nella possibilità di raggiungere livelli di prodotto migliori, grazie alla semplice passione di chi è competente e capace; credo nella forza che più menti e più braccia con quella “scintilla” possono raggiungere.

Purtroppo, però, io non ho le capacità e le nozioni adatte e necessarie per far progredire questo progetto. E questo mi rode e mi dispiace. Ma non per questo demordo.

Continuerò a seguire il forum italiano dedicato al, così ribattezzato,  telefoninux; se possibile aiuterò col tenere in ordine il wiki relativo e, quando sicuro, quello ufficiale-internazionale; proporrò idee e aiuterò a incanalare nel verso giusto gli sforzi di tutti. Ciò che mi ostino a non capire è che NON potrò mai saper fare quello che fanno “loro”.

Ci sono immensi e divertenti thread nei quali mi tuffo entusiasta, che arrivano quasi sempre a un punto di caotici rimandi a “semplici” comandi, che mi ribaltano il cervello e mi lasciano lì, incapace di risolvere una situazione che mi intriga. Oggi ho deciso che dovrò imparare a censurarmi. Quando qualcosa mi interessa, ma raggiunge un livello di preparazione troppo alto per i miei livelli, mi dovrò concedere la lettura di un massimo di tre risposte contenenti parole o concetti comprensibili al solo Sheldon Cooper. Dopodiché – click! e il quadratino arancione con la crocina bianca, verrà premuto.

Mi dispiace seriamente non essere all’altezza di modificare “una semplice variabile” in un incastro di funzioni, ma sono felice di sapere che ci sono persone che lo sanno fare e che non lesinano sforzi per poterlo permettere, in un futuro imprecisato, anche ad altri come me, ai quali se non dai un solo e semplice pulsante da premere, cominciano a tremare, respirare affannato e porsi più domande che sangue al cervello.

Così dico a voi, futuri fruitori di software libero e splendido sui vostri dispositivi mobili: “io ci sono e vi terrò aggiornati. Quando quell’oggetto e il suo contenuto saranno a prova dello stupido che sono, potrete farlo vostro”

mer-freerunner login :

It’s a pic i took 2 weeks ago, a lot of progress have been done and we are still working on it. As soon as possible we hope to release an image.

Good night..

In questo primo intervento non posso che parlare dell’OpenExpo e del discorso di Sean Moss Pulz CEO di Openmoko che forse molti hanno frainteso.

Sarà la Fine? Ma anche no!!!

In molti blog, siti o interventi riguardanti l’argomento ho letto che Openmoko ha deciso di cancellare il progetto che darà vità al GTA03, ovvero il successore del Neo FreeRunner, e che il supporto dell’attuale GTA02  è rimasto in mano alla sola comunità.

Niente di più falso!!!

Le notizie dei vari licenziamenti in casa Openmoko sono vere e di fatto diversi dipendenti, tanto per citarne alcuni Rasterman (che non è stato licenziato ma ha abbandonato Openmoko a favore di Swisscom dove si dedica interamente a e17) e Andy Green, hanno dovuto lasciare il posto per mantenere a galla la barca “bombardata” dalla crisi economica, questo anche perché se pur non avendo potenziali concorrenti Openmoko produce uno smartphone destinato (per il momento) a pochi utenti.

Ma questo non vuole dire che è tutto finito infatti entro aprile  sarà rilasciata la nuova versione “ufficiale” del sistema operativo denominata om2009.4 e lo sviluppo dell’attuale FreeRunner continuerà, difatti è stata già annunciata una settima versione dello smartphone.

Il fondo di verità è che stato effettivamente bloccato momentaneamente lo sviluppo del GTA03, difatti Openmoko ha ritenuto un inutile dispendio di risorse investire ora su questo nuovo smartphone quando ci sono ancora problemi noti da sistemare sull’attuale GTA02 e un parco software ancora immaturo per l’utenza di massa.

Sean ha inoltra accennato a un piano B del quale per il momento si sà ben poco, potrebbe essere un successore del dash un noto detersivo navigatore satellitare sviluppato dalla stessa FIC come potrebbe essere qualcosa di completamente nuovo, staremo a vedere.

In oltre c’è da precisare che i “licenziati” Openmoko non spariscono, infatti alcuni di loro continuano a sviluppare a fianco della comunità, tanto per citarne uno dei precedenti Rasterman, che continua a sviluppare illume, il porting di Enlightment sul Neo che è migliorato visibilmente nel suo ultimo rilascio.

In conclusione vi riporto il comunicato stampa della comunità italiana di telefoninux.org:

L’abbandono del progetto GTA03 da parte di Openmoko ha dato il la per una lunga serie di notizie poco chiare e incomplete. Da queste, non può che risultare un’informazione limitata e fuorviante.

La comunità che utilizza e crede nel progetto OpenMoko ci tiene a precisare che la momentanea sospensione dello sviluppo del nuovo GTA03 non comporterà un abbandono totale dello sviluppo dell’attuale FreeRunner. Anzi, riteniamo che questa pausa debba essere vista come un qualcosa di utile e positivo, che permetterà agli sviluppatori e alla comunità di concentrarsi sul dispositivo attualmente in commercio.

Ognuno di noi, come la stessa casa produttrice, è convinto che il prodotto offerto dalla OpenMoko sia rivolto a un pubblico esperto e che non sia ancora maturo per una commercializzazione su larga scala. Questo ripensamento sarà un’ottima occasione per ultimare lo sviluppo di un software stabile e risolvere gli ultimi problemi che affliggono il prodotto, in modo da poter affrontare il futuro progetto GTA03, forti di nuove esperienze e sicuri di poter raggiungere il più vasto bacino d’utenza possibile.

La comunità italiana continuerà a supportare Openmoko come ha fatto in passato, certa dell’impegno delle corrispondenti straniere.

Per chi fosse interessato al discorso integrale del CEO di Openmoko al OpenExpo 2009 tenutosi a Berna è disponibile questo video:

Se siete interessati alla presentazione di Sean in PDF potete scaricarla al seguente indirizzo:

Presentazione Openmoko@OpenExpo 2009 (PDF)

Mit dem Zugriff über openssh lässt sich das Openmoko auch bequem vom Desktop-PC konfigurieren und mit externen Daten füttern.

Quelle: Wikimedia - Lizenz: GPL

Das Openmoko Freerunner ist nicht nur ein Telefon. Es ist im Grunde ein (nahezu) vollwertiges Betriebssstem. Ein Vorteil ist dabei auch ein Nachteil: Weil der Freerunner so handlich ist, wird die Konfiguration auf der Kommandozeile zur filigranen Geschicklichkeitsübung. Um das Getippe auf dem kleinen Display zu umgehen (und auch, um bequem Daten aufzuspielen), greift man am Besten auf openssh (in diesem Artikel: per USB-Kabel) zurück.

Vorbereitung: Zunächst schließt man das Openmoko mit dem USB-Kabel an den (Linux-)PC an. Der PC hat nun ein weiteres Interface z.B. usb0. Dies kann mit dem Befehl ifconfig überprüft werden. Die Schnittstelle auf dem Freerunner (i.d.R. ebenfalls usb0) hat in der Grundeinstellung die IP-Adresse 192.168.0.202 zugewiesen. Auch dies kann mit dem Befehl ifconfig (auszuführen auf dem Freerunner) geprüft werden.

root@phone# ifconfig usb0
usb0      Link encap:Ethernet  HWaddr xx:xx:xx:xx:xx:xx
inet addr:192.168.0.202 Bcast:192.168.0.255  Mask:255.255.255.0
(…)

1. Zunächst muss dafür gesorgt werden, dass auch die USB-Schnittstelle auf dem PC eine IP zugewiesen bekommt, die im selben Netzwerksegment liegt wie das Openmoko. Beispiel (auf dem PC auszuführen):

ifconfig usb0 192.168.0.200

2. Nun wird die ssh-Verbindung hergestellt. Das Passwort für root ist in der Grundeinstellung leer und wird einfach mit ENTER bestätigt:

# ssh root@192.168.0.202
The authenticity of host ‘192.168.0.202 (192.168.0.202)’ can’t be established.
RSA key fingerprint is xxx:xx:xx.xx:xx:xx:xx:xx
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added ‘192.168.0.202′ (RSA) to the list of known hosts.
root@192.168.0.202’s password:
root@phone#

3. Nun sollte man das Rootpasswort mit dem Befehl passwd root ändern.Fertig!

4. Nun kann man mit Vergnügen auf der Kommandozeile im System des Freerunner herumwursteln. Aber auch grafische Anwendungen sind möglich. Dazu beendet man die Verbindung (oder startet gleich so ) und nutzt folgende Befehle:

# xhost +; ssh -X -v root@192.168.0.202
access control disabled, clients can connect from any host
root@192.168.0.202’s password:

5. Um nun z.B den Webbrowser Dillo zu starten verwendet man…

root@phone# dillo

…und es öffnet sich Dillo, den man nun auch bequem im Vollbildmodus nutzen könnte.

dillo per ssh (Freerunner)

Diese Anleitung beschränkt sich nur auf das grundsätzliche Setup. Nicht eingegangen wird auf Key-Authentifizierung, Datentransfer per ssh (scp) usw. Wenn die ssh-Verbindung ein “Can`t find route to host” anzeigt, kann dies daran liegen, dass das Openmoko z.B. per WLAN angebunden ist. Hier kann es helfen, die WLAN-Verbindung zu unterbrechen und den Netzwerkdienst neu zu starten. (/etc/init.d/network restart). Ein weiteres Hindernis sind mangelnde Superuserrechte. Alsom immer schön “Ich bin root – ich darf das!” spielen. Ach ja, und zumindest auf dem getesteten SUSE-System schien die Netzwerkschnittstelle usb0 manchmal einfach so ihre IP-Adresse freizugeben….

Siehe auch: http://wiki.openmoko.org/wiki/USB_Networking#SSH_Extras

Openmoko Freerunner

Das Openmoko Freerunner Telefon wird standardmäßig mit vorinstalliertem Kernel und root-Dateisystem geliefert. Diese Dateien werden bei der Produktion aufgespielt und sind nicht aktuell. Inzwischen gibt es eine Reihe von verschiedenen Distributionen für den Freerunner, die sich ständig weiterentwickeln. Um einen neuen Kernel und ein neues root-Dateisystem aufzuspielen, kann der Freerunner geflasht werden.

Hardwarevoraussetzungen:
— Ein Openmoko Freerunner
— Ein regulären Linux PC
— Ein USB-Verbindungskabel (Standardmäßig mitgeliefert)

Softwarevoraussetzungen auf dem regulären Linux-PC:
— das Tool dfu-util
— ein root-Dateisystem (rootfs)  – per download (i.d.R. mit der Dateiendung   .jffs2)
— ein Kernel-Image (uI mage) – per download (Dateiendung   .bin)

Das folgende Beispiel bezieht sich auf Images von freesmartphone.org (FSO). Falls nötig, Backup nicht vergessen!

1. dfu-util installieren (Ubuntu: sudo apt-get install dfu-util)
2. Das rootfs und das Kernelimage auf den PC herunterladen (in diesem Beispiel von: http://downloads.freesmartphone.org/fso-stable/milestone5/om-gta02/)
3. Freerunner ausschalten
4. Freerunner in das NOR-Bootmenü booten. Dazu die Taste AUX und dann gleichzeitig die Taste POWER für ein paar Sekunden drücken.
5. Achtung! Nun sollte es zügig weitergehen, da sich der Freerunner in dieser Phase nach 30 Sekunden Inaktivität abschaltet.
6. Erst jetzt (nicht zuvor!) den Freerunner per USB mit dem Linux-PC verbinden.
7. Mit dfu-util -l kann man sich anzeigen lassen, ob Freerunner erkannt wird:

use:/home/moko # dfu-util -l
dfu-util – (C) 2007-2008 by OpenMoko Inc.
This program is Free Software and has ABSOLUTELY NO WARRANTY
Found Runtime: [0x1d51:0x5113] devnum=3, cfg=0, intf=0, alt=0, name=”UNDEFINED”

8. Manchmal werden hier mehrere Geräte angezeigt, dfu-util verweigert den Dienst. (“More than one DFU capable USB device found, you might try `–list’ and then disconnect all but one device“). Hier kann man versuchen das Kabel zu ziehen und neu zu verbinden. Oder man gibt das gewünschte Gerät beim Flashen (siehe weiter unten) mit der Option –device exakt an. Um das “ungewollte” device abzunabeln, merkt man sich die Bezeichnung (Bsp: [0x1d51:0x5113] ). Dann identifiziert man das entsprechende devive über den Befehl lsusb. Auch integrierte Webcams, WLAN-Karten usw.usw. können als usb-Geräte in lsusb auftauchen. Ein simples Ausschalten des Schalters für das WLAN führte bei mir zum Erfolg.
9. Nun kann das rootfs (Endung: .jffs2) aufgespielt werden (hier im Beispiel mit genauer Angabe des device 0×1d51:0×5113):

Wegen eines “bugs” in der Darstellung von codes auf wordpress wird statt –device leider -device angezeigt. Also 2 mal “minus” vor device setzen!

dfu-util –device 0×1d51:0×5113 -a rootfs -R -D fso-image-om-gta02.jffs2

10. Falls erfolgreich, sollte man den download starten sehen, der dann so endet:

Starting download: [##################################################] finished!
state(2) = dfuIDLE, status(0) = No error condition is present
Done!
Resetting USB to switch back to runtime mod

11. Nun den Kernel (Endung: .bin) aufspielen (Achtung 30 Sekunden!)

dfu-util –device 0×1d51:0×5113 -a kernel -R -D uImage-2.6.28 oe1+gitr34240a1c06ae36180dee695aa25bbae869b2aa26-r3-om-gta02.bin

12. Falls erfolgreich, sieht man eine ähnliche Rückmeldung wie beim rootfs

13. Fertig! Freerunner nun neu booten (durch Drücken des Knopfes POWER)

Weitere Infos: http://wiki.openmoko.org/wiki/Flashing#.232_Image_files_to_flash_into_FreeRunner_memory

Alternative Distribution für die offene Hardwareplattform sind das native Openmokoimage Om 2008.8, sowie  FDOM , Qtopia. Android , Debian und Gentoo.

Eine schöne Einführung in das Thema Openmoko Freerunner ist in der Aprilausgabe von freiesMagazin zu lesen: ftp://ftp.freiesmagazin.de/2009/freiesMagazin-2009-04.pdf

2-3 back came a sad and shocking news (atleast to me) that Openmoko has sacked/let go of 50% of its work force and has ceased all developments for GTA03. Furthermore Openmoko has stopped funding FSO. Both of which were grim developments to hear.

On a brighter note, FSO has started work on the Vala/C implemention of the reference Python implementation named cornucopia, which mainly aims at the general defragmentation of all the middleware code out there for handheld devices. Whats more, the first subsystem to be ported to this new codebase will be odeviced, which happened to be my project for the Google Summer of Code 2008.

For more, check this recent blog entry by Mickey.

Patches all the way …

continuando i precedenti esperimenti, ho scritto un pezzo di codice in python per calcolare la distanza tra due veicoli in movimento, che siano collegati ovviamente in qualche modo, nel mio caso col wi-fi.

dopo aver configurato la rete wi-fi ad-hoc bisogna lanciare questo script:

#!/usr/bin/python

import os
import string
import time
import sqlite3
import math
import sys

//ip = raw_input(‘\nother IP: ‘)
//ip=ip.rstrip()
t = raw_input(‘Set interval (sec): ‘)
t=t.rstrip()

while 1>0:
command=”gpspipe -w -n 8 | grep GLL”
out=os.popen(command)
gpsdata= out.read()
gpsdata=gpsdata.split(” “)

command_r=”gpspipe -w -n 8 192.168.1.2:2947| grep GLL”
out_r=os.popen(command_r)
gpsdata_r= out_r.read()
gpsdata_r=gpsdata_r.split(” “)

if gpsdata[0] ==”":
print “no gps fix”
time.sleep(10)
else:
latA = float(gpsdata[3])
lonA = float(gpsdata[4])
latB = float(gpsdata_r[3])
lonB = float(gpsdata_r[4])

r = 6372.795477598

radLatA = math.pi * latA / 180
radLonA = math.pi * lonA / 180
radLatB = math.pi * latA / 180
radLonB = math.pi * lonB / 180

phi = abs(radLonA – radLonB)

p = math.acos( (math.sin(radLatA) * math.sin(radLatB)) + (math.cos(radLatA) * math.cos(radLatB) * math.cos(phi)) )

distanza = p * r

print str(distanza)[0:7]

time.sleep(int(t))

che altro non fa che collegarsi al proprio gpsd e a quello remoto e, prendendo di volta in volta le coordinate, ne calcola la distanza.

dai test effettuati, nel tragitto per arrivare in pizzeria, la distanza massima tra le due macchine e’ stata di 122 metri (questo pero’ non so se sia stato reale oppure qualche errore nel prendere le coordinate gps per via del brutto tempo qualche altro fattore)

un’altra cosa che ho notato, che pero’ non ho verificato se sia vero o meno, e’ che quando si perde il segnale wi-fi per la troppa distanza, i due telefoni si ricollegano una volta riavvicinati.