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 🙂

Using Android tablet as SIRC remote control (#2)

This is my second program to use a tablet as a remote control. The first one (read here for additional infos) was based on a simple IR-Led plus resistor, placed on the “hidden” serial port present on the tablet’s dongle. Such solution was very cheap, but needed for some firmware modding and and for dongle opening, to solder wires on (sometimes) difficult points. So, I modified the software (and the hardware) to make it easier to install on every “original” Android tablet. The only mandatory request is that the tablet must have a “driver” for USB to RS232 interfaces. I tried with units based on popular PL2303 chip (from Prolific) or CP210x chips (from Silicon Labs) and both were detected (as ttyUSB5). The whole system is shown in the picture below :

Note that the “dongle” is open, but it’s only ‘cause all my devices are always “under testing” 🙂 . You don’t need to “look inside”, just plug the USB to RS232 interface in the USB socket and go. Note that the interface shown in the picture is based on PL2303 chip. Obviously, the USB to RS232 isn’t enough to send SIRC commands to your TV. You must build (or ask to a friend to build for you) this VERY SIMPLE interface :

As you can see, there is one DB9-F connector (for RS232), one resistor, one IR-Led and one diode. With such components, I can control my Sony Bravia TV from up to 1.5 meters distance (aiming the receiver spot). If you add some active components (transistors), that distance can be widely enlarged.

Well, now let’s look at the software. When you install the apk on your tablet and start the program, you will receive a screen like this :

The program was written for 800×480 screen tablets, landscape orientation. For my tests I used a LAVA 7″ (original firmware) tablet. This tablet recognized the USB to RS232 interface and assigned the /dev/ttyUSB5 name to it. My program, actually, uses this name as fixed setting. It will NOT work if the interface is recognized with another name (you will receive an error). Obviously, this can be modified, but I will do it in a next release.

In the “display” box, you can see “cmd: 21” ; this is the default command the device will send to your TV when you touch the button “Send”. This command is the TV-On or TV-Off. If you want modify the command, for example to send a Channel+, type on the numeric keys “16” then touch “Set” and your display will show “cmd:16”. Now, touching “Send” will send the command to your TV that will ( if powered-on ! ) skip on next channel. The “Can” key will erase a bad typed number. Note that this behaviour isn’t particular “user friendly”, just ‘cause I developed the program as a “tool” for my experiments. Not a problem to write some “fixed” keys, more user friendly  🙂

For a list of available commands, you can take a look at the following picture (the red rectangle at the right) :

Note that all the images in this article can be enlarged clicking on the miniatures.

Finally, the apk to be installed can be download directly from this link. It doesn’t exists on “the market”, ‘cause I don’t like that way to distribute software. I think it’s too monopolistic way and I don’t agree with such terms. So, the disclaimer is : TRY THIS PROGRAM AT YOUR OWN RISKit’s my original work, and is not certified or approved by others than me 🙂

ASUS tablet TF101 bootstrap

My son has a tablet… while I have all low-cost clone devices, he has an expensive Asus TF101 model. Obviously, it wasn’t purchased by me 🙂 but has been received as birthday’s gift. Well, this tablet is fast, powerful, elegant, really better than the ones I own. But now there is a problem. As usual, the tablet was connected to the Internet and received, automatically, a firmware upgrade. After that firmware upgrade, the tablet WON’T TURN ON anymore. If you turn it off (not suspend), you can’t turn on again, even pressing the button for two o three minutes. After a lot of @@##@@ to the upgrade authors, I went on the Internet, looking for a “forum” and for some info about this. The info was that ASUS knows the problem and in Taiwan there are technicians working on this.

The tablet (after a lot of tests) can be powered ON again if is connected via USB to a PC or to the charger. Well, isn’t completely dead… but I can’t connect to the charger while on the road and also I don’t want to take with me a PC just for starting the tablet ! So I realized this small tool that is my bootstrap device 🙂

As you can see, it’s simply a 3V battery (CR2025) connected to one USB plug. That’s all. With the tablet off, insert the usb cable into this device, then press the tablet’s power-on button… The tablet will start 🙂 Ok, remove quickly the “bootstrap” circuit to avoid any current flowing from the tablet into the battery (that is NOT rechargeable) and you have done. In the next picture, the device has been fully covered by insulating tape. Much more secure and professional 😉

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”.

Update: a new program to rebuild the SPI flash memory contents

In my previous post here I proposed a program that was able to create the SPI flash memory contents for an Android tablet, starting from U-boot.bin and W-load.bin taken from FirmwareInstall folder of a working, original or modded, firmware rom. The previous program had a limit : the environment variables (and the boot script that is stored in the same space) were not used in the creation of the my-spi.bin output file, so when you re-program the SPI flash memory with the file produced by the old program, you must supply the needed instructions to upgrade the system via serial terminal.

Now, the new version adds the full environment variables and the necessary CRC32 code to the output file my-spi.bin, making the file much more useful and easy to use. Obviously, while in the first version you had to supply only two “input” files (u-boot.bin and w-load.bin), now you must supply a third: the env_uboot, that can be found on the FirmwareInstall/env/ folder or the usual, working, firmware distribution related to the tablet.

The instructions for use are exactly the same as for previous version, just add the env_uboot file in the program folder. As usual, the program was written in FreeBASIC and compiled under Win7. It doesn’t require installation, just unzip the downloaded file in a folder, and add the needed input files, then start the application…. that’s all. Hope this will be useful for someone 🙂

Download the zip file at this link.

The memory areas of the resultant my-spi.bin files are:

0x00000 to 0x5FFFF reserved for u-boot.bin
0x60000 to 0x6FFFF reserved for environment variables
0x70000 to 0x7FFFF reserved for w-load.bin

Remember to get the right w-load—.bin file from the FirmwareInstall folder.
Generally, in most of the tablets I’ve seen (but NOT in all), the right one has the string DDR3_700M_1066M_8bit_2_256MB in the filename. Obviously, when you copy this file in the application folder, you must rename it in w-load.bin, ‘cause the program looks exactly for that file name.

Gambas2 su tablet WM8650 9.7″ (prove)

Programmare in Gambas2 ( Basic visuale per Linux ) direttamente su un tablet cinese da 100 Euro ? Si può fare !

Nella foto, una applicazione di esempio, compilata quindi avviata, per il test della porta seriale ttyS0 del tablet ; mediante un’ interfaccia RS232 collegata al dispositivo, si trasmettono e ricevono dati con il programma HyperTerminal ( o qualsiasi altro terminale seriale ) su un PC Windows ( protocollo 19200,N,8,1 ). Funziona.! Cliccare sull’immagine per una visione ingrandita.

Backup your SPI flash memory on SD card (Wm8505 – Wm8650 tablets)

The most important thing to do before attempting to change / upgrade / modify the default firmware for a tablet (we speak about the WM8505 / WM8650 models), is to create a backup of the internal SPI flash memory. The internal SPI flash memory is the hearth of a tablet. If you can rewrite it with original contents, you can always restore your tablet to the original state.

I highly recommend, for anyone wants to play this “game” with his own tablet, to build a serial interface, that is a basic, but powerful, instrument to “look” inside a tablet. There are many interfaces available to convert the 3.3V signals, present in the tablet, to RS232 levels, and other cheap circuits that directly connect 3.3V true logic from the tablet to USB port, that is seen as COM port from a PC. I suggest to use my own design circuit proposed on my page at this link, ‘cause is powered by the tablet itself, so it doesn’t introduce any voltage in the device input lines when the device itself isn’t powered on. I have had problems, with direct USB to TTL interfaces, due to the presence of positive voltages on transmitting side of the interface even if the tablet was off. So, please, build my circuit (it works !), or use one similar…

In the oldest tablet I own, the Evodroid Devo, based on WM8505 processor, there isn’t any “dongle” for the USB / LAN / Serial. There is just a mini plug for USB, but the serial port is always present inside the tablet. So, opening the case, you can solder the 4 wires needed for a serial terminal connection on the 4 pads as in the picture below :

The TXD is intended as tablet TXD, so is the output from tablet, while RXD is obviously, the data input to tablet.

Using a terminal emulator and the RS232 interface, we can make huge amount of tests and experiments. I recently updated my PC serial terminal program for some problems encountered on WM8505 tablets. In the new version, available for download at this link , I added the sequence “+++” ; if you quickly type this sequence on your PC keyboard, the terminal sends a Ctrl-C plus a CR to the tablet, stopping the autoboot (as default, U-Boot automatically starts the Linux Kernel and Android OS that are stored on tablet’s mass storage NAND flash).

Note that, for storing a copy of the internal SPI flash memory, you must insert a FAT32 freshly formatted microSD card in the tablet’s slot !

Well, if you have the serial interface connected to your PC, launch the terminal program, then turn on the tablet. You will see the W-load and the U-Boot messages ; immediatly type on the PC the +++ sequence (or type Ctrl-C and Enter if using another terminal program)… After a while the U-Boot will stop writing the command prompt WMT # ; the autoboot has been stopped and you can execute commands from the U-Boot provided set. Note that the U-Boot versions are different from one tablet model to another, but many commands are always available, even with small syntax differences. Here, I will describe the backups done from a relatively new 9.7″ tablet based on WM8650 processor, and from old 7″ Evodroid tablet (the one shown in the picture).

The first command to enter is the MMC initialization (MMC is the default name for the SD card), so we must type :

mmcinit 0

 (0 selects the first SD card in wm8650 tablet, that has 2 SD cards capability)

or simply :

mmcinit

 (in wm8505 that has only one SD card available)

We receive some messages from the tablet ; if all is OK, the MMC (SD) has been initialized and is ready to operate. Remember to use a FAT32 formatted one !

Now, we type the command :

cp.b FFF80000 0 80000

that means : copy bytes from address FFF80000 (the start of SPI flash memory) to address 0 (the start of RAM) for a length of 80000 bytes (that is hexadecimal, as all the data supplied), so 80000 is 8 * 64K = 512K bytes, the size of the whole SPI flash.

This operation will take a couple of seconds… then we have a copy of the whole SPI flash stored in system RAM. Now, we can use the powerful command “fatstore” to save that area to a binary file on the SD card :

fatstore mmc 0:1 0 backup.bin 80000

This command means : store a file on FAT system device mmc (our SD card), on partition 0:1 (the card is freshly formatted, so has just one partition : card 0, partition 1), reading data from RAM address 0, to a file named backup.bin, for a length of 80000 (hexadecimal) bytes. Note that in the wm8650 tablet I havent had any problem to execute this command, but in WM8505 there was something wrong while writing the SD card. The solution, was (simply) to substitute the original 4GB SD card previously used, with another one, a little bit older, sized just 128 MBytes ! That card was VERY OLD, it was in my LG cellphone by many years. So, if you have errors, try with another SD card, freshly formatted, of different type, brand or size.

When this operation terminates with success, you have a copy of your SPI flash stored on the SD card. This 512KBytes file has the U-Boot.bin, the Env_uboot.bin and the W-Load.bin files all in one. You can expand in 3 different files using my software tool that can be downloaded from this link. The zip file contains just one executable written in FreeBasic ; it does not require installation ; just deflate it in a new directory and copy in the same folder the spi.bin file you want to split ; at end of the process you will have u-boot.bin, w-load.bin and env_uboot files in the same folder.

Obviously, you can simply use the full file spi.bin file with an SPI programmer in case of tablet “hard bricked”.

To turn off the tablet, type the command :

shutdown

or, if it isn’t recognized, simply press and hold the power button. Extract the SD card and read the contents with your PC. If you want, send the BIN file to my blog, using the file transfer form ; I will collect the different roms for future help requests… 🙂

Double the size of LocalDisk on Evodroid tablet (WM8505)

Hello, I purchased an old, used, working tablet based on obsolete processor WM8505. Why an obsolete model ? The reason is very simple : there is, on the internet, a full datasheet of the processor and good documentation, in general. When new products reach the market, they are still very technical, so well documented and simple to use. When it goes to be a business, the “commercials” come in and say to technicians : “you must hide all the infos and introduce some strange key to make impossible for anyone to look inside”. This is ‘cause the “commercials” are not able to produce ideas, they are able just to speak about things they can’t understand, and always have blinded vision of the future. Someone, any time, breaks the locks and looks inside,  ‘cause the “perfect lock” doesn’t exists. The result of this stupid behaviour is that the mankind is slowered and uses 20 years to reach the results that can be achieved in two. But the “commercials” are so happy, they sell and make big business. Absolutely haven’t a long view into the future.

Ok, I opened my tablet, just for look what’s inside. Here is a picture :

Just in the middle, you can see the “coreboard”, the hearth of the system, with the processor, the SPI flash with boot program, the ram, the oscillators and … the NAND FLASH ?  I can’t see the NAND flash, the “hard disk” of my tablet. Where is the NAND flash ?

ooooh, I found it, Is on a small board, hidden under the main board. But… there are only four wires ! Naaah, the NAND flash is a very common USB memory key ! That’s incredible, so the boot program in SPI flash is able to launch the system from an USB memory… VERY interesting !

I decided to disconnect the module from the tablet and wire it to a standard USB plug, in order to analyze it with my PC.

So, now I have an USB memory key with the hard disk of my tablet… Immediatly put in my PC and use the program Win32 Disk Imager, it’s open source, it’s simple, it works very well. I create a copy (img) of full pendrive and saved to disk for cloning on another USB memory key. Obviously, for using a standard usb memory key, I mounted a female usb plug in the tablet, using the 4 wires where was attached the original board. I used a 4GB memory key as destination of image file and tried to restart my tablet with such pendrive…

Ok, wires are connected, try to boot the tablet :

Uhmmm, animation starts, but continues “ad libitum” without starting the Android OS. There must be something wrong. Now, I extracted my pendrive and put it in another PC, running Puppy Linux. This is for a simple reason, Puppy Linux is my favourite “distro” and has the great GParted program, a powerful application to “look” inside disks and partitions. Inserting the pendrive, I discovered that has MANY partitions inside !

I see the main partition (the start) hasn’t the ‘boot’ flag. May be that’s the reason for tablet not starting ? Mmhh, let’s try to check. Modified the flags adding the ‘bootable’ to the first partition, then extracted the pendrive and tried again on the tablet…

WOW, now it works ! Ok, now, coming back to the Puppy Linux, I looked at all the partitions and the contents. First, the partitions list:

and now, the contents of each one : first SDB1

then, SDB5

then, SDB6

then, SDB7

and, finally, the SDB8

This is our “localDisk” ! Now, the original NAND flash was 2 GB and I have the new one that is 4GB, so i will resize the partition, using the GParted going from this situation :

to this new organization, filling all available space :

OK, all done. Now back again to the tablet and reboot. The led lights, the system starts…

And now, let’s go to measure how big is our LocalDisk 🙂

Wow… very good. Now, I can’t have an USB memory key attached to my tablet, so I opened the pendrive’s case and discovered that the small board inside is VERY similar to the original one…

So, I desoldered the USB plug and soldered the new circuit in place of the old one. All worked perfectly, tablet closed, disk space doubled.