Un tablet open source economico
Luglio 2013
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 pure 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 RasperryPi 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)
<code>$ sudo fdisk -l</code>Successivamente, inserita la SD card nel nostro computer, occorre ripetere il comando prendendo nota del nuovo dispositivo elencato che dovrebbe essere del tipo seguente
<code>$ sudo fdisk -l</code>
<code>.</code>
<code>.</code>
<code>Partition table entries are not in disk order </code>
<code>Disk /dev/mmcblk0: 7964 MB, 7964983296 bytes </code>
<code>4 heads, 16 sectors/track, 243072 cylinders, total 15556608 sectors </code>
<code>Units = sectors of 1 * 512 = 512 bytes </code>
<code>Sector size (logical/physical): 512 bytes / 512 bytes </code>
<code>I/O size (minimum/optimal): 512 bytes / 512 bytes </code>
<code>Disk identifier: 0x7996dfb8</code>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.
<code>$ 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</code>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:
<code>$ minicom</code>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
<code># cat /proc/version</code>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:
<code>$ sudo apt-get install gcc-arm-linux-gnueabihf ncurses-dev uboot-mkimage build-essential git </code>Scarichiamo quindi il kernel ufficiale per la nostra board (che occupa circa 1.6 Gb) creando dapprima una cartella apposita, ad es. 'OlinuxMicroKernel':
<code>$ mkdir OlinuxMicroKernel</code>
<code>$ cd OlinuxMicroKernel</code>
<code>$ git clone https://github.com/linux-sunxi/linux-sunxi.git kernel</code>
<code>$ cd kernel</code>
<code>$ git checkout stage/sunxi-3.4</code>
<code>$ git pull</code>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):
<code>CONFIG_GENERIC_GPIO=y</code>
<code># CONFIG_SUN4I_GPIO_UGLY is not set</code>
<code># CONFIG_FB_CFB_FILLRECT is not set</code>
<code># CONFIG_FB_CFB_COPYAREA is not set</code>
<code># CONFIG_FB_CFB_IMAGEBLIT is not set</code>
<code># CONFIG_FB_SUNXI is not set</code>E sostituirle rispettivamente con
<code># CONFIG_GENERIC_GPIO=y</code>
<code>CONFIG_SUN4I_GPIO_UGLY=m</code>
<code>CONFIG_FB_CFB_FILLRECT=y</code>
<code>CONFIG_FB_CFB_COPYAREA=y</code>
<code>CONFIG_FB_CFB_IMAGEBLIT=y</code>
<code>CONFIG_FB_SUNXI=y</code>E sotto quest'ultima riga (CONFIG_FB_SUNXI=y) aggiungere
<code>CONFIG_FB_SUNXI_LCD=y</code>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:
<code>#!/bin/bash __ARCH=arm </code>
<code>__CROSS_COMPILE=arm-linux-gnueabihf- </code>
<code>__KBUILD_DEBARCH=arm </code>
<code>echo "Args = ARCH=${__ARCH} CROSS_COMPILE=${__CROSS_COMPILE}" </code>
<code>rm -rf deploy </code>
<code>mkdir deploy </code>
<code>mkdir deploy/fs </code>
<code>make mrproper </code>
<code>make -j5 ARCH=${__ARCH} CROSS_COMPILE=${__CROSS_COMPILE} a13om_defconfig </code>
<code>make clean </code>
<code>make -j5 ARCH=${__ARCH} CROSS_COMPILE=${__CROSS_COMPILE} menuconfig </code>
<code>make -j5 ARCH=${__ARCH} CROSS_COMPILE=${__CROSS_COMPILE} dep </code>
<code>make -j5 ARCH=${__ARCH} CROSS_COMPILE=${__CROSS_COMPILE} uImage </code>
<code>make -j5 ARCH=${__ARCH} CROSS_COMPILE=${__CROSS_COMPILE} modules </code>
<code>make ARCH=${__ARCH} CROSS_COMPILE=${__CROSS_COMPILE} INSTALL_MOD_PATH=deploy/fs modules_install </code>
<code>make ARCH=${__ARCH} CROSS_COMPILE=${__CROSS_COMPILE} INSTALL_FW_PATH=deploy/fs/lib/firmware firmware_$</code>
<code>cp .config deploy/fs/a13_olimex_micro_defconfig </code>
<code>cp arch/arm/boot/uImage deploy/fs/uImage </code>
<code>cd deploy/fs </code>
<code>tar czf ../linux.tar.gz * </code>
<code>cd ../..</code>Rendiamo eseguibile il file
<code>$ sudo chmod +x compila.sh</code>E lanciamolo con
<code>$ .\compila.sh</code>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:
<code>$ cd deploy </code>
<code>$ sudo cp linux.tar.gz /media/<partizione ext4 SD card></code>
<code>$ cd /media/<partizione ext4 SD card></code>
<code>$ sudo tar -zxvf linux.tar.gz</code>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
<code>$ cp uImage /media/<partizione FAT16 SD card> </code>
<code>$ cp a13_olimex_micro_defconfig /media/<partizione FAT16 SD card></code>Possiamo quindi eliminare i file che non servono più dalla partizione ext4 della SD card
<code>$ sudo rm uImage </code>
<code>$ sudo rm a13_olimex_micro_defconfig</code>
<code>$ sudo rm linux.tar.gz</code>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)
<code>$ cd /media/<partizione FAT16 SD card></code>
<code>$ /home/<nostra home>/OlinuxinoMicroKernel/A13_script_files/fex2bin_bin_fex_tools/bin2fex script.bin > script.fex</code>Procediamo poi modificando, come di seguito, le righe del file script.fex relative alla voce 'lcd0_para' (le altre restano invariate)
<code>[lcd0_para] </code>
<code>lcd_used = 1</code>
<code>lcd_x = 800</code>
<code>lcd_y = 480</code>
<code>lcd_dclk_freq = 33</code>
<code>lcd_pwm_not_used = 0</code>
<code>lcd_pwm_ch = 0</code>
<code>lcd_pwm_freq = 10000</code>
<code>lcd_pwm_pol = 0</code>
<code>lcd_if = 0</code>
<code>lcd_hbp = 46</code>
<code>lcd_ht = 1055</code>
<code>lcd_vbp = 23</code>
<code>lcd_vt = 1050</code>
<code>lcd_hv_if = 0</code>
<code>lcd_hv_smode = 0</code>
<code>lcd_hv_s888_if = 0</code>
<code>lcd_hv_syuv_if = 0</code>
<code>lcd_hv_vspw = 1</code>
<code>lcd_hv_hspw = 30</code>Salviamo il file e, mediante il tool fex2bin, riconvertiamo lo script nel formato bin
<code>$ /home/<nostra home>/OlinuxinoMicroKernel/A13_script_files/fex2bin_bin_fex_tools/fex2bin script.fex > script.bin</code>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)
<code>#cat /proc/version</code>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.
Solo prestate 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
<code>auto eth2 </code>
<code>iface eth2</code>
<code>inet dhcp</code>Ed eseguendo poi al prompt
<code># ifup eth2</code>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
https://www.olimex.com/wiki/A13-OLinuXino
https://www.olimex.com/Products/OLinuXino/A13/A13-OLinuXino-MICRO/
https://www.olimex.com/wiki/Configurationof_hardware_in_the_debian_image_
http://olimex.wordpress.com/2012/10/12/building-bootable-sd-card-with-debian-linux-image-for-a13-olinuxino/
http://linux-sunxi.org/GPIO
https://www.olimex.com/forum/index?topic=790.0
