Tablet bloccato : e adesso ?

1. Come tutto è cominciato…
Nella colonna a destra (links utili) potete vedere il link al sito che ha dato l’avvio alla mia sperimentazione sui tablets Android (HcH / TechKnow), nella fattispecie su quelli basati su processore WM8650 (WonderMedia), prodotti generalmente in Cina. Costano così poco (tipicamente un sesto di quelli con la meletta) che si è invogliati a sperimentare. Sperimentando sperimentando, però, si arriva spesso a una situazione in cui il tablet non si accende più !
E allora… inizia il pellegrinaggio informatico sui vari siti internet dove si trovano le soluzioni e i trucchi. Molti di questi siti sono in lingua inglese e talvolta i “noobies” (novellini) vengono trascurati (detto più esplicitamente, non se li fila nessuno). Ho ricevuto diverse richieste di “AIUTO !” dal form dei messaggi del mio blog, così ho deciso di aggiungere un articolo specifico su questo argomento : far rivivere un tablet “bricked”,  come dicono gli anglofoni (sbroccato, come diciamo noi).

2. Il reset
Il primo momento di panico e la prima sensazione di aver preso una fregatura, ci arrivano dopo un paio di giorni dall’acquisto del tablet. Questo, infatti, non si accende più. Come funziona il tablet ? Ha tre stati possibili: “acceso”, “spento” e “in sospensione”. Quando accendiamo per la prima volta il nostro tablet low-cost, vediamo il famoso robottino verde che si anima, poi la scritta “Android” che si illumina e infine appare il desktop con le varie applicazioni disponibili.
Il tablet è acceso e operativo. Ora, quando premiamo brevemente il pulsante di on/off, lo schermo si spegne e il tablet va “in sospensione”; in questo stato dovrebbe consumare quasi nulla e sarà in grado di riprendere immediatamente ad operare quando premeremo, di nuovo, brevemente il pulsante on/off. La ripresa delle operazioni è segnalata con la richiesta di strisciare un dito sul touch-screen con modalità diverse da tablet a tablet.
Una volta fatta la “strisciata”, il tablet torna al programma che stavamo eseguendo prima di andare “in sospensione”. Se premiamo il tasto di on/off a lungo, ci viene fornito un menù di scelte, tra le quali lo spegnimento totale. Quest’ultimo, inoltre, si ottiene anche continuando a tenere premuto il pulsante di on/off. Lo spegnimento totale implica che alla prossima accensione dovremo sorbirci ancora il robottino, la scritta e tutto il tempo necessario al caricamento del sistema operativo.
Nella mia esperienza pratica su tre diversi tablet, ho potuto appurare che la fase di “sospensione” consuma la batteria in modo considerevole. Cosa succede, quindi ? Succede che se avete lasciato il tablet in questa condizione e lo riprendete dopo un giorno  o due, non si riaccende più, perché la batteria è scarica. Allora pensate di collegare
l’alimentatore e ricaricare la batteria, convinti che, appena si sarà caricata, tutto funzionerà di nuovo. Bene, non è così. Il tablet, anche con la batteria completamente ricaricata, continuerà a non accendersi.
E allora… via, su internet a chiedere consiglio, aiuto, a scrivere frasi disperate: “il mio tablet si è rotto !” e la sensazione di cui parlavo all’inizio, quella di aver preso una fregatura. Calma, il rimedio c’è e si trova in un minuscolo e praticamente invisibile forellino, posto sul lato inferiore del tablet (non in tutti è nello stesso posto, bisogna cercare). Questo forellino, che in qualche caso ha una scritta “reset” e in altri ASSOLUTAMENTE NIENTE, consente di premere un pulsantino interno che provoca, per l’appunto, il reset del tablet permettendo, con la pressione del pulsante on/off, la ripartenza del sistema operativo (da zero, robottino e resto). A me, tutto ciò che ho descritto, è successo sul serio e non potete immaginare il sospiro di sollievo che ho fatto quando il tablet è ripartito. Ho avuto modo, successivamente, di creare danni molto più consistenti, ma questo sarà oggetto di successive pubblicazioni 🙂
Nota: il pulsantino di reset è interno di qualche millimetro, per cui bisogna “cercare” con l’attrezzino (la clip per documenti aperta) per trovarlo. Si deve sentire il “click” per ottenere il reset. Su alcuni tablet è più facile perché c’è un supportino di plastica che riempie la distanza tra il bordo di plastica e il tastino, ma in altri no e bisogna cercare con attenzione e cautela. Operazioni brusche e violente possono far mancare il pulsantino e magari danneggiare componenti elettronici che si trovano sul circuito vicino ad esso ; calma, quindi.
Nella foto sotto potete vedere dove si trova, tipicamente, il forellino (cliccate sull’anteprima per ingrandire).

3. La porta seriale
Per arrivare a qualche risultato, per prima cosa bisogna dotarsi di un minimo di attrezzi hardware e software. Cominciamo con un “pezzo facile”, colleghiamo un LED alla scatolina di espansione del tablet. La scatolina, quando è chiusa, mostra due connettori USB e un RJ45 per la LAN. Aprendo la scatoletta, svitando quattro viti, viene fuori il circuito che… SORPRESA… ha anche 4 fori a passo 2.54mm con i segnali della porta seriale “ttyS0” del sistema operativo Linux che sta alla base di Android.
Per prima cosa, suggerisco di saldare un connettore strip (non ha a che vedere con gli spogliarelli) per poter poi collegare eventuali interfacce seriali.
Il più semplice dispositivo che possiamo collegare per vedere se il nostro tablet esegue ancora qualche operazione al “boot” è costituito da un normalissimo LED (questo nella foto è verde, ma va bene anche giallo o rosso) e da una resistenza. Ecco un esempio costruttivo: (cliccate sull’anteprima per l’immagine ingrandita)

Quando questo circuito è collegato e si accende il tablet (power on), si vede il LED illuminarsi e tremolare. Significa che il sistema Linux sta inviando al terminale (che potrebbe essere connesso) tutto l’elenco delle proprie attività. Quando il sistema è completamente avviato (e voi vedete il bello schermo di Android), l’attività sul LED sarà visibile solo con un rapido “blip” una volta ogni 60 secondi. Questo perché Linux, una volta al minuto, esegue una uscita seriale per invitare un eventuale utente collegato su terminale ad effettuare il login. Quindi, la prima prova da fare su un tablet “bloccato” è quella di collegare questa interfaccia e vedere come si comporta il LED.

4. Il terminale
Se la “prova del LED” è stata superata, quindi siamo sicuri che il nostro tablet mandi fuori dei caratteri dalla porta seriale, possiamo andare avanti e cercare di interagire con esso tramite un “terminale” seriale RS232.
Ci servono due cose: un software e un hardware. Per il software, sia in ambiente Windows che in Linux, c’è l’imbarazzo della scelta: fino a XP, il terminale seriale era di serie (scusate il gioco di parole) su Windows; da Win7 è stato eliminato (con accuratezza la M$ toglie i programmi più utili ad ogni nuova versione) e bisogna reperirlo altrove. Io, di solito, uso RealTerm su Win XP e CuteCom su Linux (sono un fanatico di Puppy Linux). Se volete un miniterminale essenziale, ma comunque funzionante, potete utilizzare quello scritto da me (si chiama miterm-en). Lo potete scaricare da questo link . Il programma è stato scritto con FreeBASIC e compilato per Windows e gira tranquillamente su Win7. Non c’è bisogno di installazione: semplicemente prendete il file ZIP, estraete il file eseguibile EXE e lo cliccate. Il programma parte “di default” con la porta seriale COM4. Se la vostra porta seriale (o interfaccia usb-rs232) ha un numero diverso, il programma darà errore e vi chiederà di inserire un’altra porta oppure di dare il “return” senza scrivere nulla, per uscire. Nell’immagine sottostante potete vedere la schermata d’inizio sul mio PC. L’interfaccia usb-rs232 che utilizzo, installa sul sistema la porta COM19 e infatti scrivo com19 quando il programma si inizializza e mi comunica di non poter usare la porta di default COM4.

L’altra cosa che ci serve è l’interfaccia hardware. Abbiamo parlato finora di convertitori
usb-rs232, ma la porta seriale del tablet è a livello TTL (segnali SOLO POSITIVI di ampiezza 3.3 Volts) e quindi NON POSSIAMO collegare direttamente i segnali di TXD e  RXD della DB9, in quanto questi hanno livelli diversi (positivi E NEGATIVI e con logica inversa), ma dobbiamo convertirli con un apposito circuito. Io ne ho realizzato una versione personale, usando un integrato smd tipo MAX-3232 (oppure ST-3232, più economico) e disegnando un circuito stampato idoneo. Tutto il materiale (schema elettrico e disegno PDF in scala 1:1 per la fotoincisione del circuito stampato) è disponibile per il download a questo link .

Esistono, ovviamente, anche prodotti commerciali che fanno le stesse cose. Dietro segnalazione di un amico (arrivata DOPO che avevo costruito il tutto…) ho acquistato su ebay una interfaccia usb-seriale TTL, ad un costo irrisorio (meno di 3 Euro, spedizione compresa).

Purtroppo, però, il produttore è in Estremo Oriente ed i tempi di consegna sono dell’ordine di tre settimane. Se utilizzerete questa interfaccia usb-seriale TTL, dovrete collegare solo i tre fili GND, TXD, RXD direttamente dall’interfaccia PC a quella del tablet. Collegamento DIRETTO, quindi GND con GND, TXD con TXD e RXD con RXD, contrariamente a quello che dovete fare se usate la mia interfaccia nella quale è necessario collegare ANCHE il 3.3 Volt e i segnali RXD e TXD sono incrociati. Aggiungo una nota che può essere utile : con l’interfaccia “cinese” e in genere con tutte le interfacce usb-rs232, può essere necessario intervenire sul setup della porta seriale per disattivare il buffer FIFO, in modo da eliminare latenze e ritardi introdotti dal driver. Il circuito descritto, se lo acquisterete, vi arriverà senza disco di driver, perché è basato sul chip CP2102 della Silicon Labs che viene riconosciuto immediatamente dal sistema.
Se sul vostro PC le cose dovessero andare diversamente, cercate il sito della Silicon Labs e scaricate da lì il driver aggiornato per CP210x per il vostro sistema operativo.

5. Caccia allo U-Boot
Bene, abbiamo costruito (o comperato) l’interfaccia, abbiamo installato il programma per il terminale e siamo pronti per vedere cosa trasmette il nostro tablet. Avviamo il programma sul PC e accendiamo il tablet…
Ecco subito arrivare i primi messaggi:

WonderMedia Technologies, Inc.
W-Load Version : 0.15.00.01
UPDATE_ID_0_4_3_0_2_256MB_0150001
ethaddr............found
wloader finish

Questo ci dice che il nostro tablet è basato su un processore WonderMedia, tipicamente il WM8650 o, se più vecchio, il WM8505. La fase di W-load è andata a buon fine e quindi viene avviato lo U-Boot. Ecco come proseguono i messaggi :

U-Boot 1.1.4 (May 12 2011 - 15:34:56)
WonderMedia Technologies, Inc.
U-Boot Version : UPDATEID_0.04.00.00.07
U-Boot code: 03F80000 -> 03FC2A30 BSS: -> 03FCCC4C
boot from spi flash.
SF0: ManufID = 20, DeviceID = 2013 (Missing or Unknown FLASH)
Use Default - Total size = 8MB, Sector size = 64KB
SF1: ManufID = 0, DeviceID = 0 (Missing or Unknown FLASH)
Use Default - Total size = 8MB, Sector size = 64KB
flash:
Bank1: FF800000 -- FFFFFFFF
Bank2: FF000000 -- FF7FFFFF
Flash: 16 MB
sfboot NAND:env nand config fail, use default flash id list info
pllb=0xc30, spec_clk=0x190a0fff
T1=3, clk1=16, div1=7, Thold=1, tREA=25+delay(9)
T2=2, clk2=18, div2=8, Thold2=1, comp=1
Tim1=524288 , Tim2=442368
T2=1, clk2=34, div2=15, Thold2=1, comp=1
Tim1=442368 , Tim2=557056
T2 is greater and not use
T=2, clk=18, divisor=8, Thold=0x601
divisor is set 0x8, NFC_timing=0x2424
USE_HW_ECC ECC24bitPer1K
1 Nand flash found.

Nand Flash Size: 2048 MB

In: serial
Out: serial
Err: serial
### main_loop entered: bootdelay=1

Ed ecco il punto che mi ha fatto IMPAZZIRE. Nell’ultima riga vedete il commento che avvisa che si è entrati nella fase principale e si vede che il bootdelay è uguale a 1. Questo significa che il programma, prima di partire con il caricamento di tutto il resto, DOVREBBE aspettare 1 secondo per consentire ad un eventuale utente collegato sul terminale seriale di fermare tutto ed entrare nella fase comandi di U-Boot, fase nella quale è possibile effettuare modifiche utili per correggere eventuali problemi. Ho scritto DOVREBBE perché invece non è così. La versione di U-Boot che mi ha fatto sudare 7 camicie NON si ferma, qualsiasi carattere si invii da terminale, né ctrl-c, né spazio, né altro. Ho addirittura scritto un programmino che inviava una tripletta di caratteri “idonei” immediatamente dopo aver ricevuto la scritta “main_loop entered”, pensando che forse io ero troppo lento (sono solo un essere umano) ad inviare i caratteri in quel secondo di tempo concessomi. Beh, non era così. Semplicemente questa particolare versione di U-Boot non si ferma -E BASTA- . Se siete in questa situazione, non potete fermare lo U-Boot e quindi non potete effettuare modifiche. Il programma prosegue e ci invia altri messaggi :

logocmd="nandrw r ${wmt.nfc.mtd.u-boot-logo} ${wmt.display.logoaddr} 10000; nandrw r ${wmt.nfc.mtd.u-boot-logo2} ${wmt.display.logoaddr2} 40000; nandrw r ${wmt.nfc.mtd.kernel-logo} ${wmt.kernel.animation.addr} 80000; display init force; decompanima -f ${wmt.display.logoaddr2} 0x3000000; decompanima -f ${wmt.display.logoaddr} 0x3000000"
Load Image From NAND Flash
col=0x2150, row = 0x3ff80
block2047 tag=42627430 version =1
col=0x2150, row = 0x3ff00
block2046 tag=31746242 version =1
bbt table is found
USE_HW_ECC ECC24bitPer1K
Too Many Error
Too Many Error
Too Many Error
Err1 at 11080
Load Image From NAND Flash
USE_HW_ECC ECC24bitPer1K
Too Many Error
Too Many Error
Err1 at 11100
Load Image From NAND Flash
USE_HW_ECC ECC24bitPer1K
Too Many Error
Too Many Error
Err1 at 11280
[VOUT] ext dev : LCD
[VOUT] int dev : NO
[LCD] wmt default lcd (id 4,bpp 24)
vpp_config(800x480@60),pixclock 40000000
div_addr_offs=0x35c PLL_NO=1
[VPP] get base clock PLLC : 400000000
1div_addr_offs=0x374 PLL_NO=2
find the equal valuePLLN64, PLLD5, PLLP2, divisor2 freq=40000000Hz
PLL0x5440, pll addr =0xd8130208
PLLN64, PLLD5, PLLP2, div2 div_addr_offs=0x374
read divisor=2, pll=0x5440 from register
[GOVRH] set clock 40000000 ==> 40000000
div_addr_offs=0x374 PLL_NO=2
[VPP] get base clock PLLB : 40000000
vo_lcd_visible(1)

E qui il mio tablet si bloccava, perché (come si nota dai numerosi errori listati) avevo modificato con un editor esadecimale i dati del logo (il robottino verde) creando un errore grave. Se il programma di U-Boot si blocca PRIMA della verifica dei dati nella SD card esterna, non può evidentemente effettuare il caricamento di una nuova versione di ROM, e quindi tutto rimane fermo. Schermo nero, nessuna successiva attività. In questa situazione tremenda, non avendo trovato altre soluzioni da software, ho deciso di aprire il tablet, dissaldare la memoria SPI, riprogrammarla con una coppia W-Load ed U-Boot “fresca” (e con il bootdelay messo a 3 secondi, così ho tutto il tempo per fermarlo !!!) e quindi saldare nuovamente il chip sul circuito stampato. Purtroppo ho rovinato due “pads” ed ho dovuto fare una certosina operazione di recupero. Trovate tutta la descrizione sul mio articolo a questo link . La descrizione è in inglese perché originariamente l’ho scritta per segnalarla sul forum HcH / TK che è stato la mia fonte principale di apprendimento. Con il nuovo U-Boot, finalmente, ho ricevuto il messaggio che dice di premere un tasto
qualsiasi per entrare in modalità comandi. Ho premuto un tasto e FINALMENTE sono entrato in modalità comandi ! Ho premuto il carattere ‘?’ che di solito avvia la lista dei comandi (help) ed ecco cosa ho ricevuto :

WMT # ?
?       - alias for 'help'
autoscr - run script from memory
base    - print or set address offset
bdinfo  - print Board Info structure
boot    - boot default, i.e., run 'bootcmd'
bootd   - boot default, i.e., run 'bootcmd'
bootm   - boot application image from memory
bootp\0x09- boot image via network using BootP/TFTP protocol
cmp     - memory compare
coninfo - print console devices and information
cp      - memory copy
crc32   - checksum calculation
dhcp\0x09- invoke DHCP client to obtain IP/boot params
diskboot- boot from IDE device
show    -
echo    - echo args to console
erase   - erase FLASH memory
exit    - exit script
fatinfo - print information about filesystem
fatload - load binary file from a dos filesystem
fatls   - list files in a directory (default /)
fatstore - store binary file to a dos filesystem
flinfo  - print FLASH memory information
go      - start application at address 'addr'
help    - print online help
icrc32  - checksum calculation
ide     - IDE sub-system
iloop   - infinite loop on address range
imd     - i2c memory display
iminfo  - print header information for application image
imls    - list all images found in flash
imm     - i2c memory modify (auto-incrementing)
ims  - set i2c device context from memory
imw     - memory write (fill)
inm     - memory modify (constant address)
iprobe  - probe to discover valid I2C chip addresses
itest\0x09- return true/false on integer compare
loadb   - load binary file over serial line (kermit mode)
loads   - load S-Record file over serial line
loop    - infinite loop on address range
memory bit operation :
Format : mbit <parameter>
md      - memory display
mii     - MII utility commands
mm      - memory modify (auto-incrementing)
mmcinit - init mmc card
mmcinit 0 -- init mmc device 0
mmcinit 1 -- init mmc device 1
mmcread - read data from SD/MMC card
<dev_id> <addr> <block_num> <bytes>
-read data from SD/MMC card block address 'block_num' on 'dev_id'
to memory address 'addr' size is 'bytes'
mmcwrite - write data to SD/MMC card
<dev_id> <addr> <block_num> <bytes>
-write data to SD/MMC card block address 'block_num' on 'dev_id'
from memory address 'addr' size is 'bytes'
mtest   - simple RAM test
mw      - memory write (fill)
nandrw  - NAND sub-system
nboot   - boot from NAND device
nfs\0x09- boot image via network using NFS protocol
nm      - memory modify (constant address)
ping\0x09- send ICMP ECHO_REQUEST to network host
printenv- print environment variables
protect - enable or disable FLASH write protection
rarpboot- boot image via network using RARP/TFTP protocol
reset   - Perform RESET of the CPU
run     - run commands in an environment variable
saveenv - save environment variables to persistent storage
sdwaitins - wait sd card inserted or removed
sdwaitins 0 -- waiting removed
sdwaitins 1 -- waiting inserted
setenv  - set environment variables
sleep   - delay execution for some time
test    - minimal test like /bin/sh
textout - show text to the screen
textout x y "str" color
color is 24bit Hex, R[23:16], G[15:8], B[7:0]
for example: textout 0 0 "hello world" FFFFFF
tftpboot- boot image via network using TFTP protocol
version - print monitor version
WMT #

In un prossimo articolo descriverò alcuni di questi comandi che sono particolarmente utili per ricavare informazioni sul proprio tablet e per modificare alcuni parametri (variabili di ambiente) per correggere eventuali errori dovuti all’ installazione di rom non adeguate.

Do it before modding your tablet !

This is not a suggestion to have nice time with your girl-friend (or droid-friend, freely choose) but a smart way to operate when going to change your tablet from the “usual” Android to the “excellent” Uberoid. I have seen so much posts, in the HCH TechKnow forum, with messages like “help me, I just upgraded my tablet and now it autonomously speaks in ancient languages even if turned off”. Stop it, let we operate in a smart way. Prior to change, we must know what are we changing. Don’t post messages like “my tablet doesn’t work; it has -probably- a 7 inches screen, help me”, but change your approach. Your tablet is a complex machine, it looks like a toy, but has very sophisticated solutions inside it.

Your tablet COMMUNICATES with you, in its manner, but you can’t see the messages until the display goes on and the user-interface fully starts. BUT… there is some initial activity that is very, very interesting to indagate. I’m speaking about the U-boot.
The U-boot, as all of you can remember, is an underwater… no, sorry, I’m confusing with my other job. Redo: the U-boot is the first program that’s executed by the processor which animates your tablet (in our specific case, the WonderMedia WM8650).

The U-boot has big potential, you can -really- make any sort of operations on your tablet’s core, but the full list of such possibilities is too big to be exposed in this small page. So I just want to point your attention to some commands.

Let’s start. First of all: where U-boot comes out ? And, how can I interact with the program ? Good questions (I like to say to myself I pose good questions).
The answer is that you can’t see the U-boot activity without a little hardware and some software ; both of them are easily available. Note that the time you can lose with this preliminaries, will be widely balanced by that you can spare avoiding to brick your tablet with wrong rom upgrade.

HARDWARE

We need to look at the U-boot messages that are sent to the system serial port. Even if you can’t see any connector, the serial port is ALWAYS present on such tablets (for this generation). Now, the first operation requires some hardware. You must find 3 basic signals: TXD, RXD and GND. These are, respectively, the serial output, serial input and common (ground) signals of ttyS0 peripheral (assigned by the system to the console device). Any tablet has its own arrangement. In my experience, all the tablets that have an external connector for USB and LAN has also pads for such signals in the same external box, while tablets having USB and LAN built-in, must be OPENED (mechanically) to gain access to the lines.

Look at the pictures posted below to some examples of serial port wires in tablets I have used for my embedded applications (click images to enlarge).

This is the expander for a 7″ tablet with 24 pin connector. Wiring is easy ‘cause there are 4 holes 0.100″ spaced. Soldering wires is easy and low probability to destroy pads for overheating.

This is the expander for a 9.7″ tablet with 30 pin connector. Wiring is a little bit more difficult ‘cause the pads haven’t holes; you must take care of overheating to not destroy pads.

 

Another model of expander for a 9.7″ tablet with 30 pin connector. Wiring is difficult due to small pads without holes. Be carefully, high probability of destroy pads for overheating or pulling of soldered wires. Use small, flexyble wires and apply some strong adhesive tape to mantain them in position and to protect pads from strapping.

Connections for a 10.1″ tablet that hasn’t external expander. The USB and LAN ports are inside, so you must mechanically open the tablet to gain access to the pads. You must follow the same rules as for previous model.

This image is very interesting ‘cause you connect the wires directly to the WM8650 CoreBoard, so this solution will be valid for about ALL the tablets based on it. Note that I used 4 wires, getting gnd, txd, rxd and +3.3V, so the power can be used to supply an external interface.

 

Now, the signals have to be connected to your PC to interact with the U-Boot. The processor serial port signal are swinging from 0 to 3.3 Volts in negative logic, while a standard serial port (RS-232) has typically -5 to +5 Volts signals in positive logic, so you can’t connect directly the tablet signals to the PC ones: you need for an interface to logic inversion and level translation.

At least, you have two chances: the first is my own circuit you can find in another my article here ; you have to build it by yourself, it isn’t for sale…

I noticed that my interface was added as part of zip file “kit for tablet unbricking” by the Uberoid guru HcH ! Thanks for considering this small hardware as a useful tool 🙂

 

 

With this interface you can connect a standard PC serial port ( or USB to RS232 adapter) to the tablet; in case you try an USB adapter, remember to disable the FIFO buffers or reduce anyway the latence of signals at the minimum using the device properties menu.

The second option is to buy this USB-Serial-TTL interface. I found it on ebay after the suggestion of a friend; it’s very cheap and (obviously) doesn’t requires any solder works. Just one problem: the shipping time from the Far Orient was 3 weeks, here in Italy. Even with this usb interface (that your PC discovers like a serial port) you will turn OFF the FIFO buffers or decrease the latency to the minimum.

Using my interface, you have to connect 4 wires: +3.3V, Txd, Rxd, Gnd (‘cause the circuit is powered by the tablet’s 3.3V), and must cross Txd and Rxd signals between tablet and interface (look at the project’s page for detailed pictures) ; with the commercial interface, you just have to connect Gnd, Txd and Rxd of the circuit to the correspondant signals of the tablet (NO crossing).

SOFTWARE

The software needed is simply a serial terminal. We have many different choises; under Windows the most famous is the HyperTerm, but in Win7 it has been removed (but why ?), so you must use somewhat different. Usually, I use RealTerm under Windows and CuteCom under Linux. There is, also, my own terminal, called miterm-en you can download from this link . The zipped file contains the executable, compiled for Windows (working in Win7) and the source file in FreeBasic, so, if you want, you can easily modify, expand, arrange and compile, for example, under Linux. FreeBasic is a GREAT free compiler available for Windows and Linux. It can be used for small programs like this, but even for huge and sophisticated programs. It’s fast, simple, compatible with old “Basic” dialects like GW-basic, Qbasic etc. and it’s FREE. I use it with the Geany editor (under Win7) and is one of the powerful instruments on my software workbench. In the picture below you can see the program screen at start. The default serial port is COM4, but if such port isn’t available on your system, the program asks you for a new available one. In the example, I typed in the com19, ‘cause is the port number assigned to the usb-serial-ttl interface.
The program simply writes on the screen what comes in from the serial input and puts on serial output what you type on the keyboard. There are only 2 “command” keys: the [Esc] for program terminate and the [Ctrl-R] for toggling on-off the logging of the received data on a disk file.

In the next screen you can see what happens if you type [Ctrl-R]: the recording starts on file named log_xxx.txt, where xxx is a number that increases every second (system timer).

Now, I have my serial port connected to the tablet (that’s actually turned OFF, not suspended, really OFF). Now, I press the power button and the tablet sends a lot of data to my PC, then asks to press any character to stop the autoboot (typically for 3 seconds, then the autoboot takes place). Ok, quickly pressed [cr], and the transmission stopped here…

As you can see, we have the WMT# prompt that indicates we can send commands to the U-Boot program, finally… But we still are recording to a log file, so stop now typing again [Ctrl-R]. If you look inside the last log_xxx.txt file, you can see all the messages sent from the tablet. Please, note that the txt file logs data as sent from the tablet, and this data is in Linux mode, so you can experience missing line breaks when using a Windows program like the Notepad as the viewer, but if you use Geanie or any text editor able to handle the Unix/Linux format, there are no problems. Now, type the question mark then [cr]. This is the alias for HELP, so you will receive a list of ALL possible commands you can execute with U-Boot. Here is what I received on my tablet :

?       - alias for 'help'
autoscr - run script from memory
base    - print or set address offset
bdinfo  - print Board Info structure
boot    - boot default, i.e., run 'bootcmd'
bootd   - boot default, i.e., run 'bootcmd'
bootm   - boot application image from memory
bootp   - boot image via network using BootP/TFTP protocol
cmp     - memory compare
coninfo - print console devices and information
cp      - memory copy
crc32   - checksum calculation
decompanima - decompress logo image to the dest position.
dhcp    - invoke DHCP client to obtain IP/boot params
diskboot- boot from IDE device
show    -
echo    - echo args to console
erase   - erase FLASH memory
exit    - exit script
fatinfo - print information about filesystem
fatload - load binary file from a dos filesystem
fatls   - list files in a directory (default /)
fatstore - store binary file to a dos filesystem
flinfo  - print FLASH memory information
go      - start application at address 'addr'
help    - print online help
icrc32  - checksum calculation
ide     - IDE sub-system
iloop   - infinite loop on address range
imd     - i2c memory display
iminfo  - print header information for application image
imls    - list all images found in flash
imm     - i2c memory modify (auto-incrementing)
ims  - set i2c device context from memory
imw     - memory write (fill)
inm     - memory modify (constant address)
iprobe  - probe to discover valid I2C chip addresses
itest   - return true/false on integer compare
loadb   - load binary file over serial line (kermit mode)
loads   - load S-Record file over serial line
loop    - infinite loop on address range
memory bit operation :
Format : mbit
md      - memory display
mii     - MII utility commands
mm      - memory modify (auto-incrementing)
mmcinit - init mmc card
  mmcinit 0 -- init mmc device 0
  mmcinit 1 -- init mmc device 1
mmcread - read data from SD/MMC card

   -read data from SD/MMC card block address 'block_num' on 'dev_id'
    to memory address 'addr' size is 'bytes'
mmcwrite - write data to SD/MMC card

   -write data to SD/MMC card block address 'block_num' on 'dev_id'
    from memory address 'addr' size is 'bytes'
mtest   - simple RAM test
mw      - memory write (fill)
nandrw  - NAND sub-system
nboot   - boot from NAND device
nfs - boot image via network using NFS protocol
nm      - memory modify (constant address)
ping    - send ICMP ECHO_REQUEST to network host
poweroff - wmt device power off.
printenv- print environment variables
protect - enable or disable FLASH write protection
randmac - generate a random MAC address and save to "ethaddr" environment variable
rarpboot- boot image via network using RARP/TFTP protocol
reset   - Perform RESET of the CPU
run     - run commands in an environment variable
saveenv - save environment variables to persistent storage
sdwaitins - wait sd card inserted or removed
sdwaitins 0 -- waiting removed
sdwaitins 1 -- waiting inserted
setenv  - set environment variables
sleep   - delay execution for some time
test    - minimal test like /bin/sh
textout - show text to the screen
textout x y "str" color
color is 24bit Hex, R[23:16], G[15:8], B[7:0]
for example: textout 0 0 \"hello world\" FFFFFF
tftpboot- boot image via network using TFTP protocol
version - print monitor version
WMT #

The command that can save us from a wrong rom upgrade is “printenv”. This command simply puts out the env list that actually is stored in your tablet. This is an example taken from my 9.7″ tablet. This tablet has been modded with Uberoid, but it works, so all the settings are right.

memtotal=212M
mmcid=0
lpj=AUTO
ipaddr=192.168.0.2
serverip=192.168.0.1
gatewayip=192.168.0.1
netmask=255.255.255.0
kernelargs=setenv bootargs mem=${memtotal} root=${filesystem-NAND_mtd} noinitrd rootfstype=yaffs2 rw console=ttyS0,115200n8 lpj=${lpj} ${android_bootargs} ${platform_bootargs} quiet
bootcmd=nandrw r ${kernel-NAND_ofs} 0x1000000 ${kernel-NAND_len}; if iminfo 0x1000000; then run kernelargs; bootm 0x1000000; fi; echo No kernel found
logocmd=nandrw r ${wmt.nfc.mtd.u-boot-logo} ${wmt.display.logoaddr} 10000; nandrw r ${wmt.nfc.mtd.u-boot-logo2} ${wmt.display.logoaddr2} 40000; nandrw r ${wmt.nfc.mtd.kernel-logo} ${wmt.kernel.animation.addr} 80000; display init force; decompanima -f ${wmt.display.logoaddr2} 0x3000000; decompanima -f ${wmt.display.logoaddr} 0x3000000
wmt.display.logoaddr=500000
#=chg emilio next line - wmt.display.logoaddr2 550000
wmt.display.logoaddr2=500000
wmt.kernel.animation.addr=f600000
#wmt.audio.spi=1:0:0
wmt.audio.i2s=vt1603:f1:f2:ff:ff:100
wmt.io.pwbn=100:0:2000
wmt.eth.param=1
wmt.gpi.bat=[0:0:00020000:d8110040:d8110080:d8110000:d8110480:d81104C0][1:0:00000020:d8110040:d8110080:d8110000:d8110480:d81104C0][2:1:00010000:d8110040:d8110080:d8110000: d8110480:d81104C0]
wmt.gpo.camera1=1:0:7:D8110040:D8110080:D81100C0
wmt.gpo.wifi=6:1:6:d8110040:d8110080:d81100C0
wmt.gpt.gsensor=3:8:d8110040:d8110080:d8110000:d8110480:d81104c0:83000000:d8110300:8:d8110320:6
wmt.io.bat=3:2:1000:d7a:b22:d7a:d3d:d02:cc5:c8b:c4e:c12:bd6:b9c:b5e:b22
wmt.io.gsensor=1:3:4:0:1:1:-1:2:-1
wmt.sys.keypad=wms8151a:1:rc_1:4:c0_72:c1_73:r0_9e:r2_76:1:9e_8b
wmt.pwbn.param=100:0:500
wmt.ui.storage=7
wmt.io.touch=1:uor615x:0:1024:768
wmt.bus.i2c=i2c0:1:1:i2c1:1:1
bootdelay=3
wmt_ui_hibernation=1
wmt_sys_powerhold=0
wmt.gpo.vibrator=1:1:2:D8110040:D8110080:D81100C0:1
wmt.camera.param=1:1
android_bootargs=init=/init
platform_bootargs=wmtvo=2:0:16:1024:768:60
wmt.display.param=2:0:16:0:0:0
wmt.display.tmr=65000:0:320:480:1024:260:10:6:768:16
wmt.display.pwm=0:50:1000:999
wmt.io.mxcgsensor=1:3:4:0:-1:1:-1:2:-1
##=chg emilio next line - wmt.vt160x.bat 0:1:10:0
#wmt.vt160x.bat=1:0:10:0
wmt.vt160x.bat=0:1:10:0
wmt.gpo.camera=1:1:7:D8110040:D8110080:D81100C0
wmt.model.no=yongpeng_9.7inch_usbcamera
#=chg emilio next line - wmt.io.ts.2dcal 40 -30251 117186489 24194 22 -8405089 106502
wmt.io.ts.2dcal=40 -30251 117186489 24194 22 -8405089 106502
kernel-NAND_mtd=/dev/mtdblock9
kernel-NAND_ofs=0x2600000
kernel-NAND_len=0x800000
initrd-NAND_mtd=/dev/mtdblock10
initrd-NAND_ofs=0x2e00000
initrd-NAND_len=0x600000
filesystem-NAND_mtd=/dev/mtdblock11
filesystem-NAND_ofs=0x3400000
filesystem-NAND_len=0x20000000
wmt.nfc.mtd.u-boot-logo2=0x23500000
ethaddr=00:40:63:26:75:03
serialnum=c93521e3eb114a4ab51e6912e1ed7c4f
sys.flt=1324841537
wmt_sys_restore=0
wmt.nfc.mtd.u-boot-logo=23400000
wmt.nfc.mtd.kernel-logo=23c00000
wmt.io.wifi.drv=start
stdin=serial
stdout=serial
stderr=serial
ver=U-Boot 1.1.4 (Aug 24 2011 - 10:14:10)

Environment size: 2945/65531 bytes
WMT #

Note that in the row wmt.model.no you have your tablet model, that’s more precise than say: “the green led with the black button and the gray case” etc. Also note the row wmt.io.ts.2dcal that contains the touchpad calibration values. Don’t consider the rows in which you can read “emilio” ‘cause are experiments I did changing the default env_uboot file.
Look with attention to the values your tablet has built-in BEFORE trying to update the rom. A quick comparison with the contents of file env_uboot in the FirmwareInstall/env/ folder of the rom you have selected for modding can advice you if there is some incompatibility. Also, look inside the wmt_scriptcmd for some wrong parameter. The screen size for example, if wrong, can lock your tablet in the very first steps of upgrading process. The third and last step to do before a tablet upgrade, can be done without any hardware tool. You just need for a terminal program to run on the tablet, like the Android_Terminal_Emulator or others. Once installed the apk, run the terminal emulator on the tablet and execute the dmesg command, re-directing the output on a file, then save that file on the sdcard. You will have a list of the drivers and all was running in your tablet with the original rom. If you want to take a look to a dmesg.txt file coming from one of my tablets, click on this link (use the right mouse button and “save destination as” if you want to download a copy on your PC).

That’s all, for now. I hope this document can help someone to save time and to choose the right rom for making his tablet the best (with Uberoid 🙂


 

Riparare il tablet: operazione rischiosa…

Rispondo qui al commento inviatomi da Tommaso per il precedente articolo :

Ciao Emilio,
dai tuoi articoli sembra che tu conosca bene i tablet. Io ne ho uno guasto che non riesco a riparare con i miei strumenti, potresti farlo tu per me, con un contributo da parte mia per il tempo che perderai e la copertura delle spese postali ?
Ti ringrazio per la disponibilità

Buongiorno Tommaso.
Nessuna preoccupazione, non sei il primo a chiedermi se posso recuperare un tablet ! Non puoi immaginare quanta gente si trovi nella tua stessa situazione… in Italia e all’estero. Fino ad oggi ho sempre risposto di no, perché riparare tablet NON è il mio mestiere 🙂
L’ultima volta che mi è accaduta una cosa simile, è stata con un docente che aveva acquistato il tablet per organizzare delle lezioni e subito lo aveva “brickkato” (bloccato) ; avendo una buona conoscenza informatica, aveva eseguito alcune operazioni da terminale con lo U-Boot, provocando per errore la cancellazione totale di ogni cosa ! Disperato, era andato sul forum di HCH / TechKnow e avendo visto che “Robotop” era un italiano (il qui presente), mi aveva contattato in privato (allora c’era ancora la mia email) per chiedermi se potevo fare il lavoro per lui.
In breve, gli ho risposto di no, ma lui mi ha comunque inserito come “membro onorario” in una sua associazione per lo sviluppo delle conoscenze informatiche ecc. ecc. Insomma, dopo qualche tempo, diverse email e piccoli miei articoli “postati” sul suo forum, gli ho offerto una certa cifra per vendermi il suo tablet guasto. Così è stato. Una volta ricevuto il tablet l’ho aperto, ho fatto quello che c’era da fare e tutto è tornato a posto.
Poi, dato che stavo lavorando “a progetto” con un’azienda, proprio per utilizzare un tablet come interfaccia utente nel controllo di una complicata macchina, ho usato PROPRIO quel tablet per realizzare il primo prototipo “demo” che è stato fornito al cliente finale.
Ora, ho finito il progetto e mi sono rimasti anche dei tablet in più… Quindi la storia non si ripeterà 🙂

D’altro canto, mi dispiace non poterti aiutare, però vorrei che tu considerassi queste cose:
1) ogni tablet è un caso a parte. Non c’è il 100% di probabilità di poterlo riparare
2) il tablet deve essere aperto e  questo significa sollevare la plastichetta che ricopre lo schermo e la cornice (puoi fare una prova sollevando un angolino) per raggiungere le viti (piccolissime) che si trovano sul perimetro interno di detta cornice. L’operazione potrebbe portare alla rottura del touchscreen nel caso in cui il tuo tablet sia del modello “sfigato” (il termine è usato anche dai Ministri della Repubblica, quindi lo userò anch’io) che ha un potente biadesivo sia sulla cornice, sia sul touchscreen. La cosa mi è successa ed ora ho un tablet senza più touchscreen che funziona solo con un mouse wireless il cui ricevitore è piazzato all’interno del tablet stesso (vedi post su HCH/TK).
3) supponendo di riuscire ad aprire il tablet senza fare danni al touch e senza fare grossi graffi alla “carrozzeria”, arriva il momento di dissaldare la memoria SPI. L’ho fatto diverse volte, ma una di queste si sono staccate due “pads” dal circuito stampato ed ho dovuto usare due fili di rame grandi come capelli per cercare di recuperare la situazione. Ci sono riuscito, ma i miracoli tendono ad essere eventi unici 🙂
4) smontata la memoria SPI si deve “ricostruire” quello che c’era dentro. Io ho scritto un programma che utilizza parte dei files contenuti nella directory FirmwareInstall della versione Uberoid che funziona per il tablet in oggetto e quindi ho bisogno di questi files.
5) supponendo che la memoria SPI non si rompa per il calore durante la dissaldatura, si potrà utilizzarla di nuovo (è una flash) riscrivendo i dati all’interno… se però si è rotta (succede) allora bisogna comprarne una di ricambio. Costa poco, circa 1 euro, ma le spese di spedizione sono di 9 Euro ! Pazzesco. In ogni caso, c’è da aspettare che arrivi.
6) Riprogrammata la SPI, bisogna saldarla di nuovo sul circuito. Anche qui è questione di destrezza e FORTUNA. Diciamo che finora, in fase di saldatura, non ho avuto mai problemi, ma non v’è certezza assoluta.
7) Si inserisce di nuovo la scheda microSD con la versione Uberoid corretta e si fa l’Upgrade. Supponiamo che vada tutto bene… si deve richiudere la meccanica e piazzare di nuovo la plastichetta di copertura, dopo aver riavvitato le piccolissime viti.
8) Si deve preparare un pacco postale ben protetto e sigillato e si deve andare all’ufficio postale, di mattina perché al pomeriggio c’è l’isola pedonale (c’è sempre un’isola pedonale vicino ai pubblici uffici) e quindi attendere la solita mezz’ora (se va bene) per poter spedire il pacco. Pagare i soliti 11,40 Euro per il pacco celere 3 (se nel frattempo non è aumentato) e quindi tornare a casa.
9) Il pacco parte, viene deposto con delicatezza sul furgone (lanciato da un’altezza di tre metri da un nerboruto individuo totalmente disinteressato al contenuto) e si incammina verso la più vicina stazione delle Ferrovie dello Stato, ove viene trasferito con le stesse modalità (lancio) nel vagone postale.
10) Tu ricevi il tablet da me riparato e magari si è rotto durante il trasporto. Allora mi scrivi e mi dici “ma che @#@# hai combinato ?” ed io ti rispondo “ma come, ho fatto del mio meglio !” e così via…

Bene, se i dieci punti non ti hanno dissuaso, ti faccio presente che un tablet molto simile a quello che mi hai descritto in privato (9.7″ basato su processore WM8650, sistema operativo Android 2.2, touchscreen resistivo) costa on-line 109.99 Euro, compresa IVA e spedizione da Unione Europea, quindi senza dazi aggiuntivi.