Roteiro de Teste de Funcionamento do Módulo conversor TTL para RS485 Arduino

O Módulo conversor TTL para RS485 é um módulo utilizado para conversão de dados TTL para o protocolo RS485, ou RS485 para TTL. No contexto da utilização do módulo junto a embarcados como Arduino, o módulo se mostra bastante eficiente, permitindo a conexão de vários periféricos conectados ao sistema, podendo atuar com vários escravos em uma conexão, juntamente a uma alta velocidade de transmissão de dados. Além de atuar com grande performance em ambientes ruidosos e de longas distâncias.

O Módulo conversor TTL para RS485 Arduino é amplamente utilizado em aplicações em que são necessárias a transmissão de comunicação de um Arduino em linguagem TTL para um protocolo RS485, ou vice e versa, podendo atuar em aplicações de controle industrial e sistemas de automação.

Principais elementos que compõe o Módulo conversor TTL para RS485 Arduino

 Pino VCC – +5V Alimentação Positiva

 Pino B – Inversor da Entrada do Receptor e a Saída do Driver

 Pino A – Entrada do Receptor Não Inversor e Saída do Driver

 GND – Terra

 Borne Comum a A e B – Pontos A e B comum aos pinos A e B

 LED Indicador – Led Indicador de funcionamento

 DI – Entrada do Driver

 DE – Ativação da Saída do Driver

 RE – Habilitação de Saída do Receptor

 RO – Saída do Receptor

 Chip MAX485 – Chip conversor TTL para RS485, composto

Diagrama eletrônico dos Módulos conversores TTL para RS485, conectados como emissor e receptor respectivamente

Conexão Módulo Emissor

Pino VCC Módulo Emissor conectado ao 5V

Pino B Módulo Emissor conectado ao B do Módulo Receptor

Pino A Módulo Emissor conectado ao A do Módulo Receptor

Pino GND Módulo Emissor conectado ao GND

Pino RO Módulo Emissor conectado ao Pino 10 Arduino Emissor

Pino RE e DE do Módulo Emissor conectados ao Pino 3 Arduino Emissor

Pino DI Módulo Emissor conectados ao Pino 11 Arduino Emissor

Pino A0 Arduino Emissor conectado ao pino 1 do botão, o pino 2 do botão no GND

Conexão Módulo Receptor

Pino VCC Módulo Receptor conectado ao 5V

Pino B Módulo Receptor conectado ao B do Módulo Emissor

Pino A Módulo Receptor conectado ao A do Módulo Emissor

Pino GND Módulo Receptor conectado ao GND

Pino RO Módulo Receptor conectado ao Pino 10 Arduino Receptor

Pino RE e DE Módulo Receptor conectados ao Pino 3 Arduino Receptor

Pino DI Módulo Receptor conectados ao Pino 11 Arduino Receptor

Pino GND Arduino Receptor conectado ao GND Arduino Emissor

Compilação do código para o Emissor

Para utilização do Módulo conversor TTL para RS485 Arduino como Emissor, conecte o cabo de comunicação do Arduino Emissor com o computador, e em seguida copie o software “Emissor” disponibilizado na descrição do vídeo ou e em “Roteiro de Teste de funcionamento Módulo conversor TTL para RS485”; cole o software na IDE do Arduino e compile-o para o Arduino Emissor, como na imagem a seguir.

Abra o monitor Serial, e pressione o Botão para enviar os dados ao receptor. A mensagem “Botão pressionado. Enviando dados!” será exibida.

Compilação do código para o Receptor

Os dados de botão pressionado serão enviados ao receptor, porém, como ainda não compilamos o código para ele, nada será recebido. Para recebimento, iremos compilar o código “RECEPTOR” para o Arduino receptor, de modo que ele possa receber os dados por meio do Módulo Receptor conversor TTL para RS485.  Para isso, vamos alimentar o Arduino emissor com uma fonte externa. E colocaremos o cabo de interface entre o Arduino Receptor e o computador, para a transferência do software para o receptor, e análise do recebimento do sinal emitido pelo Botão.

Abra o monitor Serial do programa compilado para o Receptor, e pressione o Botão conectado ao emissor para enviar os dados ao receptor. A mensagem “Botão pressionado. Recebendo Dados” será exibida, comprovando a comunicação entre Emissor e Receptor, com atuação dos Módulos conversores TTL para RS485.

Softwares RECEPTOR e EMISSOR

Software RECEPTOR:
 

/*************** Eletrodex Eletrônica ******************
Teste Conversor TTL para RS485 Arduino - RECEPTOR
******************************************************/

#include

//Pinos de comunicacao serial do modulo RS485
#define Pino_RS485_RX 10
#define Pino_RS485_TX 11

//Pino de controle transmissao/recepcao
#define SerialTxControle 3

#define RS485Emissor HIGH
#define RS485Receptor LOW

//Define led 13 para mostrar atividade na comunicacao
#define Pin13LED 13

//Cria a serial por sofware para conexao com modulo RS485
SoftwareSerial RS485Serial(Pino_RS485_RX, Pino_RS485_TX);

//Armazena os dados que chegam pela serial
String inputString = "";
//Variavel de string completa
boolean stringComplete = false;

void setup()
{
//Inicializa a serial do Arduino
Serial.begin(9600);
Serial.println(" -------------- ELETRODEX ELETRÔNICA --------------");
Serial.println("Teste Módulo conversor TTL para RS485 Arduino");
Serial.println("Aguardando dados do Emissor...");
Serial.println("Pressione o Botão...");

pinMode(Pin13LED, OUTPUT);

pinMode(SerialTxControle, OUTPUT);

  //Coloca o modulo RS485 em modo de recepcao
  digitalWrite(SerialTxControle, RS485Receptor);

  //Inicializa a serial do modulo RS485
  RS485Serial.begin(4800);
}

void loop()
{
  //Recebe os dados do RS485 via porta serial
  if (RS485Serial.available())
  {
    while (RS485Serial.available())
    {
      //Recebe os dados e monta a string
      char inChar = (char)RS485Serial.read();
      inputString += inChar;
      
      if (inChar == 'n')
      {
        //Mostra no Serial Monitor a string recebida
        Serial.print(inputString);
        stringComplete = true;
        inputString = "";
      }
    }
  }
}

Software EMISSOR:

/*************** Eletrodex Eletrônica ******************
Teste Conversor TTL para RS485 Arduino - EMISSOR
******************************************************/

#include

//Pinos de comunicacao serial do modulo RS485
#define Pino_RS485_RX 10
#define Pino_RS485_TX 11

//Pino de controle Emissao/recepcao
#define SerialTxControle 3

#define RS485Emit HIGH
#define RS485Receber LOW

//Define led 13 para mostrar atividade na comunicacao
#define Pin13LED 13

//Cria a serial por sofware para conexao com modulo RS485
SoftwareSerial RS485Serial(Pino_RS485_RX, Pino_RS485_TX);

void setup()
{
//Inicializa a serial do Arduino
Serial.begin(9600);
Serial.println(" -------------- ELETRODEX ELETRÔNICA --------------");
Serial.println("Teste Módulo conversor TTL para RS485 Arduino");
Serial.println("Pressione o botao para enviar os dados...");

pinMode(Pin13LED, OUTPUT);
pinMode(SerialTxControle, OUTPUT);

//Inicializa a serial do modulo RS485
RS485Serial.begin(4800);

//Seta o pino A0 como entrada e habilita o pull up
pinMode(A0, INPUT_PULLUP);
}

void loop()
{
//Verifica se o botao foi pressionado
int valor = digitalRead(A0);
if (valor == 0)
{
Serial.println("Botao pressionado. Enviando dados!");

//Habilita o modulo para transmissao
digitalWrite(SerialTxControle, RS485Emit);

//Envia a string
RS485Serial.println("Botao pressionado. Recebendo Dados");

//Liga o led 13 para mostrar que ha conexao
digitalWrite(Pin13LED, HIGH);
delay(10);
digitalWrite(Pin13LED, LOW);

//Desabilita o modulo para transmissao
digitalWrite(SerialTxControle, RS485Receber);
while (digitalRead(A0) == 0)
{
delay(50);
}
}
}

Produtos utilizados:

• Módulo Driver p/ Motores Ponte-H Dupla L298
• Arduino UNO R3 + Cabo USB
• Motor DC 5,9V RF-300CA

Figura 1 : Apresentação do Módulo Driver p/ Motores Ponte-H Dupla L298

• Motor A e Motor B : Os bornes de Motor A e Motor B são referentes a conexão dos motores, podendo ser dois motores de corrente contínua (DC) ou um motor de passo que atue dentro da tensão máxima imposta pela placa de 12V.
• 5VEN: O Módulo Driver p/ Motores Ponte-H Dupla L298 possui um regulador de tensão que permite ao driver uma operação segura sem risco de sobretensões, e permite também a alimentação de outros componentes dependendo da configuração escolhida:
• 5VEN atuando na configuração 5V: A configuração de “5VEN” com alimentação 5V, só é indicada para controle de motores de até 5V. Deve-se manter o Jumper referente à “5VEN” conectado para o funcionamento do módulo como no teste de funcionamento demonstrado no vídeo “Teste básico do Módulo Driver p/ Motores Ponte-H Dupla L298, com dois motores DC”. Para visualização do vídeo com o teste de funcionamento do módulo utilizando essa configuração clique aqui! O demonstrativo do esquema eletrônico de 5VEN atuando na configuração 5V, pode ser visto na figura 2.
• 5VEN atuando na configuração 12V: Na configuração com alimentação em 12V, deve-se manter o Jumper referente à “5VEN” conectado para que seja ativado o regulador de tensão. Esse regulador de tensão atua regulando a tensão de entrada de 12V para a tensão de alimentação lógica suportada pelo chip (≤ 7Vdc), impedindo que ocorram danos  por sobretensão; além de proporcionar uma saída regulada de 5V  no pino “5VEN” para que o mesmo possa alimentar outros componentes. Um demonstrativo do esquema eletrônico de 5VEN atuando na configuração 12V, pode ser visto na figura 3.

ENA e ENB: Os pinos referentes a ENA e ENB podem ser utilizados juntamente com os pinos PWM do arduíno se necessário. Eles são responsáveis pelo controle  PWM dos motores, e estão interligados diretamente aos 5V. Para efetuar o controle de velocidade, deve-se retirar os Jumperes.

Entradas IN: O Módulo Driver p/ Motores Ponte-H Dupla L298 possui um barramento de 4 entradas sendo elas IN1, IN2, IN3 e IN4. Essas entradas são referentes a rotação dos motores A e B, sendo as entradas IN1 e IN2 referente ao Motor A, e IN3 e IN4 referente ao Motor B.  As tabelas à seguir demontram os comandos de ativação dos motores A e B por meio dos pinos de entrada:

Esquema eletrônico do Módulo Driver p/ Motores Ponte-H Dupla L298, nas configurações 5V e 12V:

• Esquema eletrônico na configuração de 5V:

Figura 2: Demonstrativo do esquema eletrônico de 5VEN atuando na configuração 5V.

• Esquema eletrônico na configuração de 12V:

Figura 3: Demonstrativo do esquema eletrônico de 5VEN atuando na configuração 12V.

Software de funcionamento Módulo Driver p/ Motores Ponte-H Dupla L298 :

• 
/*
_____________________________________________________________________________________________________
****************************************Eletrodex Eletrônica**************************************Teste básico do Módulo Driver p/ Motores Ponte-H Dupla L298, com dois motores DCFuncionamento do programa Primeiro o motor A é ativado girando no sentido horário, logo depois o motor A é pausado, e o Motor B gira no sentido horário e pausa. Em seguida, o motor A é ativado girando no sentido anti-horário, e logo o mesmo é pausado, e o motor B inicia sua rotação em sentido anti-horário e pausa. Assim, o processo fica em Loop entre os dois motores, indo de sentido horário para freio e ativação do sentido anti-horário. *///Pinos do Arduino ligados a entrada da Ponte H
  int IN1 = 4;
  int IN2 = 5;
  int IN3 = 6;
  int IN4 = 7;void setup()
  {
  //Definindo os pinos como saida
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);
  }void loop()
  {
  //Gira o Motor A no sentido horário
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, LOW);
  delay(2000);
  //Freia o motor A
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, HIGH);
  delay(500);
  //Gira o Motor B no sentido horário
  digitalWrite(IN3, HIGH);
  digitalWrite(IN4, LOW);
  delay(2000);
  //Freia o motor B
  digitalWrite(IN3, HIGH);
  digitalWrite(IN4, HIGH);
  delay(500);//Gira o Motor A no sentido anti-horário
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, HIGH);
  delay(2000);
  //Freia o motor A
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, HIGH);
  delay(500);
  //Gira o Motor B no sentido anti-horario
  digitalWrite(IN3, LOW);
  digitalWrite(IN4, HIGH);
  delay(2000);
  //Freia o motor B
  digitalWrite(IN3, HIGH);
  digitalWrite(IN4, HIGH);
  delay(500);
  }

Descrição dos Pinos:

GPIO (GPB0 à GPB7) e (GPA0 à GPA7) – São pinos multifunção, podendo ser configurados como INPUT ou OUTPUT individualmente

CS – Chip Select (habilitar transferência de dados)

SCK – Relógio Serial (sinal do relógio do microcontrolador)

SI: MOSI – Saída Mestre, Entrada Escravo (saída do microcontrolador, entrada MCP23S17)

SO: MISO – Entrada Master, Saída Slave (entrada do microcontrolador, saída MCP23S17)

INTA – Pino de interrupção do barramento A

INTB – Pino de interrupção do barramento B

A2, A1 e A0 – Pinos de configuração do endereço do dispositivo.

 A transferência de dados é feita via linhas MOSI e MISO, sendo a linha MOSI utilizada para a transferência de dados do microcontrolador para o expansor de porta, enquanto a linha MISO é utilizada para transferência de dados do expansor de porta para o microcontrolador. O microcontrolador inicia a transferência de dados quando o pino CS é colocado em nível baixo (0) enviando um sinal de clock (SCK).

 

 

Teste de Funcionamento do MCP23S17 – Módulo Expansor Bidirecional 16 bits:

Acesse a página do produto clicando aqui: MCP23S17 – Módulo Expansor Bidirecional 16 bits

 Diagrama eletrônico do teste de funcionamento do Módulo MCP23S17-E/SO com Arduino

Conexões Módulo MCP23S17-E/SO ao Arduino:

Pino VCC do Módulo MCP23S17 = 5V podendo ser alimentado com o próprio VCC ou 5V do Arduino UNO

Pino GND do Módulo MCP23S17 ao GND Arduino UNO

Pino CS do Módulo MCP23S17 ao SPI CS (Uno 10)

Pino SCK do MCP23S17 ao SPI SCK (Uno 13)

Pino SI do Módulo MCP23S17 ao SPI MOSI (Uno 11)

Pino SO do Módulo MCP23S17 ao SPI MISO (Uno 12)

Pino A0, A1, A2 do Módulo MCP23S17 ao GND

Pino RESET do Módulo MCP23S17 através de um resistor de ~10kohm a VCC

Pino A0 (GPA0) do Módulo MCP23S17 ao botão, o outro lado, ao terra

A0 é o pino 0 do barramento A para programação

Pino A1 (GPA1) do Módulo MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

A1 é o pino 1 do barramento A para programação

Pino A2 (GPA2) do Módulo MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

A2 é o pino 2 do barramento A para programação

Pino A3 (GPA3) do Módulo MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

A3 é o pino 3 do barramento A para programação

Pino A4 (GPA4) do Módulo MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

A4 é o pino 4 do barramento A para programação

Pino A5 (GPA5) do Módulo MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

A5 é o pino 5 do barramento A para programação

Pino A6 (GPA6) do Módulo MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

A6 é o pino 6 do barramento A para programação

Pino A7 (GPA7) do Módulo MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

A7 é o pino 7 do barramento A para programação

Pino B0 (GPB0) do Módulo MCP23S17 ao botão, o outro lado ao terra 

BO é o pino 8 do barramento B para programação

Pino B1 (GPB1) do Módulo MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

B1 é o pino 9 do barramento B para programação

Pino B2 (GPB2) do Módulo MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

B2 é o pino 10 do barramento B para programação

Pino B3 (GPB3) do Módulo MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

B3 é o pino 11 do barramento B para programação

Pino B4 (GPB4) do Módulo MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

B4 é o pino 12 do barramento B para programação

Pino B5 (GPB5) do Módulo MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

B5 é o pino 13 do barramento B para programação

Pino B6 (GPB6) do Módulo MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

B6 é o pino 14 do barramento B para programação

Pino B7 (GPB7) do Módulo MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

B7 é o pino 15 do barramento B para programação

 Diagrama eletrônico do teste de funcionamento do Circuito Integrado MCP23S17-E/SO com Arduino

Conexões CI MCP23S17-E/SO ao Arduino:

Pino Vdd MCP23S17 = 5V podendo ser alimentado com o próprio VCC ou 5V do microcontrolador Arduino

Pino nº 9 (Vdd) do MCP23S17 ao VCC ou 5V do microcontrolador Arduino UNO

Pino nº 10 (Vss) do MCP23S17 ao GND do microcontrolador Arduino UNO

Pino nº 11 (CS) do MCP23S17 ao SPI CS (Uno 10)

Pino nº 12 (SCK) do MCP23S17 ao SPI SCK (Uno 13)

Pino nº 13 (SI) do MCP23S17 ao SPI MOSI (Uno 11)

Pino nº 14 (SO) do MCP23S17 ao SPI MISO (Uno 12)

Pino nº 15, 16 e 17 (A0,A1,A2) do MCP23S17 ao GND

Pino nº 18 (RESET) do MCP23S17 através de um resistor de ~10kohm a Vcc

Pino nº 21 (GPA0) do MCP23S17 ao botão, o outro lado ao terra

GPA0 é o pino 0 do barramento A para programação

Pino nº 22 (GPA1) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

GPA1 é o pino 1 do barramento A para programação

Pino nº 23 (GPA2) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

GPA2 é o pino 2 do barramento A para programação

Pino nº 24 (GPA3) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

GPA3 é o pino 3 do barramento A para programação

Pino nº 25 (GPA4) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

GPA4 é o pino 4 do barramento A para programação

Pino nº 26 (GPA5) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

GPA5 é o pino 5 do barramento A para programação

Pino nº 27 (GPA6) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

GPA6 é o pino 6 do barramento A para programação

Pino nº 28 (GPA7) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

GPA7 é o pino 7 do barramento A para programação

Pino nº 1 (GPB0) do MCP23S17 ao botão, o outro lado ao terra

GPB0 é o pino 8 do barramento B para programação

Pino nº 2 (GPB1) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

GPB1 é o pino 9 do barramento B para programação

Pino nº 3 (GPB2) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

GPB2 é o pino 10 do barramento B para programação

Pino nº 4 (GPB3) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

GPB3 é o pino 11 do barramento B para programação

Pino nº 5 (GPB4) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

GPB4 é o pino 12 do barramento B para programação

Pino nº 6 (GPB5) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

GPB5 é o pino 13 do barramento B para programação

Pino nº 7 (GPB6) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

GPB6 é o pino 14 do barramento B para programação

Pino nº 8 (GPB7) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

Para mais informações, acesse o datasheet clicando aqui!

Software de funcionamento:

/* ===================================================================================================================== 

                                      ELETRODEX ELETRÔNICA  Teste MCP23S17 

   ===================================================================================================================== 

   Para funcionamento definimos como entrada os pinos 0 e 8, sendo o 0 o acionamento por botão 

   do banco A e o 8, o acionamento por botão do Banco B. 

    Pino Vdd MCP23S17 = 5V podendo ser alimentado com o próprio microcontrolador (Vcc) 

   Pino nº 9 (Vdd) do MCP23S17 a Vcc (alimentação do IC) 

   Pino nº 10 (Vss) do MCP23S17 ao terra (terra do IC) 

   Pino nº nº 11 (CS) do MCP23S17 ao SPI CS (Uno 10) 

   Pino nº 12 (SCK) do MCP23S17 ao SPI SCK (Uno 13) 

   Pino nº pino nº 13 (SI) do MCP23S17 ao SPI MOSI (Uno 11) 

   Pino nº pino nº 14 (SO) do MCP23S17 ao SPI MISO (Uno 12) 

   Pino nº pinos 15, 16 e 17 (A0,A1,A2) do MCP23S17 ao terra 

   Pino nº pino 18 (RESET) do MCP23S17 através de um resistor de ~10kohm a Vcc 

   Pino nº pino 21 (GPA0) do MCP23S17 ao botão, o outro lado ao terra | GPA0 é o pino 0 do barramento A para programação 

   Pino nº pino 22 (GPA1) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm | GPA1 é o pino 1 do barramento A para programação 

   Pino nº pino 23 (GPA2) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm | GPA2 é o pino 2 do barramento A para programação 

   Pino nº pino 24 (GPA3) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm | GPA3 é o pino 3 do barramento A para programação 

   Pino nº pino 25 (GPA4) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm | GPA4 é o pino 4 do barramento A para programação 

   Pino nº pino 26 (GPA5) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm | GPA5 é o pino 5 do barramento A para programação 

   Pino nº pino 27 (GPA6) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm | GPA6 é o pino 6 do barramento A para programação 

   Pino nº pino 28 (GPA7) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm | GPA7 é o pino 7 do barramento A para programação 

   Pino nº pino 1 (GPB0) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm | GPBO é o pino 1 do barramento B para programação 

   Pino nº pino 2 (GPB1) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm | GPB1 é o pino 2 do barramento B para programação 

   Pino nº pino 3 (GPB2) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm | GPB2 é o pino 3 do barramento B para programação 

   Pino nº pino 4 (GPB3) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm | GPB3 é o pino 4 do barramento B para programação 

   Pino nº pino 5 (GPB4) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm | GPB4 é o pino 5 do barramento B para programação 

   Pino nº pino 6 (GPB5) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm | GPB5 é o pino 6 do barramento B para programação 

   Pino nº pino 7 (GPB6) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm | GPB6 é o pino 7 do barramento B para programação 

   Pino nº pino 8 (GPB7) do MCP23S17 aao botão, o outro lado ao terra | GPA0 é o pino 8 do barramento B para programação 

*/ 

#include           // Arduino SPI library 

#include      // Majenko MCP23S17 Library 

 

const uint8_t chipSelect = 10; 

MCP23S17 BancoA(&SPI, chipSelect, 0);    // usando endereço padrão 0 

MCP23S17 BancoB(&SPI, chipSelect, 0);    // usando endereço padrão 0 

 

//=================================================================================================================== 

//  Iniciando 

//=================================================================================================================== 

  void setup() { 

  BancoA.begin();            // usando endereço padrão 0 

  BancoB.begin();            // usando endereço padrão 1 

  BancoA.pinMode(0, INPUT_PULLUP);  // Botão de entrada entrada 

  BancoB.pinMode(8, INPUT_PULLUP);  // Botão de entrada entrada 

  BancoA.pinMode(1, OUTPUT); // LED1 de saída 

  BancoA.pinMode(2, OUTPUT); // LED2 de saída 

  BancoA.pinMode(3, OUTPUT); // LED3 de saída 

  BancoA.pinMode(4, OUTPUT); // LED4 de saída 

  BancoA.pinMode(5, OUTPUT); // LED5 de saída 

  BancoA.pinMode(6, OUTPUT); // LED6 de saída 

  BancoA.pinMode(7, OUTPUT); // LED7 de saída 

  BancoB.pinMode(9, OUTPUT); // LED8 de saída 

  BancoB.pinMode(10, OUTPUT); // LED9 de saída 

  BancoB.pinMode(11, OUTPUT); // LED10 de saída 

  BancoB.pinMode(12, OUTPUT); // LED12 de saída 

  BancoB.pinMode(13, OUTPUT); // LED13 de saída 

  BancoB.pinMode(14, OUTPUT); // LED14 de saída 

  BancoB.pinMode(15, OUTPUT); // LED15 de saída 


 Serial.begin(9600); 

 Serial.print(" TESTE MCP23S17 "); 

} 


void loop() { 

  int BotaoA = 0; 

  int BotaoB = 8; 

 
 BotaoA = BancoA.digitalRead(0); 

 BotaoB = BancoB.digitalRead(8); 

 
//CONDIÇÃO BANCO A 

  if (BotaoA == 0)  // Se botão pressionado 

   { BancoA.digitalWrite(1, LOW);  // Acende LED 1 

    //Serial.println("LED1 LIGADO"); 

    BancoA.digitalWrite(2, LOW);  // Acende LED 2 

    //Serial.println("LED2 LIGADO"); 

    BancoA.digitalWrite(3, LOW);  // Acende LED 3 

    //Serial.println("LED3 LIGADO"); 

     BancoA.digitalWrite(4, LOW);  // Acende LED 4 

    //Serial.println("LED3 LIGADO"); 

     BancoA.digitalWrite(5, LOW);  // Acende LED 5 

    //Serial.println("LED3 LIGADO"); 

     BancoA.digitalWrite(6, LOW);  // Acende LED 6 

    //Serial.println("LED3 LIGADO"); 

     BancoA.digitalWrite(7, LOW);  // Acende LED 7 

    //Serial.println("LED3 LIGADO"); 

    Serial.println("Botão Banco A pressionado, LED's Banco A acionados"); 
  
    } 

  else 

   { BancoA.digitalWrite(1, HIGH); // Apaga LED 1 

   //Serial.println("LED1 APAGADO"); 

   BancoA.digitalWrite(2, HIGH);  // Apaga LED 2 

   //Serial.println("LED2 LIGADO"); 

   BancoA.digitalWrite(3, HIGH);  // Apaga LED 3 

   //Serial.println("LED3 LIGADO"); 

   BancoA.digitalWrite(4, HIGH);  // Apaga LED 4 

   //Serial.println("LED4 LIGADO"); 

   BancoA.digitalWrite(5, HIGH);  // Apaga LED 5 

   //Serial.println("LED5 LIGADO"); 

   BancoA.digitalWrite(6, HIGH);  // Apaga LED 6 

   //Serial.println("LED6 LIGADO"); 

   BancoA.digitalWrite(7, HIGH);  // Apaga LED 7 

   //Serial.println("LED's Banco A Apagados"); 

   delay(100);} 
 
//CONDIÇÃO BANCO B 

      if (BotaoB == 0)  // Se botão pressionado 

   { BancoB.digitalWrite(9, LOW);  // Acende LED 1 

   BancoB.digitalWrite(10, LOW);  // Acende LED 2 

   BancoB.digitalWrite(11, LOW);  // Acende LED 3 

   BancoB.digitalWrite(12, LOW);  // Acende LED 4 

   BancoB.digitalWrite(13, LOW);  // Acende LED 5 

   BancoB.digitalWrite(14, LOW);  // Acende LED 6 

   BancoB.digitalWrite(15, LOW);  // Acende LED 7 

   Serial.println("Botão Banco B pressionado, LED's Banco B acionados");} 

   else{ 

   BancoB.digitalWrite(9, HIGH); // Apaga LED 1 

   BancoB.digitalWrite(10, HIGH); // Apaga LED 2 

   BancoB.digitalWrite(11, HIGH); // Apaga LED 3 

   BancoB.digitalWrite(12, HIGH); // Apaga LED 4 

   BancoB.digitalWrite(13, HIGH); // Apaga LED 5 

   BancoB.digitalWrite(14, HIGH); // Apaga LED 6 

   BancoB.digitalWrite(15, HIGH); // Apaga LED 7 

   //Serial.println("LED's Banco B Apagados");    

      } 

} 

O sensor de cores utiliza o chip TCS3200 para detectar os níveis de luzes RGB dos objetos através do envio de dados para um microcontrolador, como o Arduino, Rasbperry, Pic, entre outros. Esse chip tem 64 fotodiodos, sendo com 16 filtros para a cor vermelha, 16 para a verde, 16 para a azul e 16 sem filtro, permitindo a criação de sistemas detecção de cores eficientes. Também possui quatro LEDs brancos para iluminação e oito pinos de conexão.

O vídeo com o demonstrativo de funcionamento do Sensor de Cores TCS3200 pode ser acessado clicando aqui

Materiais Utilizados:

• Sensor de Cores TCS3200
• LED RGB – OSTAPA5B3AA – Alto brilho Anodo Comum 30°
• Display Pinagem Superior 16×2 – 1602A-ELE – Azul
• Arduino Uno

Como o Sensor de Cores TCS3200 funciona?

Os 64 fotodiodos que estão distribuídos de forma uniformemente no sensor, são responsáveis por captar a luminosidade, filtrar as cores recebidas e gerar na saída do sensor um sinal de onda quadrada que traz informações sobre a intensidade das cores RGB (Red, Green, Blue). Ele atua efetuando uma análise do comprimento de onda de cada uma as cores RGB, e torna essas informações disponíveis para verificação de qual cor foi identificada. Além disso, com a identificação dos valores RGB lidos, pode-se efetuar também mudanças no código de programação, de modo que sensor reconheça não só as cores RGB, mais também as demais cores.

Descrição de pinagem do Sensor

Tabela de Nível Lógico disponibilizada no Datahseet do chip TCS3200

Conexão de montagem para teste do sensor de Cores TCS3200 utilizando LED RGB na exibição do reconhecimento das cores RGB

Conexão Sensor de Cor:

 Pino GND do sensor: Conectado ao GND do Arduino

Pino OE do sensor: Não conectado

Pino S0 do sensor: Conectado ao pino 9 do Arduino

Pino S1 do sensor: Conectado ao pino 10 do Arduino

Pino S2 do sensor: Conectado ao pino 11 do Arduino

Pino S3 do sensor: Conectado ao pino 12 do Arduino

Pino OUT do sensor: Conectado ao pino 8 do Arduino

Pino VCC do sensor: Conectado ao 5V do Arduino

Atenção:  Devido as diferentes variações de LED RGB Anodo Comum disponíveis no mercado, pode-se haver a inversão dos pinos G e B. É aconselhável a efetuação do teste pino a pino para averiguação da ordem das cores, de modo a garantir o correto funcionamento do sistema de exibição de reconhecimento da cor.

Conexão LED RGB:

 Pino 1 do LED (R – Vermelho): Conectado ao pino 2 do Arduino, e ao resistor

de 150 ohms, o outro lado do resistor deve ser conectado ao GND do Arduino.

Pino 2 do LED (Anodo Comum): Conectado ao VCC do Arduino.

Pino 3 do LED (B – Azul): Conectado ao pino 3 do Arduino, e ao resistor de

100 ohms, o outro lado do resistor deve ser conectado ao GND do Arduino.

Pino 4 do LED (G – Verde): Conectado ao pino 4 do Arduino, e ao resistor

de 100 ohms, o outro lado do resistor deve ser conectado ao GND do Arduino.

Após efetuada a montagem, como demonstrado acima, compile o código “teste do sensor de Cores TCS3200 utilizando LED RGB na exibição do reconhecimento das cores RGB” disponibilizado no fim do roteiro, para o microcontrolador Arduino como demonstrado abaixo, e faça o teste de reconhecimento das cores

Conexão de montagem para teste do sensor de Cores TCS3200 utilizando Display LCD na exibição do reconhecimento das cores

Conexão Sensor de Cor:

Pino GND do sensor: Conectado ao GND do Arduino

Pino OE do sensor: Não conectado

Pino S0 do sensor: Conectado ao pino 9 do Arduino

Pino S1 do sensor: Conectado ao pino 10 do Arduino

Pino S2 do sensor: Conectado ao pino 11 do Arduino

Pino S3 do sensor: Conectado ao pino 12 do Arduino

Pino OUT do sensor: Conectado ao pino 8 do Arduino

Pino VCC do sensor: Conectado ao 5V do Arduino

Conexão Display:

Pino 1 do Display: Conectado ao GND do Arduino

Pino 2 do Display: Conectado ao 5V do Arduino

Pino 3 do Display: Conectado ao pino 2 do Potenciômetro

Pino 4 do Display: Conectado ao pino 2 do Arduino

Pino 5 do Display: Conectado ao pino GND do Arduino

Pino 6 do Display: Conectado ao pino 3 do Arduino

Pino 11 do Display: Conectado ao pino 4 do Arduino

Pino 12 do Display: Conectado ao pino 5 do Arduino

Pino 13 do Display: Conectado ao pino 6 do Arduino

Pino 14 do Display: Conectado ao pino 7 do Arduino

Pino 15 do Display: Conectado a dois resistores de 220 Ohms, o outro lado dos resistores vai no 5V do Arduino

Pino 16 do Display: Conectado ao GND do Arduino

Conexão Potenciômetro:

Pino 1 Potenciômetro: Conectado ao GND do Arduino

Pino 2 Potenciômetro: Conectado ao pino 3 do Display

Pino 3 Potenciômetro: Conectado ao 5V do Arduino

Após efetuada a montagem, como demonstrado acima, compile o código “teste do sensor de Cores TCS3200 utilizando Display LCD para reconhecimento das cores” disponibilizado no fim do roteiro, para o microcontrolador Arduino, e faça o teste de reconhecimento das cores, como demonstrado no vídeo. Vale ressaltar que o teste efetuado foi feito em um laboratório com luminosidade ambiente, sofrendo interferência direta da iluminação externa. Para uso do sensor utilizando esse software, indicamos uma proteção ao sensor contra luminosidade externa, garantindo assim uma fiel leitura do sensor sem variações de iluminação pois a variação de iluminação afeta diretamente no reconhecimento e definição das cores pelo reconhecimento utilizando o código disponibilizado.

Com o código compilado para o Arduino, abra o monitor serial, ou analise no próprio Display LCD os valores lidos. Inicialmente aparecerá “Sem cor detectado!”, com os valores de Vermelho, Verde e Azul no monitor serial, ou R, G e B no display.  Como demostrado a seguir:

Adicione o cartão com a cor a ser detectada, e analise novamente os valores lidos. Os valores lidos são os valores referentes a cor a ser detectada, assim, no campo “readRGB” do software, edite esses valores para o range dentro dos valores lidos.

Como exemplo, falaremos sobre a leitura efetuada da cor Vermelho. Os valores lidos, como pode ser visto no display da primeira amostragem de cor, foi R=10, G=21 e B=17; sendo assim, vamos editar os valores da linha da cor vermelho, colocando os valores dentro do range, dando um pequeno intervalo entre os valores. A variável R (Vermelho) possui valor de 10, então colocamos como mínimo > 8, e como máximo <12 garantindo um range de 9 a 11.  Na variável G (Verde) colocamos como mínimo > 19, e como máximo <23 garantindo um range de 20 à 22, e Na variável B (Azul) colocamos como mínimo > 15, e como máximo <19 garantindo um range de 16 à 18, assim, a leitura dentro do intervalo dos valores setados retorna a leitura da cor Vermelho.

Para detecção das demais cores, efetuamos a leitura dos valores referentes a cada cor, e reconfiguramos os intervalos dos valores na linha da respectiva cor, assim como efetuamos com vermelho.
Efetuado a reconfiguração de todas as cores, recompilamos o código e testamos as cores como se segue, sendo as cores detectadas com êxito, comprovando assim, a aprovação do sensor de cores.

Vale ressaltar que, como o teste efetuado não foi feito em um ambiente controlado, a cada mudança externa do clima como o clarear ou o escurecer do dia chuvoso em que efetuamos o teste, foi-se necessário refazer a reconfiguração dos valores das cores. Para a solução desse problema pode-se implementar uma função filtro no código de programação, ou garantir uma proteção contra a luminosidade externa ao sensor. 

SOFTWARES utilizados para Teste:

SOFTWARE 1: Utilizando LED RGB

/********************* Eletrodex Eletrônica *************************
********* Teste do Sensor de cor TCS3200 utilizando LED RGB ************
************ na exibição do reconhecimento das cores RGB *************
****************************************************************/
//Definicão de conexão dos pinos do módulo ao Arduino
const int s0 = 9;
const int s1 = 10;
const int s2 = 11;
const int s3 = 12;
const int out = 8;
//Definicão de conexão dos pinos do LED RGB ao Arduino
int pinoledverm = 2;
int pinoledverd = 4;
int pinoledazul = 3;
 
//Variaveis cores
int red = 0;
int green = 0;
int blue = 0;
 
void setup()
{ //Definicão de entradas e saídas
  pinMode(s0, OUTPUT);
  pinMode(s1, OUTPUT);
  pinMode(s2, OUTPUT);
  pinMode(s3, OUTPUT);
  pinMode(out, INPUT);
  pinMode(pinoledverm, OUTPUT);
  pinMode(pinoledverd, OUTPUT);
  pinMode(pinoledazul, OUTPUT);
  Serial.begin(9600);
  digitalWrite(s0, HIGH);
  digitalWrite(s1, LOW);
}
 
void loop()
{
  //Deteção de cores
  color();
  //Exibição dos valores das cores no serial monitor
  Serial.print("Vermelho :");
  Serial.print(red, DEC);
  Serial.print(" Verde : ");
  Serial.print(green, DEC);
  Serial.print(" Azul : ");
  Serial.print(blue, DEC);
  Serial.println();
 
  //Verifica se a cor vermelha foi detectada
  if (red < blue && red < green && red < 100)
  {
    Serial.println("Vermelho");
    digitalWrite(pinoledverm, LOW); //Acende o led vermelho
    digitalWrite(pinoledverd, HIGH);
    digitalWrite(pinoledazul, HIGH);
  }
 
  //Verifica se a cor azul foi detectada
  else if (blue < red && blue < green && blue < 1000)
  {
    Serial.println("Azul");
    digitalWrite(pinoledverm, HIGH);
    digitalWrite(pinoledverd, HIGH);
    digitalWrite(pinoledazul, LOW); //Acende o led azul
  }
 
  //Verifica se a cor verde foi detectada
  else if (green < red && green < blue)
  {
    Serial.println("Verde");
    digitalWrite(pinoledverm, HIGH);
    digitalWrite(pinoledverd, LOW); //Acende o led verde
    digitalWrite(pinoledazul, HIGH);
  }
  Serial.println();
 
  //Delay para reiniciar o processo
  delay(50);
  digitalWrite(pinoledverm, HIGH);
  digitalWrite(pinoledverd, HIGH);
  digitalWrite(pinoledazul, HIGH);
}
 
void color()
{
  //Rotina que lê o valor das cores
  digitalWrite(s2, LOW);
  digitalWrite(s3, LOW);
  //count OUT, pRed, RED
  red = pulseIn(out, digitalRead(out) == HIGH ? LOW : HIGH);
  digitalWrite(s3, HIGH);
  //count OUT, pBLUE, BLUE
  blue = pulseIn(out, digitalRead(out) == HIGH ? LOW : HIGH);
  digitalWrite(s2, HIGH);
  //count OUT, pGreen, GREEN
  green = pulseIn(out, digitalRead(out) == HIGH ? LOW : HIGH);
}

SOFTWARE 2: Utilizando Display LCD

/********************* Eletrodex Eletrônica ********************
********* Teste do Sensor de cor TCS3200 utilizando ************
************ Display LCD para reconhecimento das cores *********
****************************************************************/


#include 
LiquidCrystal lcd(2, 3, 4, 5, 6, 7);

#define outPin 8
#define s0 9
#define s1 10
#define s2 11
#define s3 12

boolean DEBUG = true;

// Variáveis
int Vermelho, Verde, Azul;
String cor ="";
long startTiming = 0;
long elapsedTime =0;

void setup(){
  Serial.begin(9600);
  
  pinMode(s0, OUTPUT); //Definição de entrada e saída dos pinos do arduino
  pinMode(s1, OUTPUT);
  pinMode(s2, OUTPUT);
  pinMode(s3, OUTPUT);
  pinMode(outPin, INPUT); 

  // Configurando a escala de frequência para 100% em nível alto
  digitalWrite(s0,HIGH);
  digitalWrite(s1,HIGH);

  lcd.begin(16, 2);
  lcd.clear();
  lcd.setCursor (1,0);
  lcd.print("---Eletodex---");
  lcd.setCursor (1,1);
  lcd.print("Sensor de cor");
  delay(6000);  
  lcd.clear();  
  startTiming = millis();
}

void loop(){
  getcor();
   
  if(DEBUG)printData(); 
  elapsedTime = millis()-startTiming; 
  if (elapsedTime > 1000) {
     showDataLCD();
    startTiming = millis();
  }
}

/* Leitura RGB */
void readRGB(){
  Vermelho = 0, Verde=0, Azul=0;
  
  int n = 10;
  for (int i = 0; i < n; ++i){ //Leitura do vermelho digitalWrite(s2, LOW); digitalWrite(s3, LOW); Vermelho = Vermelho + pulseIn(outPin, LOW); //leitura do verde digitalWrite(s2, HIGH); digitalWrite(s3, HIGH); Verde = Verde + pulseIn(outPin, LOW); //leitura do azul digitalWrite(s2, LOW); digitalWrite(s3, HIGH); Azul = Azul + pulseIn(outPin, LOW); } Vermelho = Vermelho/n; Verde = Verde/n; Azul = Azul/n; } /************************************************************** Mostrando os dados da leitura dos valores RBG no Serial Monitor ***************************************************************/ void printData(void){ Serial.print("Vermelho= "); Serial.print(Vermelho); Serial.print(" verde= "); Serial.print(Verde); Serial.print(" Azul= "); Serial.print(Azul); Serial.print (" - "); Serial.print (cor); Serial.println (" detectado!"); } /*************************************************** Mostrando os dados da leitura dos valores RBG no LCD ****************************************************/ void showDataLCD(void){ lcd.clear(); lcd.setCursor (0,0); lcd.print("R"); lcd.print(Vermelho); lcd.setCursor (6,0); lcd.print("G"); lcd.print(Verde); lcd.setCursor (12,0); lcd.print("B"); lcd.print(Azul); lcd.setCursor (0,1); lcd.print("cor: "); lcd.print(cor); } void getcor(){ readRGB(); if(Vermelho>3  && Vermelho<12 && Verde>19 && Verde<23 && Azul>15 && Azul<19) cor = "Vermelho"; else if(Vermelho>14 && Vermelho<18 && Verde>10 && Verde<15 && Azul>6  && Azul<10) cor = "Azul"; else if(Vermelho>13 && Vermelho<17 && Verde>11 && Verde<15 && Azul>11 && Azul<16) cor = "Verde"; else if(Vermelho>24 && Vermelho<29 && Verde>30 && Verde<35 && Azul>24 && Azul<28) cor = "Preto"; else if(Vermelho>6  && Vermelho<10 && Verde>7  && Verde<11 && Azul>5  && Azul<9) cor = "Branco"; else if(Vermelho>5  && Vermelho<8 && Verde>7  && Verde<10 && Azul>10  && Azul<14) cor = "Amarelo";
else  cor = "Sem cor";}

Organização do roteiro:

• Teste do Módulo Bluetooth HC-05 Master/Slave por meio do acionamento de Led’s via celular, demonstrando a atuação no modo de Comunicação. (PÁG 1)
• Teste do Módulo Bluetooth HC-05 Master/Slave por meio do demonstrativo da ativação dos modos AT e Comunicação. (PÁG 4)
• Software de ativação dos modos AT e Comunicação no Módulo Bluethooth HC-05 Master/Slave. (PÁG 5)
• Software de acionamento de Led’s via celular utilizando o Módulo Bluetooth HC-05 Master/Slave. (PÁG 6)

O vídeo com o demonstrativo de funcionamento das duas formas de teste pode ser acessado clicando aqui!

Teste do Módulo Bluetooth HC-05 Master/Slave por meio do acionamento de Led’s via celular, demonstrando a atuação no modo de Comunicação.

Para o acionamento de Led’s via celular utilizando o Módulo Bluetooth HC-05 Master/Slave serão necessários para a montagem do circuito:

1 Arduíno Uno

1 Módulo Bluetooth HC-05 Master/Slave

7 Led’s

7 Resistores de 220 Ohms (vermelho, vermelho, marrom dourado)

1 Resistor de 1K Ohms (marrom, preto, vermelho e dourado)

1 Resistor de 2,2K Ohms (vermelho, vermelho, vermelho dourado)

Esquema eletrônico do acionamento de Led’s via Módulo Bluetooth HC-05 Master/Slave:

Após a montagem como no esquemático acima, deve ser feito o pareamento do bluetooth do seu aparelho smartphone com o módulo HC-05. Para isso, basta ativar o bluetooth do celular e selecionar “Parear novo dispositivo”, a procura irá retornar o bluetooth do módulo, geralmente de nome HC-05; ao seleciona-lo, uma senha será requisitada, essa senha geralmente é 0000, ou 1234. Digite 1234 e clique em OK.

Agora, faça o download do software de comunicação Bluetooth na loja play store em seu smartphone. O aplicativo de comunicação Bluetooth utilizado nesse teste foi o Bluetooth SPP Manager, demonstrado a seguir:

Após a instalação do aplicativo, deve-se fazer upload da programação de funcionamento para o arduíno. A programação efetuada está disponibilizada na descrição desse módulo, em Software de acionamento de Led’s via celular utilizando o Módulo Bluetooth HC-05 Master/Slave.

Funcionamento do projeto:

Abra o aplicativo Bluetooth SPP Manager; na aba Devices selecione o Device:HC-05 e aguarde até que a conexão seja estabilizada. Será exibido connecting referente a conectando, e se tudo ocorrer como o esperado, a conexão será estabilizada exibindo connection established como a seguir:

Com a conexão estabilizada, na aba Bt Messenger Digite as letras maiúsculas de “A” à “G” para acender o led referente a ele. Como nos exemplos a seguir, “A” acende o último LED, “B” acende o penúltimo e assim por diante.

A imagem a seguir demonstra o comando enviado com todas as letras maiúsculas referente a todos os leds, acionando assim, todos os 7 led’s.

Digite as letras minúsculas para apagar o led referente a ele. Como nos exemplos a seguir, “a” apaga o último LED, “b” apaga o penúltimo e assim por diante.

Já para o desligamento de todos os leds basta enviar o comando minúsculo de todas as letras de “a” à “g” referente a todos os leds, assim, todos os 7 led’s serão apagados juntamente, como pode ser visto a seguir:

Teste do Módulo Bluetooth HC-05 Master/Slave por meio do demonstrativo da ativação dos modos AT e Comunicação.

Organização do roteiro de Teste do Módulo Bluetooth HC-05 Master/Slave por meio do demonstrativo da ativação dos modos AT e Comunicação. 

• Detalhamento MODO AT.
• Acesso a tabela de comandos AT, e ao vídeo explicativo.
• Esquema eletrônico de conexão para ativação do modo AT no Módulo Bluetooth HC-05 Master/Slave.
• Software de ativação dos modos AT e Comunicação no Módulo Bluethooth HC-05 Master/Slave.

__________________________ Detalhamento MODO AT _________________________

No monitor serial, em taxa de transmissão, os campos de modo de dados e velocidade devem estar Ambos, NL e CL; e 9600 selecionados inicialmente para utilização da programação disponibilizada. Caso necessite modificar a velocidade de transmissão de 9600 para 38400 no código, essa modificação também deve ser feita no monitor serial, se não a frase “Digite os comandos AT:” não será impressa corretamente, exibindo apenas caracteres sem sentidos.

1.Como chegar ao modo AT.

Modo 1: Retire o fio de alimentação 5V que sai do Arduino para o VCC do módulo, pressione o botão de reset do módulo bluetooth por 5 segundos e ainda segurando o botão, conecte novamente o fio referente ao pino VCC do módulo, no 5V do arduino. O led piscará com intervalo de 2 segundos indicando que o módulo entrou no moto AT.

Modo 2: Retire o fio de alimentação 5V que sai do Arduino para o VCC do módulo, coloque o pino EN (KEY) do módulo em nível baixo. Conecte novamente o fio referente ao pino VCC do módulo, no 5V do arduino. Coloque o Pino EN (KEY ou PIN34) em nível alto. O led piscará com intervalo de 2 segundos indicando que o módulo entrou no moto AT.

Modo 3: Coloque o pino EN(KEY) em nível baixo. Retire o fio de alimentação 5V que sai do Arduino para o VCC do módulo, aguarde por 5 segundos. Conecte o pino EN(KEY) ao PIN 3.3V. Em seguida reconecte o fio de alimentação 5V que sai do Arduino para o VCC do módulo. O módulo entrará no modo AT. Mas neste momento, a taxa de velocidade é 38400. Desta forma, o usuário deve alterar a taxa de transmissão no arduino e no monitor serial.

 2. Como voltar ao modo de comunicação:

Modo 1: Insira o nível baixo (LOW) no EN(KEY), em seguida Insira o nível alto (HIGH) no EN(KEY). Assim o módulo entrará no modo de comunicação e pode ser usado para emparelhamento.

Modo 2: Insira o nível baixo (LOW) no EN(KEY), em seguida retire a alimentação VCC, pressione o botão por 3 segundos, e com ele ainda pressionado, conecte novamente o fio referente ao pino VCC do módulo, no 5V do Arduino.

3.Notas.

(1) Os comandos do HC-03 e HC-05 devem terminar com “\r\n”. Significa que quando você terminar a programação, você deve clicar em (“ENTER” ou “0x0d 0x0a”). Já os módulos HC-04 e HC-06 não precisam desse comando final.

(2) Os comandos mais comuns para HC-03 e HC-05 são: AT+NAME (para visualizar ou modificar o nome do módulo), AT+VERSION (para visualizar a verão do firmware), AT+ROLE (set master–slave), AT+CMODE(para definir pareamento de endereços), AT+PSWD (para definir senha). Se você deseja que o módulo mestre tenha a função de conectar com algum módulo escravo em específico e que ele atue sempre sob esse pareamento, o mais maneira simples é: Primeiro, defina AT+CMODE=1. Faça o pareamento do módulo mestre com o módulo escravo. Segundo, defina AT+CMODE=0. Então o módulo mestre só poderá fazer par com aquele módulo escravo especificado.

(3) Quando o pino EN(KEY) mantém o nível alto, todos os comandos podem ser usados. Caso contrário, apenas alguns deles podem ser usados.

2.

_________________ Acesso a tabela de comandos AT, e ao vídeo explicativo_______________

• Para acessar todos os comandos disponíveis no modo AT acesse “Tabela de comandos AT Módulo HC-05” disponibilizada na descrição desse anúncio do Módulo Bluetooth HC-05 Master/Slave, ou clique aqui!
• Para visualizar o vídeo explicativo de todos os passos a serem seguidos clique aqui!

3.

Esquema eletrônico de conexão para ativação do modo AT no Módulo Bluetooth HC-05 Master/Slave 

Software de ativação dos modos AT e Comunicação no Módulo Bluethooth HC-05 Master/Slave

/* --------------------------------------------- Eletrodex Eletrônica ----------------------------------------------------

Software de ativação dos modos AT e Comunicação no Módulo Bluethooth HC-05 Master/Slave

---------------------------------------------------------------------------------------------------------------------------------*/

 

 

#include <SoftwareSerial.h>

 

SoftwareSerial BTSerial( 10, 11); // RX | TX

 

void setup()

{

pinMode(9, OUTPUT); // este pino puxará o pino 34(EN ou KEY) do HC-05 (pino chave) HIGH para mudar o módulo para o modo AT

digitalWrite(9, HIGH);

Serial.begin(9600);

Serial.println("Digite os comandos AT:");

BTSerial.begin(38400); // Velocidade padrão do HC-05 no comando AT more

}

 

void loop()

{

 

// Continue lendo do HC-05 e envie para o Arduino Serial Monitor

if (BTSerial.available())

Serial.write(BTSerial.read());

 

// Continue lendo do Arduino Serial Monitor e envie para HC-05

if (Serial.available())

BTSerial.write(Serial.read());

}

Software de acionamento de Led’s via celular utilizando o Módulo Bluetooth HC-05 Master/Slave

/* --------------------------------------------- Eletrodex Eletrônica ----------------------------------------------------

Software de acionamento de Led’s via celular utilizando o Módulo Bluetooth HC-05 Master/Slave

---------------------------------------------------------------------------------------------------------------------------------*/

 

#include <SoftwareSerial.h>

#define bluetooth Serial

SoftwareSerial mySerial(0, 1); // pinos para comunicação serial

// Conecte o pino RX do módulo no 1(TX) do arduíno uno, e o TX do módulo no pino 0(RX) do arduíno

void setup()

{

pinMode(2, OUTPUT); // Definindo o pino 2 do arduíno como saída de sinal para acionamento do led

pinMode(3, OUTPUT);

pinMode(4, OUTPUT);

pinMode(5, OUTPUT);

pinMode(6, OUTPUT);

pinMode(7, OUTPUT);

pinMode(8, OUTPUT);

pinMode(9, OUTPUT);

pinMode(10, OUTPUT);

pinMode(11, OUTPUT);

pinMode(12, OUTPUT);

pinMode(13, OUTPUT);

bluetooth.begin(9600);

mySerial.begin(9600); // Estabelecendo a comunicação

delay(1000);

}

void loop()

{

char dato= bluetooth.read(); // "dato" é o nome da variável que armazena o valor digitado no celular.

 

switch(dato) //As letras maiúsculas acendem os Leds, e as letras minúsculas apaga os Leds.

{

case 'A': // Se a letra A for digitada, o pino 2 fica em nível alto e o led referente a ele acende.

{

digitalWrite(2, HIGH); // colocando o pino 2 em alto e acendendo o led referente a ele.

break;

}

case 'a': // Se a letra a for digitada, o pino 2 fica em nível baixo e o led referente a ele apaga.

{

digitalWrite(2, LOW); // colocando o pino 2 em baixo e apagando o led referente a ele.

break;

}

 

case 'B':

{

digitalWrite(3, HIGH);

 

break;

}

case 'b':

{

digitalWrite(3, LOW);

 

break;

}

case 'C':

{

digitalWrite(4, HIGH);

break;

}

case 'c':

{

digitalWrite(4, LOW);

break;

}

case 'D':

{

digitalWrite(5, HIGH);

break;

}

 

 

 

case 'd':

{

digitalWrite(5, LOW);

break;

}

case 'E':

{

digitalWrite(6, HIGH);

break;

}

case 'e':

{

digitalWrite(6, LOW);

break;

}

case 'F':

{

digitalWrite(7, HIGH);

break;

}

case 'f':

{

digitalWrite(7, LOW);

break;

}

case 'G':

{

digitalWrite(8, HIGH);

break;

}

case 'g':

{

digitalWrite(8, LOW);

break;

}

 

}

}