martedì 26 febbraio 2013

Mandelbrot in OpenGL su Linux/Debian

In questo post viene presentato un programma per creare l'insieme di Mandelbrot in OpenGL.
Questa specifica permette di scrivere codice astraendosi dai differenti acceleratori grafici con API uniformi tra le varie piattaforme in cui e' implementata OpenGL ed e' necessario avere una scheda grafica abilitata per poter funzionare

In Debian, per programmare in OpenGL, si deve installare FreeGlut (Glut e' una estensione ad OpenGL che permette di gestire la creazione delle finestre e gli eventi da tastiera anche questa indipendente tra varie piattaforme)

apt-get install freeglut3-dev


Mandelbrot in OpenGL


Per compilare il codice sottostante si usa la seguente stringa

g++ -Wall -O3 mandel.cpp -o mandel -lglut -lGLU

il codice utilizzato e' sempre quello di base gia' presentato nei precedenti esempi e sono evidenziate in giallo le direttive tipiche di OpenGL
Si deve evidenziare che in questo caso viene utilizzato un Double Buffering RGB
La cosa curiosa utilizzando OpenGL (rispetto all'esperienza con altre librerie) e' il modo di mappare i pixel
In pratica il numero di pixel non e' per definizione quella massima della finestra creata ma deve essere esplicitamente definito da gluOrtho2D(0.0,640.0,0.0,480.0);
Nel caso in cui non si glVertex2i (che accetta come input coordinate intere) ma glVertex2f (coordinate float) lo spazio delle coordinate e' compreso tra -1.0 e 1.0
--------------------------------------------------
#include <GL/gl.h>
#include <GL/glut.h>

#include <stdio.h>

#define SCREEN_WIDTH 640
#define SCREEN_HEIGHT 480


float re_min = -2.0;
float im_min = -1.2;

float re_max = 1.0;
float im_max = 1.2;

int iterazioni = 1024;


float a,b;
float x,y,x_new,y_new;

int test;

int k,j,i;
 

void disegna()
{

    float re_factor = (re_max-re_min);
    float im_factor = (im_max-im_min);
   
    glColor3f(1, 1, 1);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();


    glClear(GL_COLOR_BUFFER_BIT);
    glBegin (GL_POINTS);


    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;
        if (k%2 == 0) glVertex2i(j,i);        

        break;
        }
       x = x_new;
       y = y_new;
       }
            
      }
   
     }
    glEnd();            

    glutSwapBuffers();   
}

int main(int argc, char* argv[])
{
    glutInit (&argc, argv);
    glutInitDisplayMode (GLUT_RGB|GLUT_DOUBLE);
    glutInitWindowSize(SCREEN_WIDTH, SCREEN_HEIGHT);
    glutInitWindowPosition(0, 0);
    glutCreateWindow("Mandelbrot");
    gluOrtho2D(0.0,640.0,0.0,480.0);
    glutDisplayFunc(disegna);
    glutMainLoop();

    return 0;
}

lunedì 25 febbraio 2013

Freeglut su Virtualbox

Per fare qualche prova ho deciso di provare FreeGlut su una macchina virtuale
Per prima cosa si deve abilitare il supporto di accelerazione 3D alla macchina virtuale (altrimenti le librerie FreGlut si rifiutano di funzionare)òl



per il test ho provato ad usare il codice presente a questo link compilando mediante la riga di comando
g++ test.cpp -o test -lglut

lanciando l'eseguibile viene risposto con il seguente errore

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

luca@debian:~$ ./test 
OpenGL Warning: XGetVisualInfo returned 0 visuals for 0x8b484e8
OpenGL Warning: Retry with 0x8002 returned 0 visuals
Errore di segmentazione
-------------------------------------------

la soluzione a questo errore, ripresa da questo sito, e' la seguente
-------------------------------------------
export LIBGL_ALWAYS_INDIRECT=1
-------------------------------------------

una volta modificata questa variabile di ambiente rilanciando l'eseguibile il risultato e' quello atteso



venerdì 22 febbraio 2013

Offuscare il codice Java di Android con ProGuard

All'interno dell SDK di Android e' contenuto uno strumento per offuscare il codice Java in modo da evitare quando descritto nel precedente post Decompilare un apk

Un file di configurazione generale e' riportato in sdk/tools/proguard/proguard-android.txt mentre un altro file di configurazione, specifico per ogni progetto, e' nella root del progetto come proguard-project.txt. La configurazione di base solitamente e' sufficiente

Per attivare l'offuscamento del codice si deve togliere il commento alla riga di Proguard in project.properties

project.properties
-----------------------------------------

# To enable ProGuard to shrink and obfuscate your code, uncomment this (available properties: sdk.dir, user.home):
proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt
------------------------------------------

Una volta esportata il progetto creando il file .apk si osserva la creazione della directory proguard; importante conservare il contenuto perche' con questi file e' possibile effettuare il deoffuscamento del codice




provando ad effettuare la decompilazione dell'apk mediante il metodo del precedente post utilizzando la stessa applicazione si ha che la MainActivity risulta essere

Ralink RA5370 in Linux Debian

Per un vecchio portatile con una Debian Testing, sprovvisto di antenna WiFi, mi sono comprato per pochi euro su un sito cinese l'antenna Ralink RA5370 che supporta fino a 802.11N


Il supporto per Debian e' garantito mediante l'installazione di
apt-get install firmware-ralink

per caricare il modulo manualmente si usa il comando
modprobe rt2800usb

Decompilare un APK

Ebbene si', ho perso i sorgenti di un mio programma (nello specifico Well DrawDown Test)
Purtroppo ho formattato il portatile e non mi sono accorto che il progetto non risiedeva in "workspace" (la directory di default per i progetti di Eclipse) ed ho perso il sorgente del progetto


Pero' ho ancora l'apk (o meglio e' ancora sul Play Store)
Per recuperare il codice ho proceduto cosi'

Si mette in una directory il file .apk e lo si rinomina in .zip, a questo punto di decomprime come un normale zip e si ottiene quanto segue

a questo punto si scarica il programma dex2jar e si esegue
dex2jar classes.dex

e' arrivato quindi il momento di decompilare il codice con java decompiler 
si scompatta il pacchetto e si esegui
jd-gui

si apre quindi il file classes.dex.dex2jar e come per magia si ha il codice sorgente 


non e' esattamente come lo ho scritto io perche' alcune variabili sono diventate identificativi numerici ma e' decisamente leggibile
A questo punto rimangono da estrarre i file xml utilizzando il programma apktool
Si digita 
apktool d nome_file.apk nome_file

verra' generata una sottodirectory in cui sono contenuti tutti i file xml e il contenuto della directory /res



giovedì 21 febbraio 2013

Connessione seriale HP 48GX

In questo post viene descritto come effettuare una connessione seriale con una calcolatrice HP48GX per effettuare l'upload di programmi

Non verra utilizzata la calcolatrice reale ma il suo emulatore Linux (x48) dato che non possiedo il cavo e dato che il simulatore si comporta esattamente come l'oggetto reale

Per prima cosa si deve settare la calcolatrice in Server Mode. Cio si ottiene premendo Shift Destro + tasto 1 (modalita' I/O) e selezionando con le frecce l'opzione Start Server dal menu


terminata questa operazione lo schermo sara' di questo tipo

 Si passa quindi al lato client
La comunicazione avviene mediante il protocollo Kermit per cui si deve scaricare il pacchetto  ckermit

apt-get install ckermit

si deve poi individuare sulla schermata dell'emulatore la porta di connessione (nel caso /dev/pts/1)


e si deve inserire la seguente serie di comandi
-------------------------------------------------------------------
/home/luca/) C-Kermit>set modem type direct
(/home/luca/) C-Kermit>set port ?No keywords match - oport
(/home/luca/) C-Kermit>set port /dev/pts/1 
(/home/luca/) C-Kermit>set speed 9600
/dev/pts/1, 9600 bps
(/home/luca/) C-Kermit>set carrier-watch off
(/home/luca/) C-Kermit>set flow none
(/home/luca/) C-Kermit>set parity none
(/home/luca/) C-Kermit>set block 3
(/home/luca/) C-Kermit>set control prefix all
(/home/luca/) C-Kermit>set file type binary
(/home/luca/) C-Kermit>send /home/luca/BENO
(/home/luca/) C-Kermit>finish

-------------------------------------------------------------------
con il comando send si definisce il file del programma che si intende caricare sul calcolatore

con il comando finish la calcolatrice esce dal Server Mode e si puo' lanciare il programma secondo la normale procedura

Il programma in esecuzione



Compilatore Pascal su Android

Non e' molto utile ma molto geek utilizzare un compilatore Pascal su un terminale Android anche perche' a me ricorda i tempi del Turbo Pascal 5

Una scelta puo' essere PePe Compiler che eredita molti aspetti dal Turbo Pascal ed in generale i sorgenti per TP girano anche su PePe

Tra gli esempi vi sono alcuni superclassici come il calcolo dei numeri primi e Pi Greco


Al momento non e' pero' implementata la gestione della grafica (ad onore del vero la versione per PalmOS e' decisamente piu' avanzata e gestisce la GUI) e non e' possibile generare un file eseguibile svincolata dal compilatore...in conclusione si tratta di un gran bel giochino...ma un giochino

Privilegi di root su GT-S5570i

Le istruzioni per avere i permessi di root sul Samsung GT-S5570i sono stati ripresi da questo link

per prima cosa si salva questo file nella SD Card, dopo di cio' (a telefono spento) si premuno i tasti Accensione+Volume Su+Home fino a quando appare il menu

A questo punto si sceglie l'opzione Update from SD Card e si attende il reboot


Come si puo' vedere il programma Root Checker conferma il possesso dei privilegi di root

mercoledì 20 febbraio 2013

Emu84 Emulatore HP48GX

Ho voluto provare, avendo a disposizione l'originale, l'emulatore della calcolatrice HP48GX

Il programma si chiama Emu48 e, per quanto ne so, non ha una versione Linux
Una volta scaricato l'emulatore e' necessario reperire una ROM per l'emulatore da sito hpcalc.org (io ho usato questa) ed un file KML che corrisponde all'aspetto grafico dell'emulatore stesso (a questo indirizzo il KML per la 48GX)


fatto cio' si avvia l'emulatore e ci si trova davanti la schermata della figura precedente
Ovviamente trattandosi di un emulatore basato su una ROM estratta da una calcolatrice reale il comportamento sara' esattamente quello reale...l'unica differenza e' nel modo di caricare i dati (sarebbe stupido usare la porta seriale virtuale)

Sempre su hpcalc.org e' possibile scaricare programmi per tutta una serie di calcolatrici programmabili HP.
Una volta ottenuto il programma in formato binario (il file inizia con  un header del tipo HPHP48...) si puo' semplicemente trascinare il file sul diplay LCD dell'emulatore oppure da menu Edit/Load Object

Si vede apparire parte del codice del programma
A questo punto si clicca il pulsante alla estrema sinistra della terza fila dall'alto ('), poi doppio clic sul pulsante alpha e si inserisce il nome del programma (che sara' tra apici). Terminato si preme STO per salvarlo

Per recuperare il programma dalla memoria ed eseguirlo si preme poi il tasto VAR e si vede apparire nella riga del menu in basso al display il nome scelto (in questo caso e' MAND come Mandelbrot)



premuto il tasto funzione bianco sottostante il menu di interesse il programma viene messo in esecuzione


Lo stesso programma e' disponibile (Droid48) anche su Android (di una lentezza disarmante..piu' per colpa del telefono/Android  che dell'emulatore)


Frugando un po' ho trovato un emulatore per HP48 per Linux che si chiama X48
Si installa direttamente da pacchetto deb (non e' presente nei repository) e si deve inserire la rom nella directory .hp48

A differenza di Emu48, per caricare i programmi sull'emulatore si deve usare la porta seriale virtuale mediante il protocollo kermit come se fosse una calcolatrice fisica (un po' fastidioso)



martedì 19 febbraio 2013

Zoom estremo sull'insieme di Mandelbrot

Questa non e' ovviamente opera mia ma e' troppo bello per non pubblicarlo

Angoli di inclinazione in PhoneGap/HTML5

Sempre utilizzando PhoneGap e' possibile in modo molto semplice ottenere gli angoli di rotazione del dispositivo mobile nello spazio mediante la notazione di Eulero
Angoli di Eulero (Wikipedia)
Gli angoli sono anche definiti come
alfa = yaw (imbardata) in giallo
beta = roll (rollio) in rosso
gamma =  pitch (beccheggio) in viola

Fonte Wikipedia

il codice e' semplicemente autoesplicativo
----------------------------------------------------

<!DOCTYPE html>
<html>
  <head>
    <title>Angoli</title>

    <script type="text/javascript" charset="utf-8" src="cordova-2.3.0.js"></script>
    <script type="text/javascript" charset="utf-8">

    
    window.addEventListener('deviceorientation', function(event) {

    var alpha = 360 - event.alpha;
    var beta = event.beta;
    var gamma = event.gamma;

    // Display Euler angles
    document.getElementById("alpha").innerHTML = "Alpha : " + alpha;
    document.getElementById("beta").innerHTML = "Beta  : " + beta;
    document.getElementById("gamma").innerHTML = "Gamma : " + gamma;

}, false);
    </script>
  </head>

  <body>
<p id="alpha">Alpha : </p><br>
<p id="beta" >Beta  : </p><br>
<p id="gamma">Gamma : </p><br>
    
  </body>
</html>


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

Chrome su Linux dietro ad un proxy server



Nella versione per Linux di Google Chrome non e' presente il menu di configurazione del proxy server. Al suo posto vi e' un messaggio che cerca di indirizzare l'utente alla soluzione

Se si usano Kde o Gnome in pratica vengono assunti i settaggi del Window Manager...ma cosa fare con Lxde???

La soluzione piu' semplice e valida per tutte le distribuzioni e' lanciare Chrome da linea di comando con il seguente parametro

google-chrome --proxy-server=http://mioproxy.com:8080/

Aldebaran, Giove e Luna

Con l'arrivo della nuova macchina digitale le foto sono un po' migliorate

In questa ripresa (18/2/2013 alle 22:21 da Firenze) si vede Aldebaran (a sinistra), la Lune (chiaramente al centro) e Giove (a destra) nella stessa porzione di cielo


Qui la simulazione in Stellarium


C4Droid

C4Droid e' la prima applicazione in assoluto che abbia acquistato (2.29 euro) e devo ammettere che ne vale la pena

L'applicazione permette di programmare all'interno di un terminale Android in C/C++ con Gcc come compilatore ed con alcune librerie di uso comune all'interno di Linux come SDL e Qt. In questo modo ci si svincola dall'impiego di Java e dalla macchina virtuale Dalvik per fare applicazione di livello piu' basso come e' possibile fare con l'NDK

Per mettere alla prova il compilatore ho preso il sorgente del post che permette di disegnare l'insieme di Mandelbrot




Il codice e' stato copiato ed incollato senza nessuna modifica, quindi compilato ed eseguito

Il risultato e' riportato nella immagine sottostante


Come si puo' osservare il risultato e' quello atteso. Il tempo di esecuzione, che su un pc attuale non e' quasi misurabile dato che il risultato e' quasi istantaneo, nel telefono Samsung GT-S5570i e' di circa 18 secondi

Con lo stesso compilatore si puo' usare Ncurses. Sempre prendendo a prestito da un precedente post si puo' ottenere


La cosa divertente e' che con questo compilatore si riesce a superare il controllo della latenza di Dalvik. In pratica di norma Android interrompe una applicazione se questa per circa 30 secondi non restituisce la possibilita' di interazione all'utente

L'immagine sottostante e' stata effettuata mediante un calcolo di circa 2 minuti e 25 secondi ed e' stata terminata senza nessuna segnalazione di anomalia da parte del sistema operativo





Un buon acquisto in fine dei conti anche se in fine dei conti si tratta di un giochino piu' che di uno strumento di produzione

LLama3 Anita

A seguito di questo post ho provato a vedere ho provato a vedere cosa accadeva ad utilizzare un modello specifico per la lingua italiana in...