Conhecido por possibilitar uma comunicação wireless facilmente programável, o  Módulo Rádio Frequência HC12 possibilita a interação entre diferentes tipos de sistemas. Este componente, diferente de outras tecnologias sem fio, possui um alcance de aproximadamente 1000 metros em campo aberto, sendo superior as comunicações feitas por Módulo Bluetooth, que abrange um alcance médio de 10 metros.

          A transmissão de dados do Módulo HC12 será realizada através de radiofrequência, que pode operar entre 433,4Mhz a 473,0Mhz.


Pinagem do Módulo HC12

          Para realizar as configurações necessárias deve-se primeiramente conhecer a pinagem do Módulo HC12:




          Onde:

VCC: 3,3 V á 5 V.
GND: Negativo.
RX e TX: Comunicação Serial;
SET: Recebe os comandos AT;
Conector UFL e ANT: Antena

          Comparando a outros módulos, o funcionamento de um Módulo HC12 necessitará somente dos quatro primeiros pinos, sendo o pino SET utilizado apenas para realizar configurações em modo AT. O Módulo HC12 necessitará de uma antena para a comunicação via radiofrequência, normalmente cada Módulo HC12 é vendido junto a uma antena tipo helicoidal ou “mola” que deve ser soldada ao conector ANT.

  


          Em locais com muitos prédios haverá maior interferência na comunicação do HC12, por isso existe também a possibilidade de se utilizar uma antena externa através do conector UFL, ampliando o alcance do sinal.


Conectando a um Arduino

          Siga o seguinte exemplo:

Observação: Conecte SET em GND se quiser que o módulo entre na função AT.

         
          Este mesmo exemplo também funcionará em outros microcontroladores e conversores seriais, porém, procure observar se a corrente elétrica fornecida será suficiente para alimentar o HC12, pois será necessário pelo menos 100 mA. No caso de um Arduino UNO, por exemplo, não houve necessidade de uma alimentação externa.

          Para configurar o HC12 através da IDE do Arduino, será necessário transferir uma programação padrão que irá indicar o status de configuração do Módulo HC12 através do monitor serial.

// Projeto Curto Circuito – Configurações AT - Módulo HC12

#include <SoftwareSerial.h>
SoftwareSerial HC12(2,3);      // RX pino 2 , TX pino 3
void setup() {
  Serial.begin(9600);          // Porta Serial do computador 
  HC12.begin(9600);            // Porta Serial do HC12
}
void loop() {
  while (HC12.available()) {   // Enquanto HC12 receber dados
    Serial.write(HC12.read()); // Escreve os dados na Serial
  }
  while (Serial.available()) { // Enquanto a Serial receber dados
    HC12.write(Serial.read()); // Escreve os dados no HC12
    HC12.flush();              // Aguarda os dados, depois limpa a memória
  }
}

          Após transferir a programação abra o monitor serial, e envie a palavra “AT”, o Módulo HC12 deve responder com um “OK” ou “ERRO”, caso contrário confirme se a ligação dos pinos está correta e tente novamente até obter uma das respostas citadas acima.


Ajustando o Sinal

          Componentes como o HC12 carregam consigo algumas configurações de fábrica, sendo que os valores de potência, frequência, velocidade e taxa de transmissão do sinal seguem uma configuração de valor padrão, que em alguns casos necessitará de ajustes para que possam se comunicar.

          Tais informações podem ser alteradas através de comandos AT, que consiste em uma linguagem de programação que utiliza conjuntos de textos curtos para configurar diversos componentes eletrônicos.

          Para configurar um módulo HC12 será necessário conecta-lo a um computador via comunicação serial, no caso deste tutorial utilizaremos exemplos que consistem na configuração utilizando Placas Arduino ou conversores USB/Serial.


Comando AT

          Para configurar o Módulo HC12 será necessário utilizar os seguintes comandos:


          Exemplo: Envie AT+B9600 para que o Módulo HC12 seja configurado com uma velocidade de 9600 bps; Caso funcione, o módulo irá retornar com a mensagem “OK+B9600”.

          Para estabelecer comunicação entre dois módulos será necessário que ambos estejam com as mesmas configurações.


Taxa de Transferência

          Segundo o datasheet fornecido pela Elecrow em 2012, o Módulo HC12 vem configurado de fábrica com o padrão de transferência FU3, sendo este o modo de velocidade máxima, capaz de ajustar a taxa de transferência no ar automaticamente de acordo com a taxa de bps da porta serial.



          Os três modos de transmissão são responsáveis apenas pelo envio e o recebimento de dados, obtendo um alcance maior quando a taxa de transmissão for baixa. Os modos não se comunicam entre si, por tanto ao configurar dois Módulo HC12, por exemplo, ambos devem possuir o mesmo modo de transmissão para que seja estabelecida uma comunicação entre eles.

          O modo FU1 opera com corrente elétrica de trabalho ocioso de 3,6 mA, e pode suportar até oito tipos de dps, porém a taxa de transferência no ar é uniforme, com um valor de 250.000 dps. Já o FU2 opera com corrente de trabalho ocioso de 80μA, e suporta apenas 1,200 bps, 2,400 bps e 4,800 bps, mantendo o mesmo valor de transferência no ar que FU1. Se configurado de forma inadequada, o HC12 não irá conseguir comunicar-se de forma adequada.


Configurar o Módulo HC12 sem a IDE do Arduino

          O Módulo HC12 pode ser configurado através de outros softwares específicos para configuração de terminais, como por exemplo, o Termite 3.4, que realiza boa parte das configurações AT de forma automática, e encontra-se disponível gratuitamente.

 

          Clicando em Settings é possível ajustar a COM correspondente ao controlador ou conversor serial ao qual o Módulo HC12 estará conectado, além das opções de ajuste de taxa de transferência (em Baud rate) e potência de transmissão (em Data bits).


 

          Essas configurações são transmitidas diretamente ao Módulo HC12 após identificar a conexão com o computador.

          Assim como o monitor serial do Arduino, o Termite irá responder aos comandos AT com respostas como “OK” ou “ERRO”.



       

          Para configurar o Módulo HC12 basta enviar os mesmos comandos ordenados anteriormente: AT+P8, AT+C001, AT+B9600 e AT+FU3.

          Com isso, o Módulo HC12 está configurado e pronto para utilização. Agora iremos fazer a comunicação do Módulo HC12 através de um Arduino e também do Software Termite para que possamos dar continuidade à aprendizagem básica deste Módulo Wireless.


Fazendo a comunicação do Módulo HC12 entre Arduinos e via Termite

          Nesta parte do tutorial iremos estabelecer conexão do Módulo HC12 entre dois Arduinos ou entre um Arduino e o software Termite para que possamos entender o funcionamento básico da conectividade do Módulo HC12. Para um melhor entendimento deste tutorial é ideal que você tenha feito a leitura completa da parte do tutorial "Configurando o Módulo Wireless HC12".


Comunicação entre Arduinos

          Para fazer a comunicação do Módulo HC12 entre dois Arduinos e pelo Termite, vamos acionar um LED à distância. Para este tutorial, utilizaremos os seguintes componentes:

          Todos esses produtos você encontra em nossa loja virtual, bastando apenas clicar nos links acima para acessar a página do produto ou pode visitar a nossa loja aqui: www.curtocircuito.com.br.


Siga os seguintes passos:

          Para este tipo de atividade, os circuitos serão separados entre emissor e receptor, cada um com um módulo HC12. Em ambos os casos será utilizado o mesmo tipo de conexão para o módulo HC12. Para fazer a parte do emissor, vamos montar o circuito conforme a imagem abaixo:


Circuito HC12 Arduino


          O pino SET é utilizado apenas para as configurações em comandos AT, nos demais casos deve permanecer desconectado. Alimente as fileiras do Protoboard conectando-as no 5V e GND do Arduino.


Ligação Arduino Protoboard


          A conexão do botão deve ser realizada da seguinte maneira:

ligação botao
         1 - Fileira Negativa (Resistor);
         2 - Fileira Positiva (Jumper);

          Para fazer o circuito do Receptor, siga o mesmo exemplo acima pra encaixar o módulo ao Arduino. Encaixe um resistor entre o terminal negativo do LED e a fileira negativa do Protoboard.

ligação led proto
         
Conecte um jumper entre o polo positivo do LED e um pino digital do Arduino;

ligação circuito arduino


          Os circuitos devem possuir uma aparência similar ao demonstrado nas imagens abaixo:


Circuito 1 : Emissor

Circuito Emissor



Circuito 2: Receptor


Circuito Receptor


Programação

          Transfira as programações abaixo de acordo com o tipo de circuito.


Emissor:

// Projeto Curto Circuito - Módulo HC12 – Conectando dois Arduinos (Emissor) 

#include <SoftwareSerial.h> // Inclui Biblioteca
#define buttonPin A0 // Define buttonPin estará na porta A0
SoftwareSerial mySerial(2, 3);        // Simula RX e TX em outras portas
const int ledPin = 13;                // Define que ledPin estará na porta 13
void setup() {
  pinMode(ledPin, OUTPUT);            // Declara que ledPin é uma saída
  pinMode(buttonPin, INPUT);          // Declara que buttonPin é uma entrada
  mySerial.begin(9600);               // Taxa de transferência do HC12
  Serial.begin(9600);                 // Taxa de transferência da Serial
}
void loop() {
  int buttonState = digitalRead(buttonPin);   // Armazena o estado lógico do botão
  if (buttonState == 1) {                     // Se o botão for pressionado
    mySerial.println(2);                      // mySerial escreve 2 na serial
    digitalWrite(ledPin, HIGH);               // Led acende
  }
  else {                                      // Se não 
    digitalWrite(ledPin, LOW);                // Led desliga
  }
  mySerial.flush();                           // Limpa a memória
  delay(20);
}

 

Receptor:

// Projeto Curto Circuito - Módulo HC12 – Conectando dois Arduinos (Receptor) 

#include <SoftwareSerial.h> // Inclui Biblioteca
SoftwareSerial mySerial(2, 3);       // Simula RX e TX em outras portas 
const int ledPin = 13;               // Define que ledPin estará na porta 13
void setup() {
  Serial.begin(9600);                // Taxa de transferência da Serial
  mySerial.begin(9600);              // Taxa de transferência do HC12
  pinMode(ledPin, OUTPUT);           // Define ledPin como saída
}
void loop() {
  if (mySerial.available() > 1) {    // Se o sinal de mySerial for maior que 1
    int input = mySerial.read();     // input será igual ao valor de mySerial
    Serial.println(input);           // Escreve na serial o valor de input
  if (input != 1) {                  // O valor de input for diferente de 1
      digitalWrite(ledPin, HIGH);    // Led acende 
      delay(100);                    // 100 milissegundos 
    }   
  else {                             // Se for igual a 1 
      digitalWrite(ledPin, LOW);     // Led desliga 
      delay(100);                    // 100 milissegundos 
    }
  }
}



Detalhando o Funcionamento

          Se configurados da mesma forma, os módulos dividirão informações na serial, então quando o emissor imprimir (print) ou escrever (write) um valor o receptor irá interpretar, e de acordo com a programação executar alguma função. O LED do receptor permanecerá desligado, até o momento em que o botão do emissor for pressionado, quando isto ocorrer o LED permanecerá ligado indicando que há conexão entre eles.

          Em caso de dúvidas, adicione um leitor serial ao início do void loop de ambas as programações.

Receptor: Serial.println (input);
Emissor:  Serial.println(buttonState);

          Transfira a programação e abra o monitor serial, que irá mostrar os valores de buttonState, ou de input (isso dependerá de qual COM foi selecionada como principal), em ambos os casos pressione o botão. Se a COM do Arduino emissor for selecionado, o monitor irá exibir o estado lógico do botão, ou seja, Ligado (1) e Desligado (0). Ao pressionar o botão os valores devem alternar entre 0 e 1, caso contrário confirme a montagem do circuito. Para certificar-se de que está tudo em seu devido lugar, procure uma programação teste para botões.

Arquivos >> Exemplos >> Digital >> Button.

          Já no caso do Arduino receptor, verifique se o monitor serial irá mostrar valores como 0, 1 ou 2, pois tais valores devem alternar caso o botão do emissor seja pressionado, se confirme se as configurações dos módulos estão similar.


Comunicação via Termite

          Agora, nós iremos estabelecer uma comunicação entre dois módulos HC12, utilizando um Arduino e um conversor USB/Serial e observar a resposta através do software Termite.


Siga os seguintes passos:

          Para este tipo de atividade, os circuitos serão separados entre emissor e receptor. Em ambos os casos será utilizado o mesmo tipo de conexão para os módulos HC12. Para fazer a parte do emissor, vamos montar o circuito conforme a imagem abaixo:

Circuito HC12 Arduino


          Conecte um resistor entre o terminal negativo do LED e a fileira negativa do Protoboard.

ligação led proto


          Encaixe um jumper entre o polo positivo do LED e um dos pinos digitais do Arduino.


ligação led proto 2


          Para fazer o circuito do emissor, siga a seguinte ordem de conexão:


Circuito conversor


          Conecte o TX de um no RX do outro, e vise versa. Os demais pinos seguirão a ordem padrão, Vcc no Vcc, GND no GND e SET desconectados.

          Em alguns casos, o conversor USB/Serial não conseguirá fornecer energia suficiente para alimentar o módulo, então como sugestão, procure conectar o pino SET (temporariamente) ao pino GND do conversor, e envie comandos AT através do Termite. Caso não obtenha qualquer resposta, conecte o GND e o VCC do módulo a uma bateria externa.


Emissor com pilhas

Circuito completo 1


Emissor sem pilhas

Circuito completo 2


Circuito Receptor

Circuito completo 3



Programação

          Transfira a programação abaixo de acordo com o tipo de circuito.

Receptor:

// Projeto Curto Circuito - Módulo HC12 – Comunicação Termite 

#include <SoftwareSerial.h> // Inclui Biblioteca
SoftwareSerial mySerial(2, 3);       // Simula RX e TX em outras portas
char input;                          // Armazena os caracteres recebidos
const int led1 = 13;                 // Led 1 porta digital 13
const int led2 = 12;                 // Led 2 porta digital 12
int state = 0;                       // Alterar o estado lógico do LED1 (0 e 1)
int state2 = 0;                      // Alterar o estado lógico do LED2 (0 e 1)
void setup() {
  Serial.begin(9600);                // Taxa de transferência do Computador
  mySerial.begin(9600);              // Taxa de transferência do HC12
  pinMode(led1, OUTPUT);             // Declara led 1 como saída
  pinMode(led2, OUTPUT);             // Declara led 2 como saída
}
void loop() {
  if (mySerial.available() > 0) {   // Se a conexão estiver acessível
    input = mySerial.read();        // input será igual ao valor recebido
    if (input == '1')   {           // Se input for igual a 1
      state = !state;               // Inverte o valor de state
      digitalWrite(led1, state);    // Irá acender ou apagar de acordo com state
      if (state == 0) {             // Se state for igual a  0
        mySerial.println("Led 1 Desligado"); // Escreve a mensagem 
     }
      else {                        // Se state for diferente de  0
        mySerial.println("Led 1 Ligado");    // Escreve a mensagem 
      }
    }
    if (input == '2')  {                  // Se input for igual a 2
      state2 = !state2;                   // Inverte o valor de state
      digitalWrite(led2, state2);         // Irá acender ou apagar de acordo state
      if (state2 == 0) {                  // Se state for igual a  0
        mySerial.println("Led 2 Desligado");
      }
      else {                              // Se state for diferente de  0
        mySerial.println("Led 2 Ligado");
      }
    }
  }
}


          Após transferir a programação desconecte o Arduino do computador e alimente com uma bateria ou fonte, conecte o conversor USB ao computador e abra o software Termite e envie os números 1 ou 2, e aguarde a mensagem do software.

Termite 3.4


          Os LEDs serão ligados/desligados de acordo com a ordem enviada pelo Termite, enquanto o Arduino envia como resposta a atual situação de cada LED acionado.

          Transfira a programação e abra o monitor serial, que irá mostrar os valores de buttonState, ou de input (isso dependerá de qual COM foi selecionada como principal), em ambos os casos pressione o botão.

          Se a COM do Arduino emissor for selecionado, o monitor irá exibir o estado lógico do botão, ou seja, Ligado (1) e Desligado (0). Ao pressionar o botão os valores devem alternar entre 0 e 1, caso contrário confirme a montagem do circuito. Para certificar-se de que está tudo em seu devido lugar, procure uma programação teste para botões.

Arquivos >> Exemplos >> Digital >> Button.

          Já no caso do Arduino receptor, verifique se o monitor serial irá mostrar valores como 0, 1 ou 2, pois tais valores devem alternar caso o botão do emissor seja pressionado, se confirme se as configurações dos módulos estão similar.


Testando o Alcance

          Para fazermos o teste do alcance do Módulo HC12 , vamos elaborar um circuito que indique quando houver conexão entre os dois HC12, e testar o alcance do sinal distanciando os módulos fisicamente. Como já fora demonstrado anteriormente, em ambos os casos será utilizado o mesmo tipo de conexão para os módulos HC12, portanto, siga a ordem demonstrada no primeiro circuito deste tutorial para a construção do circuito emissor e receptor, atualizando apenas a programação.


Programação

Receptor:

 

// Projeto Curto Circuito - Módulo HC12 – Teste de Alcance 

#include <SoftwareSerial.h> // Inclui Biblioteca
#define button Pin A0 // Define que buttonPin está na porta A0
SoftwareSerial mySerial(2, 3);            // Simula RX e TX em outras portas
int cont = 0;                             // Variável cont inicia com o valor 0
int input = 0;                            // Variável input inicia com o valor 0
int ledPin = 13;                          // ledPin (Led Azul)
int off = 12;                             // off (Led Vermelho)
int on = 11;                              // on (Led Verde)
void setup() {
  pinMode(on, OUTPUT);
  pinMode(off, OUTPUT);
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);                     // Taxa de transferência da Serial
  mySerial.begin(9600);                   // Taxa de transferência do HC12
}
void loop() {
  if (mySerial.available() >=2 ) {        // Se a Serial ler um valor maior que 0
    digitalWrite(ledPin, 0);              // ledPin inicia desligado
    int input = mySerial.read();          // input será igual ao valor da Serial
    if (input == 2) {                     // Se input for igual a 2
      digitalWrite(ledPin, 0);            // ledPin desliga
      digitalWrite(on, 1);                // Led verde liga
      digitalWrite(off, 0);               // Led vermelho desliga 
      cont = 2;                           // Variável cont igual a 2
      mySerial.write(cont);               // Escreve o valor de cont na serial
    }
    if (input == 3) {                     // Se input for igual a 3
      digitalWrite(ledPin, 1);            // ledPin liga
      delay(50);                          // Aguarda 50 milissegundos
      cont = 2;                           // Variável cont igual a 2
      mySerial.write(cont);               // Led verde liga
      }  }
    else {
      delay(50);                          // Aguarda 50 milissegundos 
      digitalWrite(on, 0);                // Led verde desliga
      digitalWrite(off, 1);               // Led vermelho liga 
     digitalWrite(ledPin, 0);             // ledPin desligado
  }
}

 

Emissor:

 

// Projeto Curto Circuito - Módulo HC12 – Teste de Alcance 

#include <SoftwareSerial.h> // Inclui Biblioteca
SoftwareSerial mySerial(2, 3);          // Simula RX e TX em outras portas
#define buttonPin A0 // Define que buttonPin está na A0
int ledPin = 13;                        // Será Led do próprio Arduino
int cont = 0;                           
void setup() {
  Serial.begin(9600);                  // Taxa de transferência da Serial
  mySerial.begin(9600);                // Taxa de transferência do HC12
  pinMode(ledPin, OUTPUT);
  pinMode(buttonPin, INPUT);
}
void loop() {
  int buttonState = digitalRead(buttonPin);   // Armazena o estado lógico 
  if (buttonState == 1) {                     // Se o botão pressionado
    cont = 3;                                 // Variável cont igual a 3
    mySerial.write(cont);                     // Escreve na Serial do HC12 
    digitalWrite(ledPin, HIGH);
  }
    cont = 2;                                 // Variável cont igual a 2
      mySerial.write(cont);                   // Escreve na Serial 
      digitalWrite(ledPin, LOW);              
    }

 


          Vale Lembrar que o desempenho irá depender muito do ambiente de teste e da antena utilizada, o desempenho em cidades costuma ter maiores interferências do que em campos abertos, e o alcance do sinal poderá ser optimizado se experimentar outros tipos de antena. Para testar o alcance, conecte um dos Arduinos a uma bateria 9V e deixe o outro conectado ao computador, procure distanciar os módulos o máximo que conseguir. Enquanto o LED Verde estiver ligado haverá conexão entre os módulos.

          Este foi o nosso primeiro tutorial. A partir dele, vocês já podem brincar bastante com o Módulo HC12. Não deixe de comentar e compartilhar, é muito importante para o nosso trabalho que o máximo de pessoas possam ler esse tutorial. Até a próxima!