Don’t waste energy !

Sometimes you need to fully discharge your tablet’s battery, ‘cause you must drain all the power to obtain an Hardware Reset that can make your tablet able to restart with the upgrade process. So, I have used this simple technique to speed-up the process and to NOT WASTE energy !
I simply attached a USB battery charger to the tablet’s expander board, so while the tablet’s battery fastly discharges, my AA Ni-Mh charges 😉

dumper

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

RoboClock: alarm clock with ringing glass

I built this clock some years ago (in the 2005). It was a present for my son that has difficulties to wake-up in the morning. I decided to create a new kind of ringer, using a glass, a small cc motor and two small rubber balls tied to the motor axis. As cointainer, I used 6 “jewel case” for CDs and a lot of glue 🙂 as you can see in the picture below.

roboclock

There are 12 leds for the hours and 12 for minutes, this means that they advance at every 5 minutes boundary. I think this is sufficient ; personally, I never say: “are twelve past ten”, but use an approximation like “are ten past ten” or “a quarter part ten”, depending from the minute (and… normally I say it in Italian, my native language). This clock uses always a defect approximation, but you can modify the C source to create your own version. The control buttons are for setting the current time, the alarm time and to stop the ringer. In the schematic there is a NiCd battery (4.8V) that recharges at very low current. This just in case the power fails ; an alarm clock MUST work even if there is no supply. Obviously, today the NiCd rechargeable batteries are obsolete, but you can modify the circuit (included in the downloadable file) to change the part used for charging. Also note that the microcontroller used for this project is the AT90S2313, that’s obsolete. You can simply interchange it with the modern and active ATtiny2313 ; remember to adjust the internal fuse pattern in order to achieve the external Xtal clock running (at 4.096 MHz).

The downloadable file ef093.zip contains:
– root_1_1.pdf , the electric schematic, page 1
– root_1_2.pdf , the electric schematic, page 2
– tn_roboclock.jpg , the picture of the roboclock realized by me
– a093mio.hex , the hex file ready to be programmed into the micro
– main.c , the ‘C’ source file for this device

General purpose infrared remote control receiver with RS232 output

This circuit, based on popular micro ATtiny2313 from Atmel, can receive signals transmitted by an infrared remote control using the NEC protocol (or similar) with 32 bits of data. The received infrared stream is converted to ASCII string and transmitted on the RS232 port with format 19200,N,8,1. Power supply is taken directly from the PC serial port, if you activate the DTR or/and RTS lines. To test the circuit you can use the standard Windows HyperTerminal program.

148pic

The circuit transmits on RS232 three types of informations :
1) the character @ at micro reset and then every 5 seconds of inactivity (no signal received by the infrared sensor)
2) a string of 8 hexadecimal ASCII characters preceded by < and followed by >
3) the character # if you continue to hold down a button on the remote control, with a period given by the repetition rate of the remote control (100/200 mS approx.)

A typical string may be something like this : @@@@<00FF00FF>## where the first 4 characters @ means that there was no activity on the infrared sensor for about 20 seconds, <00FF00FF> is the key code received from remote and ## indicates that the key was pressed for 200/400 milliseconds.

Want to take a look at C source for this program ? Click here

To burn the micro, I used the freeware version of SP12 for WinXP or Win2K.
The batch files to program the micro and the fuses that are included in zip file, are tailored for this software (you can find it easily with a google search).

If you have other tools for micro programming, the fuses configuration for the application described is : Ext = 0xFF High = 0xCB Low = 0xEC

The downloadable file ef148.zip contains :
– schematic.pdf – the electric schematic in PDF format
– top.pdf – the PCB layout in 1:1 scale
– topprint.pdf – the components mounting map
– irrx.hex – the HEX file to burn the micro
– wrFuses.bat – the batch file for micro’s fuses programming
– wrProg.bat – the batch file for micro’s memory programming
– 148pic.jpg – the picture of the working circuit

This circuit was designed and programmed by me on 2008 Nov 08 ; it was published on my old sites, then removed when I closed that sites and now is here (to stay)  😉

Scrolling text on Oscilloscope (ONLY ONE COMPONENT)
Scritte scorrevoli su oscilloscopio (UN SOLO COMPONENTE)


ef140avi di robotop

Scritte a scorrimento su oscilloscopio con un SOLO componente, il micro PIC16F628A. I caratteri da visualizzare vengono memorizzati in EEPROM (codici ASCII da 0x20 a 0x5F cioè numeri, lettere maiuscole e caratteri speciali). La prima locazione di EEprom con il valore 0xFF è considerata la fine del testo scorrevole. L’ultima locazione di EEPROM (indirizzo 0x7F) contiene la velocità di scorrimento (n * 20 mS). La configuration word per questa applicazione (locazione 0x2007) vale 0x3F34. Una volta programmato il micro tramite il connettore ICSP, cortocircuitare i pin VDD e VPP con un ponticello (reset collegato a Vdd). L’oscilloscopio andrà settato per asse X a 2 mS/div e asse Y 1V/div. I caratteri visualizzati in un’unica schermata sono 10.

Il file disponibile per il download ef140.zip contiene il file oggetto .hex per programmare il micro ed il file sorgente main.c.

:: Scrolling text on oscilloscope, built with only one component: the Microchip PIC16F628A. The characters to be displayed are stored in EEPROM (ascii codes from 0x20 to 0x5f so numbers, capital letters and special characters). The first Eeprom location with 0xFF value is considered as end of text. The last Eeprom location (addr 0x7F) contains the scrolling speed in 20mS steps. The configuration word for this application (address 0x2007) is 0x3F34. After programming the micro via the ICSP connector, place a jumper between the pins VDD and VPP (reset input tied to Vdd). The oscilloscope will be set for 2mS/div on X axis and 1V/div on Y axis. One full screen contains 10 characters.

The downloadable file ef140.zip contains the object file (Hex) to program the micro and the main.c source file.

*** added 4 Sept 2009 *** Note:
When programming the micro, verify the configuration word (0x3F34) and remember that you MUST write some character to earom memory ; try with this data starting from earom address 0x00 : 0x49 0x54 0x20 0x57 0x4F 0x52 0x4B 0x53 0x20 0x41 0x54 0x20 0x45 0x4E 0x44 0xFF then write at address 0x7F: 0x0A (that’s decimal 10 * 20 mS scrolling speed). If the scrolling speed is too fast, increment the number in location 0x7F.
May be trigger level adjustment will be needed on the oscilloscope, in order to synchronize the scrolling text. The text field is preceded by a single sync pulse. Adjust the trigger level to make the text field stable. In many oscilloscopes, this will be done automatically, but some old one (like mine) will require a manual level adjust. Note that this circuit DOESN’T WORK with some digital oscilloscopes, due to the dot’s visualization method.

ef140sch The full schematic
ef140pic The prototype

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 😉