Cosino, la piattaforma che realizza le tue idee
Febbraio 2015
English version of this article available here
Nel panorama embedded esistono schede quali Arduino Yun, Arduino 3, Udoo, etc. che hanno la peculiarità di far incontrare il mondo Arduino con quello Linux. Ebbene, quella che presentiamo oggi non è semplicemente una nuova scheda che vuole integrare questi due mondi, ma è un progetto più ampio e che nasce con un’ispirazione ben diversa. Vediamo di cosa si tratta.
Il progetto Cosino
Innanzitutto Cosino è l’acronimo di “Computer Oriented to Simplify Innovation of New Objects” e sostanzialmente dà il nome alla scheda Linux attorno alla quale si basa poi l’intero progetto che qui di seguito andiamo a descrivere. Il progetto è tutto italiano, per la precisione del team toscano dell’HCE Engineering.
Ma in che cosa consiste, appunto, il progetto? Esso si basa essenzialmente sul concetto di voler semplificare il lavoro degli sviluppatori embedded e dei progettisti del mondo industriale in generale, fornendo una piattaforma ed i giusti tools che consentono in tempi brevi di avviare la prototipazione di una scheda industriale sino alla sua produzione di massa. Questo avviene mediante tre “ingredienti” principali: la board Linux, le schede add-on dette “estensioni” ed i componenti detti “periferiche”.
Partiamo quindi dalla scheda Cosino, il cui appellativo principale è quello di essere una “scheda per la prototipazione rapida”. Le caratteristiche principali della scheda sono descritte più avanti, mentre ciò che qui si vuole sottolineare è che si tratta di una scheda Linux adatta ad ambienti di tipo industriale, già certificata e quindi utile a realizzare sin da subito prodotti finiti, non solo quindi usabile per progetti di tipo hobbystico. Questo benchè la board strizzi comunque l’occhio anche ai makers, grazie alla sua integrazione con Arduino, come vedremo.
Accanto alla scheda, che rappresenta il cuore del progetto, vi sono le cosidette “estensioni” ovvero delle schede che contengono principalmente sensori ed attuatori, demandando la logica di controllo alla board Cosino: l’insieme di queste ultime e della board Cosino rappresentano quindi il nostro sistema embedded, ma col vantaggio che dobbiamo progettare solo la nostra particolare “estensione”. Un bel risparmio di tempo no?
L’idea poi si spinge oltre, perchè oltre alla scheda Linux ed oltre alle estensioni, vi sono poi le “periferiche”, ovvero una serie di componenti, sempre orientati al mondo industriale, già testati e supportati dal progetto Cosino e quindi utilizzabili sin da subito.
Oltre ai tools su citati, il sito http://www.cosino.io fornisce poi al professionista un insieme di servizi utili per la realizzazione dei propri progetti embedded. Infatti sul sito è possibile trovare documentazione, guide, tools, progetti ed il supporto tecnico necessari per abbattere i tempi di sviluppo di un prototipo. Non solo, il team Cosino è in grado di offrire supporto anche nelle successive fasi dello sviluppo del prototipo, ovvero nell’ingegnerizzazione della scheda e la messa in produzione del prodotto finito. Come è noto, questi ultimi aspetti non vanno certo trascurati ed anzi rappresentano una parte non banale nella realizzazione di un prodotto commerciabile.
La scheda Cosino
La scheda core è basata sul microcontrollore ARM9 Atmel SAM9G35, ha una memoria SDRAM da 128Mb ed una Flash da 256Mb. Sono poi previsti I/O per gestire Ethernet, USB, UART, SPI, I2C, LCD e GPIO (maggiori dettagli tecnici sono reperibili sul sito di riferimento). Questi I/O sono accessibili attraverso due header che consentono, appunto, di riutilizzare la board per diversi scopi, a seconda dell’applicazione specifica che l’utente dovrà sviluppare. Pertanto qualsiasi connettore, sia esso RJ45 jack, USB o Sd-Card va previsto sulla propria scheda esterna: questo, se da una lato potrebbe sembrare una limitazione, in realtà offre il vantaggio di poter includere sulla propria board solo i connettori ed in generale gli I/O che ci interessano.
Per quanto riguarda la parte software, Cosino al momento è già pronto per utilizzare il kernel Linux 3.10 e la distribuzione Debian 7.0 (Wheezy) nonchè la distribuzione per sistemi embedded OpenWRT versione Barrier Breaker. Ciò si traduce per l’utente nel fatto che con Cosino è possibile sin da subito disporre di decine di migliaia di software open source per i più disparati campi di applicazione.
Ancora una volta, sul sito di riferimento http://www.cosino.io, sono ben descritte le operazioni di compilazione del kernel e dell’installazione di una distribuzione Linux, fasi che comunque possono essere saltate da chi è alle prime armi o non vuole perder tempo, grazie alla disponibilità di Sd-Card col software di base già precaricato.
L’estensione per Arduino
Il fatto di avere una scheda core Cosino rappresenta di per sè un vantaggio, ma in realtà, come si è già accennato, ci sono poi comunque dei connettori esterni e degli I/O che andrebbero previsti (ovvero montati) sulla propria board. E all’inizio, realizzare una propria board da collegare a Cosino potrebbe significare, per chi sta realizzando un prototipo standard, comunque perdere del tempo.
Per tale motivo il team Cosino ha pensato di realizzare una “estensione” generica che permette sin da subito all’utente di dedicarsi allo sviluppo del software. La scheda è chiamata Mega2560 e presenta connettori RJ45, USB, RS485, JTAG e molto altro ancora. In più è presente una micro USB che può essere usata sia per alimentare la scheda stessa, sia per disporre di una console seriale di debug.
Ma la peculiarità più interessante di questa “estensione” è che presenta una sezione con un microcontrollore ATmega2560 (e relativa circuiteria) che consente di disporre di un vero e proprio Arduino Mega 2560 compatibile (da cui il nome dell’estensione). Pertanto, vista la presenza dei tipici connettori Arduino, sarà possibile utilizzare tutti gli shield (e i relativi software) previsti per l’Arduino Mega, nonchè quelli per l’Arduino UNO (purchè compatibili con l’Arduino Mega).
La comunicazione tra Linux ed Arduino avviene tramite interfaccia seriale diretta.
Prototipiamo
Facciamo allora un esempio pratico, giusto per capire quale vantaggio può derivare dal basare il proprio progetto su Cosino abbinato all’estensione Mega 2560.
Supponiamo di dover realizzare un prototipo per una scheda che, al passaggio di oggetti su un nastro trasportatore, dovrà contarne il numero e fornire la temperatura rilevata: si pensi ad esempio a dei prodotti dolciari appena usciti dal forno. Se la temperatura è inferiore o superiore a certi valori di soglia, il sistema dovrà segnalarlo in quanto vorrà dire che la cottura del prodotto non è stata ottimale. Naturalmente il tempo di arrivo dei pezzi, così come il valore di temperatura rilevata, costituiranno degli utili dati di produzione del sistema, sui quali si potranno poi realizzare reportistiche ad hoc.
Dato che inizialmente dobbiamo realizzare un prototipo, possiamo fare delle semplificazioni circa il sistema, ad esempio possiamo utilizzare come sensore di conteggio dei semplici diodi IR, per rilevare la temperatura usare i popolari DS18B20 della Dallas, mentre per la comunicazione usiamo l’interfaccia seriale anzichè la RS485 (questa in realtà è una semplificazione circuitale): passare a sensori più complessi significherà, come vedremo, dover modificare di poco il nostro progetto. Un semplice schematico è quindi il seguente:
Creiamo quindi un nuovo progetto con l’IDE di Arduino. Lo sketch dovrà leggere la temperatura del DS18B20 e rilevare l’interruzione della barriera ad infrarossi.
Sul sito di Arduino (http://playground.arduino.cc/Learning/OneWire) è già presente il driver 1-Wire per gestire il DS18B20, mentre per i diodi IR si tratterà semplicemente di leggere il livello di un segnale analogico tramite la funzione analogRead(). Questi dati saranno accessibili verso l’esterno tramite il protocollo industriale Modbus, per cui dovremo aggiungere al nostro progetto Arduino anche tale supporto, scaricando la libreria slave dal sito
https://code.google.com/p/simple-modbus.
Lo sketch Arduino ha quindi il compito di leggere le informazioni dai sensori e inviarle verso l’esterno tramite Modbus. Questo un esempio di codice:
#include <OneWire.h>
#include <SimpleModbusSlave.h>
#define IR_PIN 0
OneWire ds(10);
// Dallas address
addr[8] ={0x28, 0xA3, 0x10, 0x05, 0x04, 0x00, 0x00, 0x78 };
int16_t temp;
enum { ADC_VAL, TEMP_VAL, HOLDING_REGS_SIZE };
unsigned int holdingRegs[HOLDING_REGS_SIZE];
void setup() {
modbus_configure(&Serial, 9600, SERIAL_8N2, 2, 2,
HOLDING_REGS_SIZE, holdingRegs);
}
void loop() {
modbus_update();
// readTemp() read Dallas temperature
// and return a raw int value
temp = readTemp();
holdingRegs[ADC_VAL] = analogRead(IR_PIN);
holdingRegs[TEMP_VAL] = 0xFFFF & temp;
}
Passiamo ora al progetto su Linux. Qui il software dovrà leggere i dati ricevuti via Modbus da Arduino ed effettuare le elaborazioni del caso, ovvero nel momento in cui viene rilevata la presenza di un oggetto dovrà leggere il valore della temperatura fornita dal sensore DS18B20 e, in base a tale informazione, inviare o meno un allarme o bloccare l’avanzamento del nastro trasportatore. I dati vanno quindi scritti su un file di log o su un database. Un esempio minimale di codice (in linguaggio C, benchè possano essere utilizzati i linguaggi a noi più consoni) può essere il seguente:
#include <modbus.h>
#include <stdio.h>
#include <stdlib.h>
#define MB_ADDR 2
#define REG_START 0
#define REG_END 1
#define TEMP_L 45.0
#define TEMP_H 80.0
int main(void) {
uint16_t tab_reg[3];
modbus_t *mb;
float temp;
int ir;
mb = modbus_new_rtu("/dev/ttyS3", 9600, ’N’, 8, 2);
modbus_connect(mb);
modbus_set_slave(mb, ADDR);
while (1) {
modbus_read_registers(mb, REG_START, (REG_END - REG_START + 1), tab_reg);
ir = tab_reg[0];
temp = (float)tab_reg[1]/16.0;
if (ir > 100) {
// write data to file or database ...
if (temp < TEMP_L || temp > TEMP_H)
// alarm!! ...
}
}
modbus_close(mb);
modbus_free(mb);
return 0;
}Come si può intuire, realizzare già un primo prototipo di un tale sistema significa impiegarci davvero mezza giornata ed il tempo maggiore verrebbe dedicato concretamente allo sviluppo del software.
Naturalmente, volendo, è possibile spingersi oltre con l’esempio ed attivare su Cosino un web server Apache, storicizzare i dati su un database server o realizzare delle pagine HTML apposite, così da permettere la consultazione dei dati anche online.
A questo punto, se il nostro prototipo ci soddisfa, questo potrà essere raffinato, ad esempio i sensori ed Arduino potranno essere sostituiti con sensori industriali pilotati e gestiti da un PLC. In tal caso, visto che stiamo operando con il protocollo Modbus, lato Linux l’unica modifica che dovremo essenzialmente fare è quella di cambiare l’indirizzo slave del PLC e gli indirizzi relativi ai sensori, mentre il resto dell’applicazione rimarrà la stessa, ovvero modificare solo queste tre righe di codice:
#define MB_ADDR 2
#define REG_START 0
#define REG_END 1Se invece lo scopo del progetto è quello di realizzare una propria scheda, usando i componenti presenti sul prototipo, allora la via sarà quella di ingegnerizzare una nuova “estensione” per Cosino, ovvero progettare la sola scheda con i sensori e con l’header per accogliere la board Cosino.
Conclusioni
Come descritto, il progetto Cosino nasce per permettere ai progettisti di realizzare in tempi brevissimi lo sviluppo di un prototipo, questo anche grazie all’utilizzo di periferiche industriali già testate e supportate, senza tralasciare il vantaggio di avere disponibile anche tutto il mondo Arduino grazie all’estensione Mega2560. Quest’ultima opzione d’altronde può tornare utile anche all’hobbysta un pò più skillato che vuole cimentarsi a realizzare sistemi integrati tra Arduino e Linux.
Una volta terminato lo sviluppo del prototipo la piattaforma Cosino offre altresì la possibilità di passare immediatamente alla fase di messa in produzione del progetto oppure di ingegnerizzare la propria board e di produrla in serie, magari vendendola proprio sullo shop del sito Cosino.
