fbpixel
Criar uma aplicação com App Inventor 2

Criar uma aplicação com App Inventor 2

Aprenda a criar uma aplicação para Android facilmente com o App Inventor 2.

No campo da robótica e dos objectos conectados, uma das funcionalidades mais interessantes de se implementar é o comando à distância de um projecto eletrónico. Seja para exibir valores vindos da sua casa ou para pilotar um drone, uma solução possível é desenvolver uma aplicação para Smartphone e comunicá-la com um microcontrolador via Bluetooth. Essa aplicação pode ser criada rapidamente com o App Inventor 2 (AI2), um software online do MIT.

Equipamento

  • Computador
  • Smartphone Android com uma aplicação de leitura de QR Code
  • Arduino UNO
  • Bluetooth HC-06
  • Cabo Dupont F/M

Criação da Aplicação AI2

Neste exemplo, criaremos uma aplicação para ativar uma função (ON/OFF) e para recuperar uma medida de um sensor de uma placa Arduino. Este tutorial também serve para muitas outras aplicações.

Inscreva-se no site App Inventor 2.

Crie um novo projecto myApp

O ecrã de design do projecto irá aparecer

Configuração da Aplicação AI2

Para criar o design da nossa aplicação, iremos utilizar os objectos disponíveis nas abas do menu suspenso à esquerda do ecrã e modificar suas configurações, que aparecem à direita da tela.

Em User Interface, inclua um objecto label e renomeie-o como titleLbl. Ele irá conter o título da aplicação myApp.

Em Layout, inclua um objecto VerticalArrangement, que permite alinhar os objectos verticalmente.

No objecto VerticalArrangement, coloque um label btStatusLbl e em seguida um ListPicker btBtn, que servirão para gerenciar a conexão Bluetooth.

Acrescente em seguida um label sensorLbl, que conterá o valor recebido da placa Arduino.

Acrescente um HorizontalArrangement, que permite dispor e alinhar os objectos na horizontal. Ele conterá os botões que permitem ativar a função do Arduino.

No ‘HorizontalArrangement, inclua dois botões: onBtn e offBtn.

Então, em Connectivity, inclua um objecto BluetoothClient, que permitirá interagir com o dispositivo Bluetooth.

E em Sensor, acrescente dois objectos Clock, que permitirão enviar e receber dados a intervalos de tempo regulares.

Pode personalizar a sua aplicação como desejar, utilizando diferentes cores, fontes ou imagens.

Programação da Aplicação AI2

Para programar a aplicação, o AI2 oferece o Scratch, que possibilita criar um programa na forma de diagrama de blocos. A utilização é muito simples, mas exige um pouco de lógica de programação.

Todas as funções são disponíveis clicando nos objectos do menu suspenso à esquerda da tela. Seleccione as funções dos objectos que acrescentou na aplicação, assim como as dos objectos Variables, Text, Math e Control, que iremos utilizar.

Crie a lista dos módulos Bluetooth disponíveis no dispositivo.

Gerencie o estabelecimento da conexão e modifique status em função da conexão.

Uma variável global “command” é definida para salvar na memória o valor fornecido pelo último botão apertado (ON ou OFF).

Enviamos o valor da variável “command” via Bluetooth, se ele estiver conectado, com uma frequência definida pelo objecto Clock1.

Para receber o valor do sensor enviado do Arduino, verificamos se os dados estão disponíveis no buffer com uma frequência definida pelo Clock2. Em seguida, exibimos esse valor em sensorLbl.

Código completo

Uma vez todos os blocos colocados na interface e configurados, o código deve ter este aspecto.

Compilar e compartilhar a sua aplicação

Quando o programa Scratch estiver corretamente configurado e não aparecer erro algum, tenha em mãos uma aplicação de leitura de QR Code e compile o programa, utilizando o menu Build > App (provide QR code for .apk)

Após gerar o QR Code, poderá descarregar e instalar a aplicação no seu Smartphone.

Pode compartilhar o instalador da sua aplicação .APK para Android, ou compartilhar o projecto .AIA para que outras pessoas possam modificá-lo.

Exporte para criar o ficheiro AIA correspondente no seu computador

Importe para abrir um ficheiro AIA na aplicação online e modificar o projecto

Código Arduino

Veja abaixo o código a ser carregado na placa Arduino para enviar e receber dados para a porta serial. (Veja mais informações neste tutorial)

#include <SoftwareSerial.h>

SoftwareSerial hc06(2, 3);

String cmd = "";
float sensor_val = 0;

void setup() {
  //Initialize Serial Monitor
  Serial.begin(9600);
  //Initialize Bluetooth Serial Port
  hc06.begin(9600);
}

void loop() {
  //Read data from HC06
  while (hc06.available() > 0) {
    cmd += (char)hc06.read();
  }

  //Select function with cmd
  if (cmd != "") {
    Serial.print("Command recieved : ");
    Serial.println(cmd);
    // We expect ON or OFF from bluetooth
    if (cmd == "ON") {
      Serial.println("Function is on");
    } else if (cmd == "OFF") {
      Serial.println("Function is off");
    } else {
      Serial.println("Function is off by default");
    }
    cmd = ""; //reset cmd
  }
  // Simulate sensor measurement
  sensor_val = (float)random(256); // random number between 0 and 255

  //Write sensor data to HC06
  hc06.print(sensor_val);
  delay(100);
}

Resultado

É possível ativar e desativar a função do Arduino e receber os dados de um sensor na aplicação

Se precisar de ajuda para criar a sua aplicação ou se achar que este tutorial precisa de mais informações, deixe-nos um comentário abaixo ou contacte-nos.

Aplicações

Fontes

Gerir vários Arduinos com um barramento I2C

Gerir vários Arduinos com um barramento I2C

Estabelecer uma comunicação entre diversos dispositivos pode ser prático, sobretudo em projectos de domótica. Uma técnica empregada com frequência é o protocolo I2C (ou TWI). O protocolo I2C é um método que permite conectar diversas placas mestres e diversas placas escravas, de modo a comunicar até 128 dispositivos. Ele possibilita conexões assíncronas entre diversos componentes, para compartilhar informações por meio de um “barramento comum”.  Já falamos anteriormente sobre a comunicação pela porta serial (dita UART), utilizada para enviar o código ao Arduino através de um computador ou para conectar dois dispositivos em particular via Bluetooth.

Obs.: Vale observar que a comunicação I2C é originalmente concebida para a comunicação entre placas. Assim, ela não é adaptada à comunicação à distância (>1m).

Equipamento

  • Computador
  • Arduino UNO (2 ou mais)
  • Cabos jumper M/M (3 vezes a quantidade de placas)

Esquema de ligação do barramento I2C entre placas Arduino

O protocolo I2C também possibilita estabelecer comunicação entre diferentes sistemas (sensores, ecrã LCD, Raspberry Pi, etc.). Um exemplo interessante é a comunicação entre diversas placas Arduino. Para isso, é preciso escrever ao menos dois programas, um para a placa mestre e outro para as placas escravas.

A comunicação I2C é definida por um barramento de dois fios (também chamado de TWI, Two Wire Interface) e um endereço. Os pinos utilizados pela comunicação I2C normalmente são fixos para cada dispositivo. Há um pino para o envio dos dados (SDA Serial Data Line) e outro para o relógio de sincronização (SLC Serial Clock Line).

Pinos I2C/TWI:

  • Uno, Ethernet A4 (SDA), A5 (SCL)
  • Mega2560 20 (SDA), 21 (SCL)
  • Leonardo 2 (SDA), 3 (SCL)
  • Due 20 (SDA), 21 (SCL), SDA1, SCL1

No exemplo abaixo, utilizamos uma placa Arduino Uno, e portanto os pinos A4 e A5.

Para que as duas placas comuniquem-se entre si, é preciso ligá-las corretamente (A4 com A4 e A5 com A5) e não esquecer de conectar as terras (GND) conforme indicado no esquema a seguir.

Atenção: Se os pinos A4 e A5 forem conectados aos pinos de uma placa não alimentada, o código irá travar no momento da transmissão.

Em geral, uma das placas envia as informações (Writer) e uma outra as recebe (Reader).

Código para configuração do barramento I2C

A biblioteca Wire.h permite definir a comunicação serial no barramento I2C com facilidade. As funções são similares às da biblioteca Serial.

  • Wire.begin() permite configurar o endereço do dispositivo. O argumento da função pode ser vazio para os dispositivos mestres.
  • Wire.write() permite o envio de bytes.
  • Wire.requestFrom() gerencia a função de recepção de solicitações
  • Wire.beginTransmission() inicia a transmissão de dados e define o receptor.
  • Wire.endTransmission termina a transmissão de dados
  • Wire.onRequest() gerencia a função de recepção de solicitações
  • Wire.onRecieve() gerencia a função de recepção de dados

Código da placa Mestre

#include <Wire.h>

# define I2C_SLAVE1_ADDRESS 11
# define I2C_SLAVE2_ADDRESS 12

#define PAYLOAD_SIZE 2

int n = 0;

void setup()
{
  Wire.begin();
  Serial.begin(9600);

  Serial.println(F("-------------------------------------I am the Master"));
  delay(1000);

  //Request value of n to slave
  Wire.requestFrom(I2C_SLAVE1_ADDRESS, 1);
  n = Wire.read();
  Serial.print(F("recieved value : "));
  Serial.println(n);

  //Send value 12 to slave
  Wire.beginTransmission(I2C_SLAVE1_ADDRESS);
  Wire.write(12);
  Serial.print(F("sending value : "));
  Serial.println(12);
  Wire.endTransmission();

  Serial.print(" ");

  //Request value of n to slave after change
  Wire.requestFrom(I2C_SLAVE1_ADDRESS, 1);
  n = Wire.read();
  Serial.print(F(" new recieved value : "));
  Serial.println(n);
}


void loop()
{
  delay(100);
}

Código da placa Escrava

#include <Wire.h>

# define I2C_SLAVE_ADDRESS 11 // 12 pour l'esclave 2 et ainsi de suite

#define PAYLOAD_SIZE 2

void setup()
{
  Wire.begin(I2C_SLAVE_ADDRESS);
  Serial.begin(9600);
  Serial.println("-------------------------------------I am Slave1");
  delay(1000);
  Wire.onRequest(requestEvents);
  Wire.onReceive(receiveEvents);
}

void loop() {}

int n = 0;

void requestEvents()
{
  Serial.println(F("---> recieved request"));
  Serial.print(F("sending value : "));
  Serial.println(n);
  Wire.write(n);
}

void receiveEvents(int numBytes)
{
  Serial.println(F("---> recieved events"));
  n = Wire.read();
  Serial.print(numBytes);
  Serial.println(F("bytes recieved"));
  Serial.print(F("recieved value : "));
  Serial.println(n);
}



Abra o monitor serial das placas escravas antes do monitor da placa mestre.

No monitor serial da placa mestre:

No monitor serial da placa Escrava 1:

Podemos observar que as duas placas trocam informações. É muito simples estender este exemplo para diversas placas Arduino (Leonardo, Mini, etc.), adaptando-se as ligações e o endereço do componente no código escravo.

.

Código para identificar os periféricos conectados ao barramento I2C

Um bom teste para saber se os seus dispositivos comunicam-se bem entre si é utilizar o código abaixo (I2CScanner), que retorna os endereços de todos os dispositivos conectados à placa mestre.

#include <Wire.h>


void setup()
{
  Wire.begin();
  Serial.begin(9600);
  while (!Serial);             // Leonardo: wait for serial monitor
  Serial.println(F("\nI2C Scanner"));
}


void loop()
{
  byte error, address;
  int nDevices;

  Serial.println(F("Scanning..."));

  nDevices = 0;
  for (address = 1; address < 127; address++ )
  {
    // The i2c_scanner uses the return value of
    // the Write.endTransmisstion to see if
    // a device did acknowledge to the address.
    Wire.beginTransmission(address);
    error = Wire.endTransmission();


    if (error == 0)
    {
      Serial.print("I2C device found at address 0x");
      if (address < 16)
        Serial.print("0");
      Serial.print(address, HEX);
      Serial.println("  !");

      nDevices++;
    }
    else if (error == 4)
    {
      Serial.print("Unknown error at address 0x");
      if (address < 16)
        Serial.print("0");
      Serial.println(address, HEX);
    }
  }
  if (nDevices == 0)
    Serial.println(F("No I2C devices found\n"));
  else
    Serial.println(F("done\n"));

  delay(5000);           // wait 5 seconds for next scan
}

Se tiver qualquer dificuldade para estabelecer uma comunicação I2C entre diferentes dispositivos, deixe um comentário abaixo ou contacte-nos.

Fontes

Arduino e o Módulo Bluetooth HC-05

Arduino e o Módulo Bluetooth HC-05

O Arduino pode comunicar-se com outros dispositivos (Smartphone, computador ou algum outro microcontrolador) via conexão Bluetooth utilizando um módulo HC-05 (mestre/escravo). Desse modo, é possível conectar a sua placa Arduino a outros sistemas, para enviar e receber dados. A comunicação por Bluetooth possibilita, por exemplo, controlar o seu robô por meio de uma aplicação para Smartphone, exibir as medidas de um sensor no seu computador ou ainda permitir que outros robôs comuniquem-se entre si.

Leia antes: Comunicação Serial com Arduino

Equipamento:

  • Computador
  • 2 x placas Arduino UNO
  • 2 x cabos USB para conectar o Arduino ao computador
  • 2 x módulos Bluetooth HC-05 ZS-040 (ou 1 módulo HC-06 e 1 módulo HC-05)
  • Cabos Dupont M/F

Apresentação do módulo Bluetooth HC-05

O módulo Bluetooth HC-05 apresenta 6 pinos que permitem realizar a conexão.

  • VCC pino de alimentação. Tipicamente conectado ao pino 5V do Arduino.
  • GND terra. Tipicamente conectado ao pino GND do Arduino
  • RX pino de recepção. Tipicamente conectado ao pino de transmissão (TX) do Arduino
  • TX pino de transmissão. Tipicamente conectado ao pino de recepção (RX) do Arduino
  • Status retorna 1 quando o módulo é conectado
  • Key ou EN precisam estar alimentados para entrar no modo de configuração e não pode estar conectados para entrar em modo de comunicação.

A particularidade do módulo Bluetooth HC-05 é que pode ser utilizado em modo escravo (caso em que será equivalente a um módulo HC-06, com a mesma forma de utilização) ou em modo mestre, o que significa que pode conectar-se a um outro módulo Bluetooth (HC-06, HC-05 em modo escravo ou outro) de forma autônoma, sem ação externa.

Esquema de ligação para configuração


ATENÇÃO:

  • Utilizamos os pinos 2 e 3 para a comunicação serial com o Arduino UNO. Em função da placa escolhida, esses pinos podem ser incompatíveis com a comunicação SoftwareSerial. Em especial no caso das placas Mega, Micro e Leonardo. Verifique a documentação.
  • Como o nível lógico do módulo Bluetooth é 3,3V, recomendamos usar um divisor de tensão para reduzir a tensão de 5V do Arduino. (1k de resistência entre pin3 e Rx; 2k Ohm entre Rx e GND).

Configuração do módulo HC-05

A configuração do módulo Bluetooth pode ser interessante para verificar o seu funcionamento e para modificar os seus parâmetros, sobretudo se quiser utilizá-lo no modo master. O módulo deve estar alimentado, mas não emparelhado, e o pino Key/EN deve estar alimentado a 3V quando o módulo for aceso. Quando o módulo estiver em modo de configuração, o LED se acenderá por dois segundos a intervalos de dois segundos.

Abra o monitor serial do Arduino e certifique-se de que a opção de fim de linha esteja a exibir “Nova Linha”  e que a taxa de transferência esteja regulada a 9600.

Observe que o módulo Bluetooth HC-05 entra no modo AT com uma taxa de transferência (baud rate) de 38400 bps.

Código de configuração

Para gerir a comunicação com o módulo HC-05, utilizamos a biblioteca SoftwareSerial.h, que permite criar uma porta serial distinta da utilizada pela porta USB. O código abaixo permite modificar as configurações do módulo HC-05 (nome, código PIN, taxa de transmissão (baud rate), etc.) e localizar informações como o número da versão do firmware.

#include <SoftwareSerial.h>
#define rxPin 2
#define txPin 3
#define baudrate 38400

String msg;

SoftwareSerial hc05(rxPin ,txPin);

void setup(){
  pinMode(rxPin,INPUT);
  pinMode(txPin,OUTPUT);
  
  Serial.begin(9600);
  Serial.println("ENTER AT Commands:");
  hc05.begin(baudrate);
}

void loop(){
    readSerialPort();
    if(msg!="") hc05.println(msg);
    
    if (hc05.available()>0){
      Serial.write(hc05.read());
    }
}

void readSerialPort(){
  msg="";
 while (Serial.available()) {
   delay(10);  
   if (Serial.available() >0) {
     char c = Serial.read();  //gets one byte from serial buffer
     msg += c; //makes the string readString
   }
 }
}

Para uma boa comunicação, certifique-se de seleccionar a taxa de transmissão correta no monitor serial, bem como “nova linha” (NL) nas configurações de comunicação.

Comandos de configuração

Além da vantagem de poder se utilizado como módulo mestre, o módulo Bluetooth HC-05 também permite conhecer as configurações salvas.

Em geral, ao digitar no monitor serial AT+<command>?, obtém-se o valor registrado no módulo (ex: AT+PSWD? para descobrir o código PIN do módulo). Ao inserir a linha AT+<command>=<Param>, é possível definir um valor para o módulo (ex: AT+PWSD=0000 para alterar o código PIN para 0000).

Veja abaixo alguns comandos AT básicos:

  • Para testar a comunicação, digite AT no monitor serial da IDE do Arduino. Se tudo estiver bem, o módulo deverá responder OK.
  • Para verificar o nome do módulo, digite AT+NAME=<Param> no módulo. Ele deverá responder OK. (Ex: Para alterar o nome do módulo para BTM1, digite AT+NAME=BTM1)
  • Para alterar o código PIN do módulo, digite AT+PSWD=<Param> . O módulo deverá responder OK. (Ex: se quiser alterar o PIN para 0000, digite AT+PSWD=0000)
  • AT+ROLE=<Param> para modificar a função do módulo para mestre ou escravo (Ex: para transformar o módulo em mestre, AT+ROLE=1).
  • Para modificar a velocidade de transmissão do módulo (somente se necessário), digite AT+UART=<Param1>,<Param2>,<Param3>, sendo Param1, 2 e 3 as configurações de comunicação serial: o baud rate, o bit de parada e o bit de paridade, respectivamente. (Em modo padrão, 9600,0,0. Ex: se quiser alterar a taxa de transmissão para 115200, digite AT+UART=115200,0,0).

Veja outros comandos AT para o módulo Bluetooth HC-05 neste link.

ATENÇÃO: Existem diferentes versões do módulo HC-05 e a lista de comandos AT pode variar, assim como os procedimentos. Verifique o número de série marcado no módulo e a versão do firmware, digitando o comando AT+VERSION?. No nosso caso, o módulo HC-05 é da série ZS-040 e da versão 2.0-20100601.

N.B.: Se não funcionar, verifique a conexão e a condutividade dos cabos e a taxa de transmissão (baud rate).

Se tiver dificuldades para configurar o seu módulo Bluetooth HC-05, pode deixar um comentário abaixo.

Configuração do módulo escravo

Para o módulo escravo, pode alterar o nome digitando AT+NAME=HC05-Slave e escolher as configurações de comunicação e a senha que desejar. Certifique-se de que eles são iguais aos dos módulo master.

  • AT retorna OK
  • AT+NAME=HC05-Slave
  • AT+UART=9600,0,0
  • AT+ROLE=0
  • Insira AT+ADDR para obter o endereço do módulo escravo (no nosso caso, +ADDR:98d3:32:21450e)

Também é possível utilizar um módulo HC-06 como módulo escravo.

Configuração do módulo mestre

Para o módulo mestre, será preciso modificar a função do módulo e escolher as mesmas configurações de comunicação que para o módulo escravo.

  • AT retorna OK
  • AT+NAME=HC05-Master
  • AT+UART=9600,0,0
  • AT+ROLE=1
  • É preciso salvar o endereço do módulo escravo para que o módulo mestre consiga parear: AT+BIND=98d3,32,21450e (substitua os dois pontos “:” por vírgulas “,”)

Esquema de ligação para a comunicação

No modo de comunicação, o pino Key/EN não pode estar alimentado.

Código de comunicação

Com os módulos já configurados, poderá desconectar o pino Key ou EN, carregar os código abaixo nas suas placas Arduino e acender novamente o módulo HC-05 para entrar em modo de comunicação.

Assim como para o módulo HC-06, nós utilizamos a biblioteca SoftwareSerial.h. Aqui estão algumas das suas funções:

  • SoftwareSerial hc05(Rx,Tx) para definir a porta serial e os pinos que servirão para a comunicação
  • hc05.begin() para definir a taxa de transmissão
  • hc05.available() para verificar se os dados estão disponíveis no buffer da porta serial
  • hc05.read() para ler os dados da porta serial, um byte por vez
  • hc05.print() para enviar uma cadeia de caracteres em ASCII
  • hc05.write() para enviar dados, um byte por vez.
  • hc05.flush() para esvaziar os dados do buffer.

Código Mestre

#include <SoftwareSerial.h>

SoftwareSerial ArduinoSlave(2, 3);
String answer;
String msg;

void setup() {

  Serial.begin(9600);
  Serial.println("ENTER Commands:");
  ArduinoSlave.begin(9600);

}

void loop() {
  //Read command from monitor
  readSerialPort();

  //Read answer from slave
  while (ArduinoSlave.available()) {
    delay(10);
    if (ArduinoSlave.available() > 0) {
      char c = ArduinoSlave.read();  //gets one byte from serial buffer
      answer += c; //makes the string readString
    }
  }
  //Send data to slave
  if (msg != "") {
    Serial.print("Master sent : ");
    Serial.println(msg);
    ArduinoSlave.print(msg);
    msg = "";
  }
  //Send answer to monitor
  if (answer != "") {
    Serial.print("Slave recieved : ");
    Serial.println(answer);
    answer = "";
  }
}

void readSerialPort() {
  while (Serial.available()) {
    delay(10);
    if (Serial.available() > 0) {
      char c = Serial.read();  //gets one byte from serial buffer
      msg += c; //makes the string readString
    }
  }
  Serial.flush();
}

Código Escravo

#include <SoftwareSerial.h>

SoftwareSerial ArduinoMaster(2, 3);
String msg;

void setup() {
  Serial.begin(9600);
  ArduinoMaster.begin(9600);
}

void loop() {
  readSerialPort();

  // Send answer to master
  if (msg != "") {
    Serial.print("Master sent : " );
    Serial.println(msg);
    ArduinoMaster.print(msg);
    msg = "";
  }
}

void readSerialPort() {
  while (ArduinoMaster.available()) {
    delay(10);
    if (ArduinoMaster.available() > 0) {
      char c = ArduinoMaster.read();  //gets one byte from serial buffer
      msg += c; //makes the string readString
    }
  }
  ArduinoMaster.flush();
}




Ao abrir os dois monitores seriais correspondentes e digitar um comando no monitor da placa mestre, poderá ver o seguinte resultado: a placa mestre envia uma cadeia de caracteres que a placa escrava recebe e reenvia. Assim se verifica que a comunicação está a funcionar nos dois sentidos.

Se tiver dificuldade para configurar ou comunicar com o seu módulo Bluetooth HC-05, pode contactar-nos ou deixar um comentário.

Aplicação

E então, o que faria se a sua placa Arduino pudesse comunicar-se com outros sistemas? Escreva-nos um comentário.

Fontes

Arduino e o módulo Bluetooth HC-06

Arduino e o módulo Bluetooth HC-06

É possível comunicar com o seu Arduino via conexão Bluetooth utilizando o módulo HC-06 (escravo). Isso permite conectar a placa Arduino a um outro sistema (Smartphone, computador ou outros microcontroladores), para receber e enviar dados. A comunicação por Bluetooth permite, por exemplo, controlar o seu robô por meio de uma aplicação para Smartphone ou receber os valores de um sensor no seu computador.

Leia antes: Comunicação Serial com Arduino

Equipamento

  • Computador
  • Arduino UNO
  • Cabo USB para comunicar o Arduino ao computador
  • Módulo Bluetooth HC-06
  • Cabos Dupont M/F

Apresentação do módulo HC-06

module bluetooth hc06

O módulo Bluetooth HC-06 apresenta 4 pinos que permitem estabelecer a comunicação serial.

  • VCC pino de alimentação. Tipicamente conectado ao pino 5V do Arduino.
  • GND terra. Tipicamente conectado ao pino GND do Arduino
  • RX pino de recepção. Tipicamente conectado ao pino de transmissão (TX) do Arduino
  • TX pino de transmissão. Tipicamente conectado ao pino de recepção (RX) do Arduino

N.B.: Por tratar-se de um módulo escravo, o módulo HC-06 não pode conectar-se a outros dispositivos por si só. Para isso, é necessário usar um módulo mestre, como o módulo Bluetooth HC-05.

Esquema de ligação

arduino module hc06 schematics

Alguns módulos HC-06 funcionam em 3V3 e não suportam o nível de tensão de 5V no pino Rx. Neste caso, é necessária uma ponte divisora de tensão para converter o sinal lógico (resistência de 1k entre pin3 e Rx, e 2k Ohm entre Rx e GND).


ATENÇÃO: Utilizamos aqui os pinos 2 e 3 do Arduino UNO. Em função do microcontrolador utilizado, os pinos que servem para a comunicação SoftwareSerial podem ser diferentes. É o caso das placas Arduino Mega, Micro e Leonardo, especialmente. Verifique a documentação.

Configuração do módulo HC-06

A configuração do módulo Bluetooth pode ser interessante para testar o funcionamento do módulo e para modificar os seus parâmetros, sobretudo quando utilizamos diversos módulos. O módulo deve estar alimentado, mas não emparelhado (o LED deve piscar).

O código a seguir permite modificar o nome, o código PIN e a taxa de transmissão (baud rate) do módulo HC-06

#include <SoftwareSerial.h>

SoftwareSerial hc06(2, 3);

void setup() {
  //Initialize Serial Monitor
  Serial.begin(9600);
  Serial.println("ENTER AT Commands:");
  //Initialize Bluetooth Serial Port
  hc06.begin(9600);
}

void loop() {
  //Write data from HC06 to Serial Monitor
  if (hc06.available()) {
    Serial.write(hc06.read());
 }
  
  //Write from Serial Monitor to HC06
  if (Serial.available()) {
   hc06.write(Serial.read());
 }
}

Para testar a comunicação, digite AT no monitor serial da IDE do Arduino. Certifique-se de seleccionar o baud rate correto (9600) e “Não fim de linha” (“No end line”) nas opções de comunicação. Se tudo estiver bem, o módulo deverá responder OK. Se não funcionar, certifique-se de que o módulo esteja bem conectado e verifique a sua versão.

Para modificar o nome do módulo, digite AT+NAMEnom_module. O módulo deverá responder OKsetname. (Ex: se quiser alterar o nome do módulo para BTM1, digite AT+NAMEBTM1)

Para modificar o código PIN do módulo, digite AT+PINxxxx. O módulo deverá responder OKsetPIN. (Ex: se quiser alterar o PIN para 0000, digite AT+PIN0000)

Para alterar a taxa de transmissão do módulo (somente se necessário), digite AT+BAUDx. Ex: se quiser alterar a baud rate para 9600, digite AT+BAUD4. O módulo deverá responder OK9600. (Obs.: 1 parar 1200, 2 para 2400, 3 para 4800, 4 para 9600, 5 para 19200, 6 para 38400, 7 para 57600, 8 para 115200)

ATENÇÃO: Existem diferentes versões do módulo HC-06 e a lista de comandos AT pode variar. Verifique bem o número de série marcado no módulo e a versão do firmware com o comando AT+VERSION.

Por exemplo, o módulo HC-06 da série ZS-040 na versão 3.0-20170609 retorna ERROR(0) quando enviamos o comando AT+NAMExxxx (sendo xxxx o novo nome do módulo). Os comandos AT para este módulo são:

  • AT+NAME=xxxx para configurar o nome do módulo
  • AT+PSWD:”xxxx” para configurar a senha do módulo
  • AT+UART=115200,0,0 para configurar a taxa de transmissão

Se tiver dificuldade para configurar o seu módulo Bluetooth HC-06, pode deixar um comentário abaixo.

Emparelhamento

Feitas as configurações desejadas no módulo HC-06, poderá emparelhá-lo com o sistema que quiser, como faria com outro periférico Bluetooth qualquer. Seleccione o nome na lista dos periféricos detectados (no modo padrão: HC-06) e insira o código PIN que configurou anteriormente (no modo padrão: 1234). Isso feito, o LED do módulo deverá parar de piscar.

Código

Com o módulo emparelhado, poderá modificar o código a seguir para obter a funcionalidade desejada. No exemplo a seguir, supomos que uma aplicação enviará o comando ON ou OFF para o módulo Bluetooth para ativar uma função do código.

Para administrar o módulo HC-06, utilizamos a biblioteca SoftwareSerial.h, que gerencia as ligações seriais da placa Arduino. As funções importantes de se conhecer são:

  • SoftwareSerial hc06(Rx,Tx) para definir a porta serial e os pinos que servirão para a comunicação
  • hc06.begin() para definir a taxa de transmissão
  • hc06.available() para testar se os dados estão disponíveis no buffer da porta serial
  • hc06.read() para ler os dados da porta serial, um byte por vez
  • hc06.print() para enviar uma cadeia de caracteres em ASCII
  • hc06.write() para enviar dados, um byte por vez.
#include <SoftwareSerial.h>

SoftwareSerial hc06(2,3);

String cmd="";
float sensor_val=0;

void setup(){
  //Initialize Serial Monitor
  Serial.begin(9600);
  //Initialize Bluetooth Serial Port
  hc06.begin(9600);
}

void loop(){
  //Read data from HC06
  while(hc06.available()>0){
    cmd+=(char)hc06.read();
  }

  //Select function with cmd
  if(cmd!=""){
    Serial.print("Command recieved : ");
    Serial.println(cmd);
    // We expect ON or OFF from bluetooth
    if(cmd=="ON"){
        Serial.println("Function is on");
    }else if(cmd=="OFF"){
        Serial.println("Function is off");
    }else{
        Serial.println("Function is off by default");
    }
    cmd=""; //reset cmd
  }
  // Simulate sensor measurement
  sensor_val=(float)random(256); // random number between 0 and 255
    
  //Write sensor data to HC06
  hc06.print(sensor_val);
  delay(100);
}

Bônus: scan do baud rate

Se tiver dificuldade para encontrar a taxa de transmissão do seu módulo Bluetooth, aqui está um código que inicializa o módulo Bluetooth e envia o comando AT para cada valor de taxa de transmissão.

#include <SoftwareSerial.h>
SoftwareSerial hc06(2, 3);

void setup() {
  //Initialize Serial Monitor
  Serial.begin(9600);
  // scan
  scanBaudrate();
}

void loop() {}

void scanBaudrate() {
  unsigned long bauds[12] = {300, 1200, 2400, 4800, 9600, 19200, 38400, 57600, 74880, 115200, 230400, 250000};
  for (int i = 0; i < 12; i++) {
    hc06.begin(bauds[i]);
    delay(10);
    Serial.print(F("Baudrate "));
    Serial.println(bauds[i]);
    command("AT", 2000);

  }
}
String command(const char *toSend, unsigned long milliseconds) {
  String result;
  Serial.print("Sending: ");
  Serial.println(toSend);
  hc06.print(toSend);
  unsigned long startTime = millis();
  Serial.print(F("Received: "));
  while (millis() - startTime < milliseconds) {
    if (hc06.available()) {
      char c = hc06.read();
      Serial.write(c);
      result += c;  // append to the result string
    }
  }
  Serial.println();  // new line after timeout.
  return result;
}


Quando o baud rate estiver correto, o módulo Bluetooth deverá responder OK. Este código permite saber facilmente se o seu módulo está a funcionar e qual a taxa de transmissão utilizada.

Aplicação

Fontes

Retrouvez nos tutoriels et d’autres exemples dans notre générateur automatique de code
La Programmerie

A comunicação serial com Arduino

A comunicação serial com Arduino

A forma mais simples de comunicar com uma placa Arduino é através de um monitor serial, que é, aliás, a ferramenta mais potente para testar o seu programa e eliminar bugs. A comunicação serial também pode servir para trocar dados com outros dispositivos (Arduino, Raspberry ou outros).

Equipamento

  • Computador
  • 2 x placas Arduino UNO
  • 3 x cabos Jumper M/M

Comunicação via monitor serial

As funções de que vamos precisar são:

  • Serial.begin() permite configurar a taxa de transferência da porta serial. Se esta função estiver mal configurada, a comunicação não funcionará.
  • Serial.print() e Serial.println() permitem enviar cadeias de caracteres (String) para a porta serial. A segunda permite terminar o envio com uma quebra de linha.
  • Serial.write() permite enviar um byte de cada vez.
  • Serial.available() permite verificar se a porta serial recebeu os dados
  • Serial.read() permite receber os dados da porta serial

Carregue o código a seguir para testar a comunicação entre o computador e a placa Arduino.

char cmd="";
char old_cmd;
boolean enable=false;


void setup(){
  // Initialize serial port
  Serial.begin(9600);
  Serial.println("ENTER Commands:");        
}

void loop(){
  old_cmd=cmd;
  if (Serial.available()){ // Verify that data are available
    cmd=Serial.read();  // Read data on serial port
  } 
  
  if(cmd!=old_cmd){
    if(cmd=='O'){
      Serial.println("Set to ON"); // Send data to serial port
      enable=true;
    }else if(cmd=='F'){
      Serial.println("Set to OFF"); // Send data to serial port
      enable=false;
    }
  }

   if(enable){
      Serial.println("System is running");
      delay(200);
    }
}

Ao se digitar O e depois F na barra de comando do monitor serial, deverá aparecer isto:

Comunicação entre duas placas Arduino

É possível utilizar a porta de série (Rx0,Tx1) utilizada pela porta USB para comunicar entre duas placas Arduino. Para o fazer, basta ligar os pinos da seguinte forma

  • Arduino 1 Rx -> Arduino 2 Tx
  • Arduino 1 Tx -> Arduino 2 Rx
  • Arduino 1 GND -> Arduino 2 GND

CUIDADO: Se utilizar placas diferentes, os níveis de tensão podem não ser compatíveis. Neste caso, é necessário utilizar um conversor de voltagem. Verificar a documentação de cada quadro.

Como dissemos, os pinos 0 e 1 são utilizados pela porta USB. Para evitar conflitos com o monitor de série, vamos analisar a biblioteca SoftwareSerial que utiliza outros pinos do microcontrolador. Os exemplos seguintes também são possíveis com a porta de série do hardware. Só tem de substituir “ArduinoSlave” e “ArduinoMaster” por “Serial” nos seguintes códigos.

Em geral, as técnicas de intercâmbio de dados discutidas abaixo são aplicáveis a todas as comunicações em série.

Comunicação entre duas placas Arduino com SoftwareSerial

Também é possível comunicar entre diferentes sistemas utilizando uma porta serial. Um exemplo interessante é a comunicação entre duas placas Arduino. Para isso, é preciso escrever dois programas: um para a placa mestre (Master) e outro para a placa escrava (Slave).

Uma porta serial é definida por dois pinos e uma taxa de transferência. A biblioteca SoftwareSerial.h permite defini-la com facilidade. No nosso exemplo, escolhemos os pinos 2 e 3 (SoftwareSerial ArduinoSlave(2,3); ) e uma taxa de transferência de 9600bps (ArduinoSlave.begin(9600);).

ATENÇÃO: Utilizamos aqui os pinos 2 e 3 do Arduino UNO. Os pinos utilizados para a comunicação serial podem ser diferentes em função dos microcontrolador utilizado, em especial para as placas Arduino Mega, Micro, Leonardo. Verifique a documentação.

Para que as duas placas comuniquem entre si, é preciso ligá-las corretamente e não esquecer de ligar as terras (GND) como indicado no esquema a seguir.

Em geral, uma placa envia as informações e a outra as recebe. No nosso exemplo, verificamos que as duas placas se comunicam quando a placa escrava reenvia o que recebeu da placa mestre.

O que vem a seguir vale para qualquer comunicação serial! É possível transformar esta comunicação com fio numa comunicação sem fio com os módulos Bluetooth HC-06 e HC-05.

Código da placa Mestre

#include <SoftwareSerial.h>

SoftwareSerial ArduinoSlave(2,3);
char cmd="";
char old_cmd;
char answer="";
char old_answer;

void setup(){
  Serial.begin(9600);
  Serial.println("ENTER Commands:");
  ArduinoSlave.begin(9600);            
}

void loop(){
  old_cmd=cmd;
  old_answer=answer;
  //Read command from monitor
  if (Serial.available()){
    cmd=Serial.read();
  } 
  //Read answer from slave
  if (ArduinoSlave.available()){
    answer=ArduinoSlave.read();
  } 
  //Send data to slave
  if(cmd!=old_cmd){
    Serial.print("Master sent : ");
    Serial.println(cmd);
    ArduinoSlave.write(cmd);
  }
  //Send answer to monitor
  if(answer!=old_answer){
    Serial.print("Slave received : ");
    Serial.println(answer);
  }
}

Código da placa Escrava

#include <SoftwareSerial.h>

SoftwareSerial ArduinoMaster(2,3);
char cmd="";
char old_cmd;

void setup(){
  ArduinoMaster.begin(9600);    
}

void loop(){
  old_cmd=cmd;
  // Read data from master
  if (ArduinoMaster.available()){
    cmd=ArduinoMaster.read();
  } 
  // Send answer to master
  if(cmd!=old_cmd){
    ArduinoMaster.write(cmd);
  }
}

Digite o comando que desejar no monitor serial da placa mestre. A placa escrava deverá responder como na imagem abaixo.

Este código permite enviar um único byte por vez. Os caracteres são codificados em ASCII. Consulte a tabela ASCII para verificar como receber os seus dados. Alguns caracteres não podem ser enviados, como o sinal de grau “°” ou os acentos “é”, etc.

Sirva-se dos dados

Em alguns casos, será necessário enviar diversas informações e utilizar outros tipos de dados que não um inteiro ou um caractere. Uma solução que pode ajudar na maior parte dos casos é converter os dados em cadeias de caracteres e enviá-los com o auxílio da função print().

Código da placa Mestre

#include <SoftwareSerial.h>

SoftwareSerial ArduinoSlave(2,3);
String msg;

void setup(){

  Serial.begin(9600);
  Serial.println("ENTER Commands:");
  ArduinoSlave.begin(9600);
                
}

void loop(){
  //Read command from monitor
  readSerialPort();
  
  //Send data to slave
  if(msg!=""){
    Serial.print("Master sent : ");
    Serial.println(msg);
    ArduinoSlave.print(msg);
    msg="";
  }

}

void readSerialPort(){
 while (Serial.available()) {
   delay(10);  
   if (Serial.available() >0) {
     char c = Serial.read();  //gets one byte from serial buffer
     msg += c; //add to String
   }
 }
 Serial.flush(); //clean buffer
}

Código da placa Escrava

#include <SoftwareSerial.h>

SoftwareSerial ArduinoMaster(2,3);
String msg;

void setup(){
  Serial.begin(9600);
  ArduinoMaster.begin(9600);    
}

void loop(){
  readMasterPort();
  
  // Send answer to master
  if(msg!=""){
    ArduinoMaster.print(msg);
    Serial.print("Master sent : " );
    Serial.println(msg);
    msg=""; 
  }
}

void readMasterPort(){
 while (ArduinoMaster.available()) {
   delay(10); 
   if (ArduinoMaster.available() >0) {
     char c = ArduinoMaster.read();  //gets one byte from serial buffer
     msg += c; //makes the string readString
     Serial.println(msg);
   }
 }
 ArduinoMaster.flush();
}

O código a seguir permite enviar todo tipo de cadeia de caracteres.

Uma vez que a comunicação estiver estabelecida e as placas puderam trocar dados, é importante saber o que fazer em seguida.

Enviar e receber o valor de um sensor

Um bom exemplo de aplicação é variar o brilho de um LED conectado à placa escrava com o auxílio de um sensor conectado à placa mestre. Como captamos os dados na forma de String, é preciso convertê-los em inteiro. A função para realizar a conversão é atoi(). O valor de PWM do LED está compreendido entre 0 e 255, então é preciso converter o valor do sensor, compreendido entre 0 e 1023, com a função map().

Código da placa Mestre para ler e enviar o valor de um sensor

#include <SoftwareSerial.h>

SoftwareSerial ArduinoSlave(2,3);
String answer;
String msg;
int intVal=0,oldIntVal=0;

void setup(){

  Serial.begin(9600);
  Serial.println("ENTER Commands:");
  ArduinoSlave.begin(9600);
                
}

void loop(){
  //Read sensor
  intVal=analogRead(A0);
  //Read answer from slave
  readSlavePort();
  
  //Send data to slave
  if(oldIntVal!=intVal){
    Serial.print("Master sent : ");
    Serial.println(intVal);
    ArduinoSlave.print(intVal);
    oldIntVal=intVal; 
  }
  //Send answer to monitor
  if(answer!=""){
    Serial.print("Slave LED PWM value : ");
    Serial.println(answer);
    answer="";
  }
  delay(1000);
}

void readSlavePort(){
  while (ArduinoSlave.available()) {
   delay(10);  
   if (ArduinoSlave.available() >0) {
     char c = ArduinoSlave.read();  //gets one byte from serial buffer
     answer += c; //makes the string readString
   }
 }
}

Código da placa Escrava para receber e utilizar o valor de um sensor

#include <SoftwareSerial.h>

SoftwareSerial ArduinoMaster(2,3);

#define ledPin 11

String msg="";
int ledVal=0;
int intVal=0,oldIntVal=0;

void setup(){
  Serial.begin(9600);
  ArduinoMaster.begin(9600);
  pinMode(ledPin,OUTPUT);    
}

void loop(){
  readMasterPort();
  convertMsgToCmd();
  // Send answer to master
  if(intVal!=oldIntVal){
    Serial.print("Master sent : " );
    Serial.println(intVal);

    ledVal=map(intVal,0,1023,0,255);
    Serial.print("led value : ");
    Serial.println(ledVal);
    ArduinoMaster.print(ledVal);
    analogWrite(ledPin,ledVal);
    oldIntVal=intVal; 
  }
}

void readMasterPort(){
 while (ArduinoMaster.available()) {
   delay(10); 
   if (ArduinoMaster.available() >0) {
     char c = ArduinoMaster.read();  //gets one byte from serial buffer
     
     msg += c; //makes the string readString
   }
 }
 ArduinoMaster.flush();
}

void convertMsgToCmd(){
   if (msg.length() >0) {
    Serial.print("message length : ");
    Serial.println(msg.length());
    
     char carray1[6]; //magic needed to convert string to a number
     msg.toCharArray(carray1, sizeof(carray1));
     intVal = atoi(carray1);
     
     msg="";
 }
}

Enviar e receber dois valores de sensores

Para receber diferentes valores, a ideia é definir um separador. Neste caso, iremos utilizar o caractere “x”. Em seguida, basta localizar o caractere na cadeia por meio da funcão indexOf().

Código da placa Mestre para enviar dois valores diferentes

#include <SoftwareSerial.h>

SoftwareSerial ArduinoSlave(2,3);
String answer;
String msg;
int intVal1=0,oldIntVal1=0;
int intVal2=0,oldIntVal2=0;


void setup(){
  Serial.begin(9600);
  Serial.println("ENTER Commands:");
  ArduinoSlave.begin(9600);
                
}

void loop(){
  //Read sensors
  intVal1=analogRead(A0);
  intVal2=analogRead(A1);
  
  //Send data to slave
  if(oldIntVal1!=intVal1 || oldIntVal2!=intVal2 ){
    Serial.print("Master sent : ");
    Serial.print(intVal1);
    Serial.print("x");
    Serial.println(intVal2);
    
    ArduinoSlave.print(intVal1);
    ArduinoSlave.print("x");
    ArduinoSlave.print(intVal2);
    oldIntVal1=intVal1;
    oldIntVal2=intVal2;
  }
  delay(1000);
  //Read answer from slave
  readSlavePort();
  
  //Send answer to monitor
  if(answer!=""){
    Serial.println("Slave received : ");
    Serial.println(answer);
    answer="";
  }
  
}

void readSerialPort(){
 while (Serial.available()) {
   delay(10);  
   if (Serial.available() >0) {
     char c = Serial.read();  //gets one byte from serial buffer
     msg += c; //makes the string readString
   }
 }
 Serial.flush();
}

void readSlavePort(){
  while (ArduinoSlave.available()) {
   delay(10);  
   if (ArduinoSlave.available() >0) {
     char c = ArduinoSlave.read();  //gets one byte from serial buffer
     answer += c; //makes the string readString
   }
 }
}

Código da placa Escrava para receber dois valores diferentes

#include <SoftwareSerial.h>

SoftwareSerial ArduinoMaster(2,3);

String msg="",m1="",m2="";
int num1=-1,num2=-1;
int sep;

void setup(){
  Serial.begin(9600);
  ArduinoMaster.begin(9600);
}

void loop(){
  readMasterPort();
  convertMsgToMultiCmd();
  // Send answer to master
  if(num1!=-1 && num2!=-1){
    Serial.print("Sensor 1 : " );
    Serial.println(num1);

    Serial.print("Sensor 2 : " );
    Serial.println(num2);

    ArduinoMaster.print("Sensor 1 : " );
    ArduinoMaster.println(num1);

    ArduinoMaster.print("Sensor 2 : " );
    ArduinoMaster.println(num2);
    num1=-1;
    num2=-1;
  }
}

void readMasterPort(){
 while (ArduinoMaster.available()) {
   delay(10); 
   if (ArduinoMaster.available() >0) {
     char c = ArduinoMaster.read();  //gets one byte from serial buffer
     
     msg += c; //makes the string readString
   }
 }
 ArduinoMaster.flush();
}


void convertMsgToMultiCmd(){
   if (msg.length() >0) {
    Serial.print("message length : ");
    Serial.println(msg.length());
     sep = msg.indexOf('x');
     //Serial.println(sep);
     // expect a string like 0x0021 containing the two servo positions      
     m1 = msg.substring(0, sep); //get servo id
     m2 = msg.substring(sep+1, msg.length()); //get servo pos 
    
     char carray1[6]; //magic needed to convert string to a number
     m1.toCharArray(carray1, sizeof(carray1));
     num1 = atoi(carray1);
     
     char carray2[6];
     m2.toCharArray(carray2, sizeof(carray2));
     num2 = atoi(carray2);
      
     msg="";
 }
}

Enviar e receber diversos dados

Pode ser que a sua aplicação exija trocar diversos dados entre duas placas. Nesse caso, será preciso alterar um pouco a função de conversão. No nosso exemplo, supomos que o objectivo seja controlar o estado de um LED e a velocidade e a direção de um motor.

Código da placa Mestre para enviar diversos dados

#include <SoftwareSerial.h>

SoftwareSerial ArduinoSlave(2,3);
String answer;
String msg;
int intVal1=0,oldIntVal1=0;
int intVal2=0,oldIntVal2=0;


void setup(){

  Serial.begin(9600);
  Serial.println("ENTER Commands:");
  ArduinoSlave.begin(9600);
                
}

void loop(){
  //Read command from monitor
  readSerialPort();
 
  //Read answer from slave
  readSlavePort();
  
  //Send data to slave
  if(msg!=""){
    Serial.print("Master sent : ");
    Serial.println(msg);
    ArduinoSlave.print(msg);
    msg="";
  }
  
  //Send answer to monitor
  if(answer!=""){
    Serial.print("Slave received : ");
    Serial.println(answer);
    answer="";
  }
  delay(1000);
}

void readSerialPort(){
 while (Serial.available()) {
   delay(10);  
   if (Serial.available() >0) {
     char c = Serial.read();  //gets one byte from serial buffer
     msg += c; //makes the string readString
   }
 }
 Serial.flush();
}

void readSlavePort(){
  while (ArduinoSlave.available()) {
   delay(10);  
   if (ArduinoSlave.available() >0) {
     char c = ArduinoSlave.read();  //gets one byte from serial buffer
     answer += c; //makes the string readString
   }
 }
}

Código da carta Escrava para receber diversos dados

#include <SoftwareSerial.h>

SoftwareSerial ArduinoMaster(2,3);

String msg="";
int ledVal=0;
int sep;
String data[3];
unsigned int data_count=0;

void setup(){
  Serial.begin(9600);
  ArduinoMaster.begin(9600);
}

void loop(){
  readMasterPort();
  convertMsgToMultiCmd();

  //Use data
  if(data_count==3){
    for(int i=0;i<(data_count+1);i++){
      switch(i){
        case 0: //led status
          if(data[0]=="ON"){
            Serial.println("Switch led ON");
          }else if(data[0]=="OFF"){
            Serial.println("Switch led OFF");
          }else{
            Serial.println("Led wrong command");
          }
        break;
        case 1: //motor PWM
           Serial.print("Set motor power to : ");
           Serial.println(stringToInt(data[1]));
        break;
        case 2: //motor direction
           if(data[2]=="forward"){
            Serial.println("Motor direction forward");
          }else if(data[2]=="backward"){
            Serial.println("Motor direction backward");
          }else{
            Serial.println("Motor wrong command");
          }
        break;
        
      }
    }
    data_count=0;
  }
  
}

void readMasterPort(){
 while (ArduinoMaster.available()) {
   delay(10); 
   if (ArduinoMaster.available() >0) {
     char c = ArduinoMaster.read();  //gets one byte from serial buffer
     
     msg += c; //makes the string readString
   }
 }
 ArduinoMaster.flush();
}


void convertMsgToMultiCmd(){
  
   if (msg.length() >0) {
    data_count=0;
    Serial.print("Master sent : ");
    Serial.println(msg);//Serial.println(msg.length());
    do{
      sep = msg.indexOf('x');
       // expect a string like 0x0021 containing the two servo positions      
       String m1 = msg.substring(0, sep); //get servo id
       msg = msg.substring(sep+1, msg.length()); //get servo pos 
      data[data_count]=m1;
      data_count++;
    } while(sep!=-1);
    
    Serial.println("data received : "); 
    for(int i=0;i<(data_count+1);i++) Serial.println(data[i]); 
     msg="";
 }
}

int stringToInt(String s){
     char carray1[6]; //magic needed to convert string to a number
     s.toCharArray(carray1, sizeof(carray1));
     return atoi(carray1);
}

Quando os dados se comunicarem corretamente, basta converter as grandezas em inteiro, se necessário, e realizar as ações desejadas em função dos dados recebidos.

Com essas informações básicas, poderá comunicar com outros módulos como controladores seriais de servomotores, outros microcontroladores ou ainda módulos Bluetooth.

Se tiver dificuldade em estabelecer uma comunicação serial no seu projecto ou se gostaria de ver outros exemplos neste tutorial, deixe-nos um comentário ou contacte-nos por mensagem.

Aplicações

Fontes

Retrouvez nos tutoriels et d’autres exemples dans notre générateur automatique de code
La Programmerie