lunedì 30 dicembre 2013

Aggiornamento PN51T

In occasione dello scadere del contratto Internet annuale con TIM e nell'incertezza se rinnovare con la stessa societa' o passare a Vodafone (che allo stesso prezzo fornisce anche l'access point mobile) ho provato ad aggiornare il firmware del PN51T per farlo funzionare con la Arduino Yun (il motivo principale per cui mi tornerebbe comodo usare il PN51T, vedi precedente post)

da una visita sul sito http://www.ondacommunication.com/it/software_manuals.html ho visto che e' disponibile all'aggiornamento alla versione 10 del firmware mentre il mio dispositivo monta ancora la versione 6 (link a file di aggiornamento)

Firmware originale
L'aggiornamento si puo' eseguire solo sotto Windows e solo dopo aver installato i driver del dispositivo


La procedura dura circa 7 minuti


Al termine il dispositivo ha aggiornato il software


Attenzione: al riavvio si deve reinserire il codice PIN dall'interfaccia Web (altrimenti l'icona di rete rimane rosssa e non si accede ad Internet)

Adesso il PN51T funziona correttamente con Arduino Yun

venerdì 27 dicembre 2013

Distanza da antenna di telefonia mobile

UPDATE:
c'e' un errore di fondo nel calcolo della distanza impiegato in questo post
Le api di Android riportano la potenza del segnale in modo differente se si tratta di GSM o UMTS. Nel primo caso il valore viene espresso in dB mentre nel secondo in Dbm
Nei prossimi post cerchero'  di correggere l'errore
------------------------------------------------------------------------

Utilizzando la funzione signalStrength.getGsmSignalStrength() di Android e' possibile stimare la potenza del segnale della rete GSM e convertirla nel suo valore espresso in dB

Utilizzando la formula di FSPL (Free Space Path Loss) e' possibile inoltre risalire alla distanza tra l'antenna della telefonia mobile ed il proprio dispositivo mobile

Riprendendo da Wikipedia, la FSPL espressa per valori in GHz e' la seguente

dove
d = distanza tra l'antenna ed il dispositivo mobile
f = frequenza (2.1 GHz per la rete GSM italiana)
FSPL = il valore riportato dalla funzione Android

invertendo per ottenere la distanza e semplificando i calcoli (dato che la frequenza e' sempre la stesssa) si ha che
distanza = 10E((FSPL-98.89)/20)

Questa formula e' stata implementata in un semplice programma che mostra i dati di telefonia correlati ai dati derivanti dal GPS per una verifica (grossolana) dell'efficacia del sistema. Possono inseriti anche fattori di attenuazione e guadagni delle antenne ma nel caso in esame sono dati non disponibili


(la massima copertura di una antenna di telefonia e' di circa 24 Km)
Per la posizione delle antenne di telefonia mobile sono stati presi i dati da http://www.opencellid.org o da developer.opensignal.com
-----------------------------------------------------
Caso 1:
il telefono e' ubicato in posizione
Long : 11°17'27,32'' (ovvero 11.290922)
Lat : 43°45'33,05" (ovvero 43.759181)

La cella agganciata ha identificativo
MCC : 222
MNC :88
LAC : 36057
CID : 27988244
Long : 11.291428
Lat : 43.757431



La distanza stimata mediante il metodo FSPL e' di 0.16 Km mentre la distanza reale e' di Km 0.2


-----------------------------------------------------
Caso 2:
il telefono e' ubicato in posizione
Long : 11°18'38,73'' (ovvero 11.310758)
Lat : 43°50'1,61" (ovvero 43.833781)

La cella agganciata ha identificativo
MCC : 222
MNC :88
LAC : 36057
CID : 27997133
per una posizione dell'antenna di
Long : 11.304655
Lat : 43.8257665



La distanza stimata mediante il metodo FSPL e' di 0.2 Km mentre la distanza reale e' di Km 1.017


 -----------------------------------------------------
Caso 3:
il telefono e' ubicato in posizione
Long : 11°13'47,94'' (ovvero 11.229983)
Lat : 43°47'2,92" (ovvero 43.784144)

La cella agganciata ha identificativo
MCC : 222
MNC :88
LAC : 36057
CID : 27988287
per una posizione dell'antenna di
Long : 11.2312
Lat : 43.7845993



La distanza stimata mediante il metodo FSPL e' di 0.04 Km mentre la distanza reale e' di Km 0.11


 -----------------------------------------------------
Caso 4:
il telefono e' ubicato in posizione
Long : 11°18'38.73'' (ovvero 11.229983)
Lat : 43°50'1.5" (ovvero 43.784144)

La cella agganciata ha identificativo
MCC : 222
MNC :88
LAC : 36057
CID : 27997133
per una posizione dell'antenna di
Long : 11.304655
Lat : 43.825766






La distanza stimata mediante il metodo FSPL e' di 0.2 Km mentre la distanza reale e' di 4.7 Km 

 -----------------------------------------------------
Caso 5:
il telefono e' ubicato in posizione
Long : 11°18'38.73'' (ovvero 11.310758)
Lat : 43°50'1.5" (ovvero 43.83375)

La cella agganciata ha identificativo
MCC : 222
MNC :88
LAC : 36057
CID : 27988276
per una posizione dell'antenna di
Long : 11.245845
Lat : 43.79564150






La distanza stimata mediante il metodo FSPL e' di 0.05 Km mentre la distanza reale e' di Km 6.7
-----------------------------------------------------
Caso 6:
il telefono e' ubicato in posizione
Long : 11°16'48.99'' (ovvero 11.28)
Lat : 43°48'22.2" (ovvero 43.806167)

La cella agganciata ha identificativo
MCC : 222
MNC :88
LAC : 36057
CID : 27988315
per una posizione dell'antenna di
Long : 11.272541
Lat : 43.793081






La distanza stimata mediante il metodo FSPL e' di 1.27 Km mentre la distanza reale e' di Km 1.54
-----------------------------------------------------
Caso 7:
il telefono e' ubicato in posizione
Long : 11°17'32.39'' (ovvero 11.292222)
Lat : 43°48'58.15" (ovvero 43.816153)

La cella agganciata ha identificativo
MCC : 222
MNC :88
LAC : 36057
CID : 28021137
per una posizione dell'antenna di
Long : 11.2440335
Lat : 43.787733


La distanza stimata mediante il metodo FSPL e' di 0.02 Km mentre la distanza reale e' 4.9 di Km
-----------------------------------------------------
Caso 8:
il telefono e' ubicato in posizione
Long : 11°17'41.9'' (ovvero 11.294972)
Lat : 43°49'9.97" (ovvero 43.819436)

La cella agganciata ha identificativo
MCC : 222
MNC :88
LAC : 36057
CID : 28021135
per una posizione dell'antenna di
Long : 11.295127
Lat : 43.818963



La distanza stimata mediante il metodo FSPL e' di 0.16 Km mentre la distanza reale e' di 0.054 Km

In conclusione si osserva in alcuni casi un ottimo accordo tra la distanza calcolata e la distanza reale mentre in altri il valore e' sensibilmente differente. Probabilmente presumere la frequenza fissa e' un assunto non valido

lunedì 23 dicembre 2013

Database antenne telefonia mobile

Per ottenere la posizione delle antenne cellulari, oltre all'interfaccia web, e' possibile scaricare anche l'intero database in modo da effettuare una consultazione offline



Il database si scarica all'indirizzo http://downloads.opencellid.org/ ed e' particolarmente corposo perche' e' attualmente costituito da un file da 57 Mb compressi di posizioni testuali di celle (corrispondenti a  2390305entrate) e da oltre 4.5 Gb compressi di dati di misure (divisi in 12 file di cui ogni file contiene circa 500.000 misure)

Ovviamente e' impossibile consultare con un editor di testo tale mole di dati e quindi e' necessaria la conversione in database, in particolare MySQL

Per prima cosa si crea la struttura della tabella
----------------------------------------------------------------

-- MySQL dump 10.13  Distrib 5.5.33, for debian-linux-gnu (x86_64)
--
-- Host: localhost    Database: celle
-- ------------------------------------------------------
-- Server version 5.5.33-1

/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
/*!40101 SET NAMES utf8 */;
/*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */;
/*!40103 SET TIME_ZONE='+00:00' */;
/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;

--
-- Table structure for table `celle`
--

DROP TABLE IF EXISTS `celle`;
/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE `celle` (
  `mcc` int(11) NOT NULL,
  `mnc` int(11) NOT NULL,
  `lac` int(11) NOT NULL,
  `cellid` int(11) NOT NULL,
  `long` double NOT NULL,
  `lat` double NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
/*!40101 SET character_set_client = @saved_cs_client */;
/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;

/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;
----------------------------------------------------------------

In seguito ci si logga dentro mysql (mysql -u root -p) e si digita il seguente comando

load data infile '/home/luca/Desktop/cell_towers.csv' into table celle columns terminated by ',';

per il seguente risultato
Query OK, 2390305 rows affected, 65535 warnings (1 min 33.18 sec)
Records: 2390305  Deleted: 0  Skipped: 0  Warnings: 2390386

A questo punto si puo' fare una semplice pagina web di consultazione
--------------------------------------------------------
<form action="search.php" method="post">     
MCC: <input type="text" name="mcc" />
MNC: <input type="text" name="mnc" />
LAC: <input type="text" name="lac" />
CellId: <input type="text" name="cellid" />
<input type="Submit" /></form>
--------------------------------------------------------

ed il corrispondente script in Php
--------------------------------------------------------
<?php
$username="root";
$password="xxxxxx";
$database="celle";
mysql_connect(localhost,$username,$password);
@mysql_select_db($database) or die( "Unable to select database");
$query="SELECT * FROM celle WHERE mcc='".$_POST['mcc']."' AND mnc='".$_POST['mnc']."' AND lac  LIKE '".$_POST['lac']."%' AND cellid  LIKE '".$_POST['cellid']."%'";

print $query."<br>";
$result=mysql_query($query);
$num=mysql_numrows($result);


while($row = mysql_fetch_array($result))
  {
  echo "<a target=blank href=\"http://www.openstreetmap.org/?mlat=".$row['lat']."&mlon=".$row['long']."&zoom=12\">MCC:".$row['mcc']."-MNC:".$row['mnc']."-LAC:".$row['lac']."-CellId:".$row['cellid']."</a>";
  echo "<br>";
  }

mysql_close();
?>
--------------------------------------------------------
Lo script riporta un link, cliccando sopra si evidenzia la posizione su Openstreetmap

Similarmente si puo' fare per il database delle misure

Effettuando una esportazione dei punti che sono compresi tra 10-11.9° di longitudine e 42-44.5° latitudine (piu' o meno i confini della Toscana) si osserva che sono censite 6780 antenne di telefonia cellulare ma la loro distribuzione e' molto disomogenea con una curiosa predilezione per le grandi vie di comunicazione



Arduino e pannello solare

Per una prova (senza troppe velleita' di utilizzo reale) ho provato ad accoppiare una Arduino con un pannellino solare per verificare la possibilita' di una alimentazione alternativa alle batterie od alla corrente di rete

Il pannellino e' stato attaccato sull'ingresso VIn ed eroga un massimo di 6 V-350mA (cosi' da non necessitare un limitatore di tensione per proteggere l'Arduino)



La prova sul campo ha verificato che
1) si puo' alimentare l'Arduino soltanto con illuminazione diretta. In giornate invernali nuvolose, dove sono presenti velature, il pannello non e' sufficiente per alimentare Arduino
2) e' stato montato per prova lo sketch Blink. E' stato verificato che, con il led verde di On accesso, in caso di scarsa alimentazione Arduino non e' in grado di eseguire il programma ed accendere il led (forse il led verde e' a monte del processore)

In fine dei conti si puo' utilizzare il  pannellino per ricaricare un pacco batterie (che a sua volta alimenta l'Arduino) ma in maniera diretta non e' utile

giovedì 19 dicembre 2013

Sensore umidita' YL-69/YL-38 su Arduino - Comparatore di voltaggio

Ho avuto modo di provare questo sensore di umidita' per suoli
Si tratta di un elettrodo da inserire nel terreno (quello a forchetta)  e di un modulino di lettura
Il modulo di lettura  ha 4 connessioni
1) Vcc (5-3.3 V)
2) GND
3) A0 : lettura del valore analogico da collegare alla porta analogica dell'Arduino
4) D0 : lettura on/off da collegare alla porta digitale dell'Arduino. Si attiva se viene superata una soglia impostata mediante il potenziometro

Gli elettrodi sono del tipo piu' semplice ovvero galvanizzati (alcuni vecchi sensori usavano elettrodi di materiale differente)


In generale, tra tutti i sensori di umidita', questo e' il meno preciso, con la minore ripetibilita' e con le maggiori influenze esterne quindi va bene sostanzialmente solo per uso domestico od hobbistico

L'aspetto piu' interessante e didattico di questo sensore e' la presenza di un comparatore di voltaggio realizzato mediante l'utilizzo di un componente LM393

http://home.cogeco.ca/~rpaisley4/Comparators.html
Come si vede dallo schema sopra riportato un comparatore di voltaggio e' un sistema per cui  il componente ha due stati logici (0,1) a seconda se la corrente misurata e' sopra o sotto ad una tensione di riferimento (normalmente impostata mediante un potenziometro)

Un altro uso utile dell LM393 e' quello del generatore di onda quadra

Nexgate NSA 1041 con ZeroShell

Questa network appliance del 2005 giaceva inutilizzata perche' era stata da tempo sostituita da un modello Cisco come VPN



Era quindi tempo di ridarle una nuova vita. Una volta riaccesa il sistema non e' partito (forse uno dei motivi per cui all'epoca fu dismessa) con il boot di FreeBsd fermo ai primi passi
Una volta aperto il case la prima sorpresa



Non si tratta di hardware proprietario ma di una comune motherboard (seppur del formato piu' piccolo) che monta una normale memoria RAM  da 256 Mb, una CF da 128 Mb ed un Pentium III da 600 MHz. C'e' spazio per un disco fisso sulla sinistra


Dalla scheda tecnica della scheda madre si vede che questa configurazione puo' essere considerata una antesignana della Raspberry in quanto sono disponibili porte GPIO ed un canale I2C
Ho cercato su Internet ma sembra che oramai nessun software per network appliance riesca piu' ad entrare in una CF da 128Mb ed invece di comprarne una nuova da 1Giga ho preferito montare un vetusto HD da 40 Giga parcheggiato come fermaporta

Con l'hard disk e senza CF

Come software ho deciso di montare Zeroshell perche' e' una soluzione piu' moderna e piu' completa rispetto ad IPCop. L'installazione non e' proprio banalissima, piu' che altro per la mancanza del CDRom

Si parte scaricando ZeroShell-2.0.RC3-IDE-USB-SATA-Disk-2GB.img.gz per creare una chiavetta USB di avvio. Per copiare i file sulla chiave non si usa dd ma il seguente comando

gunzip -c  ZeroShell-2.0.RC3-IDE-USB-SATA-Disk-2GB.img.gz > /dev/sdb

finito si vede che nella chiavetta sono presenti tre partizioni. Si deve quindi copiare il file ZeroShell-2.0.RC3-IDE-USB-SATA-Disk-2GB.img.gz su una delle partizioni della chiavetta (per me la migliore era /dev/sdb3 dove e' presente solo lo swap e c'e' spazio per l'immagine)

si fa quindi partire l'appliance da USB (il Bios e' quello di un normale computer quindi non ci sono problemi).
Quando il sistema e' partito si preme il tasto S per entrare in shell
si monta la chiavetta in loop

mount /dev/sdb3 /mnt/loop1

ci si sposta in /mnt/loop1 e si digita il comando per copiare l'immagine sul disco fisso
gunzip -c  ZeroShell-2.0.RC3-IDE-USB-SATA-Disk-2GB.img.gz > /dev/sda

si smonta il tutto e si fa reboot

In linea di principio e' possibile usare questo sistema anche per farci girare Debian ma si precisa che l'appliance non ha il tasto on/off ma solo quello di reset sul retro e quindi sarebbe piuttosto scomodo come computer. Peraltro il sistema e' piuttosto rumoroso pur essendo una appliance a causa delle due ventole.

Ed adesso di nuovo dentro al rack a fare un nuovo lavoro



mercoledì 18 dicembre 2013

Esempio GUI con Cocoa

Era da tempo che non aggiornavo il medesimo esempio di GUI creato con diversi linguaggi e librerie
Oggi e' il tempo di Cocoa, con XCode 4.2 su Snow Leopard
Preciso che prima di oggi ero totalmente a digiuno della programmazione sotto MacOs X ma ho trovato difficolta' ad adattarmi ad una interfaccia spiccatamente orientata al mouse, di cui si trovano relativamente pochi esempi su Internet (la maggior parte sono video di Youtube a dimostrare come sia difficile spiegare per scritto le azioni via mouse) e di quei pochi esempi molti sono relativi a versioni precedenti (per esempio XCode 3) che hanno un metodo sostanzialmente differente

In ogni caso con un po' di difficolta' ci sono arrivato (avrei preferito impiegarci meno tempo..)


----------------------------------------
#import "AppDelegate.h"

@implementation AppDelegate

@synthesize window = _window;
@synthesize casellatesto = _casellatesto;
@synthesize barra = _barra;
@synthesize progressione = _progressione;

- (void)dealloc
{
    [super dealloc];
}
- (void)applicationDidFinishLaunching:(NSNotification *)aNotification
{
    // Insert code here to initialize your application
}
- (IBAction)scivola:(id)sender {

    _casellatesto.stringValue = _progressione.stringValue;
    _barra.doubleValue = _progressione.doubleValue;
   }

@end



----------------------------------------
----------------------------------------
#import <Cocoa/Cocoa.h>

@interface AppDelegate : NSObject <NSApplicationDelegate>

@property (assign) IBOutlet NSWindow *window;

@property (assign) IBOutlet NSTextField *casellatesto;
@property (assign) IBOutlet NSProgressIndicator *barra;
@property (assign) IBOutlet NSSlider *progressione;

@end

martedì 17 dicembre 2013

Mandelbrot a colori su Arduino

In questo post viene mostrata  la creazione di un insieme di Mandelbrot su Arduino con un display LCD a colori da 320x240 pixel
La scheda impiegata e' stata una Arduino UNO


Il codice per la generazione dell'insieme e' riportata al termine del post. Di seguito invece il video in tempo reale. Considerando che questo schermo ha piu' o meno le dimensioni della schermata grafica di un Commodore 64 (anche se con un numero di colori maggiori) fa abbastanza pensare come un Commodore 64 agli inizi degli anni 90 impiegasse oltre 1 ora per lo stesso compito che una Arduino esegue in meno di tre minuti





----------------------------------------------------------------------
#define LCD_CS A3    
#define LCD_CD A2    
#define LCD_WR A1   
#define LCD_RD A0    
#define LCD_RESET A4

#define C0           0x00FF
#define C1           0x0F00
#define C2           0xF800
#define C3           0xF880
#define C4           0x8008
#define C5           0x8800
#define C6           0xFF00
#define C7           0xFFFF

#define SCREEN_WIDTH 320
#define SCREEN_HEIGHT 240

float re_min = -2.0;
float im_min = -1.2;
float re_max = 1.0;
float im_max = 1.2;
int iterazioni = 124;
float a,b;
float x,y,x_new,y_new;
int test;
int k,j,i;

#include "TFTLCD.h"
TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);

void setup(void) {

  tft.reset();
  tft.initDisplay();
  tft.fillScreen(0x0000);

  //---------------------------------
  float re_factor = (re_max-re_min);
  float im_factor = (im_max-im_min);
  for (i=0;i<SCREEN_HEIGHT;i++)
     {
     for (j=0;j<SCREEN_WIDTH;j++)
      {
      a = re_min+(j*re_factor/SCREEN_WIDTH); 
      b = im_min+(i*im_factor/SCREEN_HEIGHT);
      x = 0;
      y = 0;
      test = 0;
      for (k=0;k<iterazioni;k++)
       {
       x_new = (x*x)-(y*y)+a;
       y_new = (2*x*y)+b;
       if (((x_new*x_new)+(y_new*y_new))>4)
        {
        test = k;
        switch (k%8)
          {
            case 0 : tft.drawPixel(i,j,C0); break;     
            case 1 : tft.drawPixel(i,j,C1); break;      
            case 2 : tft.drawPixel(i,j,C2); break;      
            case 3 : tft.drawPixel(i,j,C3); break;      
            case 4 : tft.drawPixel(i,j,C4); break;      
            case 5 : tft.drawPixel(i,j,C5); break;      
            case 6 : tft.drawPixel(i,j,C6); break;      
            case 7 : tft.drawPixel(i,j,C7); break; 
         }     
        break;
        }
       x = x_new;
       y = y_new;
       }
      }
     }
}

void loop(void) {
  while (1) {}
}



LCD Shield SPFD5408 su Arduino

Mi sono comprato questo shield Arduino su un e-commerce cinese allettato dal prezzo modesto (circa una decina di euro spedizione compresa) e dato l'accoppiamento con un touch screen

Vista da sopra - Si osservi il pessimo montaggio del touch screen

Vista inferiore

Quando mi e' arrivato mi sono reso conto subito di un paio di cose:
1) lo shield e' montato in modo pessimo (il touch screen e' montato storto rispetto all'LCD)
2) tutti i piedini dell'Arduino sono coperti per cui in sostanza si puo' usare il solo shield

Ma i problemi non erano questi, il difficile e' stato farlo funzionare.

Sul sito del venditore viene dichiarato che ha un controller spfd5408 che non risulta supportato dalla libreria UTFT (quella standard per gli shield originali Arduino)

Frugando su Internet ho finalmente trovato questo link ad una libreria che permette di utilizzare questo dispositivo.

Il display (diciamolo francamente) fa abbastanza schifo un quanto se si accende tutto con il medesimo colore di fondo mostra delle bande di colore leggermente differenti.
Comunque vale la solita regola, spendi poco ottiene poco

Ecco il video della demo grafica (compresa negli esempi della libreria)



PS: la libreria non permette l'utilizzo dell' SD Reader

lunedì 16 dicembre 2013

Servizio Stadio Fiorentina

Servizio Stadio con la Pubblica Assistenza

Fiorentina-Bologna 3-0 15/11/2013

Fiorentina Milan 0-0 19/11/2011

Flashare un Nokia C7-00

In questi giorni e' arrivato al settore informatico in Nokia C7-00 aziendale bloccato con il pin.
Impossibile risalire all'utente e tutti i pin stupidi (0000,1234 etc) non hanno sbloccato il telefono
Pur non essendo un gran terminale e' comunque considerato di fascia medio-alta per un costo superiore ai 300 euro (sul mercato dell'usato e' sui 100 euro) e quindi vale la pena perderci un po' di tempo per riprenderne il possesso



Non avevo esperienza con i Nokia ma una breve ricerca su Internet mi ha fatto approdare sul software Phoenix (attenzioni: molte indicazioni che si trovano nei blog sono vecchie e non funzionano piu', si devono selezionare solo fonti recenti, per esempio il software Navifirm+ e' dichiarato non piu' funzionante, le stesse operazioni si possono compiere dall'interno di Phoenix)

Per prima cosa si deve disattivare l'antivirus perche' Phoenix viene visto come programma ostile e si devono concedere i permessi per aprire alcune porte sul firewall (non ne conosco il motivo ma per sicurezza la procedura e' stata fatta su una macchina muletto sacrificabile in caso di problemi di sicurezza)

A questo punto si identifica il Product Code nascosto sotto la batteria (nel caso 059D8F3) per scaricare il firmware, il software identifica correttamente il tipo di software RM-675 e si scarica un file da ben 327 Mb


A questo punto si va in firmware update e si lancia Refurbish (verificare che la stringa nel Product Code sia corretta) e verificare che il Options non ci siano scritte in rosso (eliminare nel caso)


Si lancia e si attende



Al termine il terminale e' sbloccato ed usabile. Semplice ed indolore




venerdì 13 dicembre 2013

Geolocalizzazione su Android senza GPS

Attualmente e' possibile effettuare la geolocalizzazione di un telefono Android mediante la rete cellulare,una possibilita', un tempo riservata a forze dell'ordine ed ai gestori della telefonia mobile.

Mediante le Api di Android e' possibile ottenere le informazioni sulla antenna agganciata dal telefono.
I parametri sono
MCC e MNC : relativi al gestore (in questo caso MCC 222 e MNC 88 indica Wind Italia)
CID e LAC : sono gli identificativi dell'antenna

Il codice per ottenere queste informazioni  si possono ottenere con il codice riportato al termine del post


A questo punto ci si puo' affidare a servizi come quello fornito da Cellphonetrackers.org, per ottenere una geolocalizzazione


Il segreto e' che esiste un database pubblico della posizione e degli ID delle antenne di telefonia mobile denominato OpenCellID che permette di convertire le informazioni di telefonia in informazioni geografiche

Con la scheda Wind non sono riuscito a identificare le NeighboringCellInfo ne' il numero del cellulare (che e' gestito a livello di rete e non e' contenuto fisicamente nella SIM)
Con Vodafone invece la lista delle antenna vicine si popola con tre elementi di cui viene indicato l'RSSI ma non il LAC ed il CID (quindi fondamentalmente e' inutile)

Modifica il file Manifest
<uses-permission android:name="android.permission.READ_PHONE_STATE"/>

------------------------------------------------
 TelephonyManager mTelephonyMgr;
        mTelephonyMgr = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
        String networkOperator = mTelephonyMgr.getNetworkOperator();
        GsmCellLocation cellLocation = (GsmCellLocation) mTelephonyMgr.getCellLocation();
        nr_phone = mTelephonyMgr.getLine1Number();
        cid = cellLocation.getCid();
        lac = cellLocation.getLac();
        if (networkOperator != null) {
            mcc = Integer.parseInt(networkOperator.substring(0, 3));
            mnc = Integer.parseInt(networkOperator.substring(3));
        }
------------------------------------------------

questo invece e' il codice per le celle vicine che non mi funziona



------------------------------------------------
  List<NeighboringCellInfo> NeighboringList = mTelephonyMgr.getNeighboringCellInfo();
        String stringNeighboring = "Neighboring List- Lac : Cid : RSSI\n";
        for(int i=0; i < NeighboringList.size(); i++){
         
        String dBm;
        int rssi = NeighboringList.get(i).getRssi();
        if(rssi == NeighboringCellInfo.UNKNOWN_RSSI){
        dBm = "Unknown RSSI";
        }else{
        dBm = String.valueOf(-113 + 2 * rssi) + " dBm";
        }
 
        stringNeighboring = stringNeighboring
         + String.valueOf(NeighboringList.get(i).getLac()) +" : "
         + String.valueOf(NeighboringList.get(i).getCid()) +" : "
         + dBm +"\n";
        }
------------------------------------------------

Debian su Asus ET1611

Ho avuto modo di incrociare le armi su un curioso All-In-One della Asus
Il motivo dell'interesse e' stato che la macchina e' stata recapitata con un sistema operativo denominato "Asus Express Gate Cloud Os", una interfaccia minimale che permette di navigare e mandare mail con il touchscreen  o con la tastiera


Gia' con una configurazione cosi' minimale il calcolatore ha mostrato evidenti limiti: il monitor e' pessimo sia come assemblaggio (il monitor non e' a filo con lo schermo) che come qualita', il touch e' piuttosto impreciso e non reattivo (non e' chiaro se il lag sia software od hardware)

Il computer e' dotato di un processore Atom D450 e cio' da solo fa escludere l'installazione di Windows 7 (anche se in effetti la Asus commercializza la famiglia ET1611 con questo sistema operativo)

E' stato provato quindi ad installare Debian che non ha fatto una piega nell'installazione.
Sulla macchina e' installata una scheda di rete cablata della Realtek mentre la parte WiFi e' gestita da un Atheros



L'aspetto da rimarcare da questa prova e' che l'Asus ET1611 e' lento anche con Debian, tanto che mi verrebbe voglia da taggare questo post come Obsoleto.
Per finire la chicca, il costo del calcolatore e' di circa 400 euro (commenti superflui)

ThinkerKit DMX Receiver

Mi hanno prestato il DMX Relay Receiver della ThinkerKit
Si tratta di un componente che dovrebbe essere collegato al DMX Master Shield ma la presenza del processore ATMega32U4 lo rende anche indipendente



Prima osservazione: non usatelo su Windows. Richiede i driver e non sono riuscito a trovarli. Usarlo su Linux e' invece una passeggiata
Il sistema viene riconosciuto e programmato come una Arduino Micro anche se di fatto puo' solo pilotare i propri relay
Per permettere la commutazione dei rele' e' necessario utilizzare una alimentazione esterna a 12 V

Per rendere operativa la scheda si usa la libreria DMX (l'identificativo della scheda, modificabile mediante i jumper, e' stato impostato a 3)
---------------------------------
#include <DmxMaster.h>

int ADDRESS = 3; 
int led = 13;


void setup() {
  DmxMaster.maxChannel(ADDRESS + 3);
  pinMode(led, OUTPUT);  
  Serial.begin(9600);
}

void loop() {
  for (int i = ADDRESS; i < ADDRESS + 4; i++) {
    digitalWrite(led, HIGH);
    DmxMaster.write(i, HIGH);
    delay(1000);
    Serial.println(i);

    DmxMaster.write(i, LOW);
    digitalWrite(led, LOW);
  }
}
---------------------------------
In conclusione direi che il sistema e' costoso (oltre i 40 euro) e piu' complicato che non usare il semplice metodo presentato in questo post oppure in questo

giovedì 12 dicembre 2013

Gestire l'evento onrelease su pulsante di Android

Sto sviluppando una applicazione che mandi un segnale di allarme in caso di necessita' da parte di un utente.
Per inviare il messaggio e' previsto che l'utente prema un pulsante, grande quanto lo schermo
E' necessario pero' evitare falsi allarmi quindi il pulsante deve essere tenuto premuto per un determinato tempo (diciamo 1 secondo) e quindi non si puo' generare l'evento sull'onclick ma si deve fare in modo di calcolare la differenza di tempo tra l'evento onclick ed onrelease

Di seguito il codice per gestire questo problema
---------------------------------------------------------------
package com.test.onrelease;

import android.os.Bundle;
import android.app.Activity;
import android.graphics.Color;
import android.view.*;
import android.view.View.OnTouchListener;
import android.widget.Button;

public class MainActivity extends Activity {



private Button pulsante;
long lastDown;
long lastDuration;

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


pulsante = (Button)  findViewById(R.id.button1);

pulsante.setText("Premere il pulsante per almeno 1 secondo");

pulsante.setOnTouchListener(new OnTouchListener() {
    public boolean onTouch(View v, MotionEvent event) {
       if(event.getAction() == MotionEvent.ACTION_DOWN) {
          lastDown = System.currentTimeMillis();
       } else if (event.getAction() == MotionEvent.ACTION_UP) {
          lastDuration = System.currentTimeMillis() - lastDown;
          if (lastDuration > 1000)
          {
           pulsante.setBackgroundColor(Color.GREEN);
           pulsante.setText("Richiesta accettata. Invio in corso");
          }
           else
           {
           pulsante.setBackgroundColor(Color.RED);
           pulsante.setText("Premere il pulsante per almeno 1 secondo");
           }
       }
return false;
    }
 });


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

mercoledì 11 dicembre 2013

Debian su IBM A31P

Il modello su cui e' stata provata Debian e' in questo caso un vetusto IBM A31P, il modello base dei portatili IBM della prima meta' degli anni 2000.
Dato il periodo di uscita e la fascia "economica" (sempre che IBM abbia mai fatto qualcosa di economico) si nota il peso oltre i 3 Kg, l'assenza di Wireless (per maggiori dettagli vedere qui), il connettore micro FireWire

A dispetto della batteria completamente priva di capacita' di carica, il portatile si distingue per una risoluzione del monitor di 1600x1200 pixel (un record per l'epoca ed anche per altri portatili piu' recenti)
Da segnalare la presenza di una Ultraport ben nascosta nel lato alto del display

Sulla macchina e' stata montata una Debian Squeeze (l'installazione di questo portatile risale al giugno di due anni fa ma solo in questi giorni mi e' ritornata tra le mani)

Non e' certo una macchina veloce ma la fantastica tastiera IBM fa dimenticare il peso eccessivo