Comunicazione UART con The Tactigon

The TactigonCiao! 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.

Spread the love

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

Questo sito usa Akismet per ridurre lo spam. Scopri come i tuoi dati vengono elaborati.