Un tablet Open Source economico

IMGP9017c
 
Oggigiorno siamo abituati a vedere in giro persone che usano il proprio tablet per lavoro, svago, o semplicemente per svolgere compiti per i quali sarebbe superfluo l'uso di un PC o netbook e scomodo l'utilizzo di uno smartphone. Se però volessimo un tablet compatto altamente personalizzabile nell'hardware e nel software col quale poter interfacciare qualsiasi sensore o dispositivo e che fosse anche economico, probabilmente non riusciremmo a trovarlo in alcun negozio. La buona notizia è che, seguendo il nostro articolo, questo tablet "custom" possiamo tranquillamente realizzarlo da soli.
 

Introduzione

La scheda OLinuXino-Micro è una scheda a basso costo, prodotta dalla società bulgara Olimex, adatta per applicazioni PC-oriented ma che ha una robustezza di tipo industriale. Il SoC a bordo della scheda è un ARM Cortex A8 (A13) prodotto dalla Allwinner Technology, casa cinese maggior fornitrice di chipset per tablet Android.
 
Tra le caratteristiche della scheda OLinuXino-Micro abbiamo:
  • Processore A13 Cortex A8 da 1GHz, con scheda grafica 3D Mali400 GPU;
  • 256 MB RAM;
  • 1 USB-host;
  • 1 USB-OTG (utile per alimentare la scheda);
  • Connettore SD card per avviare Linux;
  • Uscita video VGA;
  • Uscita audio mini jack;
  • Pin per input di un microfono (non incluso);
  • Tasto di reset;
  • Connettore IDC 40 pin per connettere un LCD esterno;
  • Connettore UEXT per collegare moduli esterni;
  • Connettore da 68/74 pin con: 8 GPIO, 3x I2C, 2x UART;
  • Dimensioni 100 x 85 mm.
La scheda è prodotta con licenza "Creative Commons Attribution-Share Alike 3.0" ovvero sono forniti gli schemi circuitali, i pcb ed ogni altra documentazione utile a realizzare in proprio la board secondo lo spirito del movimento Open Source Hardware. Anche tutto il software ed i drivers forniti sono rilasciati con licenza GPL.
 
Questo fatto differenzia tale scheda dalla Rasperry Pi per la quale gli schemi sono parzialmente disponibili, o dalla BeagleBone, la cui complessità non permette di produrla in piccole quantità. Altra differenza è che la OLinuXino è una board industriale, quindi capace di operare in ambienti gravosi.
 
 
In questo articolo vedremo come far funzionare la OLinuXino-Micro, come compilare il kernel e come utilizzare uno schermo LCD da 7" così da avere a disposizione un vero e proprio tablet Open Source.
Per chi volesse vedere subito le potenzialità del progetto OLinuXino, l'invito è quello di guardare i video presenti su youtube, come ad esempio
 
 

 

Unboxing

All'interno del tipico scatolotto cartonato Olimex è presente solo la scheda racchiusa in un involucro di plastica. Nulla altro viene fornito visto che tutta la documentazione ed i software sono presenti on-line. Ad esempio il manuale utente è un PDF che fornisce una panoramica della scheda e, ovviamente, la descrizione dei connettori, dello schema circuitale, etc.
 
 

Accessori necessari

Per iniziare ad usare la scheda sono necessari i seguenti accessori:
  • un alimentatore esterno da 5V 1A con presa microUSB oppure jack;
  • una scheda microSD da almeno 4Gb.
mentre opzionali sono:
  • un monitor esterno VGA e relativo cavo;
  • un hub USB con alimentatore: infatti on board è presente una presa USB-host high speed (che non supporta tastiere e mouse) ed una presa USB-OTG alla quale è possibile collegare tali perifiche ma che necessita di uno specifico adattatore. Pertanto meglio optare per un hub USB, più facilmente reperibile, da collegare proprio alla presa USB-host;
  • un convertitore USB-Ethernet: la scheda in questione non ha un'uscita Ethernet, benchè il software supporti un completo stack TCP/IP, quindi per scaricare software o aggiornamenti è utile avere tale accessorio;
  • schermo LCD da 4.3", 7" o 10" con o senza touch screen (venduto dalla stessa Olimex): in tal caso occorre procurarsi anche un connettore IDC da 40 fili per collegare lo schermo alla board.
 
Ora, in realtà è possibile usare la scheda anche senza mouse, tastiera e monitor mediante un convertitore seriale-USB da collegare tra board e PC: lanciando sul nostro computer il programma terminale preferito (ad es. minicom, putty o hyperterminal) potremo testare che la scheda funzioni correttamente. Pertanto è consigliabile avere sin da subito tale accessorio.
 

Avvio della board

Vediamo quindi come fare per iniziare ad usare la Olinuxino-Micro proprio senza mouse, tastiera e monitor esterno, utilizzando, appunto, un convertitore seriale-USB.
Partiamo scaricando da questo link l'immagine Debian "preliminare" per la scheda. E' un archivio RAR da 770Mb da scompattare, ottenendo il file immagine IMG. Usando il comando 'dd' su Linux o Win32DiskImager su Windows, l'immagine andrà copiata sulla nostra SD card. A titolo di esempio su Linux i comandi da lanciare da terminale sono (prima di aver inserito la scheda SD card nel proprio PC o notebook)
$ sudo fdisk -l
Successivamente, inserita la SD card nel nostro computer, occorre ripetere il comando prendendo nota del nuovo dispositivo elencato che dovrebbe essere del tipo seguente
$ sudo fdisk -l 
.
.
Partition table entries are not in disk order 
Disk /dev/mmcblk0: 7964 MB, 7964983296 bytes 
4 heads, 16 sectors/track, 243072 cylinders, total 15556608 sectors 
Units = sectors of 1 * 512 = 512 bytes 
Sector size (logical/physical): 512 bytes / 512 bytes 
I/O size (minimum/optimal): 512 bytes / 512 bytes 
Disk identifier: 0x7996dfb8
Ovvero /dev/mmcblk0.
A questo punto, dopo aver effettuato un 'umount' della SD card da riga di comando o dal vostro file manager, con il comando seguente potremo copiare l'immagine sulla scheda SD, ponendo davvero molta attenzione ad indicare il corretto device alla fine del comando (/dev/mmcblk0), altrimenti si potrebbero verificare delle serie compromissioni del vostro computer Linux.
$ sudo dd bs=4M if=A13_Micro_Debian_1GHz_GPIO_100kHz_I2C_WIFI_USB_LAN_without_X_
and_touch_first_release.img of=/dev/mmcblk0
L'operazione risulterà terminata all'apparire del prompt dei comandi; reinserendo la scheda SD nel PC o notebook dovremmo visualizzare due partizioni, una FAT16 da 17Mb contenente il bootloader ed altri file di configurazione ed una ext4 (non leggibile direttamente da windows) da 1.9Gb contenente il file system linux debian per ARM
 
 
Colleghiamo quindi il cavo seriale-USB nell'apposito connettore sulla scheda (vedasi foto) ed inseriamo l'altro capo del cavo ad una porta USB del PC. Attenzione a collegare correttamente alimentazione e massa (per non sbagliare sotto la board sono serigrafate le connessioni)
 
 
Andiamo poi a configurare il nostro programma terminale con un baud rate di 115200, 8 bit dati, nessuna parità, 1 bit di stop, nessun controllo di flusso.
Su Linux possiamo usare ad esempio il programma testuale minicom:
$ minicom
Premendo CTRL+A e, dopo, il tasto 'O' avremo il menu seguente  
 
 
seguendo le indicazioni dovrebbe essere agevole configurare il programma come prima indicato.
 
Abbiamo finito, nel senso che per verificare che la board funzioni correttamente non dobbiamo fare altro che alimentarla a 5V: dovremo a questo punto vedere accendersi il led rosso di alimentazione, in caso contrario andremo a controllare che l'alimentatore sia ben collegato ed in grado di erogare almeno 1 A di corrente.
Se il led rosso è acceso (a sinistra nella foto sotto), nel programma terminale del PC vedremo finalmente l'avvio del kernel linux sino al prompt dei comandi. 
 
 
Se invece sul programma terminale vedremo dei caratteri strani quasi certamente abbiamo invertito i collegamenti di TX ed RX o non impostato correttamente i parametri di connessione. 
Al login digiteremo come utente 'root' e password 'password'.
 
 
Certi che la scheda funziona correttamente, volendo, possiamo a questo punto collegare un monitor esterno, quindi mouse e tastiera usando l'hub connesso a sua volta alla presa USB-host della board.
 
Impartendo il comando
# cat /proc/version
Otterremo la versione corrente del kernel, ovvero la 3.0.52
 
 

Compilare il kernel

Dato che il nostro obiettivo è quello di far funzionare la OLinuXino-Micro con un LCD da 7" (o da 4.3" o da 10"), vediamo ora come procedere. Infatti, benchè con l'immagine preliminare scaricata sia teoricamente possibile fare questo (modificando opportuni file della SD card) si è visto che ciò non corrisponde al vero, in quanto si verifica un reboot infinito del sistema operativo.
 
Grazie al contributo degli utenti del forum del sito Olimex si è riusciti invece a far funzionare tutto, ma ciò comporta la ricompilazione del kernel (che in più verrà aggiornato rispetto alla versione della preliminary release). Si tenga presente che i passi qui indicati valgono solo se si dispone di una macchina Linux.
 
Prima di tutto occorre installare sul proprio PC alcuni tools e la toolchain per la compilazione del kernel linux su piattaforma ARM. Da riga di comando è sufficiente impartire:
$ sudo apt-get install gcc-arm-linux-gnueabihf ncurses-dev uboot-mkimage
build-essential git 
Scarichiamo quindi il kernel ufficiale per la nostra board (che occupa circa 1.6 Gb) creando dapprima una cartella apposita, ad es. 'OlinuxMicroKernel':
$ mkdir OlinuxMicroKernel
$ cd OlinuxMicroKernel
$ git clone https://github.com/linux-sunxi/linux-sunxi.git kernel
$ cd kernel
$ git checkout stage/sunxi-3.4
$ git pull 
Creiamo, sotto la directory, kernel/arch/arm/configs/ il file a13om_defconfig con il contenuto presente a questo link.
 
In questo file occorrerà trovare le seguenti righe (non successive):
CONFIG_GENERIC_GPIO=y
# CONFIG_SUN4I_GPIO_UGLY is not set 
# CONFIG_FB_CFB_FILLRECT is not set 
# CONFIG_FB_CFB_COPYAREA is not set 
# CONFIG_FB_CFB_IMAGEBLIT is not set 
# CONFIG_FB_SUNXI is not set
E sostituirle rispettivamente con
# CONFIG_GENERIC_GPIO=y
CONFIG_SUN4I_GPIO_UGLY=m
CONFIG_FB_CFB_FILLRECT=y 
CONFIG_FB_CFB_COPYAREA=y 
CONFIG_FB_CFB_IMAGEBLIT=y 
CONFIG_FB_SUNXI=y
E sotto quest'ultima riga (CONFIG_FB_SUNXI=y) aggiungere
CONFIG_FB_SUNXI_LCD=y
Queste modifiche permetteranno allo schermo LCD di funzionare correttamente.
 
Per compilare il kernel creiamo, sotto la cartella 'kernel', un file di script (ad es. compila.sh) avente il seguente contenuto:
#!/bin/bash
__ARCH=arm 
__CROSS_COMPILE=arm-linux-gnueabihf- 
__KBUILD_DEBARCH=arm 
echo "Args = ARCH=${__ARCH} CROSS_COMPILE=${__CROSS_COMPILE}" 
rm -rf deploy 
mkdir deploy 
mkdir deploy/fs 
make mrproper 
make -j5 ARCH=${__ARCH} CROSS_COMPILE=${__CROSS_COMPILE} a13om_defconfig 
make clean 
make -j5 ARCH=${__ARCH} CROSS_COMPILE=${__CROSS_COMPILE} menuconfig 
make -j5 ARCH=${__ARCH} CROSS_COMPILE=${__CROSS_COMPILE} dep 
make -j5 ARCH=${__ARCH} CROSS_COMPILE=${__CROSS_COMPILE} uImage 
make -j5 ARCH=${__ARCH} CROSS_COMPILE=${__CROSS_COMPILE} modules 
make ARCH=${__ARCH} CROSS_COMPILE=${__CROSS_COMPILE} INSTALL_MOD_PATH=
deploy/fs modules_install
make ARCH=${__ARCH} CROSS_COMPILE=${__CROSS_COMPILE} INSTALL_FW_PATH=
deploy/fs/lib/firmware firmware_$
cp .config deploy/fs/a13_olimex_micro_defconfig 
cp arch/arm/boot/uImage deploy/fs/uImage 
cd deploy/fs 
tar czf ../linux.tar.gz * 
cd ../..

Rendiamo eseguibile il file

$ sudo chmod +x compila.sh
e lanciamolo con

$ .\compila.sh
Quando appare la maschera come da foto spostarsi sul pulsante 'Exit'.
 
 
Attendiamo quindi qualche minuto fino al termine della compilazione.
Terminata l'operazione troveremo, sotto la directory corrente 'kernel', la nuova cartella 'deploy' al cui interno c'è il file linux.tar.gz. Quest'ultimo andrà scompattato nella partizione ext4 della SD card:
$ cd deploy
$ sudo cp linux.tar.gz /media/<partizione ext4 SD card>
$ cd /media/<partizione ext4 SD card>
$ sudo tar -zxvf linux.tar.gz
Nella partizione FAT16 della SD card invece andremo a copiare i file 'a13_olimex_micro_defconfig' e 'uImage' che si trovano nell'altra partizione (ovvero quella corrente) della medesima scheda

$ cp uImage /media/<partizione FAT16 SD card>
$ cp a13_olimex_micro_defconfig /media/<partizione FAT16 SD card> 
Possiamo quindi eliminare i file che non servono più dalla partizione ext4 della SD card
$ sudo rm uImage
$ sudo rm a13_olimex_micro_defconfig
$ sudo rm linux.tar.gz 

Configurare le GPIO

A questo punto vediamo come impostare la OLinuXino-Micro affinchè invii l'output non ad un monitor esterno VGA, bensì allo schermo LCD.
Innanzitutto scarichiamo da questa pagina il file ZIP seguendo il link "A13 script bin and fex tool" che poi scompatteremo (ad es. sotto 'OlinuxMicroKernel'). A sua volta occorrerà poi scompattare il file fex2bin_bin_fex_tools.tar.gz cosicchè nella cartella 'fex2bin_bin_fex_tools' troveremo gli eseguibili che ci occorrono.
Infatti per modificare il file 'script.bin', presente nella partizione FAT16 della SD card, dovremo usare il tool bin2fex, che converte un file da bin a fex (che è un formato testuale)
$ cd /media/<partizione FAT16 SD card>    
$ /home/<nostra home>/OlinuxinoMicroKernel/A13_script_files/fex2bin_bin_fex_tools/
bin2fex script.bin > script.fex
Procediamo poi modificando, come di seguito, le righe del file script.fex relative alla voce 'lcd0_para' (le altre restano invariate)

[lcd0_para]
lcd_used = 1
lcd_x = 800
lcd_y = 480
lcd_dclk_freq = 33
lcd_pwm_not_used = 0
lcd_pwm_ch = 0
lcd_pwm_freq = 10000
lcd_pwm_pol = 0
lcd_if = 0
lcd_hbp = 46
lcd_ht = 1055
lcd_vbp = 23
lcd_vt = 1050
lcd_hv_if = 0
lcd_hv_smode = 0
lcd_hv_s888_if = 0
lcd_hv_syuv_if = 0
lcd_hv_vspw = 1
lcd_hv_hspw = 30 
Salviamo il file e, mediante il tool fex2bin, riconvertiamo lo script nel formato bin
$ /home/<nostra home>/OlinuxinoMicroKernel/A13_script_files/fex2bin_bin_fex_tools/
fex2bin script.fex > script.bin
Si noti che nella partizione FAT16 sono presenti già due cartelle che contengono gli 'script.bin' per l'LCD o per il monitor VGA, ma la procedura sopra descritta è generale nel senso che permette di configurare opportunamente qualunque GPIO della board, agendo proprio sul file script.bin.
 

Colleghiamo lo schermo LCD

Abbiamo ricompilato il kernel della OLinuXino-Micro ed attivato il supporto per lo schermo LCD. Non resta che collegare quest'ultimo tramite il connettore IDC da 40 fili e far ripartire la board. Se tutto sarà andato liscio vedremo sullo schermo LCD direttamente il prompt dei comandi (l'avvio di linux non viene mostrato, ma possiamo monitorarlo sempre dal programma terminale del PC).
 
 
Digitando dalla tastiera connessa alla board (se impartiamo i comandi dal programma terminale del PC, questi non vengono visualizzati sull'LCD)
#cat /proc/version
Vedremo che apparirà la nuova versione 3.4.43 del kernel
 
 
A questo punto possiamo sbizzarrirci ad installare via rete (tramite l'accessorio USB-ethernet) i software che desideriamo, partendo certamente dal nostro window manager preferito, quindi installando i pacchetti relativi al browser, al player audio/video, agli applicativi office e così via.
 
Prestate solo attenzione al fatto che, inserito il convertitore USB-ethernet, l'interfaccia di rete utilizzata potrebbe non risultare la predefinita eth0, ma ad es. eth2, per cui occorrerà modificare il file /etc/network/interfaces aggiungendo le righe
auto eth2
iface eth2
inet dhcp 
Ed eseguendo poi al prompt
# ifup eth2
Nella foto seguente, per semplicità, è stato installato un ambiente X window minimale (ovvero solo i pacchetti xinit e libx11-dev quindi senza alcun desktop manager), ed eseguito un programma C che usa appunto le librerie X11 per mostrare il messaggio "Hello World".
 
 

Conclusioni

Come indicato ad inizio articolo la cosa interessante di questa scheda, rispetto ad altre, è che tutto il progetto, sia hardware che software, è assolutamente Open Source, per cui il sistema può essere, volendo, adattato alle nostre specifiche esigenze applicative.
Tenendo poi presente il basso costo della board (circa 35,00 EUR) e dell'LCD (il 7" circa 50,00 EUR, il 4.3" circa 35,00 EUR, mentre l'accessorio touch screen 10,00 EUR) con poco meno di 100,00 EUR ed installando i desiderati pacchetti applicativi, si riesce ad avere a disposizione un semplice ed economico tablet Open Source.
 
Riferimenti:
 
STAMPA     Tags:, ,

20 Comments

  1. MGa.MAX 24 febbraio 2014
  2. AntonioBlescia 3 luglio 2013
  3. Boris L. 3 luglio 2013
  4. mscafoglieri 3 luglio 2013
  5. mscafoglieri 3 luglio 2013
  6. darkstar55 3 luglio 2013
  7. Piero Boccadoro Piero Boccadoro 3 luglio 2013
  8. mscafoglieri 3 luglio 2013
  9. darkstar55 3 luglio 2013
  10. darkstar55 3 luglio 2013
  11. Boris L. 5 luglio 2013
  12. Piero Boccadoro Piero Boccadoro 5 luglio 2013
  13. darkstar55 5 luglio 2013
  14. Piero Boccadoro Piero Boccadoro 5 luglio 2013
  15. Uninstall 15 ottobre 2013
  16. mscafoglieri 6 maggio 2014
  17. lampone1967 30 maggio 2014
  18. mscafoglieri 30 maggio 2014
  19. lampone1967 30 maggio 2014

Leave a Reply

Vuoi leggere un articolo Premium GRATIS?

RFID: un acronimo mille possibilità