Comunicação Serial entre dois Arduinos Uno (não pelos pinos Tx e Rx)

Comunicação Serial, assíncrono serial, entre dois Arduinos Uno.

Referências para consulta:

* https://www.arduino.cc/en/Tutorial/SoftwareSerialExample

* https://learn.sparkfun.com/tutorials/serial-communication

* http://www.zonnepanelen.wouterlood.com/arduino-bare-basics/arduino-...

Explicando este experimento:

* Neste experimento são necessários dois Arduinos, o Arduino(1) e o Arduino(2)

*   o Arduino(1) envia o número '1' ou o número '2' para o Arduino(2).

*   o Arduino(2) responde para o Arduino(1) enviando a string de caracteres "blue" ou "red",

     respectivamente, se receber o '1' ou '2'.

*   o Arduino(1) recebe e imprime a resposta do Arduino(2) no Serial Monitor.

* Observação: como não utilizaremos os pinos nativos de comunicação serial dos Arduinos (1) e (2),

  pinos D0 e D1, será possível observar os dados enviados ou recebidos no Serial Monitor tanto

  do lado do Arduino(1) quanto do Arduino(2).

Pinagem entre os dois Arduinos Uno:

* Arduino(1) <==> Arduino(2)

* D10 (Rx)            D11 (Tx)

* D11 (Tx)             D10 (Rx)

* 5V                     Vin (se for alimentar o Arduino(2) através do Arduino(1))

* GND                  GND

Código (sketch) para o Arduino(1):

-------------------------------------------------------------------------------------------------------------------------------------------------

#include <SoftwareSerial.h>                      // incluir a biblioteca para comunicação Serial
#define rxPin 10                                       // define pino D10 como Rx
#define txPin 11                                       // define pino D11 como Tx
SoftwareSerial mySerial(rxPin, txPin);       // instanciar objeto de SoftwareSerial e definir que o pino

                                                             // D11 será Rx e o D10 será TX no Arduino(2)

byte outByte = 1;

void setup() {
  Serial.begin(9600);                                // definir velocidade de comunicação no Serial Monitor,

                                                             // necessário se quiser depurar este sketch

  pinMode (rxPin, INPUT);                        // definir modo do pino Rx
  pinMode (txPin, OUTPUT);                    // definir modo do pino Tx
  mySerial.begin(9600);                          // definir velocidade de comunicação na porta do

                                                            // SoftwareSerial

  mySerial.write(outByte);                       // enviar, inicialmente, o caracter 1 para o Arduino(2)
}

void loop() {
  if(mySerial.available() > 0) {                  // se dados disponíveis na porta SoftwareSerial
    delay(100);                                       // esperar todos os caracteres chegarem, vindos do

                                                           // Arduino(2)
    String xString="";                              // ou... criar uma string
    char inString[10];                              // ou... criar uma matriz de caracteres com 10 posições
    int k=0;

    while(mySerial.available() > 0) {
      inString[k] = mySerial.read();           // ou... atribuir o caracter recebido do Arduino(2) em uma

                                                           // nova posição da matriz
      xString += inString[k];                     // ou... concatenar o caracter recebido do Arduino(2)

                                                           // na string
      k++;                                              // incrementar o ponteiro da matriz para a próxima

                                                           // posição desocupada
      delay(50);
    }
    Serial.print("Enviado ==> ");
    Serial.print(outByte);
    Serial.print(". Resposta ==> ");
    for (int i=0; i < k; i++){                       // ou... imprimir cada caracter da matriz no Serial Monitor
      Serial.print(inString[i]);
    }
    Serial.print(" ");
    Serial.print(xString);                          // ou... imprimir a string no Serial Monitor
    Serial.println(".");

    delay(6000);

    if(outByte == 1){
      outByte = 2;
    }else{
      outByte = 1;
    }
    mySerial.write(outByte);                    // enviar o caracter 1 ou o 2 para o Arduino(2)
  }
}

-------------------------------------------------------------------------------------------------------------------------------------------------

Código (sketch) para o Arduino(2):

-------------------------------------------------------------------------------------------------------------------------------------------------

#include <SoftwareSerial.h>                  // incluir a biblioteca para comunicação Serial
#define rxPin 10                                   // define pino D10 como Rx
#define txPin 11                                   // define pino D11 como Tx
SoftwareSerial mySerial(rxPin, txPin);   // instanciar objeto de SoftwareSerial e definir que o

                                                         // pino D11 será Rx e o D10 será TX no Arduino(2)

void setup() {
  Serial.begin(9600);                            // definir velocidade de comunicação no Serial Monitor

  pinMode (rxPin, INPUT);                    // definir modo do pino Rx
  pinMode (txPin, OUTPUT);                // definir modo do pino Tx
  mySerial.begin(9600);                       // definir velocidade de comunicação na porta do

                                                        // SoftwareSerial

  Serial.print("Esperando caracter ==>");
}

void loop() {
  if(mySerial.available() > 0) {               // se dados disponíveis na porta SoftwareSerial
    byte inChar = mySerial.read();         // leia caracter recebido
    Serial.print(" \"");
    Serial.print(inChar);
    Serial.print("\" recebido.");

    switch(inChar){                               // responder ao Arduino(1) de acordo com o pedido feito,

                                                        // 1 ou 2
      case 1:
        mySerial.write("blue");                // .write() (o mesmo que .print()), enviar string "blue" para

                                                        // o Arduino(1) se o pedido foi o caracter '1'
        Serial.println(" Enviando \"blue\".");
        break;
      case 2:
        mySerial.print("red");                  // .print() (o mesmo que .write()), enviar string "red" para

                                                        // o Arduino(1) se o pedido foi o caracter '2'
        Serial.println(" Enviando \"red\".");
        break;
      default:
        mySerial.write("error");
        Serial.println(" Enviando \"error\".");
        break;
    }
    Serial.print("Esperando caracter ==>");
  }
}

--------------------------------------------------------------------------------------------------------------------------------------------------

Exibições: 4773

Responder esta

Respostas a este tópico

Analisando a comunicação SPI com o Saleae Logic16 Analyzer:

Observar no gráfico do Saleae Logic16, abaixo, que:

* quando não há comunicação entre os Arduinos, os Tx são mantidos em estado ALTO.

* quando o Arduino(1) inicia a comunicação com o Arduino(2), o Tx do Arduino(1) (linha no gráfico denominado Ard(1) Tx) é colocado em estado BAIXO daí enviando a série de bits, dentre eles aqueles que comporão o byte '1' ou '2' a serem enviados ao Arduino(2).

* logo em seguida, o Arduino(2) (linha no gráfico denominado Ard(2) Tx) envia a sequência de caracteres que comporão as strings 'red' ou 'blue' como resposta ao Arduino(1)

No Serial Monitor do Arduino(1) você verá o seguinte resultado...

RSS

© 2024   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço