Bluetooth Low Energy Central Role con The Tactigon

The TactigonCiao! Nello scorso articolo abbiamo visto come programmare, tramite l’IDE Arduino, la nostra scheda The Tactigon, per poter trasmettere ad un dispositivo quale smartphone, autoradio, Raspberry Pi, personal computer o altro dispositivo Arduino i dati registrati dal sensore inerziale. Questa volta, andremo ad analizzare la programmazione come Bluetooth Low Energy Central Role con The Tactigon, per poter leggere i valori di sensori esterni e, perchè no, di un altra scheda The Tactigon.

Lo sketch che andremo a caricare sul nostro The Tactigon è molto semplice e andrà a connettersi ad un altra scheda The Tactigon su cui avremo caricato il secondo sketch presentato.  

Bluetooth Low Energy Central Role con The Tactigon

Requisiti

Questo esempio utilizza due schede The Tactigon, per semplicità. Potete utilizzare qualsiasi altro dispositivo (modificando lo sketch) per provare il Bluetooth Low Energy Central Role con The Tactigon.  Sarà necessario un cavo micro USB per la connessione della scheda al nostro PC e dell’IDE Arduino configurato come abbiamo visto nell’articolo dedicato.

Sketch

L’utilizzo dell’Bluetooth Low Energy con The Tactigon è reso estremamente semplice dalle librerie fornite da Next Industries. Anche se in questo caso utilizziamo la modalità TACTIGON_BLE_PERIPHERAL, è possibile configurare il dispositivo anche in modalità TACTIGON_BLE_CENTRAL, cosa che ci permetterà di far dialogare due schede The Tactigon, oppure interrograre sensori esterni.

Qui potete leggere il codice sorgente da caricare sulla scheda The Tactigon che avrà il ruolo CENTRAL:

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
73
74
75
76
77
78
79
80
81
82
/** Questo sketch di esempio mostra come inviare          **/
/** dati tra due The Tactigon (central e peripheral role) **/
/** tramite Bluetooth Low Energy                          **/
/** Michele Valentini - Red Sheep Labs - www.yarosia.it   **/
 
#include "tactigon_led.h"
#include "tactigon_IMU.h"
#include "tactigon_BLE.h"
 
T_Led rLed, bLed, gLed;
 
T_QUAT qMeter;
T_QData qData;
 
T_BLE bleManager;
UUID targetUUID;
uint8_t targetMAC[6] = {0xbe, 0xa5, 0x7f, 0x2e, 0x7d, 0x4b};
T_BLE_Characteristic accChar, gyroChar, magChar, qChar;
 
const uint8_t BUFF_SIZE = 12;
char buffData[BUFF_SIZE];
 
int ticks, ledCnt;
float roll, pitch, yaw;
 
 
void setup() {
  ticks = 0;
  ledCnt = 0;
 
  //Inizializzazione LEDs
  rLed.init(T_Led::RED);
  gLed.init(T_Led::GREEN);
  bLed.init(T_Led::BLUE);
  rLed.off();
  gLed.off();
  bLed.off();
 
  //Inizializzazione del BLE
  bleManager.setName("Tacti");
  bleManager.InitRole(TACTIGON_BLE_CENTRAL);                  //BLE role: CENTRAL
  targetUUID.set("7ac71000-503d-4920-b000-acc000000001");     //target characteristic
  bleManager.setTarget(targetMAC, targetUUID);                //target: mac device and its char UUID
}
 
void loop() {
  //Eseguiamo il codice @ 50Hz (20msec)
  if (GetCurrentMilli() >= (ticks + (1000 / 50))) {
    ticks = GetCurrentMilli();
 
    //Aggiorniamo i quaternioni e gli angoli di Eulero
    qData = qMeter.getQs();
 
    //Convertiamo gli angoli di Eulero da radianti a gradi
    roll = qData.roll * 360 / 6.28;
    pitch = qData.pitch * 360 / 6.28;
    yaw = qData.yaw * 360 / 6.28;
    memset(buffData, 0, BUFF_SIZE);
    //fill buffData to write in BLE characteristic
    memcpy(&buffData[0], &roll, sizeof(float));
    memcpy(&buffData[4], &pitch, sizeof(float));
    memcpy(&buffData[8], &yaw, sizeof(float));
 
    //Verifichiamo la connessione e la presenza della caratteristica specificata
    if (bleManager.getStatus() == 3) {
 
 
      bLed.on();
      ledCnt++;
      if (ledCnt > 50) {
        ledCnt = 0;
        rLed.off();
        bLed.off();
        gLed.off();
      }
      //Scriviamo nella Caratteristica BLE
      bleManager.writeToPeripheral((unsigned char *)buffData, BUFF_SIZE);
    } else {
      bLed.off();
    }
  }
}

Mentre questo sketch è dedicato alla scheda The Tactigon che avrà il ruolo PERIPHERAL:

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
/** Questo sketch di esempio mostra come inviare          **/
/** dati tra due The Tactigon (central e peripheral role) **/
/** tramite Bluetooth Low Energy                          **/
/** Michele Valentini - Red Sheep Labs - www.yarosia.it   **/
 
#include "tactigon_led.h"
#include "tactigon_BLE.h"
#include "tactigon_UserSerial.h"
 
//Valori ricevuti
float roll;
float pitch;
float yaw;
float threshold = 10;
//RGB LEDs
T_Led rLed, bLed, gLed;
 
//BLE Manager, BLE Characteristic and its UUID
T_BLE bleManager;
T_BLE_Characteristic cmdChar;
UUID uuid;
const uint8_t CHAR_SIZE = 12;
 
//Callback ricezione dati BLE
void cbBLEcharWritten(uint8_t *pData, uint8_t dataLen) {
  memcpy(&roll, &pData[0], sizeof(float));
  memcpy(&pitch, &pData[4], sizeof(float));
  memcpy(&yaw, &pData[8], sizeof(float));
}
 
void setup() {
  char charProg;
  roll = 0;
  pitch = 0;
  yaw = 0;
 
  rLed.init(T_Led::RED);
  gLed.init(T_Led::GREEN);
  bLed.init(T_Led::BLUE);
 
  rLed.off();
  gLed.off();
  bLed.off();
 
  //Inizializzazione del BLE
  bleManager.InitRole(TACTIGON_BLE_PERIPHERAL);
  uuid.set("7ac71000-503d-4920-b000-acc000000001");   //command char
  cmdChar = bleManager.addNewChar(uuid, CHAR_SIZE, 1);
 
  //Impostiamo la callback lanciata in caso di ricezione dati
  charProg = cmdChar.setWcb(cbBLEcharWritten);
}
 
void loop() {
  if (roll < threshold && roll > -threshold) {
    rLed.on();
  } else {
    rLed.off();
  }
  if (pitch < threshold && pitch > -threshold) {
    bLed.on();
  } else {
    bLed.off();
  }
  if (yaw < threshold && yaw > -threshold) {
    gLed.on();
  } else {
    gLed.off();
  }
}

Descrizione

Il dispositivo CENTRAL, alla frequenza di 50 Hz, aggiorna i valori degli angoli di Eulero (Rollio, Beccheggio ed Imbardata) tramite la funzione:

qData = qMeter.getQs();

converte questi valori da radianti a gradi, e li scrive nella caratteristica target, dopo aver verificato se la connessione è stata stabilita.

bleManager.writeToPeripheral((unsigned char *)buffData, BUFF_SIZE);

Sul device PERIPHERAL, andremo innanzitutto a definire la nostra callback, da lanciare alla ricezione di nuovi dati tramite Bluetooth Low Energy.

1
charProg = cmdChar.setWcb(cbBLEcharWritten);

La callback non si occuperà di altro che spacchettare i bit ricevuti e ricomporre i tre valori float originariamente trasmessi.

Nel loop andremo ad analizzare questi valori, che andranno ad interagire con i LED in base alla soglia preimpostata.

Conclusioni

Come potete vedere trasmettere dei dati tramite Bluetooth Low Energy con The Tactigon è semplicissimo grazie alle librerie che si occupano del dialogo tra microcontroller STM32 e BlueNRG.

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.