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 orderDisk /dev/mmcblk0: 7964 MB, 7964983296 bytes4 heads, 16 sectors/track, 243072 cylinders, total 15556608 sectorsUnits = sectors of 1 * 512 = 512 bytesSector size (logical/physical): 512 bytes / 512 bytesI/O size (minimum/optimal): 512 bytes / 512 bytesDisk 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-mkimagebuild-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=armecho "Args = ARCH=${__ARCH} CROSS_COMPILE=${__CROSS_COMPILE}"rm -rf deploymkdir deploymkdir deploy/fsmake mrpropermake -j5 ARCH=${__ARCH} CROSS_COMPILE=${__CROSS_COMPILE} a13om_defconfigmake cleanmake -j5 ARCH=${__ARCH} CROSS_COMPILE=${__CROSS_COMPILE} menuconfigmake -j5 ARCH=${__ARCH} CROSS_COMPILE=${__CROSS_COMPILE} depmake -j5 ARCH=${__ARCH} CROSS_COMPILE=${__CROSS_COMPILE} uImagemake -j5 ARCH=${__ARCH} CROSS_COMPILE=${__CROSS_COMPILE} modulesmake ARCH=${__ARCH} CROSS_COMPILE=${__CROSS_COMPILE} INSTALL_MOD_PATH=deploy/fs modules_installmake ARCH=${__ARCH} CROSS_COMPILE=${__CROSS_COMPILE} INSTALL_FW_PATH=deploy/fs/lib/firmware firmware_$cp .config deploy/fs/a13_olimex_micro_defconfigcp arch/arm/boot/uImage deploy/fs/uImagecd deploy/fstar 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:
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
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:
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:
Complimenti davvero per l’articolo! Una piccola domanda. Ho visto che utilizzi un tuo cavo USB-seriale… Sinceramente non vorrei smembrare il mio per questa scheda. posso acquistare questa ? https://www.olimex.com/Products/Components/Cables/USB-Serial-Cable/USB-Serial-Cable-F/
Ti ringrazio!
Ottimo articolo, molto interesante.
Senti, una domanda: ma quando dici “se si dispone di una macchina Linux”, intendi dire che non sarebbe possibile far le stesse cose su Windows e su MAC? Oppure si?
E che cambia?
Ti ringrazio per i complimenti e rispondo alla tua domanda:
Puoi usare qualsiasi cavo USB-seriale, l’importante è che accetti in ingresso una tensione di almeno 3.3V.
Quello che hai indicato va quindi benissimo.
Ciao
Salve, son contento che l’articolo sia stato di tuo interesse.
Riguardo la domanda, la compilazione del kernel è la parte della procedura che richiede una macchina linux. Infatti se a livello teorico è sufficiente avere il sorgente del kernel e gcc installato sulla propria macchina per effettuare la compilazione, nella pratica questa soluzione non funziona a causa delle varie dipendenze dei file headers e file c.
Invece più fattibile è l’idea di installarsi una macchina linux virtuale in Windows o Mac (con virtual box o parallels) e lavorare con quella.
Ciao
Davvero un bell’articolo.. Complimenti!!!
Rispetto alla Raspberry (a parte la possibilità di replicazione) quali differenze vi sono?
Sarebbe possibile usare la RB PI per realizzare un Tablet ?
Infine… E’ possibile avere un articolo comparativo su tutte le innumerevoli schede SoC sul mercato? Magari comparando anche con Arduino II, perchè ormai mi sono perso !!!!
Ve sono che usano uP ATOM (per una compatibilità legacy) ?
Grazie e ancora complimenti
Un articolo comparativo sui soc… questa è un’idea.
L’ultimo che abbiamo scritto ormai è datato e sarebbe interessante scrivere di cosa è cambiato nel corso del tempo…
Se l’autore vuole può occuparsene certamente 🙂
Grazie davvero per il positivo riscontro.
Riguardo la tua domanda sul Raspberry, le differenze tecniche si possono cogliere solo confrontando i datasheet delle due board, ma qualitativamente posso risponderti che la raspberry nasce come piccolo computer a basso costo, mentre la scheda dell’articolo è di tipo general purpose e destinata anche ad ambienti più ostili come quelli industriali.
Certamente però anche con il raspberry si potrebbe realizzare un tablet, bisognerebbe solo trovare un LCD adatto (raspberry dispone di uscita video videocomposito ed HDMI), oppure un LCD usb come quello di questo link: http://www.chalk-elec.com/?page_id=1280#ecwid:category=3094861&mode=product&product=14647624 (che però costa).
In realtà i problemi principali per realizzare un tablet non sono di natura tecnica, ma legati all’ottenimento di una buona autonomia di alimentazione del dispositivo e dal riuscire a contenere dimensioni e peso (ed ovviamente costi) del device.
Ciao
Carissimo Piero.
Per fortuna ci sei tu a darmi una mano.
Le schede ormai escono come funghi in autunno, non si sa quale scegliere per un progetto o per un percorso didattico che sia nel contempo economico, significativo sul piano didattico e non obsoleto dopo qualche mese.
Già vi era la guerra tra AVR e PIC, poi anche gli ARM hanno fatto capolino, e quindi la Texas coi suoi ultraeconomici MSP.
Tutti interessanti e tutti splendidi. Il problema è che non ho più il tempo (e tantomeno la voglia) di STUDIARE DataSheet da 600 pagine almeno per ognuno: nemmeno la Bibbia ne ha altrettante!!!!
Lo stesso discorso nel campo dell’impiantistica: non si fa tempo a leggere l’ultima raccolta di norme che già sono cambiate 2 volte!!!
Non si ha più tempo a realizzare e impratichirsi su qualcosa: lo si perde tutto a studiare nuovi dispositivi, nuove norme…
Un articolo che leggerei con infinito piacere si intitolerebbe:
“MANUALE DELLA SOPRAVVIVENZA ALLE NOVITA PER TECNICI ELETTRICI”
– ovvero come non farsi intrappolare da troppe novità e spendere il tempo a fare e non solamente a studiare –
Se penso che ho studiato per 7 mesi “Campi elettromagnetici e circuiti” al Poli di Torino: Tensori, Diadiche, Delta di Dirac Tridimensionali, equazioni di Maxwell e condizioni al contorno, equazioni diff. di tutte le salse…. per poi saper progettare una Yaghi Uda che costa 5 E !!!!!
Sono stanco di buttare via il mio tempo su libri e pagine stampate… Tante chiacchiere per che cosa????
Grazie x la risposta.
Non intendevo cimentarmi su un Tablet con RB PI, ma avere un confronto sulla capacità di gestione delle periferiche nelle due board.
Più in generale l’argomento che mi sta a cuore lo ho esposto nel mio ultimo post. Ovvero: qual’è attualmente la board più completa e versatile in commercio? Qual’è la board “Killer”? Questo per non disperdere tempo ed energie su qualcosa che solo domani sarà una ferraglia da buttare in soffitta.
Naturalmente la domanda non ha una risposta. Arduino non si ripeterà. Anche se oggi ha valide alternative, è stato per anni davvero unico.
Ancora complimenti
Francesco
Aspettate però non ho capito.
Che c’entra Raspberry Pi con Arduino?!
Non sono soc tutti e due…
No, fermi tutti… un po’ di ordine: Arduino NON è una soluzione completa e funzionalmente autosufficiente come Raspberry Pi.
A tal proposito, date uno sguardo agli articoli su Arduino DUE che abbiamo pubblicato, spiegandone caratteristiche e potenzialità, per averne un’idea più chiara.
Arduino è una soluzione easy (relativamente) per programmare un micro in linguaggio “più” naturale”.
Raspberry punta a fare da pc autosufficiente E da piattaforma di prototipazione…
Spero sia chiaro il messaggio 😉
Raspberry e Arduino sono sistemi completamente differenti.. Il mio paragone tra le due si riferiva al fatto che Arduino ha avuto un successo esplosivo e solo da relativamnte poco ha trovato valide alternative (quasi) originali. RB PI è invece stata subito contornata da una miriade di SoC, quasi tutte simili, quasi tutte diverse. La KILLER board che è stato Arduino non si è ripetuta.. almeno secondo il mio parere.
Non sottovalutare il fattore “novità”.
Arduino quando è uscita era una novità non dico assoluta ma…dico assoluta! 🙂
Raspi è uscita, ahilei, quando in giro l’idea del pc credit card-sized era già galoppante.
E comunque ha una marci in più, cioè i pin di I/O, che è difficilmente “arrivabile” 😉
Non so se poi ti hai visto questo:
http://it.emcelettronica.com/lmk802-iiis-con-android-41-lorgoglio-di-rikomagic-vana-gloria
Ma no, dai, Debian Embedded non si può proprio vedere! È ingiusto come Mer sia sottovalutata 😉
Salve, ottima guida ero intezionato a costruirlo, in quanto ha un espandibilità incredibile. Volevo usare come scheda A20 al posto della a13, oppure non è consigliabile usarla?? e due batterie da 300mah
Ciao,
certamente puoi utilizzare la scheda A20 (sempre della Olimex) al posto della A13, nessuna controindicazione particolare 🙂 probabilmente dovrai scegliere un diverso schermo LCD (specifico per la A20) o comunque effettuare dei settaggi appositi per quello indicato nell’articolo.
Riguardo le batterie tieni conto che Olimex indica che la sola scheda (quindi senza LCD) necessita di max 1A di corrente, ma realisticamente assorbe circa 200-500mA, per cui 300mAh sono un pò pochini per avere una certa autonomia. Pertanto meglio orientarsi verso pacchi di batterie da 1400mAh e oltre.
ciao ottimo questo oggetto di sviluppo anche le spiegazioni sono perfette . Una sola domanda ma come posso fare per fare uno slideshow di foto secondo te usando tutto questa macchina ?
Salve,
ringrazio per i complimenti. Riguardo la domanda, come indicato a fine articolo, è sufficiente installare un windows manager leggero ed un qualunque pacchetto di visualizzazione di immagini (tutto sotto Linux ovviamente). Le foto poi dovranno risiedere sulla scheda SD della scheda.
Buona giornata
Ti ringrazio tantisssssimo stavo impazzendo se non arrivavi tu
Interessante per un utilizzo CAR-PC!!