Arduino 33 BLE: Usando Funções do Mbed OS

Vimos no post anterior que o runtime do Arduino 33 BLE roda em cima do Mbed OS. Isto nos permite chamar diversas funções de Mbed OS no nosso código. As funções disponíveis no Mbed podem ser vistas aqui; é claro que algumas delas dependem de hardware não disponível no Arduino 33 BLE, mas ainda sobra muita coisa bacana.


Como um exercício, vamos criar duas threads adicionais no nosso programa, uma para piscar o LED e outra para ler o sensor inercial. O nosso programa principal receberá pela serial o caracter cujo código será piscado no LED e envirá pela serial os valores lidos do sensor.

Vamos começar vendo como criar uma thread, que é uma rotina que roda em paralelo ("simultaneamente") ao nosso programa principal:

view plaincopy to clipboardprint?

1. #include <mbed.h>  
2.   
3. using namespace rtos;  
4.   
5. Thread thLed;  
6.   
7. void setup() {  
8.   Serial.begin (115200);  
9.   thLed.start(piscaLed);  
10. }  
11.   
12. void loop() {  
13.   // put your main code here, to run repeatedly:  
14. }  
15.   
16. void piscaLed() {  
17.   pinMode (LED_BUILTIN, OUTPUT);  
18.   for (;;) {  
19.     digitalWrite (LED_BUILTIN, HIGH);  
20.     delay (300);  
21.     digitalWrite (LED_BUILTIN, LOW);  
22.     delay (300);  
23.   }  
24. }  

#include <mbed.h>

using namespace rtos;

Thread thLed;

void setup() {
  Serial.begin (115200);
  thLed.start(piscaLed);
}

void loop() {
  // put your main code here, to run repeatedly:
}

void piscaLed() {
  pinMode (LED_BUILTIN, OUTPUT);
  for (;;) {
    digitalWrite (LED_BUILTIN, HIGH);
    delay (300);
    digitalWrite (LED_BUILTIN, LOW);
    delay (300);
  }
}

O passo seguinte é fazer a comunicação entre o programa principal e a thread. Para isto vamos usar uma queue (fila):

view plaincopy to clipboardprint?

1. #include <mbed.h>  
2.   
3. using namespace rtos;  
4.   
5. Thread thLed;  
6. Queue<int, 20> filaLed;  
7.   
8. void setup() {  
9.   Serial.begin (115200);  
10.   thLed.start(piscaLed);  
11. }  
12.   
13. void loop() {  
14.   if (Serial.available() > 0) {  
15.     int c = Serial.read();  
16.     filaLed.put((int *) c);  
17.   }  
18. }  
19.   
20. void piscaLed() {  
21.   pinMode (LED_BUILTIN, OUTPUT);  
22.   for (;;) {  
23.     // Aguarda ter algo na fila  
24.     osEvent evt = filaLed.get();  
25.     if (evt.status == osEventMessage) {  
26.       // Pisca o valor binário do caracter retirado da fila  
27.       int c = (int) evt.value.p;  
28.       for (int i = 0; i < 8; i++) {  
29.         digitalWrite (LED_BUILTIN, (c & 0x80)? HIGH : LOW);  
30.         delay (300);  
31.         digitalWrite (LED_BUILTIN, LOW);  
32.         delay (200);  
33.         c = c << 1;  
34.       }  
35.       delay (1000);  
36.     }  
37.   }  
38. }  

#include <mbed.h>

using namespace rtos;

Thread thLed;
Queue<int, 20> filaLed;

void setup() {
  Serial.begin (115200);
  thLed.start(piscaLed);
}

void loop() {
  if (Serial.available() > 0) {
    int c = Serial.read();
    filaLed.put((int *) c);
  }
}

void piscaLed() {
  pinMode (LED_BUILTIN, OUTPUT);
  for (;;) {
    // Aguarda ter algo na fila
    osEvent evt = filaLed.get();
    if (evt.status == osEventMessage) {
      // Pisca o valor binário do caracter retirado da fila
      int c = (int) evt.value.p;
      for (int i = 0; i < 8; i++) {
        digitalWrite (LED_BUILTIN, (c & 0x80)? HIGH : LOW);
        delay (300);
        digitalWrite (LED_BUILTIN, LOW);
        delay (200);
        c = c << 1;
      }
      delay (1000);
    }
  }
}

Aqui o código ficou um pouco mais complicado. Indo por partes:

• Queue<int, 20> indica que estamos criando uma fila com 20 inteiros.
• filaLed.put((int *) c)  coloca 'c' na fila. O cast (int *) é necessário porque put espera um ponteiro e estamos colocando um inteiro.
• filaLed.get() aguarda ter algo na fila e o devolve dentro de um objeto osEvent

Estamos usando aqui apenas o básico do objeto Queue, Ele suporta prioridades e timeouts para aplicações mais sofisticadas.

Agora já podemos montar o código completo, usando a classe MemoryPool do Mbed para gerencias as áreas onde colocaremos as leituras:

view plaincopy to clipboardprint?

1. #include <mbed.h>  
2. #include <Arduino_LSM9DS1.h>  
3.   
4. using namespace rtos;  
5.   
6. typedef struct {  
7.   float x, y, z;  
8. } LEITURA;  
9. MemoryPool<LEITURA, 5> mpoolLeit;  
10.   
11. Thread thLed;  
12. Thread thIMU;  
13. Queue<int, 20>    filaLed;  
14. Queue<LEITURA, 5> filaIMU;  
15.   
16. void setup() {  
17.   Serial.begin (115200);  
18.   if (!IMU.begin()) {  
19.     Serial.println ("Erro ao iniciar IMU");  
20.   }  
21.   thLed.start(piscaLed);  
22.   thIMU.start(leIMU);  
23. }  
24.   
25. void loop() {  
26.   if (Serial.available() > 0) {  
27.     int c = Serial.read();  
28.     filaLed.put((int *) c);  
29.   }  
30.   osEvent evt = filaIMU.get(0);  
31.   if (evt.status == osEventMessage) {  
32.     LEITURA *pLeitura = (LEITURA *) evt.value.p;  
33.     Serial.print ("Leitura bussola: X=");  
34.     Serial.print (pLeitura->x);  
35.     Serial.print (" Y=");  
36.     Serial.print (pLeitura->y);  
37.     Serial.print (" Z=");  
38.     Serial.println (pLeitura->z);  
39.     mpoolLeit.free (pLeitura);  
40.   }  
41. }  
42.   
43. void piscaLed() {  
44.   pinMode (LED_BUILTIN, OUTPUT);  
45.   for (;;) {  
46.     // Aguarda ter algo na fila  
47.     osEvent evt = filaLed.get();  
48.     if (evt.status == osEventMessage) {  
49.       // Pisca o valor binário do caracter retirado da fila  
50.       int c = (int) evt.value.p;  
51.       for (int i = 0; i < 8; i++) {  
52.         digitalWrite (LED_BUILTIN, (c & 0x80)? HIGH : LOW);  
53.         delay (300);  
54.         digitalWrite (LED_BUILTIN, LOW);  
55.         delay (200);  
56.         c = c << 1;  
57.       }  
58.       delay (1000);  
59.     }  
60.   }  
61. }  
62.   
63. void leIMU() {  
64.   for (;;) {  
65.     if (IMU.magneticFieldAvailable()) {  
66.       LEITURA *pLeitura = mpoolLeit.alloc();  
67.       IMU.readMagneticField(pLeitura->x, pLeitura->y, pLeitura->z);  
68.       filaIMU.put(pLeitura);  
69.       delay (1000);  
70.     }  
71.     delay (100);  
72.   }  
73. }  

#include <mbed.h>
#include <Arduino_LSM9DS1.h>

using namespace rtos;

typedef struct {
  float x, y, z;
} LEITURA;
MemoryPool<LEITURA, 5> mpoolLeit;

Thread thLed;
Thread thIMU;
Queue<int, 20>    filaLed;
Queue<LEITURA, 5> filaIMU;

void setup() {
  Serial.begin (115200);
  if (!IMU.begin()) {
    Serial.println ("Erro ao iniciar IMU");
  }
  thLed.start(piscaLed);
  thIMU.start(leIMU);
}

void loop() {
  if (Serial.available() > 0) {
    int c = Serial.read();
    filaLed.put((int *) c);
  }
  osEvent evt = filaIMU.get(0);
  if (evt.status == osEventMessage) {
    LEITURA *pLeitura = (LEITURA *) evt.value.p;
    Serial.print ("Leitura bussola: X=");
    Serial.print (pLeitura->x);
    Serial.print (" Y=");
    Serial.print (pLeitura->y);
    Serial.print (" Z=");
    Serial.println (pLeitura->z);
    mpoolLeit.free (pLeitura);
  }
}

void piscaLed() {
  pinMode (LED_BUILTIN, OUTPUT);
  for (;;) {
    // Aguarda ter algo na fila
    osEvent evt = filaLed.get();
    if (evt.status == osEventMessage) {
      // Pisca o valor binário do caracter retirado da fila
      int c = (int) evt.value.p;
      for (int i = 0; i < 8; i++) {
        digitalWrite (LED_BUILTIN, (c & 0x80)? HIGH : LOW);
        delay (300);
        digitalWrite (LED_BUILTIN, LOW);
        delay (200);
        c = c << 1;
      }
      delay (1000);
    }
  }
}

void leIMU() {
  for (;;) {
    if (IMU.magneticFieldAvailable()) {
      LEITURA *pLeitura = mpoolLeit.alloc();
      IMU.readMagneticField(pLeitura->x, pLeitura->y, pLeitura->z);
      filaIMU.put(pLeitura);
      delay (1000);
    }
    delay (100);
  }
}