Pesquisar

Módulo AFSmart Rádio com RF4432 
Este módulo ainda ira dar muito assunto interessante
Ainda falando do módulo AFSmartRádio, iremos realizar uma implementação semelhante a que realizamos com o Rádio RF4463PROMas utilizando o rádio RF4432 que pode ser adquirido AQUI .

O módulo AFSmartRádio, ainda irá nos fornecer muitos assuntos, visto sua versatilidade, não havíamos nem pensado na possibilidade de utilizar o rádio RF4432, ele possui aproximadamente 1.6mm de diferença entre o barramento principal e o pino da antena, mas sem muito esforço foi possível usa-lo no módulo AFSmartRádio, embora possua esta diferença de  1.6mm menor que o Rádio RF4463Pro a pinagem do barramento principal é exatamente disponibilizado na mesma sequência, tornando possível o desenvolvimento com o AFSmartRádio, aumentando ainda mais as possibilidades.

E claro não podíamos deixar de realizar uma aplicação com um rádio com um custo menor. Medidas de desempenho serão adicionados em momento oportuno.

Por ser um rádio mais "barato" e não possuir a blindagem dos outros dois rádios, claro que isso reduz a distância de transmissão,  mas não deixa de ser uma ótima oportunidade e mais uma opção para desenvolvimento, possibilitando aprendizado por um custo menor e mostrar a versatilidade do módulo de desenvolvimento AFSmartRádio.

Assim aumentamos demasiadamente as opções para profissionais, entusiastas, estudantes, etc...


Mostraremos uma aplicação com o Rádio RF4432 e Arduino
A comunicação com o Rádio é feita via SPI, usando o Arduino Pro-MIni que já há o soket pronto na placa de desenvolvimento.

Caso já possua o Pro-Mini, apenas verifique a pinagem de seu Pro-Mini é igual ao da imagem abaixo? pois há algumas variações em relação à este modelo de Arduino, senão pode adquirir AQUI.

AFSmarto Radio e RF4432 915Mhz
Módulo AFSmartRadio montado com Pro-Mini e Radio RF4432 915Mhz

O rádio abordado será o módulo transceptor RF4432 915Mhz, a placa base desenvolvida pela AFEletrônica suporta ainda os Rádios RF4463Pro e Lora1276 

O tipo de antena deve ser escolhido de acordo com a aplicação. 

O barramento de conexão dos rádios segue montado para apenas um rádio, caso adquira somente o módulo sem os rádios deve informar o fabricante para qual rádio deve ser montado Lora1276 ou RF4463Pro que é o mesmo slot para o RF4432 - para isso deve ser deixado uma mensagem na compra. Caso não seja informado, o conector para o Slot segue desmontado, ai você deve realizar a montagem, e claro possuir familiaridade em solda.

Especificações módulo base AFSmartRadio:

Tensão de Alimentação: 9~15Vdc

Entrada para módulos: Rf4463PRO & RF4432 ou Lora1276 (necessário montar Slot conforme modelo escolhido) - possível montar os dois modelos, mas extremamente importante atentar a posição de montagem uma vez que as pinagens são distintas para cada modelo de Rádio.

Slot para Arduino Pro-Mini - necessário atentar ao modelo pois o Pro-Mini possui algumas variantes com relação à pinagem, Pode ser usado Pro-Mini versão 3v3@8Mhz ou Pro-Mini 5v@16Mhz, para o módulo AFSmart é transparente um ou outro modelo.

Slot para Cartão MicroSD lado de baixo da placa
Saída Rele: 250Vac@5A
Botão para uso Geral
Led de Status para uso Geral
Slot para aplicações futuras ou necessidade do usuário
Entrada Para Antena Externa
Slot para comunicação com periféricos I2c
Slot para Ethernet Enc28j60 ou necessidade do usuário
Conector para comunicação com periféricos I2c
Projeto de sensor interno para leitura da tensão de alimentação.
Conector SMA para antena externa

Consumo Rádio Lora1276 100mW
SleepMode < 200nA @20dBm
Modo Rx 13mA @20dBm
Modo Tx 120mA @20dBm

Consumo rádio RF4463Pro 100mW
SleepMode < 100nA @20dBm
Modo Rx 13.5mA  @20dBm
Modo Tx 85mA  @20dBm

Consumo rádio RF44632 100mW
SleepMode < 800nA @20dBm
Modo Rx 18.5mA  @20dBm

Modo Tx 85mA  @20dBm

Possibilidade de montar uma memória I2c modelo 24C256/8_TSSOP - pode inclusive ser solicitado para o fabricante enviar montado mediante o pagamento para aquisição e montagem da mesma.

O módulo AFSmart é comercializado com ou sem os módulos:
Arduino ou Rádios.

Mapa Pinagem Módulo AFSmart

Para implementação desta matéria foi utilizado dois módulos AFSmart com os rádios RF4432.

Módulo Cliente - envia a mensagem "RF4432 esta ai?"

Módulo Server -  responde com a mensagem "Estou aqui ouvindo 100%";

Há também um status onde podemos ouvir o Rele da placa Server sendo acionado a cada mensagem recebida, de forma a facilitar os testes em campo.

Método utilizado para realizar a gravação do Arduino Pro-mini, escrevemos sobre isso em uma outra matéria acesse aqui


Método utilizado para envio da aplicação ao Arduino Pro-Mini



Código módulo Cliente - baseado no exemplo de: rf22_client.pde


//NOTA IMPORTANTE em RH_RF22.cpp necessário setar frequencia para 915Mhz


#include <SPI.h>
#include <RH_RF22.h>

// Singleton instance of the radio driver
RH_RF22 rf22;

void setup()
{
  pinMode(9, OUTPUT);   // Necessário colocar SDN em GND para que este rádio inicialize
  digitalWrite(9,LOW);  // Necessário colocar SDN em GND para que este rádio inicialize
  Serial.begin(9600);
  if (!rf22.init())
    Serial.println("init failed");
  // Defaults after init are 434.0MHz, 0.05MHz AFC pull-in, modulation FSK_Rb2_4Fd36
 // rf22.setFrequency(915.00);
  rf22.setFHStepSize(5);

}

void loop()
{

  Serial.println(rf22.lastRssi()); //Imprime Valor RSSI em dbm
  Serial.println("Sending to rf22_server");
  // Send a message to rf22_server
  uint8_t data[] = "RF4432 Esta ai?";
  rf22.send(data, sizeof(data));

  rf22.waitPacketSent();
  // Now wait for a reply
  uint8_t buf[RH_RF22_MAX_MESSAGE_LEN];
  uint8_t len = sizeof(buf);

  if (rf22.waitAvailableTimeout(500))
  {
    // Should be a reply message for us now 
    if (rf22.recv(buf, &len))
    {
      Serial.print("got reply: ");
      Serial.println((char*)buf);
    }
    else
    {
      Serial.println("recv failed");
    }
  }
  else
  {
    Serial.println("No reply, is rf22_server running?");
  }
  delay(400);
}



Código módulo Servidor - baseado no exemplo de: rf22_server.pde



#include <SPI.h>
#include <RH_RF22.h>

//Instância driver do rádio
RH_RF22 rf22;
const int relay =  4;      // pino rele
const int SDNpin =  9;      // SDNpin


void setup() 
{
   
  pinMode(relay, OUTPUT);  
  digitalWrite(relay,LOW); //começa rele desligado
  pinMode(SDNpin, OUTPUT); // SDNpin como Saída
  digitalWrite(SDNpin,LOW); // Necessário colocar SDNpin em GND para que o rádio inicialize
  Serial.begin(9600);
  if (!rf22.init())
    Serial.println("Inicializacao do Radio Falhou");  
  //NOTA IMPORTANTE em RH_RF22.cpp necessário setar frequencia para 915Mhz
}

void loop()
{
   
  
  if (rf22.available())
  {
    // Should be a message for us now   
    uint8_t buf[RH_RF22_MAX_MESSAGE_LEN];
    uint8_t len = sizeof(buf);
    if (rf22.recv(buf, &len))
    {
      //RF22::printBuffer("request: ", buf, len);
      Serial.print("Pergunta: ");
      Serial.println((char*)buf);
      Serial.print("RSSI: ");
      Serial.println(rf22.lastRssi(), DEC);
      
      // Send a reply
      uint8_t data[] = "Estou aqui ouvindo 100%";
      rf22.send(data, sizeof(data));
      rf22.waitPacketSent();
      Serial.println("Enviou uma Resposta");
      digitalWrite(relay,LOW);
      delay(100);
      digitalWrite(relay,HIGH);
    }
    else
    {
      Serial.println("Falha ao Receber dado");
    }
  }
}

AFSmartRadio Tranceiver 915Mhz Lora

AFSmartRadio Tranceiver 915Mhz Lora

Módulo Lora
Módulo AFsmart Lora V1.0 montado Arduino Pro-Mini e Rádio Rf4463PRO

A Internet das coisas (IOT) evoluiu de tal forma que cada dia surge novidades, menores e com mais "fome" para comunicar com as "coisas", o que era impossível há alguns anos. 

Atualmente as  tecnologias como GSM e WiFi são as mais usadas para este tipo de aplicação, mas  em qualquer tecnologia há suas vantagens e desvantagens:

Tecnologia GSM, 3G, LTE : embora os valores vem caindo, ainda possuem altos custos, no lado da infraestrutura, um plano de dados é necessário para comunicações, e também demanda um alto consumo de energia

Tecnologia WiFi, BLUETOOTH : cobertura de curta distância algumas dezenas de metros dentro dos edifícios, e alto consumo de energia.
A transmissão de dados usando radio frequência 315@915Mhz é a bola da vez, é bastante difundida em países da Europa inclusive utilizando o protocolo LoRa®, ou Sigfox, permitindo uma comunicação a longas distâncias com um baixo consumo de energia, e com um  custo mais acessível que os atualmente existentes no mercado.
Essa tecnologia se baseia em uma topologia de rede estrela, parecido com uma rede celular. A principal aplicação são sistemas IoT (internet das coisas) como monitoramento de sensores (luz, pressão, controle on_off, temperatura, entre outros). Principalmente aqueles operados por bateria, com mensagens relativamente curtas.
Topologia Estrela
No Brasil atualmente esta em expansão dois modos de comunicação LoRa® e o Sigfox.

Claro que paralelamente aos meios/protocolos de transmissão de dados mencionados é possível realizar aplicações distintas para aprendizado, cursos, e mesmo aplicações profissionais, desenvolvimento de produtos, etc.


A ideia não é se prender em nenhum  protocolo. A proposta é informar os dois meios disponíveis atualmente para pesquisa.

Como os rádios para desenvolvimento possuem tamanhos relativamente reduzidos, dificultando o trabalho para um grande número de pessoas/desenvolvedores, a AFEletrônica desenvolveu um módulo para vir facilitar este desenvolvimento e despertar o interesse de mais pessoas para o mundo maker desenvolvendo aplicações com rádios nas fequèncias 915Mhz ou 433Mhz.


Lora 1276  RF4463Pro e Arduino

A comunicação com o módulo é feita via SPI, usando um módulo Arduino ou outro processador para a configuração. Adicional aos sinais SPI, esses rádios requerem o tratamento de sinais adicionais. À medida que o módulo funciona com tensão máxima de 3v3 em seus terminais.
Portanto se faz necessário uma tradução de nível lógico de sinal entre Arduino/Processador e SX1276 ou RF4463Pro 
Percebe-se que não é tão trivial o desenvolvimento de aplicações com o módulo em casa por exemplo, devido ao seu tamanho e dificuldade para manuseio, o rádio possui seus exatos: 17,30 x 17,0 x 2,6 mm e passo de seus terminais de 1,27mm, daí a dificuldade de manuseio, impossível? claro que não, mas convenhamos que não é para qualquer um.

Pensando nesta dificuldade a engenharia da AFEletrônica deu um passo à frente desenvolvendo um equipamento que suporta os dois rádios, Lora 1276 e RF4463Pro, entre outras possibilidades que você ira perceber ao longo desta matéria.


Radio Lora
Módulo AFSmartRadio montado com Pro-Mini e Radio RF4463Pro

O rádio aqui abordado será o módulo tranceptor RF4463Pro 915Mhz, a placa base desenvolvida pela AFEletrônica suporta dois rádios distintos, o próprio RF4463Pro quanto o rádio Lora1276 que iremos entrar em detalhe em uma próxima oportunidade, bastando apenas escolher a montagem no slot referente a cada modelo de rádio, uma vez que os módulos possuem disposições distintas para os pinos de alimentação e comunicação. Para suportar os dois modelos o módulo AFSmartRadio, foi desenvolvido para ambos, abrindo assim um leque de possibilidades para o desenvolvedor.


O módulo AFSmartRadio (vamos chamar placa base, ou placa mãe), possui algumas variações de montagem que deve ser escolhida no momento da aquisição. Pode ser montado com conector aparafusado ou barra de pinos nas saídas/entradas disponibilizadas na lateral da placa, visando sempre facilitar quem estará usando o equipamento.

O tipo de antena deve ser escolhido de acordo com a aplicação/necessidade. 

Embora o módulo possua uma antena impressa on-board, sendo possível com apenas um jumper de estanho conecta-la ao pino Antena do Rádio. O desempenho não é grande mas para estudos e pequenas distâncias funcionam perfeitamente, a distância conseguida em teste chegou em aproximadamente 40 metros. 


Com antena 915Mhz externa de 1.5 dBi longa conectada no conector SMA com o rádio RF4463Pro, a história já foi outra, se conseguiu em teste de campo um desempenho de 0,36Km de raio em area livre, conforme imagem ao final desta matéria.

O módulo também pode ser montado com antena helicoidal  915Mhz, neste caso é interessante solicitar a placa sem o conector SMA, a antena deve ser escolhida conforme desejo respeitando tão somente a frequência de 915Mhz. Há outros modelos claro, inclusive no próprio site da AFEletrônica.


 Antena Helicoidal 915Mhz


Os pinos de conexão dos rádios segue montado para apenas um rádio, caso adquira somente o módulo sem os rádios deve informar o fabricante para qual rádio deve ser montado Lora1276 ou RF4463Pro - para isso deve ser deixado uma mensagem na compra, no entando quando eles percebem que a compra foi somente do módulo AFSmartRadio eles irão lhe questionar a respeito via mensagem pelo próprio site.

Especificações módulo base AFSmartRadio:

Tensão de Alimentação: 9~15Vdc

Entrada para módulos: Rf4463PRO ou Lora1276 (necessário montar Slot conforme modelo escolhido) - possível montar os dois modelos, mas extremamente importante atentar a posição de montagem uma vez que as pinagens são distintas para cada modelo de Rádio.

Slot para Arduino Pro-Mini - necessário atentar ao modelo pois o Pro-Mini possui algumas variantes com relação à pinagem, Pode ser usado Pro-Mini versão 3v3@8Mhz ou Pro-Mini 5v@16Mhz, para o módulo AFSmart é transparente um ou outro modelo.

Slot para Cartão MicroSD lado de baixo da placa

Saída Rele: 250Vac@5A

Botão para uso Geral

Led de Status para uso Geral

Slot para aplicações futuras ou necessidade do usuário

Entrada Para Antena Externa

Slot para comunicação com periféricos I2c

Slot para Ethernet Enc28j60 ou necessidade do usuário

Conector para comunicação com periféricos I2c

Possui antena impressa on-board distância alcançada 40 metros campo aberto
Projeto de sensor interno para leitura da tensão de alimentação.

Conector SMA para antena externa

Consumo Rádio Lora1276
SleepMode < 200nA @20dBm
Modo Rx 13mA @20dBm
Modo Tx 120mA @20dBm

Consumo rádio RF4463Pro
SleepMode < 100nA @20dBm
Modo Rx 13.5mA  @20dBm
Modo Tx 85mA  @20dBm


Possibilidade de montar uma memória I2c modelo 24C256/8_TSSOP - pode inclusive ser solicitado para o fabricante enviar montado mediante o pagamento para aquisição e montagem da mesma.


O módulo AFSmart é comercializado com ou sem os módulos:
Arduino, Rádios RF4463Pro ou Lora 1276.
Módulo Adapção rádio Lora e Arduino
Descrição das pinagens - atente ao modelo com barra de pinos



Para implementação desta matéria foi utilizado dois módulos AFSmart com os rádios RF4463Pro.

Módulo Cliente - envia a mensagem "AFEletronica Ola voce esta ai?"

Módulo Server - uma vez recebeu a mensagem "AFEletronica Ola voce esta ai?" responde com a mensagem "Ola AFEletronica estou aqui 100%";

Há também um status visual via LedStatus que esta ligado ao pino A3 do Pro-Mini de forma a informar visualmente que há comunicação entre ambos.

No Módulo cliente para auxiliar nas medidas realizadas em campo e não precisar ficar olhando para o LedStatus ligamos e desligamos também o Rele que esta no pino IO4 do Pro-Mini, assim pelo som de atracamento do rele foi possível verificar que havia comunicação ao mesmo tempo que o módulo cliente era distanciado do módulo Servidor.

Método utilizado para realizar a gravação do Arduino Pro-mini, escrevemos sobre isso em uma outra matéria acesse aqui


Método utilizado para envio da aplicação ao Arduino Pro-Mini





Código módulo Cliente - baseado no exemplo de: rf24_client.pde

#include <SPI.h>
#include <RH_RF24.h>

// Singleton instance of the radio driver
RH_RF24 rf24;

const int ledPin =  A3 ;       // LedStatus ligado ao pino A3 do Pro-Mini
const int RelayPin = 4;       // Rele
int ledState = LOW;           // ledState usado para comutar o LED
int RelayState = LOW;       // RelayState usado para comutar o Rele
int chipSelect = 8;             // chipSelect SDCard

void setup() 
{
  pinMode(chipSelect , OUTPUT);
  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin,HIGH);
  pinMode(RelayPin, OUTPUT);
  digitalWrite(RelayPin,LOW);
  Serial.begin(9600);

  
  
  if (!rf24.init())
    Serial.println("init failed");
//Para 915Mhz descomentar em RH_RF24.cpp a linha radio_config_Si4464_30_915_2GFSK_5_10

}


void loop()
{

  float temperatura = rf24.get_temperature();  
  Serial.println("Sending to rf24_server");
  Serial.println(temperatura);
  // Envia Mensagem para o  Rf4463PRO Servidor
  uint8_t data[] = "AFEletronica Ola voce esta ai?";
  rf24.send(data, sizeof(data));
  
  rf24.waitPacketSent();
  // Aguarda uma resposta do Servidor 
  uint8_t buf[RH_RF24_MAX_MESSAGE_LEN];
  uint8_t len = sizeof(buf);

  if (rf24.waitAvailableTimeout(500))
  { 
    // A resposta deve ser "Ola AFEletronica estou aqui 100%"
    if (rf24.recv(buf, &len))
    {
      Serial.print("got reply: ");
      Serial.println((char*)buf);
      //Inverte o estado do led (HIGH/LOW) - se receber a resposta do servidor comuta o led        quanto o Rele e escreve na serial
     
      ledState = !ledState;                 //comuta LedStatus
      RelayState = !RelayState;        //Comuta Rele
      //Aciona a porta do led
      digitalWrite(ledPin, ledState);
      digitalWrite(RelayPin, RelayState);
     
    }
    else
    {
      Serial.println("recv failed");
    }
  }
  else
  {
    Serial.println("No reply, is rf24_server running?");
  }
  delay(400);
}

Código módulo Servidor - baseado no exemplo de: rf24_server.pde



#include <SPI.h>
#include <RH_RF24.h>

// Intancia o rádio
RH_RF24 rf24;
const int ledPin = A3;          // LedStatus ligado ao pino A3 do Pro-Mini
int ledState = LOW;             // usado para comutar o LED
void setup() 
{
  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, HIGH);
  Serial.begin(9600);
  if (!rf24.init())
    Serial.println("init failed");
//Para 915Mhz descomentar em RH_RF24.cpp a linha radio_config_Si4464_30_915_2GFSK_5_10
  
}

void loop()
{
  
  if (rf24.available())
  {
    // Aguarda a mensagem que deve ser    "AFEletronica Ola voce esta ai?"
    uint8_t buf[RH_RF24_MAX_MESSAGE_LEN];
    uint8_t len = sizeof(buf);
    if (rf24.recv(buf, &len))
    {
//      RF24::printBuffer("request: ", buf, len);
      Serial.print("got request: ");
      Serial.println((char*)buf);
      Serial.print("RSSI: ");
      Serial.println((uint8_t)rf24.lastRssi(), DEC);
      
      // Responde ao cliente com a mensagem abaixo
      uint8_t data[] = "Ola AFEletronica estou aqui 100%";
    
      //Inverte o estado do led (HIGH/LOW)
      ledState = !ledState;
      //Aciona a porta do led
      digitalWrite(ledPin, ledState);
      rf24.send(data, sizeof(data));
      rf24.waitPacketSent();
      Serial.println("Sent a reply");
    }
    else
    {
      Serial.println("recv failed");
    }
  }
}



Resultado dos Testes com Rádio RF4463PRO 
Resultado testes

Programando Módulo AFSmart ESp8266 ESP12F

O módulo AFSmart ESP12F pode ser programado como um Arduino clássico, mas sua principal característica é a sua conexão Wi-Fi, o que lhe permite publicar dados para um servidor ou um painel on-line.
Módulo AFSmart ESP8266 esp12F - AFS001705


Ou criar facilmente objetos conectados, que pode ser controlado a partir de um servidor de automação residencial/Industrial ou de um aplicativo móvel (desenvolvido com Blynk ou Cayenne, por exemplo). Nesta matéria, iremos aprender como programar o ESP8266 para se comportar como um servidor Web . Ou seja, podemos interagir com o programa, o GPIO ... a partir de uma interface web acessível a partir de um navegador da Web.

Iremos usar como base nossa primeira aplicação implementando o controle utilizando do protocolo Wiegand-26 - Neste novo caso, iremos realizar o controle do Rele2 do módulo ESP8266 AFSmart , bem como mostrar no web-browser a temperatura de um sensor de temperatura, e o código lido pelo usuário no leitor de cartões.

Caso ainda não tenha instalado em sua IDE as placas ESP8266 - siga o exemplo abaixo, Seção1, caso já possua instalado, basta ir para Seção2.

Seção1


Instale as bibliotecas e placas ESP8266 na Arduino IDE


Antes de iniciar, é necessário verificar se todas as bibliotecas necessárias estão instaladas.http://arduino.esp8266.com/stable/package_esp8266com_index.json

Vá para o gerente da placa e procure por esp8266 , então clique em instalar.


Após instalar, feche sua IDE e abra novamente de forma a reinicar e carregar as placas instaladas.

Seção2

Na sua IDE Arduino escolha a Placa conforme imagem abaixo


Para a Porta COM verifique qual foi porta atribuída pelo Windows, caso não saiba, basta ir em Gerenciador de Dispositivos e verificar.

Para esta aplicação será utilizado o módulo AFSmart AF12F  desenvolvido pela AFEletronica, pode ser adquirido Clicando no link.

Qual a vantagem? 

Se trata de um produto de tamanho reduzido já com entrada para sensor de temperatura DS18B20, entrada para sensores Infra Vermelho Tx e Rx, o módulo possui versão para alimentação AC ou DC onde se conecta diretamente na rede AC 127/220V ou a versão DC onde possui as versões 9V/12V.

Possui ainda dois reles para uso geral. Conversor de nível nas IO´s IO0 e IO4, onde pode ser implementado comunicação I2c, Serial, quando a linha de dados do periférico externo possui tensão superior à 3V3.

Neste caso iremos utilizar este conversor para comunicar com um leitor de cartão Wiegand-26, onde será conectado ao barramento Data0 e Data1 do Wiegand-26 do leitor de cartões, onde sua tensão é de 5Vdc.

Não bastasse os pinos não utilizados internamente ao módulo, foi disponibilizado em um barramento lateral para uso Geral.

ESP12F

A aplicação deste projeto irá apresentar as seguintes características
Mostrar no Browser a temperatura lida pelo sensor DS18B20
Controle do Rele1 via leitor de Cartão Wiegand-26, será dado um pulso de 3s após a leitura do cartão, será realizado a leitura de dois cartões ou dois usuários, o código deste cartão será apresentado no browser informando se o mesmo é do usuário 1 ou usuário 2.
Será realizado o controle do Rele2 do módulo via browser.

Portanto para implementação será necessário:
01 - módulo AFSmart  
01 - com sensor de temperatura DS18B20 conectado/soldado ao módulo
01 Leitor de Cartão Wiegand-26
01 Conversor USB-Serial para envio da aplicação ao módulo

O código:


#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
#include <Wiegand.h>
#include <OneWire.h>

#define ssid      "SSID"       // WiFi SSID
#define password  "password"  // WiFi password
#define Rele2      16          // Led
#define Rele1       14
byte i;
byte present = 0;
byte type_s;
byte data[12];
byte addr[8];
float celsius, fahrenheit;

float   t = 0 ;
float   h = 0 ;
float   p = 0;
long code = 0 ;
int user = 0;
String  etatLed = "OFF";

#define FALSE 0      
#define TRUE  1 
const int rele1 = 14;
long Usuario1 = 0x97F8A5; // código cartao MiFire
long Usuario2 = 0x5C2FE5; // código cartao MiFire

WIEGAND wg;
OneWire  ds(2);  // pino que esta ligado o Sensor de Temperatura
ESP8266WebServer server ( 80 );
String getPage(){
  String page = "<html lang=pt-BR><head><meta http-equiv='refresh' content='10'/>";
  page += "<title>ESP8266 Demo - www.afeletronica.com.br</title>";
  page += "<style> body { background-color: #fffff; font-family: Arial, Helvetica, Sans-Serif; Color: #000088; }</style>";
  page += "</head><body><h1>ESP8266 AFSmart - Protocolo Wiegand </h1>";
  page += "<h3>DS18B20</h3>";
  page += "<ul><li>Temperatura : ";
  page += celsius;
  page += "&deg C</li>";
  page += "</li></ul>";
  page += "<ul><li>Codigo Wiegand : ";
  page += code;
  page += "</li></ul>";
  page += "<ul><li>Usuario : ";
  page += user;
  
  page += "<h3>Rele2</h3>";
  page += "<form action='/' method='POST'>";
  page += "<ul><li>Rele2 (estado: ";
  page += etatLed;
  page += ")";
  page += "<INPUT type='radio' name='LED' value='1'>ON";
  page += "<INPUT type='radio' name='LED' value='0'>OFF</li></ul>";
  page += "<INPUT type='submit' value='Atualizar'>";

  page += "</body></html>";
  return page;
}
void handleRoot(){ 
  if ( server.hasArg("LED") ) {
    handleSubmit();
  } else {
    server.send ( 200, "text/html", getPage() );
  }  
}
void handleSubmit() {
  // Actualise le GPIO / Update GPIO 
  String LEDValue;
  LEDValue = server.arg("LED");
  Serial.println("Set GPIO "); Serial.print(LEDValue);
  if ( LEDValue == "1" ) {
    digitalWrite(Rele2, LOW);
    etatLed = "On";
    server.send ( 200, "text/html", getPage() );
  } else if ( LEDValue == "0" ) {
    digitalWrite(Rele2, HIGH);
    etatLed = "Off";
    server.send ( 200, "text/html", getPage() );
  } else {
    Serial.println("Err Led Value");
  }
}

void ds_18b20(){
  
  if ( !ds.search(addr)) {
   // Serial.println("No more addresses.");
    //Serial.println();
    ds.reset_search();
    delay(250);
    return;
  }
  
  //Serial.print("ROM =");
  for( i = 0; i < 8; i++) {
    //Serial.write(' ');
    //Serial.print(addr[i], HEX);
  }

  if (OneWire::crc8(addr, 7) != addr[7]) {
      //Serial.println("CRC is not valid!");
      return;
  }

  ds.reset();
  ds.select(addr);
  ds.write(0x44, 1);        // start conversion, with parasite power on at the end
  
  delay(1000);     // maybe 750ms is enough, maybe not
  // we might do a ds.depower() here, but the reset will take care of it.
  
  present = ds.reset();
  ds.select(addr);    
  ds.write(0xBE);         // Read Scratchpad

  for ( i = 0; i < 9; i++) {           // we need 9 bytes
    data[i] = ds.read();

  }

  // Convert the data to actual temperature
  // because the result is a 16 bit signed integer, it should
  // be stored to an "int16_t" type, which is always 16 bits
  // even when compiled on a 32 bit processor.
  int16_t raw = (data[1] << 8) | data[0];
  if (type_s) {
    raw = raw << 3; // 9 bit resolution default
    if (data[7] == 0x10) {
      // "count remain" gives full 12 bit resolution
      raw = (raw & 0xFFF0) + 12 - data[6];
    }
  } else {
    byte cfg = (data[4] & 0x60);
    // at lower res, the low bits are undefined, so let's zero them
    if (cfg == 0x00) raw = raw & ~7;  // 9 bit resolution, 93.75 ms
    else if (cfg == 0x20) raw = raw & ~3; // 10 bit res, 187.5 ms
    else if (cfg == 0x40) raw = raw & ~1; // 11 bit res, 375 ms
    //// default is 12 bit resolution, 750 ms conversion time
  }
  celsius = (float)raw / 16.0;
  fahrenheit = celsius * 1.8 + 32.0;
}

    

void readCard(){

if(wg.available())
  {
    Serial.print("Wiegand HEX = ");
    //Serial.print(wg.getCode(),HEX);
    //code = (wg.getCode(),HEX);
     code = wg.getCode();
    
    Serial.print(code,HEX);
    Serial.print(", DECIMAL = ");
    Serial.print(wg.getCode());
    Serial.print(", Gate= ");
    Serial.print(wg.getGateActive());
    Serial.print(", Type W");
    Serial.println(wg.getWiegandType());    

    //if the code matches to claires card
    if(wg.getCode() == Usuario1)
    {
      Serial.println("Usuario1\n");
       user = 1;
       //open the door
      digitalWrite(14, LOW);
      //turn on her pathway lights
      //digitalWrite(5, HIGH);
      //wait 2 seconds before lock the door
      delay(3000);
      digitalWrite(14, HIGH);
      //wait 1 minute before turning off the lights
      //delay(60000);

    }

    if(wg.getCode() == Usuario2)
    {
      Serial.println("Usuario2\n");
       user = 2;
       //open the door
      digitalWrite(14, LOW);
      //turn on her pathway lights
      //digitalWrite(5, HIGH);
      //wait 2 seconds before lock the door
      delay(3000);
      digitalWrite(14, HIGH);
      //wait 1 minute before turning off the lights
      //delay(60000);

    }
       
    }

  
}
void setup() {
  Serial.begin ( 115200 );
// PIN assigment and declaration for Arduino Mega 
  //GATE A 
  wg.D0PinA =0;   
  wg.D1PinA =4;   

  //GATE B
  //wg.D0PinB =18;  
 // wg.D1PinB =19;   

  //GATE C
//  wg.D0PinC =20;  
//  wg.D1PinC =21;
 // Reader enable
  wg.begin(TRUE, FALSE, FALSE);  // wg.begin(GateA , GateB, GateC)

  pinMode(14,OUTPUT);
  pinMode(16,OUTPUT);
  digitalWrite(14,HIGH);
  digitalWrite(16,HIGH);
  
  WiFi.begin ( ssid, password );
  // Attente de la connexion au réseau WiFi / Wait for connection
  while ( WiFi.status() != WL_CONNECTED ) {
    delay ( 500 ); Serial.print ( "." );
  }
  // Connexion WiFi établie / WiFi connexion is OK
  Serial.println ( "" ); 
  Serial.print ( "Connected to " ); Serial.println ( ssid );
  Serial.print ( "IP address: " ); Serial.println ( WiFi.localIP() );
  // On branche la fonction qui gère la premiere page / link to the function that manage launch page 
  server.on ( "/", handleRoot );
  server.begin();
  Serial.println ( "HTTP server started" );
  
}
void loop() {
  server.handleClient();
  readCard();
  ds_18b20();

}

Para pegar o número IP do módulo AFSmart, abra o monitor serial, em seguida, conecte-se  ao módulo a ele a partir de um navegador da Web para acessar a interface da estação meteorológica.

Imagem da aplicação:


Vídeo da leitura do Cartão MiFire