Debian in tasca : Nokia N810 e N900

Il Nokia 900 e' stato per tanto tempo un irraggiungibile terminale (piu' che altro per il prezzo) che mi ha interessato per la programmazione diretta in Qt

Anche ai nostri giorni su Ebay si trovano dei Nokia N900 a prezzo di circa 350 euro,,,frugando ed aspettando ho comunque avuto modo di mettere le mani su un paio di Nokia N810 e N900 ad una cirnquantina di euro

Sono entrambi dispositivi risalenti agli anni 2008 e 2009 ma si differenziano sostanzialmente, Il Nokia N810 e' praticamente un tablet ante litteram (solo connessione WiFi) mentre il Nokia N900 e' un vero e proprio smartphone (giusto per la cronaca nel 2009 era venduto a circa 500 dollari ed era a pari prezzo con i primi IPhone)

Scatola completa nel Nokia N900

Accessori N810

Il Nokia 810 ed il Nokia 900 erano basati su un sistema operativo Linux fortemente derivato da Debian con un kernel della serie 2.6 Linux Nokia-N810-43-7 2.6.21-omap1 Oct 14 2008 armv61 (piu' in dettaglio N810 monta Diablo mentre N900 monta Fremantle)

Si puo' usare questi dispositivi al giorno d'oggi....con un po' di pazienza si'.
Per prima cosa si devono aggiornare i repository perche' quelli originali di Nokia sono morti da tempo. Per fare cio' si deve prima installare rootsh per acquisire i privilegi di root (apt-get install rootsh)
si digita poi

sudo gainroot

e si edita il file in /etc/apt/sources.list.d/hildon-application-manager.list

visto che usare vi con la tastiera del telefono e' un dramma si fa prima a cancellare il file e poi a digitare

per N810

echo "deb http://repository.maemo.org/extras/ diablo free non-free" > hildon-application-manager.list

Per N900

echo "deb http://repository.maemo.org/extras/ fremantle free non-free" > hildon-application-manager.list

apt-get update ed ecco che si puo' configurare il dispositivo...ovviamente e' software datato..tanto per dare un'idea viene installato Python 2.5

Ma si puo' sviluppare al giorno d'oggi applicazioni per Nokia N900??

La via Linux (quella difficile)

E' possibile scaricare una immagine Ubuntu 9.04 dell'SDK ma una volta aperta ci si accorge che non c'e' software preinstallato ma solo degli script (che ovviamente non funzionano piu')

per prima cosa si deve aggiornare la sources.list per aggiornare i pacchetti. Essendo una distribuzione dismessa i pacchetti sono messi in http://old-releases.ubuntu.com/ubuntu/dists/

-------------------------------------------------
#deb cdrom:[Ubuntu 9.04 _Jaunty Jackalope_ - releases i386 (20090420.1)]/
jaunty main restricted
# See http://help.ubuntu.com/community/UpgradeNotes for how to upgrade to
# newer versions of the distribution.

deb http://old-releases.ubuntu.com/ubuntu/ jaunty main restricted
deb-src http://old-releases.ubuntu.com/ubuntu/ jaunty main restricted

## Major bug fix updates produced after the final releases of the
## distribution.
deb http://old-releases.ubuntu.com/ubuntu/ jaunty-updates main restricted
deb-src http://old-releases.ubuntu.com/ubuntu/ jaunty-updates main restricted

## N.B. software from this repository is ENTIRELY UNSUPPORTED by the Ubuntu
## team. Also, please note that software in universe WILL NOT receive any
## review or updates from the Ubuntu security team.
deb http://old-releases.ubuntu.com/ubuntu/ jaunty universe
deb-src http://old-releases.ubuntu.com/ubuntu/ jaunty universe
deb http://old-releases.ubuntu.com/ubuntu/ jaunty-updates universe
deb-src http://old-releases.ubuntu.com/ubuntu/ jaunty-updates universe

## N.B. software from this repository is ENTIRELY UNSUPPORTED by the Ubuntu
## team, and may not be under a free licence. Please satisfy yourself as to
## your rights to use the software. Also, please note that software in
## multiverse WILL NOT receive any review or updates from the Ubuntu
## security team.
deb http://old-releases.ubuntu.com/ubuntu/ jaunty multiverse
deb-src http://old-releases.ubuntu.com/ubuntu/ jaunty multiverse
deb http://old-releases.ubuntu.com/ubuntu/ jaunty-updates multiverse
deb-src http://old-releases.ubuntu.com/ubuntu/ jaunty-updates multiverse

## Uncomment the following two lines to add software from the 'backports'
## repository.
## N.B. software from this repository may not have been tested as
## extensively as that contained in the main releases, although it includes
## newer versions of some applications which may provide useful features.
## Also, please note that software in backports WILL NOT receive any review
## or updates from the Ubuntu security team.
# deb http://old-releases.ubuntu.com/ubuntu/ jaunty-backports main
restricted universe multiverse
# deb-src http://old-releases.ubuntu.com/ubuntu/ jaunty-backports main
restricted universe multiverse

## Uncomment the following two lines to add software from Canonical's
## 'partner' repository.
## This software is not part of Ubuntu, but is offered by Canonical and the
## respective vendors as a service to Ubuntu users.
# deb http://archive.canonical.com/ubuntu jaunty partner
# deb-src http://archive.canonical.com/ubuntu jaunty partner

deb http://old-releases.ubuntu.com/ubuntu jaunty-security main restricted
deb-src http://old-releases.ubuntu.com/ubuntu jaunty-security main restricted
deb http://old-releases.ubuntu.com/ubuntu jaunty-security universe
deb-src http://old-releases.ubuntu.com/ubuntu jaunty-security universe
deb http://old-releases.ubuntu.com/ubuntu jaunty-security multiverse
deb-src http://old-releases.ubuntu.com/ubuntu jaunty-security multiverse

deb http://scratchbox.org/debian/ stable main

deb http://repository.maemo.org/ fremantle/sdk free non-free
deb-src http://repository.maemo.org/ fremantle/sdk free

deb http://repository.maemo.org/ fremantle/tools free non-free
deb-src http://repository.maemo.org/ fremantle/tools free
-------------------------------------------------

poi si installano i seguenti pacchetti

sudo apt-get install scratchbox-core scratchbox-devkit-apt-https scratchbox-devkit-autotools-legacy scratchbox-devkit-debian-squeeze scratchbox-devkit-doctools scratchbox-devkit-git scratchbox-devkit-perl scratchbox-devkit-python-legacy scratchbox-devkit-qemu scratchbox-devkit-svn scratchbox-libs scratchbox-toolchain-cs2007q3-glibc2.5-arm7 scratchbox-toolchain-cs2007q3-glibc2.5-i486 scratchbox-toolchain-host-gcc

si scarica il file, lo si rende eseguibile e lo si esegue

wget http://repository.maemo.org/stable/5.0/maemo-sdk-install_5.0.sh

c'e' un piccolo problema quando si deve accettare l'EULA di Nokia perche' non e' disponibile. Basta saltare..

a questo punto se tutto e' andato bene si puo' aprire la shell di scratchbox e si digitando i comandi

sb-conf select FREMANTLE_ARMEL

si edita il file /etc/apt/sources.list (non e' quello generale gia' modificato) aggiungendo la riga

deb http://repository.maemo.org/ fremantle/4bc37c7c77ebe90177c050b805a8dc79 nokia-binaries

si salva e si digita

apt-get update

fakeroot apt-get install nokia-binaries nokia-apps

si deve ripetere la procedura con 

sb-conf select FREMANTLE_X84

andando di nuovo a modificare il fi

le sources.list ed installando i pacchetti

quasi finito. Si esce da scratchhox (exit) e si apre una shell e digita

Xephyr :2 -host-cursor -screen 800x480x16 -dpi 96 -ac &

mentre su un'altra shell si riapre scratchbox e si digita

export DISPLAY=:2

>af-sb-init.sh start

Si ha alla fine la finestra dell'emulatore funzionate

La via Windows (la via facile)

Si puo' utilizzare il pacchetto Nokia_Qt_SDK_Win_offline_v1_0_en per ottenere l'ambiente di sviluppo Qt e l'emulatore per Nokia N900 (piu' Symbian) senza sforzo

Lo sviluppo e' molto simile a quello di una normale applicazione Qt salvo per il target che deve essere selezionato come Mobile Qt Application

L'emulatore e' incluso nel pacchetto e si attiva automaticamente

il progetto compilato si mostra come un classico pacchetto Debian da installare sul dispositivo

Per i dettagli su come trasportare il pacchetto deb sul dispositivo reale si rimanda a questo link

Firebase Test Lab

Un aspetto dello sviluppo Android che puo' mandare fuori di testa e' quello di avere segnalazioni di crash dagli utenti ma non riuscire a ripeterli. Un ottimo sistema per gestire il Crash Report e' gia' stato visto su Firebase ma la soluzione ideale e' quella di testare l'applicazione prima di rilasciarla

Su questo aspetto viene incontro Test Lab di Firebase. Con questo strumento si puo' testare su un certo numero di dispositivi fisici o virtuali l'applicazione in un contesto automatizzato.

Dipendentemente dal tipo di profilo (il mio e' quello gratuito) esistono un limite giornaliero di test di apk. Per prima cosa si carica il file

Poi si devono identificare le piattaforme di test (in alto i dispositivi fisici, in basso quelli virtuali)

Dopo circa 5 minuti sono riportati gli eventuali errori

con il dettaglio per il debug

Ho avuto modo di provarlo se un caso reale e si e' rivelato uno strumento molto utile ed affidabile

Android Notification

un breve codice per creare una notifica su Android che, una volta cliccata, riporti in primo piano l'applicazione che la ha generata

public static final int NOTIFICATION_ID = 1;
private NotificationManager notificationManager;

Codice per generare la notifica con l'icona ed il testo nella status bar. L'evento associato al clic sulla notifica e' quello di mettere in primo piano, nel caso fosse in background, l'applicazione
---------------------

public void sendNotification() {
    NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
    builder.setSmallIcon(R.drawable.ic_3);
    // resume on notification tap
    Intent intent = new Intent(getApplicationContext(),MainActivity.class );
    intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
    PendingIntent pendingIntent = PendingIntent.getActivity(this, (int) System.currentTimeMillis(), intent, PendingIntent.FLAG_UPDATE_CURRENT);
builder.setContentIntent(pendingIntent);
    builder.setLargeIcon(BitmapFactory.decodeResource(getResources(), R.drawable.ic_launcher));
    builder.setContentTitle("Title");
    builder.setContentText("");
    builder.setSubText("Tap per aprire");
    notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
    notificationManager.notify(NOTIFICATION_ID, builder.build());
}

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

per rimuovere la notifica in uscita dall'applicazione
---------------------

@Overridepublic void onDestroy()
{
  if (notificationManager == null)
    notificationManager = (NotificationManager)  getSystemService(NOTIFICATION_SERVICE);
notificationManager.cancelAll();
super.onDestroy();
}

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

La cosa piu' difficile da creare e' l'icona da mettere nella traybar. Io ci sono riuscito dopo un giorno di prove e non riesco a ricostruire quale sia stato il giusto procedimento. In alcuni casi l'icona era visualizzata come un quadrato bianco, in altri casi completamente trasparente... la soluzione dovrebbe essere mettere i livelli di grigio come livello di trasparenza (Gimp ha un menu' apposito) ma non sono sicuro che sia stato questo il passo giusto

Crash Report con Firebase su Android

Sto sviluppando una applicazione, non destinata al PlayStore, da usare in un gruppo ristretto di persone. Al momento c'e' il problema e' che l'applicazione funziona perfettamente sul mio Nexus 5 con Android 6.0.1 ma crasha miseramente su un Samsung Galaxy A3 sempre con Android 6.0.1

Non potendo avere il telefono A3 a disposizione per le prove l'unica soluzione e' quella di usare una libreria di crash report. Il supporto di Firebase e' semplicemente fantastico e semplice da implementare

Esiste una procedura automatica interna ad Android Studio per aggiungere il crash reporting ad un progetto gia' esistente. Si parte dal menu' Tools e si seleziona Firebase

Si seleziona quindi crash reporting tra i vari servizi forniti. 

Si arriva quindi al menu della pagina sottostante

Cliccando sui due pulsanti (Connect to Firebase ed Add Crash....) il progetto viene configurato in modo automatico....i meglio dovrebbe. Seguendo la procedura automatica e tenendo la build del progetto viene generato l'errore Execution failed app:processDebugGoogleServices missing api_key/current..la soluzione e' quello di inserire a mano il file google-services.json a mano nella root del progetto.

Da qui in poi e' una passeggiata. Ogni volta che viene generato un errore, l'applicazione la notifichera' sulla consolle di Firebase con un ritardo massimo di un paio di minuti

Ftp e Bash

un piccolo script, rubato su Internet non ricordo dove, per mandare in batch l'upload di un file

--------------
#!/bin/bash
HOST=ftp.xxxx.altervista.org
USER=xxxxx
PASS=xxxxx
ftp -inv $HOST << EOF
user $USER $PASS
cd SMSTracker
put test.txt
bye

EOF

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

Realtek 8188CUS su Debian

Premessa: puo' essere che non sia stato capace io....

E' da tempo che non trovavo un hardware non compatibile con la mia Debian..la cosa divertente e' che il dongle in foto e' stato ripreso da una Raspberry (Raspbian) su cui funzionava perfettamente. Iniziamo la storia

Il dispositivo con lsusb si presenta come
Bus 001 Device 002: ID 0bda:8176 Realtek Semiconductor Corp. RTL8188CUS 802.11n WLAN Adapter

su Debian il modulo che gestisce la Realtek 8188CUS e' gestito dal driver rtl8192cu e si installa facilmente mediante
apt-get install firmware-realtek

fino a qui niente di strano...il dispositivo viene montato e si mostra in ifconfig...sembra tutto funzionare..

root@debian:/home/luca# iwconfig
wlan0     IEEE 802.11bgn  ESSID:"AndroidAP"  Nickname:"<WIFI@REALTEK>"
          Mode:Managed  Frequency:2.462 GHz  Access Point: 02:1A:11:FD:D2:1B   
          Bit Rate:72.2 Mb/s   Sensitivity:0/0  
          Retry:off   RTS thr:off   Fragment thr:off
          Encryption key:****-****-****-****-****-****-****-****   Security mode:open
          Power Management:off
          Link Quality=100/100  Signal level=100/100  Noise level=0/100
          Rx invalid nwid:0  Rx invalid crypt:0  Rx invalid frag:0
          Tx excessive retries:0  Invalid misc:0   Missed beacon:0

quando si cerca pero' di accoppiare con l'access point accade qualcosa di strano

wpa_supplicant -B -i wlan0 -c <(wpa_passphrase AndroidAP passwortd) 
Successfully initialized wpa_supplicant
nl80211: Driver does not support authentication/association or connect commands
wlan0: Failed to initialize driver interface

ok proviamo a modificare con wext

wpa_supplicant -B -i wlan0 -c <(wpa_passphrase AndroidAP Tmd1ccdUs) -D wext

a questo punto viene iniziata l'autenticazione con l'access point che non va mai a buon fine

cercando su Internet sembra che il problema sia relativo al kernel Linux e sono state apportate patch al pacchetto standard dei driver in particolare su https://github.com/pvaret/rtl8192cu-fixes. Ho seguito le istruzioni niente successo.

In conclusione ho preso una Ralink...

SMS Server su Android

Se con i vecchi Nokia era molto semplice creare un SMS server, con Android cio' non e' possibile perche' i dati sono contenuti in una sezione del disco non accessbile in modo immediato e non esiste la possibilita' di default di creare un backup.
Alcuni hanno sviluppati applicazioni Android che leggono il database degli SMS e li reinviano via mail ma la soluzione non e' molto elegante e flessibile...l'ideale e' accedere via ADB

Per prima cosa pero' e' necessario effettuare il root del dispositivo (nel mio caso un Moto E)

i dati degli SMS sono contenuti nel file  /data/data/com.android.providers.telephony/databases/mmssms.db 
(e' un database Sqlite) che risulta essere accessibile solo a root....il gioco e' quindi copiarlo in una porzione del disco raggiungibile via adb pull come /data/local/tmp (da creare a mano via adb shell una volta per tutte).

----------------------------------
adb shell "su -c 'rm /data/local/tmp/mmssms.db'"

adb shell "su -c 'cp /data/data/com.android.providers.telephony/databases/mmssms.db /data/local/tmp'"
adb shell "su -c 'chmod 755 /data/local/tmp/mmssms.db'"

adb pull /data/local/tmp/mmssms.db

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

Una volta ottenuto il file sul proprio computer gran parte del lavoro e' fatto.

Usando DB Browser for SQLite (per comodita') si osservano tutte le tabelle

il mio interesse e' quello di avere in uscita in CSV dei soli dati degli SMS. 

A questo punto mi interessa estrarre solo i campi body e date_sent e si puo' fare con il seguente script bash

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

sqlite3 mmssms.db << EOF
.mode csv
.headers on
.separator ";"
.output sms2.csv
select body,datetime(date_sent/1000, 'unixepoch','localtime') from sms;
.exit
EOF

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

Geological compass for Micro:bit (2)

In questo post viene aggiornato il programma Geocompass per Micro:Bit visto qui aggiungendo la possibilita' di salvare i dati sulla memoria non volatile di Micro:Bit

Geocompass in uso di campagna

E la bussola meccanica per confronto

prima di tutto per accedere al file system di Microbit e' necessario installare microfs mediante
pip install microfs

per listare il file si usa
ufs list

per copiare i file da Microbit al pc si usa
ufs get nomefile.ext

i dati di strike e dip vengono salvati in un file testo nel formato nr.progr strike/dip

2 197/32

3 116/41

4 17/34

5 153/26

e' presente anche un file last_data.txt che contiene il progressivo dell'ultima misura.

MicroPython ha alcune limitazione rispetto a Python normale.
Le piu' evidenti nella gestione dei file sono:

- non esiste l'append in scrittura file ..si deve quindi leggere tutto il file, metterlo in un buffer, aggiungere una stringa in coda al buffer e poi si riscrive sulla memoria non volatile. Il comando write semplicemente cancella il file se gia' presente

- per verificare su un file e' gia' presente non si puo' usare os.path.isfile(fname) ma si usa il costrutto try..except per la gestione delle ecccezioni

- non e' possibile scorrere un file di testo riga per riga con una sintassi classica
Attenzione : ogni volta che viene flashato il programma, i dati vengono cancellati

-----------------------
from microbit import display
import microbit
import math

display.scroll("GEOCOMPASS")

cc = 180/math.pi
teta = 0
dip = 0
buffer = ""
ls = 0  # contatore progressivo delle misure

# guarda se ci sono misure gia' presenti e prende l'ultimo 
# dato progressivo dal file nel variabile ls
try:
    with open("last_data.txt") as ll2:
        ls = int(ll2.read())
except:
    ls = 0
while True:
    if microbit.button_a.is_pressed():
        # if necessary calibrate the compass
        if not microbit.compass.is_calibrated():
            display.scroll("Calibrate compass")
            microbit.compass.calibrate()
            microbit.sleep(2500)
        gx = microbit.accelerometer.get_x()
        gy = microbit.accelerometer.get_y()
        gz = microbit.accelerometer.get_z()
        hd = microbit.compass.heading()
        # change the sign to uniform to Android
        gx = - gx
        gz = - gz
        pitch = math.atan2(gy, math.sqrt((gx*gx)+(gz*gz)))
        roll = math.atan2(-gx, gz)
        # from pitch/roll to strike/dip
        p2 = math.sin(pitch)*math.sin(pitch)
        r2 = math.sin(roll)*math.sin(roll)
        t1 = math.sqrt(p2+r2)
        # ---
        teta = (cc * math.asin(t1))
        sigma = math.asin(math.sin(roll)/t1)
        sigma = (cc * sigma)
        # -----
        # primo quadrante
        if ((gy <= 0) and (gx < 0)):
            sigma = sigma
        # secondo quadrante
        if ((gy > 0) and (gx < 0)):
            sigma = 180 - sigma
        # terzo quadrante
        if ((gy > 0) and (gx >= 0)):
            sigma = 180 - sigma
        # quarto quadrante
        if ((gy <= 0) and (gx >= 0)):
            sigma = 360 + sigma
        ss = (sigma + hd) % 360
        display.scroll("Str " + str(int(ss)) + "/Dip " + str(int(teta)), 300)
        # controlla se c'e' il file su disco
        try:
            with open("geodata.txt") as ll:
                buffer = ll.read()
        except:
            buffer = ""
        # scrive i dati sul disco ultima misura
        ls = ls + 1   # incrementa contatore
        with open("geodata.txt", 'w') as out:
            aa = str(ls) + " " + str(int(ss)) + "/" + str(int(teta)) + "\n"
            out.write(buffer + aa)
        with open("last_data.txt", "w") as out2:
            out2.write(str(ls))
        microbit.sleep(500)
    if microbit.button_b.is_pressed():
        # the B button repeat the last measure
        display.scroll("Str " + str(int(ss)) + "/Dip " + str(int(teta)), 300)

Micro:Bit

Microbit e' un progetto promosso per introduzione all'informatica dei bambini nel Regno Unito. In estrema sintesi vengono regalati ai ragazzi di 11-12 anni delle piccole schede dotate di un processore Arm, Accelerometro, Bluetooth, un array di led 5x5, due pulsanti ..ed altre cose; con queste in classe fanno dei piccoli esperimenti

Questo esperimento non e' nuovo perche' agli inizi degli anni 80 era stato lanciato il progetto BBC Micro (basato su 6502)

Comfronto tra la scheda ed una moneta da 1 euro

In Italia la scheda si trova su Amazon a circa 25 euro nel kit con il cavo USB ed il pacco batterie

Quando si apre la confezione la cosa che salta piu' all'occhio e' l'assenza della scheda...e' talmente piccola che e' stata messa nel pacchetto di cartone sulla sinistra

Per programmare la scheda ci sono molte opzioni on line, dall'interfaccia tipo Blockly all'editor testuale. In alcuni casi e' presente anche un emulatore per provare il codice. Usare Python e' particolarmente fastidioso perche' non e' presente l'emulatore e non si puo' fare l'upload diretto del programma nella scheda (si deve compilare e scaricare il compilato e quindi trascinare il file dentro alla cartella di Micro:bit che si presenta come un disco USB)

Questa e' la IDE per Javascript con l'emulatore sulla sinistra ed il sistema di composizione dei comandi a blocchi sulla destra

Molto piu' comodo (anche se ha le sue idiosincrasie) e' usare Mu, un editor offline per MicroPython che effettua direttamente l'upload e permette alla riga di comando REPL di Python

La cosa un po' folle e' il sistema di debugging...l'errore scorre, carattere a carattere sul display...giusto per cronaca l'errore del video sottostante e'

Line 27 AttributeError module object has no attribute arcsin

sfido chiunque a capirlo al primo tentativo

Geological compass for Micro:bit

Aggiornamento qui
Un semplice programma in MicroPython per usare l'accelerometro e la bussola di Micro:bit come bussola da rilevamento geologico

Premendo il pulsante A si acquisisce la misura (se la bussola non e' stata calibrata sara' necessario farlo ruotando il dispositivo fino a creare un cerchio sul display). Il pulsante B ripete la visualizzazione dell'ultima misura
Il costo finale, compreso di batterie, e' di circa 25 euro

Il calcolo matematico di pitch e roll partendo dai dati dell'accelerometro e' stato ripreso da qui

Mark Pedley, Tilt Sensing Using a Three-AxisAccelerometer. Freescale Semiconductor Document Number: AN3461 Application Note Rev. 6, 03/2013


Il calcolo di strike e dip partendo da pitch e roll e' stato ripreso da questo articolo

 R.N. Barbosa *,1 , J.B. Wilkerson2 , H.P. Denton3 and D.C. Yoder 2, Slope Gradient and Vehicle Attitude Definition Based on Pitch and Roll Angle Measurements: A Simplified Approach. The Open Agriculture Journal, 2012, 6, 36-40

in questa immagine l'orientazione degli assi dell'accelerometro e della bussola rispetto alla scheda (da notare che l'accelerazione Gz e' negativa perche' all'accelerometro e' saldato sulla parte opposta della scheda)

(nota : i valori di accelerazione vengono mostrati come numeri interi e non come float (m/s2) o come frazioni dell'accelerazione di gravita' (come in Android)
----------------------
from microbit import display
import microbit
import math

display.scroll("GEOCOMPASS")

cc = 180/math.pi
teta = 0
dip = 0

while True:
    if microbit.button_a.is_pressed():
        # if necessary calibrate the compass
        if not microbit.compass.is_calibrated():
            display.scroll("Calibrate compass")
            microbit.compass.calibrate()
            microbit.sleep(2500)
        gx = microbit.accelerometer.get_x()
        gy = microbit.accelerometer.get_y()
        gz = microbit.accelerometer.get_z()
        hd = microbit.compass.heading()
        # change the sign to uniform to Android
        gx = - gx
        gz = - gz
        pitch = math.atan2(gy, math.sqrt((gx*gx)+(gz*gz)))
        roll = math.atan2(-gx, gz)
        # from pitch/roll to strike/dip
        p2 = math.sin(pitch)*math.sin(pitch)
        r2 = math.sin(roll)*math.sin(roll)
        t1 = math.sqrt(p2+r2)
        # ---
        teta = (cc * math.asin(t1))
        sigma = math.asin(math.sin(roll)/t1)
        sigma = (cc * sigma)
        # -----
        # primo quadrante
        if ((gy <= 0) and (gx < 0)):
            sigma = sigma
        # secondo quadrante
        if ((gy > 0) and (gx < 0)):
            sigma = 180 - sigma
        # terzo quadrante
        if ((gy > 0) and (gx >= 0)):
            sigma = 180 - sigma
        # quarto quadrante
        if ((gy <= 0) and (gx >= 0)):
            sigma = 360 + sigma
        dip = (sigma + hd) % 360
        display.scroll("Dip " + str(int(teta)) + "/Str " + str(int(dip)))
        microbit.sleep(500)
    if microbit.button_b.is_pressed():
        # the B button repeat the last measure
        display.scroll("Dip " + str(int(teta)) + "/Str " + str(int(dip)))
----------------------

Integrazione GitHub e XCode

L'integrazione tra GitHub e XCode e' piuttosto semplice.
Per prima cosa dall'interfaccia Web si crea un nuovo progetto e nella root del progetto si digitano i seguenti comandi (come da istruzioni a video)

-----
git init
git add .
git commit -m "first commit"
git remote add origin https://github.com/[nome_utente]/[nome_progetto].git
git push -u origin master
-----

fatto cio' aprendo il menu Source Control di XCode si trova gia' il tutto configurato. Da qui in poi si puo' gestire tutto da XCode

Io ed il guardiano : chiavi RSA

Ad un certo punto, mentre stavo rientrando nella mia citta' medievale, mi sono ritrovato chiuso fuori dalle mura. Per farmi aprire le porte dal guardiano dovevo convincere il guardiano,all'interno e che non mi poteva osservare, della mia identita'.....il tutto cio' senza consegnare le chiavi della citta' al nemico accampato li' vicino e pronto all'assalto

Ovviamente non potevo parlare perche' sarei stato ascoltato.

Il guardiano mi ha passato da sotto alla porta un foglietto con la sua chiave pubblica generata con la sequenza (la chiave privata e' rimasta custodita all'interno delle mura)
openssl genrsa -out private_key.pem 1024 (generazione chiave privata)

openssl rsa -in private_key.pem -out public_key.pem -outform PEM -pubout (la chiave privata scritta sul foglietto e' un public_key.pem)

a questo punto ero in grado di comunicare con il guardiano in modo segreto ma cio' non e' che aiuta molto perche' se avessi criptato il messaggio con il mio nome, il nemico avrebbe potuto rubare il foglio con la mia risposta e si sarebbe impossessato della mia identita'..necessita quindi un messaggio variabile che puo' essere utilizzato solo per pochissimo tempo (tipo un secondo)

Sia io che il guardiano riusciamo a vedere l'orologio della torre e ci eravamo messi d'accordo che il mio messaggio era composto dal mio codice personale e dall'ora in un determinato formato (in questo modo il messaggio sarebbe stato valido solo per un minuto)

ho proceduto quindi a creare il mio messaggio nel seguente modo
---------------------------------
#!/bin/bash
rm encrypt.dat
rm new_encrypt.txt
rm messaggio.txt
SEED=4096 #questa e' il codice identificativo persona
NOW=$(date +"%Y%H%M")
MESSAGGIO=$(($SEED * $NOW)) # il messaggio ricalcola
echo $MESSAGGIO > messaggio.txt
openssl rsautl -encrypt -inkey public_key.pem -pubin -in messaggio.txt -out encrypt.dat
---------------------------------
il guardiano ha letto il messaggio ed ha decodificato il mio codice. Ha controllato con la sua tabella e mi ha fatto entrare
---------------------------------
#!/bin/bash

openssl rsautl -decrypt -inkey private_key.pem -in encrypt.dat -out new_encrypt.txt #descritta il messaggio con la chiave privata del server

NOW=$(date +"%Y%H%M") 

TEXT=$(<new_encrypt.txt)
CHIAVE=$(($TEXT / $NOW))
echo $CHIAVE #controlla se la chiave e' presente nella lista del guardiano delle persone che possono passare
----------------------------------

con sapendo le informazioni di come formare il messaggio (con la chiave pubblica ed il metodo di combinazione del codice privato con l'orario) l'unica soluzione rimasta ai nemici chiusi fuori era quella di continuare a bussare al guardiano cercando di indovinare il codice ...peccato che il guardiano non e' uno sprovveduto ed accetta solo un foglietto sotto la porta al minuto..con codici identificativi sufficientemente lunghi si fa prima a buttare giu' la porta con la forza che a cercare di farsi aprire la serratura

Sonoff

Sonoff e' una linea di prodotti IoT di ITEAD per la domotica. Ho provato ad utilizzare un interruttore WiFi basato su un sistema ESP8266

Le connessioni hanno un verso..attenzione al lato input ed output

Per interagire con Sonoff si deve utilizzare l'applicazione EWebLink.
Per prima cosa si deve premere il pulsante per almeno 10 secondi. In questo modo il dispositivo di configura in modalita' Access Point (la password e' 12345678); tramite l'applicazione e' possibili settare le configurazioni della WiFi casalinga. (il sistema di accoppiamento e' gestito da Espressif)

Modalita' HotSpot di Sonoff

Una volta configurata il dispositivo, Sonoff si aggancia alla Wifi casalinga

Il dispositivo non e' piccolissimo ma riesce ad entrare in una cassetta elettrica da muro (c'e' da verificare l'attenuazione sul segnale WiFi su un montaggio all'interno del muro)

Il pulsante nero, oltre ad essere impiegato per configurare il WiFi, funziona anche come tasto fisico per accendere e spengere la luce (pressione breve)

Un paio di considerazioni : la trasmissione dei dati avviene completamente via Cloud. Anche se Sonoff ed il telefono sono collegati sulla stessa WiFi l'attivazione avviene sempre con un sistema esterno... il che vuol dire che se il servizio Cloud viene sospeso l'interruttore cessa di funzionare

Provando a sniffare il traffico con Charles si osservano chiamate verso

• alog.umengcloud.com/app_logs
• eu-api.coolkit.cc:8080
• eu-long.coolkit.cc:8080

con queste informazioni ho scoperto che qualcun altro aveva gia' fatto lo stesso lavoro (molto meglio)

Se la corrente viene a mancare l'interruttore riaggancia in modo automatico la rete WiFi, se viene persa la connessione con il WiFi l'interruttore mantiene lo stato (in pratica non si spenge automaticamente se si perde la connessione Wireless... cio' puo' essere un vantaggio od uno svantaggio..dipende dal punto di vista)

Esiste la possibilita' di riprogrammare il firmware con prodotti non ufficiali basati sul protocollo MQTT

Programmazione Iwatch

Primi passi di programmazione di ioWatch di Apple


1) a differenza di Android Wear, Apple Watch non ha una connessione via cavo con cui effettuare la programmazione. La basetta magnetica infatti non ha dei pin ma effettua la ricarica in modalita' Wireless. Per questo motivo per inviare il programma allo smartwatch e' necessario che questo sia sempre accoppiato al telefono.

2) Come Android Wear, una applicazione per iWatch e' composta da due componenti. Una applicazione sul telefono (app companion) e l'applicazione sul telefono). Il progetto sara' quindi composto da due storyboard e da differenti assets

Assets della parte iWatch. Le icone sono differenti rispetto a quelle standard IOS

3) Per compilare il programma ed effettuare le prove sull'emulatore si deve cliccare in alto sulla lista dei dispositivi e selezionare lo scheme seguito da WatchKit App. Cio' ha come risultato che vengono aperti due emulatori (il primo per un IPhone 7 ed il secondo emulatore per lo smartwatch). Se invece si vuole effettuare il debug sul dispositivo fisico si deve selezionare il primo scheme (quello che riporta il solo telefono)..sara' il telefono via bluetooth ad inviare il programma verso lo smartwatch

4) il file che viene eseguito di default in un progetto IOS e' ViewController mentre in un progetto iWatch e' InterfaceController

5) anche comandi semplici come cambiare il testo di un pulsante segue sintassi differenti su IOs e su WatchKit

iOs

[_point_left setTitle:@"00" forState:UIControlStateNormal];

Watchkit 

[_point_left setTitle:@"00"];