Ciao! Nello scorso articolo abbiamo visto come programmare, tramite l’IDE Arduino, la nostra scheda The Tactigon, sia come Central Role che come Peripheral Role, e poter quindi trasmettere ad un dispositivo qualisiasi a patto che abbia connettività Bluetooth Low Energy. Questa volta, invece, andremo ad interfacciare un dispositivo dotato di comunicazione UART con The Tactigon, per ampliare ulteriormente le applicazioni della scheda wearable.
Lo sketch che andremo a caricare sul nostro The Tactigon è molto semplice e non farà altro che inviare i Byte ricevuti dalla UART al monitor seriale USB, lasciando al lettore la libertà di scegliere il dispositivo adatto. Verrà utilizzata la porta UART1, esposta nel connettore GROVE a bordo scheda. E’ comunque disponibile una seconda porta UART, indipendente da questa utilizzata.
Comunicazione UART con The Tactigon
Requisiti
Questo esempio utilizza una scheda The Tactigon, ed un dispositivo che abbia connettività UART. E’ possibile utilizzare anche un cavo FTDI USB, e simulare il dispositivo inviando dati da PC, oppure un Raspberry Pi, Arduino o altri sensori. Sarà necessario un cavo micro USB per la connessione della scheda al nostro PC (per programmazione e utilizzo del monitor seriale) e dell’IDE Arduino configurato come abbiamo visto nell’articolo dedicato.
Sketch
L’utilizzo della comunicazione UART con The Tactigon è reso estremamente semplice dalle librerie fornite da Next Industries. E’ possibile utilizzare entrambe le porte UART disponibili sulla scheda wearable, impostarne il baudrate e definire una callback per la ricezione del singolo Byte o di una riga ASCII.
In questo sketch sarà presentata la configurazione della porta UART1, esposta nel connettore GROVE, la gestione dell’alimentazione esposta nello stesso connettore e la definizione di una callback per la ricezione di un Byte, che lo inoltrerà al monitor seriale.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 | /** Questo sketch di esempio mostra come inviare **/ /** i dati ricevuti tramite UART al monitor seriale USB **/ /** Michele Valentini - Red Sheep Labs - www.yarosia.it **/ #include "tactigon_led.h" #include "tactigon_UserSerial.h" #include "tactigon_IO.h" //RGB LEDs T_Led rLed, bLed, gLed; //UART T_UserSerial tSerial; //GPIO T_GPP gpp4; //Gestione Intermittenza LEDs int ticksLed, stp; void setup() { rLed.init(T_Led::RED); gLed.init(T_Led::GREEN); bLed.init(T_Led::BLUE); rLed.off(); gLed.off(); bLed.off(); //Inizializzazione GPIO, il GPIO4 viene utilizzato come interruttore dell'alimentazione esposta nel connettore GROVE gpp4.init(T_GPP::GPP4, T_GPP::GPP_OUT); //Inizializzazione UART gpp4.write(1); //Alimentiamo il dispositivo connesso tSerial.init(T_UserSerial::B_9600, T_UserSerial::T_SERIAL1); //Specifichiamo il baudrate e quale UART utilizzare (T_SERIAL1 è disponibile sul connettore GROVE, mentre T_SERIAL2 è posizionata sul connettore J502) tSerial.setRxByteCB(cbUartRxByte); //Questa callback viene chiamata alla ricezione di un singolo Byte da UART } void cbUartRxByte(uint8_t bb) { //Scriviamo nel monitor seriale esattamente ciò che riceviamo dal dispositivo UART connesso Serial.write(&bb, 1); //Accendiamo tutti e tre i LED alla ricezione di un Byte rLed.on(); gLed.on(); bLed.on(); } void loop() { //Intermittenza LEDs if (GetCurrentMilli() >= (ticksLed + (1000 / 1))) { ticksLed = GetCurrentMilli(); if (stp == 0) { rLed.on(); gLed.off(); bLed.off(); } else if (stp == 1) { rLed.off(); gLed.off(); bLed.on(); } else if (stp == 2) { rLed.off(); gLed.on(); bLed.off(); } stp = (stp + 1) % 3; } } |
Descrizione
Il dispositivo attende la ricezione di un Byte da UART1. Non appena questo viene ricevuto la callback
void cbUartRxByte(uint8_t bb) |
invierà il dato direttamente alla seriale USB, tramite la funzione
Serial.write(&bb, 1) |
Nel loop è presente solamente la gestione dei LEDs, ricezione e trasmissione avvengono tramite la callback vista sopra.
Conclusioni
L’utilizzo della comunicazione UART con The Tactigon, grazie alle callback, è molto semplice. Questo ci permetterà di utilizzare sensori GROVE, collegare Arduino, Raspberry, e altri dispositivi, come alcune schede controllo motori (Sabertooth ad esempio) che lavorano tramite UART.
Download
Qui è possibile scaricare il file sorgente dello sketch analizzato in questo articolo.