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

Debugger integrato ESP32S3

Aggiornamento In realta' il Jtag USB funziona anche sui moduli cinesi Il problema risiede  nell'ID USB della porta Jtag. Nel modulo...