Confira o vídeo com o teste de funcionamento do SCT-013 – Sensor de Corrente não Invasivo
100A clicando aqui!

O SCT-013 é um excelente sensor para medições de corrente alternada de forma não invasiva, podendo assim, ter contato direto com os fios elétricos para aferição da variação do campo magnético. O SCT-013 possui capacidade de medição de até 100A, e é uma ótima opção para medições de forma segura, e de fácil instalação, sendo necessário apenas a inserção do fio pelo sensor.

O sensor SCT-013 é amplamente utilizado em desenvolvimento de projetos de automação residencial, comercial e projetos didáticos com a utilização de microcontroladores como o Arduino, atuando na medição de corrente elétrica dos mais diversos sistemas.

Conexão de montagem para teste do SCT-013 Sensor de Corrente não Invasivo 100A

Conexão do SCT-013

• Insira dois fios (colocamos um amarelo e um laranja) em um conector Jack J2 para cabo, que pode ser encontrado clicando aqui
• Conecte o Plug do Sensor SCT-013 ao conector Jack J2
• O fio amarelo deve ser conectado juntamente com o terminal positivo do capacitor de 100uf, um dos terminais de cada um dos dos dois resistores de 10 KOhms (Marrom, Preto, Laranja, Dourado), e um dos terminais de 330 Ohms (Laranja, Laranja, Marrom, Dourado) também devem ser conectados ao fio amarelo.
• O outro lado de um dos resistores de 10 KOhms deve ser conectado ao negativo do capacitor e o outro lado do resistor de 10 Kohms deve ser conectado ao positivo 5VCC do arduino
• O fio laranja deve ser conectado no outro terminal do resistor de 330 Ohms juntamente com o Pino A0 do arduino

Conexão do Display LCD

• Pino 1 (VSS) – Conectado ao GND do Arduino
• Pino 2 (VDD) – Conectado ao 5V+ do Arduino
• Pino 3 (V0) – Conectado ao pino 2 do potenciometro, o pino 1 do potenciômetro deve ser conectado ao GND e o pino 3 do potenciômetro deve ser conectado ao pino 3.
• Pino 4 (RS) – Conectado ao pino 12 do Arduino
• Pino 5 (RW) – Conectado ao pino GND do Arduino
• Pino 6 (E) – Conectado ao pino 13 do Arduino
• Pino 11 (D4) – Conectado ao pino 7 do Arduino
• Pino 12 (D5) – Conectado ao pino 6 do Arduino
• Pino 13 (D6) – Conectado ao pino 5 do Arduino
• Pino 14 (D7) – Conectado ao pino 4 do Arduino
• Pino 15 (A) – Conectado ao pino 5V do Arduino
• Pino 16 (K) – Conectado ao pino GND do Arduino

Circuito de medição de corrente utilizado para teste do SCT-013 Sensor de Corrente não Invasivo 100A

Após efetuada a montagem, basta inserir o sensor no circuito para a medição de corrente. O teste efetuado foi feito utilizando um ferro Hikari SC-50 de 42W, conectado diretamente a rede elétrica. Para facilitar a medição fizemos uma extensão com fios paralelos para medição de apenas um dos fios, (para a medição correta de corrente do circuito, deve-se utilizar apenas um dos fios). Foi inserido no circuito um alicate amperímetro de modo a comprovar a eficácia de medição do sensor SCT-013.

Software utilizado para teste do SCT-013 Sensor de Corrente não Invasivo 100A, mensurando corrente e potência

Após efetuada a montagem, faça a exportação da biblioteca “EmonLib-master” disponibilizada na descrição do vídeo ou na descrição do anúncio do produto, para dentro da IDE do Arduino, e compile o”Software utilizado para teste do SCT-013 Sensor de Corrente não Invasivo 100A, mensurando corrente e potência”, para o Arduino.

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

****************** Teste SCT-013 Sensor de Corrente não Invasivo 100A **************

***************************************************************************/

 

#include "EmonLib.h"

#include <LiquidCrystal.h>

EnergyMonitor SCT013;

LiquidCrystal lcd(12, 13, 7, 6, 5, 4); // Pinagem do LCD

 

int pinSCT = A0;   //Pino analógico conectado ao SCT-013

int tensao = 127;

int potencia;

int correntea;

 

void setup()

{

SCT013.current(pinSCT, 6.0606);

Serial.begin(9600);

lcd.begin(16, 2);

lcd.clear();

lcd.setCursor (0,0);

lcd.print("----Eletrodex---");

lcd.setCursor (1,1);

lcd.print("Sensor  SCT013");

delay(6000);

lcd.clear();

 

 

}

void loop()

{

double Irms = SCT013.calcIrms(1480);   // Calcula o valor da Corrente

 

 

potencia = Irms * tensao;   // Calcula o valor da Potencia Instantanea

Serial.print("Corrente = ");

Serial.print(Irms);

Serial.println(" A");

 

Serial.print("Potencia = ");

Serial.print(potencia);

Serial.println(" W");

 

delay(200);

Serial.print(".");

delay(200);

Serial.print(".");

delay(200);

Serial.println(".");

delay(200);

 

lcd.clear();

lcd.setCursor(1, 0);      // 2 = 2 colunas para a direita. 1 = Segunda linha

lcd.print("Corrente");

lcd.setCursor(10, 0);

lcd.print(Irms);

lcd.print("A");

lcd.setCursor(2, 1);

lcd.print("Potencia");

lcd.setCursor(11, 1);

lcd.print(potencia);

lcd.print("W");

delay(1000);
}

No monitor serial é possível a visualização da medição de corrente e potência efetuadas pelo sensor SCT-013.

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";}

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);
  }

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;

}

 

}

}