Simple trick to add zip file to jpg image

Sometimes I have a PCB (printed circuit board) to realize. Usually, I send my design to local (italian) producers, but recently I’ve seen on a famous internet shop (four letters, starting with ‘e’ ending with ‘y’) some advertise from chinese producers, giving the PCB service at VERY low price. My PCB design files are always in GERBER format, with all sections shrinked in a single zip file.

If you decide to send your design to such chinese producers, generally you must mail your zipped gerber to the factory using your private email, ‘cause the “famous internet shop” only accepts jpg files as attachments in messages from buyer to seller (or viceversa).

This limit gaves me an idea : to create a jpg file that has a image part (my logo, for example) and hidden embedded gerber file. This way, I can send the data using the mail messaging offered by “the famous internet shop” without the need to use my private email account.

The procedure to create such embedded jpg is VERY simple:

a) put the gerber.zip (or ANY OTHER zip file) and the “container” image.jpg on a temp folder…

b) open a “dos command” window, navigate to the temp folder, then type: copy /b image.jpg + gerber.zip miximage.jpg (I usually create a batch file with this command in that folder,)

This command creates a copy (binary copy, thanks to the /b option) of the jpg PLUS the zip file. Now, if you open the resultant miximage.jpg with an image viewer, you will see the “container” image, but if you right click on the same jpg file, choosing “open with”, and selecting the application 7zFM.exe (from folder 7-Zip, under program files), you will discover that all your zip file contents are also present. The link to 7Z, my favourite zip/unzip application, is on the right side of this page, under useful links.

With this “mixed” file, you can use the mail message system of the “famous internet shop” to send your data to the chinese factory, attaching to your message the embedded jpg file. This is good for avoiding to use your private email and for have a seller-buyer transaction covered by the payment protections of the shop.

Hope this will be useful for someone…

Html più Php = labirinto interattivo

Ho realizzato, qualche tempo fa per scopi didattici, usando unicamente html e php, un piccolo “labirinto” interattivo che può essere facilmente installato su qualsiasi host (io uso, ovviamente, Altervista) che permetta di far “girare” programmi PHP. Per disegnare le “stanze” con le varie combinazioni di porte e oggetti, ho usato un software 3D dell’Ikea:si chiamava Kitchen Planner, era una versione “free” del 2005, se non sbaglio. Una volta disegnate le varie stanze, ne ho fatto dei files jpg che vengono richiamati a seconda della “mappa” del labirinto, inserita in un file di testo, e della “porta” scelta dall’utente durante l’esplorazione dello “strano edificio”. In qualche stanza ci sono “oggetti” cliccabili, ma non voglio dirvi tutto… Se volete dargli un’occhiata cliccate su questo link e vi troverete sulla pagina di partenza, che vedete qui sotto…

labishot

FreeBASIC – Esercizi

Steganografia
Vi propongo un altro esercizio per il FreeBASIC. Si tratta di un programmino scritto da me che consente di leggere un messaggio “nascosto” in una immagine. Il file immagine che contiene il messaggio è questo qui sotto:

foto con messaggio nascosto :)

Si tratta, come vedete, di una immagine in formato BMP con 256 toni di grigio. L’utilizzo di questo formato è dettato dalla semplicità di decodifica di tale tipo di file. Invito chiunque fosse interessato (basta fare una ricerca su Google) a studiare cosa c’è scritto nell’intestazione (lo header) di un file .BMP ; non è per niente complicato.
Bene: come possiamo “nascondere” un testo in una fotografia ? Semplice… ogni pixel di una foto in formato BMP a 256 toni di grigi è un byte che può avere un valore da 0 a 255 ; lo zero rappresenta il nero totale, il 255 invece è il bianco pieno. Tutti i valori intermedi sono i vari livelli di grigio. Allora noi che facciamo ? prendiamo il bit meno significativo di ognuno di questi bytes e lo modifichiamo per comporre una sfilza di bits che saranno il nostro messaggio testuale “nascosto”. Cambiare il colore di un pixel da 255 a 254, per esempio, risulterà totalmente invisibile all’occhio umano, perché si passerà da un bianco pieno a un bianco appena un po’ meno pieno. Lo stesso dicasi di un pixel che aveva valore 000 (tutto nero) e passa a 001 (appena un po’ meno nero). L’occhio non percepisce queste piccole differenze, specie perché è attirato dalla visione “globale” della fotografia.
Vi propongo il listato del programma sorgente in FreeBASIC che esegue il lavoro di decodifica. Appena lo avrete compilato, mandatelo in esecuzione e vi troverete un nuovo file di testo, chiamato epgficara.txt, contenente un mio breve curriculum vitae. Nota importante: mettete nella stessa cartella il programma che compilerete e il file immagine epgficara.bmp che potrete scaricare da questa pagina cliccando con il tasto destro e facendo “salva con nome” e assicuratevi che la cartella in cui mettete le cose sia provvista dei diritti di scrittura, altrimenti il programma non potrà produrre il file di testo in uscita.
Ecco, quindi, il file sorgente per FreeBASIC:

dim shared as string nfi, a
dim shared as long start, leng, fl
dim shared as ubyte db, src

print "Decodifica steganografia in file BMP - 256 livelli grigio - V13.0316 - (c)2013 Emilio P.G. Ficara"
nfi = "epgficara.bmp" ' nome del file da decodificare
If Dir(nfi) = "" then
  Print "Errore: il file ";nfi;" non esiste"
  Goto exits
EndIf

Open nfi for binary as #1 ' apri il file da leggere
a = Input$(54,#1) ' leggi solo l'intestazione (header)
If Left(a, 2) <> (Chr(&h42) + Chr(&h4d)) then ' se errato il "magic number"
  Print "Errore: non è un file BMP"
  Goto exits
EndIf
If Mid(a,&h1C+1,2) <> (Chr(8)+Chr(0)) then ' se non è 8 bit per pixel
  Print "Errore: non è 8 bit per pixel"
  Goto exits
EndIf
If Mid(a,&H1E+1,4) <> (Chr(00)+Chr(00)+Chr(00)+Chr(00)) then ' se è compresso
  Print "Errore: è compresso RLE-8 o RLE-4"
  Goto exits
EndIf
If Mid$(a,&H2E+1,4) <> (Chr(00)+Chr(01)+Chr(00)+Chr(00)) then ' se non è 256 toni di grigio
  Print "Errore: non è 256 toni di grigio"
  Goto exits
EndIf

start = Asc(Mid(a,&H0a+1,1)) ' calcola l'indirizzo di inizio del primo pixel d'immagine
start = start + Asc(Mid(a,&H0b+1,1))*&H100
start = start + Asc(Mid(a,&H0c+1,1))*&H10000
start = start + Asc(Mid(a,&H0d+1,1))*&H1000000

leng = Asc(Mid(a,&H22+1,1)) ' calcola lunghezza in bytes dell'immagine
leng = leng + Asc(Mid(a,&H23+1,1))*&H100
leng = leng + Asc(Mid(a,&H24+1,1))*&H10000
leng = leng + Asc(Mid(a,&H25+1,1))*&H1000000

Open "epgficara.txt" for output as #9 ' apri file di uscita (testo)

fl = 54 ' salta la tabella dei colori
While fl < start
  get #1,,src ' leggi un pixel (un byte) del file BMP
  fl = fl+1
Wend

fl = 0 ' contatore dei bytes in input
db = 0 ' byte ricomposto dai singoli bits (inizialmente a 0)
While fl < leng
  If (fl > 0) And ((fl and 7) = 0) then ' per 8 bytes di immagine (excludendo il primo)
    Print #9, Chr(db); ' scrivi un carattere sul file di output (testo)
    db = 0 ' azzera il byte per la ricomposizione dei bits
  EndIf

  get #1,,src ' leggi un pixel (un byte) dal file BMP
  If (src and &H01) then ' se il nostro bit nascosto è 1
    db = db Or (2 ^ (fl and 7)) ' metti a 1 il relativo bit nel byte ricomposto
  EndIf
  If db = &Hff then exit while ' se trovo la combinazione &HFF (8 volte 1), il testo è finito
  fl = fl + 1 ' altrimenti incremento il numero di bytes letti
Wend

exits:
close ' chiudi tutti i files aperti
End

P.S. se qualcuno preferisse avere il programma già compilato e pronto per essere eseguito, potrà scaricare il file stegodec.zip , decomprimerlo in una qualsiasi cartella, aggiungere -come detto prima- il file BMP da decrittare e lanciare l’eseguibile. Non è richiesta alcuna installazione, non viene modificata nessuna voce di registro.

FreeBASIC – esercizi

Permutazioni semplici e soluzione esercizio Bocconi

Eccomi di nuovo a voi con un programmino in FreeBASIC. L’occasione per scriverlo è capitata ieri, quando mi è stato presentato un problema di “allenamento” per le gare internazionali di matematica organizzate dall’università Bocconi. Questi “allenamenti” sono basati su esercizi dati in passato per altre gare dello stesso tipo; in particolare, questo che vi propongo si trovava in una gara del 2006. Potete prelevare il file PDF da questo link che ho trovato su internet. Nel documento PDF ci sono diversi esercizi, ma quello che mi è stato proposto è il numero 10, denominato CONNESSIONE. Devo dire che la parte più difficile della soluzione è stata quella di interpretrare la traccia che, francamente, era parecchio oscura e talvolta rasentava la mancanza di senso, come nella frase “la somma, magari costituita da un unico addendo”, ma una volta capito quello che veniva inteso, il resto è stato facile.
Con un po’ di ragionamenti (partendo dalle somme 1 e 2) si trova facilmente la soluzione, anzi una delle soluzioni possibili. E questo basta per dire di aver risolto il problema. Ok. Dopo un po’ ho pensato di realizzare un programma che trovasse, matematicamente, tutte le possibili soluzioni. Ho impostato la traccia in un modo diverso, che a me è sembrato più chiaro. Ho immaginato sette villette disposte in un certo territorio. Ogni villetta ha il proprio numero civico, da 1 a 7. Da ogni villetta si scorgono una o più delle altre (alcune non sono reciprocamente visibili) e le persone che vivono in ognuna di esse, decidono di calcolare la somma dei numeri civici delle villette che riescono a vedere. I risultati di 6 di questi personaggi sono noti (1, 2, 3, 5, 8, 13), si chiede quale sia la somma calcolata dal settimo. Ho realizzato uno schemino per spiegare queste relazioni:

casette

Sa = B
Sb = A + C + F
Sc = B + D
Sd = C + E + F + G
Se = D
Sf = B + D + G
Sg = D + F

Per ‘Sa’ si intende la somma dei numeri civici delle villette viste dall’abitazione [ a ], per ‘Sb’ quelli visti dalla villetta [ b ] e così via. In pratica le linee che collegano le casette indicano la possibilità di “vedere” le altre. Il programma, quindi, agisce così: genera tutte le possibili PERMUTAZIONI SEMPLICI di 7 elementi, calcola le equazioni per ognuna delle permutazioni e verifica nei risultati se 6 di essi corrispondono a quelli dati nella traccia ; in quel caso, rivela il settimo che è la soluzione. Le permutazioni di 7 elementi sono 5040 (corrispondenti a 7 fattoriale), ma le soluzioni sono solo 8, delle quali 4 non valide perché alcune delle somme si ripetono. Le restanti 4 danno come totale 22, 21 o 19 (quest’ultimo in due permutazioni), che sono quelle indicate come risultato dalla Bocconi.
Le permutazioni vengono tutte salvate sul file di uscita risultati.txt e dopo ogni riga valida, cioè che risponde ai requisiti, viene stampato un ‘*** Ok’ seguito dalle somma calcolate da tutti gli “abitanti” delle villette, da ‘Sa’ a ‘Sg’. Di sotto, il listato del programma :

Dim Shared As Integer contatore(7) ' array usato come contatore a 7 digit
Dim Shared As Integer civici(7) ' array dei numeri civici
Dim Shared As Integer somme(6) ' array delle somme gia' note
Dim Shared As Integer nrow ' numero riga per stampa
Dim Shared As Integer finito ' segnalatore di iterazioni finite

' subroutine per creazione nuova permutazione semplice
'-----------------------------------------------------
Sub Newrow()
Dim As Integer x,y

retry:
    x = 7 ' posiziona su elemento piu' a destra del contatore
    Do
        contatore(x) = contatore(x) +1 ' passa a nuovo digit
        If contatore(x) <= 7 Then Exit Do ' termina se non li hai usati tutti
        contatore(x) = 1 ' altrimenti ricomincia dal primo digit
        x = x -1 ' passa al digit immediatamente a sinistra
    Loop Until x = 0 ' esegui per tutti i digits
    If x = 0 Then ' se il conteggio è finito (tutti i digits usati)
        finito = 1 ' attiva segnale di conteggio terminato
        Exit Sub ' termina la subroutine
    Endif 

    ' vogliamo le permutazioni semplici, quindi saltiamo
    '  le combinazioni con elementi ripetuti
    For x = 1 to 6
        For y = x+1 to 7
            If contatore(x) = contatore(y) Then Goto retry
        Next y
    Next x
End Sub

' subroutine per la stampa della attuale permutazione
'----------------------------------------------------
Sub Outrow()
Dim As Integer x

    Print #1,nrow, ' scrivi nuova riga permutazione semplice
    nrow = nrow +1
    For x = 1 to 7
        Print #1, civici(contatore(x));" ";
    Next x
    Print #1, ' fine linea

End Sub

' subroutine per il calcolo del problema
'---------------------------------------
Sub Calcola()
Dim As Integer S(7)
Dim As Integer x, y, num

    ' calcolo somme numeri civici visibili da ogni villetta
    S(1) = civici(contatore(2)) ' Sa = b
    S(2) = civici(contatore(1)) + civici(contatore(3)) + civici(contatore(6)) ' Sb = a+c+f
    S(3) = civici(contatore(2)) + civici(contatore(4)) ' Sc = b+d
    S(4) = civici(contatore(3)) + civici(contatore(5)) + civici(contatore(6)) + civici(contatore(7)) ' Sd = c+e+f+g
    S(5) = civici(contatore(4)) ' Se = d
    S(6) = civici(contatore(2)) + civici(contatore(4)) + civici(contatore(7)) ' Sf = b+d+g
    S(7) = civici(contatore(4)) + civici(contatore(6)) ' Sg = d+f

    num = 0 ' azzera numero di somme valide
    For x = 1 to 7 ' per tutte le somme calcolate
        For y = 1 to 6 ' per tutte le somme gia' note
            If S(x) = somme(y) then
                num = num +1
                y = 6 ' termina il for interno
            Endif
        Next y
    Next x
    If num = 6 Then ' tutti le somme valide
        Print #1,"*** ok ";
        For x = 1 to 7
            Print #1, "[";S(x);"] ";
        Next x
        Print #1,
    Endif
End Sub

' programma principale
'---------------------

    Print " **********************************************************"
    Print " ** Programma per il calcolo della soluzione al problema **"
    Print " **  delle sette casette con numeri civici da 1 a 7, che **"
    Print " **  si vedono nella mappa allegata al problema.         **"
    Print " ** Compilato con FreeBasic, opzione QB - E.Ficara 2011  **"
    Print " **********************************************************"

    civici(1) = 1: civici(2) = 2: civici(3) = 3: civici(4) = 4 ' assegna numeri civici alle casette
    civici(5) = 5: civici(6) = 6: civici(7) = 7

    somme(1) = 1: somme(2) = 2: somme(3) = 3 ' assegna le somme gia' note
    somme(4) = 5: somme(5) = 8: somme(6) = 13

    For i = 1 to 6 ' inizializza contatore 7 digit
        contatore(i) = 1
    Next i
    contatore(i) = 0 ' combinazione -1 (per successivo incremento con Newrow)

    nrow = 1 ' inizializza numero linea per stampa
    finito = 0 ' inizializza il segnalatore di iterazioni complete

    Open "risultati.txt" For Output As #1 ' prepara file di uscita
    Print #1,"Permutazioni semplici:" & Chr$(13) & Chr$(10)
    Do ' inizia loop combinazioni
        Newrow ' calcola nuova permutazione semplice
        If finito > 0 then Exit Do ' esci se segnale di conteggio finito 
        Outrow ' altrimenti stampa linea
        Calcola ' esegui calcolo del problema
    Loop
    Close #1

    Print "Programma terminato. E' stato creato il file risultati.txt"
    Print "Premere un tasto qualsiasi per terminare..."
    Do
        If Inkey$ <> "" then Exit Do
    Loop
End

FreeBASIC – esercizi

Senti, ma… come lo facevano i Babilonesi ?

Sebbene il titolo possa dar adito a sospetti sull’argomento trattato, quello che vi propongo è solo un altro piccolo esempio di utilizzo del FreeBASIC. Mi sono trovato a dover fare dei calcoli con le radici quadrate in un progetto su un microcontrollore. I microcontrollori NON hanno la possibilità di eseguire calcoli di questo tipo, diciamo che in genere possono fare (in modo primitivo, cioè senza scrivere un programma apposito) addizioni, sottrazioni, moltiplicazioni e divisioni per multipli di 2 (istruzioni di shift a sinistra e a destra), ma non è questo l’argomento che ci interessa.

Insomma, trovandomi a dover fare una radice quadrata senza avere una istruzione adeguata (intendo istruzione del microcontrollore, non la mia !!!) , mi sono ricordato di un metodo con iterazioni successive che si dice sia stato inventato dai Babilonesi. Ora io, con quattromila anni di ritardo, l’ho provato con un programmino facile-facile in FreeBasic, prima di trasportare lo stesso algoritmo sul microcontrollore. Ovviamente, questo listato che vi propongo può lavorare anche con numeri con la virgola, mentre quello che adotterò sul microcontrollore potrà lavorare solo su numeri interi. Ecco il listato:

' programma principale
'---------------------

    Print " **********************************************************"
    Print " ** Programma per il calcolo della radice quadrata di un **"
    Print " **  numero con il metodo BABILONESE.                    **"
    Print " ** Compilato con FreeBasic, opzione QB - E.Ficara 2011  **"
    Print " **********************************************************"
    Do
        Print: Print "Nota: i numeri decimali vanno inseriti con il punto, non la virgola.": print
        Input "Numero di cui si vuol calcolare la radice quadrata (0 per finire) "; num
        If num < 0 Then
            Print "La radice quadrata di un numero negativo ? Non la so fare... e tu ?"
            Print " - dai, ti cambio il segno..."
            num = -num ' ecco fatto
        Endif
        If num = 0 Then Exit Do ' termina se l'utente ha inserito 0 
        prec = 0.01 ' precisione 0.01 (due cifre decimali); modificare se serve
        sq = 1 ' inizializza risultato con numero arbitrario
        old = num ' metti al massimo possibile il valore iterazione precedente 
        Do ' loop iterazioni
            sq = (sq + num / sq) / 2 ' calcola nuova iterazione
            If (old-sq) < prec Then Exit Do ' se la precisione è raggiunta, termina loop
            old = sq ' altrimenti aggiorna valore precedente
            Print "... iterazione: "; sq
        Loop
        Print "risultato: ";sq
    Loop
End

FreeBASIC – esercizi

Voglio proporvi uno strumento utile per lo sviluppo di semplici programmi in ambito matematico e non solo. Si tratta del FreeBASIC, un compilatore Basic gratuito ed open-source che funziona molto bene ed ha il grosso pregio di poter compilare anche i vecchi listati di QBasic e GW Basic che erano (un tempo) usatissimi e con i quali sono state sviluppate migliaia di applicazioni, matematiche, scientifiche e anche ludiche (i primi videogames). Io l’ho installato sul mio portatile con Win7 Home Edition e funziona a meraviglia, ma esiste anche in ambiente LINUX ed ha esattamente le stesse caratteristiche. Nella colonna a destra, sotto ‘links utili’, trovate il collegamento al sito per il download.

Calcolo numeri primi

Un paio d’anni fa mi fu proposto di risolvere un problema scolastico nel quale si chiedeva l’elenco dei numeri primi (fino a 2000) che avessero queste caratteristiche:
a) avere differenza 10 col numero primo che lo precedeva
b) avere tutte le cifre diverse

Risolsi il problema scrivendo un piccolo programmino con il GFW-Basic (un vecchio compilatore a 16 bit per Windows, molto efficiente) ed ora, con minime modifiche, l’ho ricompilato con FreeBASIC e l’ho fatto girare su Win7 (in una finestra DOS) ; funziona perfettamente. Ve lo propongo in forma di listato in modo che possiate provare a compilarlo voi stessi, una volta installato il FreeBASIC. Aggiungo il contenuto del file compila.bat che uso per creare l’eseguibile:

C:\FreeBASIC\fbc.exe -lang qb primi.bas
pause

Naturalmente, questo prevede che il FreeBASIC sia stato installato nella directory C:\FreeBASIC e che al listato abbiate dato il nome primi.bas. Se il compilatore è stato installato in una diversa directory o il nome del file sorgente è diverso, modificate il batch di conseguenza.

Ecco il listato del file sorgente primi.bas :

Dim primi(2000) ' buffer per numeri primi
Dim diff(2000) ' buffer per differenze

    Print " *********************************************************"
    Print " ** Programma per il calcolo dei numeri primi e delle   **"
    Print " **  differenze tra un numero primo e il precedente.    **"
    Print " ** Compilato con FreeBasic, opzione QB - E.Ficara 2011 **"
    Print " *********************************************************"

    primi(1) = 2 ' il primo numero primo (escludendo 1)
    diff(1) = 1 ' la prima differenza
    last = 2 ' indice iniziale dell'ultimo numero primo calcolato
    For i = 2 To 2000 ' limita la ricerca al numero 2000; modificare se serve
        For j = 1 To last - 1 ' prova divisibilita' con numeri precedenti
            If (i / primi(j)) = Int(i / primi(j)) Then Exit For ' esci se divisione intera
        Next j
        If j = last Then ' se non ha trovato divisori (e' un numero primo)
            ' NOTA: le prossime istruzioni servono per ESCLUDERE dalla lista dei numeri primi
            '       quelli che contengono cifre uguali (11 per esempio)
            m = 1110 ' inizializza valore migliaia (arbitrario) <> centinaia e decine
            c = 100 ' inizializza valore centinaia (arbitrario)
            d = 110 ' inizializza valore decine (arbitrario) <> centinaia
            u = i ' inizializza unita' con il numero in esame 
            If u >= 1000 Then ' se maggiore o uguale a 1000
                m = Int(u / 1000) ' m contiene le migliaia
                u = u - m * 1000 ' u contiene il resto (0-999)
            EndIf
            If u >= 100 Then ' se maggiore o uguale a 100
                c = Int(u / 100) ' c contiene le centinaia
                u = u - c * 100 ' u contiene il resto (0-99)
            EndIf
            If u >= 10 Then ' se maggiore o uguale a 10
                d = Int(u / 10) ' d contiene le decine
                u = u - d * 10 ' u contiene il resto (0-9)
            EndIf
            ' per mettere in lista tutti i numeri primi, sostituire la prossima linea
            ' con    If (1) Then    o eliminarla insieme al suo EndIf
            If m <> c And m <> d And m <> u And c <> d And c <> u And d <> u Then ' se m,c,d e u sono diversi
                primi(last) = i ' salva il numero in esame tra i primi
                diff(last) = i - primi(last - 1) ' calcola e salva la differenza col precedente
                last = last + 1 ' incrementa indice dell'ultimo numero calcolato
            EndIf
        EndIf
    Next i

    Open "primi.txt" For Output As #1 ' prepara file di uscita
    Print #1," 1", " 0" ' scrivi il primo numero primo :-)
    For i = 1 To last - 1 ' scrivi tabella numeri primi e differenze
        Print #1,primi(i), diff(i)
    Next i

    Print #1, ' interlinea

    ' scrivi tabella dei numeri primi che hanno differenza 10 col precedente
    For i = 1 To last - 1
        If diff(i) = 10 then
            Print #1,primi(i), diff(i), primi(i - 1)
        EndIf
    Next i
    Close #1

    Print "Programma terminato. E' stato creato il file primi.txt"
    Print "Premere un tasto qualsiasi per terminare..."
    Do
        if Inkey$ <> "" then Exit Do
    Loop

Il programma genera un file di uscita chiamato primi.txt nel quale sono elencati i numeri primi (eccetto quelli che hanno cifre uguali, tipo l’ 11 per intenderci) e, dopo questi, la lista dei numeri primi che hanno differenza 10 con il precedente (nel limite di 2000 posto come massimo per l’indagine).

Modificare le Env_Variables senza ri-flashare tutto

Ho ricevuto una domanda tramite la form per l’invio dei files:
“… Dopo modifiche software e hardware mi è venuto un dubbio che ho appena postato:
How can I update env_boot without flashing all the system?

As of is so difficult to find the correct number for our tablet we have to try many time…but is really necessary to flash completely your tablet or is possible to change only env_boot?
I don’t know…for example with an empty wmt_scriptcmd (?)

Thanks
Marco

Tu hai idea se sia possibile? …”
Rispondo a Marco: le “environment variables” possono essere modificate agendo con un apposito comando del programma U-Boot ; naturalmente per poter usare il programma, bisogna collegare un terminale seriale. Raccomando la lettura di questo articolo per “entrare in argomento”. Aggiungo che il file wmt_scriptcmd può effettuare le stesse operazioni, cioè è possibile crearne uno in cui si settano solo le env_variables e non si fa niente altro. Il programma U-Boot, infatti, come prima operazione va a vedere se c’è una MMC (la microSD) inserita nello slot, poi – se c’è – verifica se all’interno è contenuto il file wmt_scriptcmd ed eventualmente esegue le varie istruzioni programmate. E’ da notare che il file wmt_scriptcmd NON è un semplice file di testo, perché contiene all’inizio uno speciale “header” con un codice CRC per verificare che sia compilato correttamente e sia in grado di lavorare sul sistema su cui lo si sta lanciando. Partendo da un file di testo, si può utilizzare il programma mkimage.exe per ottenere il file idoneo ad essere eseguito sulla microSD.

Modificare le env_variables da terminale seriale.
Una volta entrati in connessione con il programma U-Boot, per cambiare una env_variable basta dare il comando setenv ; per esempio, se vogliamo cambiare il tempo di bootdelay, basterà scrivere setenv bootdelay 3 (da notare che in tutti i comandi setenv NON deve essere scritto il segno “=”, anche se si sarebbe indotti a farlo perché il comando printenv lo mostra a fianco della variabile ; esempio: bootdelay = 3). Con questo comando diciamo al sistema che il ritardo al boot (quello che ci permette di fermare l’autostart) sarà di 3 secondi. Per salvare questa variabile in modo permanente, basterà dare il comando saveenv ; per verificare le modifiche e per avere la lista di tutte le variabili memorizzate sulla memoria SPI flash (sì, è lì che vengono memorizzate) si potrà dare il comando printenv.

Così come per la variabile bootdelay, qualsiasi altra variabile può essere modificata nello stesso modo ; resettando il tablet, il successivo boot avverrà con i nuovi valori delle variabili salvate. Attenzione: se si scrivono valori “a casaccio” oppure semplicemente errati, si corre il rischio di rendere il tablet “un mattone” (a brick) e perciò è imperativo conoscere ciò che si fa, prima di operare ! Esiste anche un modo per eliminare una delle env_variables : basta scrivere il comando setenv e il nome della variabile, senza assegnare alcun valore. La variabile sarà eliminata. Naturalmente, anche questo comando va usato con ESTREMA cura 🙂

Le gioie di Javascript #2

Passiamo a due nuovi concetti, molto importanti : uno per il linguaggio Javascript e precisamente l’ array, e uno per il tag div dell’html e precisamente la proprietà z-index. Prima di iniziare a parlarne, vediamo una piccola “demo” di come questi due concetti possano essere applicati. Cliccando su questo link si aprirà una pagina del browser con quattro “fantasmini” che si muovono sullo schermo…

Di seguito, il listato del programma Javascript (demo2.js) :

//<!-- javascript demo #2 - Emilio Ficara 2012
var i,id,timer; // definizione variabili per indice oggetti,identificatore oggetti,timer
var xpos,ypos,xstep,ystep,xsize,ysize; // definizione variabili posizione, spostamento, dimensioni

  xpos = new Array(); // crea un array di posizioni X per i vari oggetti
  ypos = new Array(); // crea array per posizioni Y
  xstep = new Array(); // crea array per passo spostamenti X
  ystep = new Array(); // crea array per passo spostamenti Y
  xsize = new Array(); // crea array dimensione X oggetti
  ysize = new Array(); // crea array dimensione Y oggetti

  xpos[0] = 0; xpos[1] = 160; xpos[2] = 320; xpos[3] = 480; // posizione X iniziale per 4 oggetti  
  ypos[0] = 0; ypos[1] = 120; ypos[2] = 240; ypos[3] = 360; // posizione Y iniziale
  xstep[0] = 3; xstep[1] = 3; xstep[2] = 3; xstep[3] = 2; // passo spostamenti X
  ystep[0] = 2; ystep[1] = 2; ystep[2] = 2; ystep[3] = 3; // passo spostamenti Y
  xsize[0] = 64; xsize[1] = 48; xsize[2] = 80; xsize[3] = 128; // dimensioni X
  ysize[0] = 64; ysize[1] = 48; ysize[2] = 80; ysize[3] = 128; // dimensioni Y

  NewStep(); // esegui la funzione per la prima volta (dopo verrà richiamata da timer)

function NewStep() // nuovo step spostamento oggetto mobile
{
  for(i = 0; i < 4; ++i) // fai andare la variabile i da 0 a 3 con incremento di 1
    {
    xpos[i] += xstep[i]; // nuova posizione X oggetto [i] di array
    ypos[i] += ystep[i]; // nuova posizione Y oggetto [i] di array
    if(xpos[i] > (document.body.clientWidth -xsize[i]) || xpos[i] < 0) // se oggetto [i] oltre il bordo destro o sinistro
      {
      xstep[i] = -xstep[i]; // inverti lo step di spostamento orizzontale per l'oggetto [i]
      xpos[i] = xpos[i] +xstep[i] +xstep[i]; // esegui lo spostamento due volte (era andato già oltre)
      }
    if(ypos[i] > (document.body.clientHeight -ysize[i]) || ypos[i] < 0) // se oggetto [i] oltre il bordo superiore o inferiore
      {
      ystep[i] = -ystep[i]; // inverti lo step di spostamento verticale per l'oggetto [i]
      ypos[i] = ypos[i] +ystep[i] +ystep[i]; // esegui lo spostamento due volte (era andato già oltre)
      }
    id = "L"+i; // assegna identificativo L0..L3 per l'oggetto che vogliamo muovere
    document.getElementById(id).style.top=ypos[i]+"px"; // assegna la nuova posizione verticale all'oggetto [i]
    document.getElementById(id).style.left=xpos[i]+"px"; // assegna la nuova posizione orizzontale all'oggetto [i]
    }
  timer = setTimeout("NewStep()",20); // attiva timer per eseguire di nuovo la funzione NewStep tra 20 mS
}
//->

e della pagina html usata come “contenitore” (demo2.htm) :

<html><head><title>Javascript demo #2 - Emilio P.G. Ficara 2012</title></head>
<body bgcolor="#FFFFFF">
<div id="L0" style="position:absolute; z-index:1">
 <img src="img/sprite0.png">
</div>
<div id="L1" style="position:absolute; z-index:2">
 <img src="img/sprite1.png">
</div>
<div id="L2" style="position:absolute; z-index:3">
 <img src="img/sprite2.png">
</div>
<div id="L3" style="position:absolute; z-index:4">
 <img src="img/sprite3.png">
</div>
<script src="demo2.js"></script>
</body></html>

Possiamo notare, nel listato demo2.htm, la presenza di 4 tag div, ognuno dei quali ha un proprio identificativo ( id=”L0″ .. id=”L3″ ) e la proprietà z-index di valore diverso; in questo “giochetto” i diversi valori di z-index determinano quale oggetto è “in primo piano”, quale in “secondo piano”, eccetera. Lo z-index può essere considerato come un foglio trasparente su cui appiccichiamo un adesivo che è il nostro oggetto. Facciamo un esempio : i quattro “fantasmini” che vediamo nel gioco hanno ognuno un numero disegnato sopra, da 1 a 4, che corrisponde al valore di z-index che è stato assegnato al tag div che li contiene. Ho usato questi numeri per rendere più chiare le cose. Se ci fate caso, quando i fantasmini si “incrociano”, qualcuno rimane visibile, mentre un altro viene “nascosto dietro”. Questa è la funzione z-index. L’oggetto che ha z-index = 4 (il fantasmino arancione) è sempre visibile, cioè, in caso di “incroci”, copre sia il fantasmino 1, sia il 2, sia il 3. A sua volta, il fantasmino 3 rimane visibile se incrocia il 2 o l’1. Insomma, è come se avessimo i nostri quattro fogli trasparenti sovrapposti, ognuno con il suo adesivo appiccicato sopra, e muovessimo i singoli fogli : se chiamiamo “z-index = 4” il foglio in cima agli altri, è chiaro che tutto quello che c’è sotto l’adesivo non sarà visibile, perché “nascosto dietro”. Lo stesso vale per tutti gli altri livelli, foglio per foglio. Con questo principio è possibile creare animazioni in cui è presente una “profondità” dei livelli, esattamente come se stessimo lavorando con diversi fogli trasparenti sovrapposti.

Per quanto riguarda Javascript, invece, abbiamo fatto uso di arrays . Se consideriamo una variabile come una “scatola” in cui mettere delle cose, allora un array è una cassettiera, con un certo numero di cassetti, così possiamo dire “prendi le camicie che ci sono nel terzo cassetto” e dare un’indicazione esatta di dove si trova ciò che ci serve. Nella demo #1 muovevamo, sul nostro quadrato di gioco, un solo oggetto: la palla, e così avevamo una sola variabile per ognuno dei parametri che ci interessavano : xpos per la posizione orizzontale, ypos per quella verticale eccetera. Ora, nella demo #2, muoviamo 4 oggetti diversi, perciò abbiamo bisogno, per ognuno di essi, delle stesse informazioni. Allora, invece di usare una singola variabile, abbiamo usato degli arrays. Così xpos non è più una singola variabile, ma una “cassettiera” in cui possiamo andare a prendere, basandoci su un indice (la posizione del cassetto) i dati necessari per un determinato oggetto. L’uso di questa tecnica ci permette di scrivere le istruzioni per muovere tutti e quattro gli oggetti in un singolo ciclo FOR ; il ciclo FOR è scritto in modo da far andare una variabile (usata come indice, ovvero il numero del “cassetto”) da 0 a 3 compresi, così da svolgere ogni volta, al suo interno, le operazioni relative agli oggetti [0], [1], [2] e [3]. Con la stessa tecnica è possibile aumentare a piacere il numero di oggetti trattati, semplicemente “allungando” gli arrays. Si noti che gli arrays possono avere più dimensioni, in quel caso, però, è meglio far riferimento a matrici. Ne parleremo in una fase successiva.

Le gioie di Javascript #1

Le gioie di javascript, scusate l’allitterazione…
Ho iniziato questo tutorial per JavaScript sulle pagine di un forum gestito da un amico ed ora che il mio blog comincia a predere forma e consistenza, ho deciso di proseguire direttamente qui. Spero di fare cosa utile.

Ho visto in giro alcune belle animazioni realizzate con programmi specializzati. Le animazioni sono un eccezionale strumento per attirare l’attenzione su un argomento di cui si sta trattando. Gli strumenti software che si utilizzano normalmente, siano quelli a pagamento, siano quelli gratuiti, hanno tantissime possibilità e permettono la realizzazione di “effetti speciali” davvero notevoli. Tutto OK.
Vorrei però focalizzare la vostra attenzione anche su un paio di formidabili strumenti gratuiti e multipiattaforma, in grado di girare su qualsiasi sistema operativo.
Questi strumenti sono :

a) il browser, in special modo Firefox che è presente su praticamente tutte le piattaforme software
b) il linguaggio di scripting Javascript

Javascript è un linguaggio semplice e potente e basta un qualsiasi editor di testi per scrivere la propria applicazione. Dove si fa “girare” un programma scritto in Javascript ? Dentro una pagina web, usando un browser. Il bello è che il programma può essere sul vostro PC o su Internet, le cose non cambiano.
La sintassi di Javascript è simile a quella del linguaggio C e comunque la rete è strapiena di esempi interessanti. Io ne aggiungo uno mio personale, per insistere nel discorso sulle risorse gratuite e liberamente utilizzabili e soprattutto per tentare di modificare l’atteggiamento comune di prendere “roba precotta” e invitare tutti a diventare “chef”, informaticamente parlando. Cominciate con un “ovetto al tegamino” per diventare grandi programmatori 🙂

Cliccando su questo link potrete trovare un’animazione minima realizzata con Javascript. Il programma è semplicissimo e si avvale del versatile tag DIV del linguaggio HTML usato per creare la “pagina” che contiene il gioco. Con Javascript è possibile modificare la posizione di una “sezione” DIV sullo schermo ; siccome in questo esempio la sezione DIV interessata contiene l’immagine di una palla, possiamo far muovere e “rimbalzare” la palla modificando, ad intervalli regolari di tempo, le coordinate X (left) ed Y (top) del relativo tag DIV. Questo è giusto un primo passo…

Per chi vuole studiare il “come è fatto dentro”, aggiungo il listato del programmino presentato (demo1.js) :

//<!-- javascript demo #1 - Emilio Ficara 2011
var id,timer; // definizione variabili per identificatore e timer
var xpos,ypos,xstep,ystep,xsize,ysize; // definizione variabili posizione, spostamento, dimensioni

  xpos = 0; // posizione x iniziale (0,0 angolo in alto a sinistra)
  ypos = 0; // posizione y iniziale
  xstep = 3; // spostamento ad ogni step sull'asse x
  ystep = 2; // spostamento ad ogni step sull'asse y
  xsize = 30; // dimensione orizzontale oggetto mobile (pallone)
  ysize = 30; // dimensione verticale oggetto mobile pallone
  gamex = 480; // dimensione orizzontale sfondo fisso (campo)
  gamey = 303; // dimensione verticale sfondo fisso (campo)
  NewStep(); // esegui la funzione per la prima volta (dopo verrà richiamata da timer)

function NewStep() // nuovo step spostamento oggetto mobile
{
    xpos += xstep; // nuova posizione x
    ypos += ystep; // nuova posizione y
    if(xpos > (gamex - xsize) || xpos < 0) // se oltre il bordo destro o sinistro
      {
      xstep = -xstep; // inverti lo step di spostamento orizzontale
      xpos = xpos +xstep +xstep; // esegui lo spostamento due volte (era andato già oltre)
      }
    if(ypos > (gamey - ysize) || ypos < 0) // se oltre il bordo superiore o inferiore
      {
      ystep = -ystep; // inverti lo step di spostamento verticale
      ypos = ypos +ystep +ystep; // esegui lo spostamento due volte (era andato già oltre)
      }
    id = "palla"; // assegna identificativo dell'oggetto che vogliamo muovere
    document.getElementById(id).style.top=ypos+"px"; // assegna la nuova posizione verticale all'oggetto
    document.getElementById(id).style.left=xpos+"px"; // assegna la nuova posizione orizzontale all'oggetto
    timer = setTimeout("NewStep()",10); // attiva timer per eseguire di nuovo la funzione NewStep tra 10 mS
}
//->

Di seguito, il istato del file demo1.htm che costituisce il “contenitore” che sarà visualizzato con un browser (preferibilmente FireFox) sia su Windows, che su Linux o su qualsiasi altro sistema operativo che supporti un browser in grado di eseguire JavaScript :

<html>
<head>
 <title>Javascript demo #1 - Emilio P.G. Ficara 2012</title>
</head>
<body>
<h1>scendiamo in campo...</h1>
<div id="campo" style="position:absolute; top:60px; left:40px;">
 <img src="img/campo.jpg">
 <div id="palla" style="position:absolute;">
  <img src="img/palla.png">
 </div>
</div>
<script src="demo1.js"></script>
</body></html>

Immagine di un disco

In questa pagina parliamo di immagini del disco…

Questo è un disco volante 🙂 e non ha niente a che vedere con quanto voglio descrivere.
Nonostante sia definito “disco”, quello di cui voglio parlare è un dispositivo di forma rettangolare.

I più smaliziati avranno notato la totale assenza di forme rotonde ; eppure… sono dischi.

Per “immagine del disco” si intende un file in cui è salvata una copia di TUTTO il contenuto di un disco, SETTORE per SETTORE, quindi non importa che tipo di file system sia installato, quante partizioni, quali. E’ una serie di blocchi di dati grezzi, messi insieme (per comodità) in un file che può essere utilizzato (con appositi programmi) per “clonare” su altri dispositivi un disco originale, rispettandone la struttura (partizioni con relativi file-systems) ed i dati contenuti. Uno strumento formidabile per trasferire via internet (o su supporti di memoria USB) un intero disco.

Parlando di programmi in grado di “trattare” questi files immagine, ce ne sono disponibili, spesso gratuitamente, su moltissimi siti internet e basta fare una ricerca con Google per avere l’imbarazzo della scelta. Io, dopo aver dato un’occhiata in giro, ho scelto Win32 Disk Imager perché è open-source (mi piace vedere cosa c’è dentro) e si è comportato benissimo nell’uso pratico. Il link al sito dove può essere prelevato è disponibile nella parte destra della pagina, sotto “links utili”.
ATTENZIONE !!! Questi programmi scrivono sul disco in maniera “cieca”, cioè se dite loro di scrivere il contenuto del vostro file immagine copia_di_disco.img sul disco C: , vi ritrovate SENZA PIU’ IL VOSTRO SISTEMA OPERATIVO, perché il disco C: , al termine delle operazioni, è diventato il “clone” di quello salvato a suo tempo sul file copia_di_disco.img . Triplo check, quindi, della lettera indicante il supporto di destinazione per la copia.
In genere queste operazioni sulle memorie flash si effettuano su chiavette USB o sui lettori interni di SD-Card del proprio Netbook / Notebook ; verificate BENE, quindi, quale lettera di unità sia stata assegnata dal sistema alla periferica. Qui sotto c’è la finestra del programma in esecuzione :

Potete vedere in alto a sinistra il nome del file, in alto a destra la lettera di unità e in basso i comandi. Write scrive il contenuto di un file .img sul disco (F: in questo caso) e Read legge dal disco e salva su un file (qualora voleste fare una copia di un vostro disco).

Un altro programma di cui avrete sicuramente bisogno (molti files .img sono zippati per risparmiare spazio) è 7Z (7.Zip), un’applicazione “open source” (come al solito) per compattare / scompattare files. E’ molto efficiente, apre praticamente qualsiasi tipo di archivio e si integra nella shell di Windows.
Se il prezioso tecnicismo “si integra nella shell” vi fa venire in mente solo una scena al distributore di benzina, allora mi correggo e dico: “il programma aggiunge se stesso al menù che viene fuori quando cliccate su un file con il tasto DESTRO del mouse”.
Il link per accedere al sito dove potrete scaricare il programma è, come al solito, nella colonna a destra della pagina, sotto “links utili”.