Projeto IoT de tomada CA inteligente baseado em fótons

Dispositivos de carga de plugue têm uma grande participação no consumo geral de energia. Os dispositivos de carga de plugue são equipamentos normais de construção (como luzes, lâmpadas, ar condicionado, ventiladores, aquecedores etc.) que consomem energia de um plugue de CA comum. Nos Estados Unidos, o consumo de energia de dispositivos de carga de plugue conta cerca de 20 por cento do consumo total de energia. Na Índia, ele responde por até 40 por cento do consumo total de energia no país. Com a rápida urbanização em países em desenvolvimento como a Índia, a participação de dispositivos de carga de plugue no consumo nacional de energia está prestes a aumentar ainda mais. Esses dispositivos dissipam muita energia na forma de calor e levam a uma perda considerável de energia. Para economizar eletricidade e minimizar as perdas de energia de dispositivos de carga de plugue, tomadas de energia inteligentes podem ser uma solução. Essas tomadas podem ser ainda mais interligadas com eletrônicos inteligentes que monitoram o consumo de energia e mantêm um registro dele online. Dessa forma, as contas de eletricidade também podem ser controladas e reduzidas para melhor otimização.
Neste projeto, é projetada uma tomada inteligente que pode ser comutada automaticamente por meio de um relé. O soquete tem interface com um dispositivo Particle Photon IoT, que monitora o consumo de energia usando um sensor de corrente ACS 712 e ajuda a desconectar automaticamente a conexão do soquete com a rede elétrica quando o consumo de energia de um dispositivo excede um valor limite. O Photon também permanece conectado a um servidor web via hotspot Wi-Fi e continua atualizando os dados de consumo de energia para o servidor.
Este soquete inteligente é construído em Particle Photon. O Photon é uma placa IOT compatível com Arduino desenvolvida e fornecida pela Particle (antiga Spark). O código do programa no Photon precisa ser escrito no Web IDE fornecido no site oficial do Particle. Antes disso, um engenheiro de projeto precisa criar uma conta no site Particle e registrar a placa Photon em sua conta. O desenvolvedor pode registrar vários fótons ou outros painéis de partículas em sua conta de usuário. O desenvolvedor precisa escrever o código no Web IDE e selecionar uma placa para transferir o código para a placa selecionada no AIR, ou seja, através da Internet. Se a placa IOT selecionada estiver ligada e conectada ao serviço Particle's Cloud, o código é gravado na placa pela internet e a placa começa a se comportar de acordo com o código transferido.
O Photon se conecta a uma página da Web de onde o dispositivo conectado ao soquete inteligente pode ser controlado. A página possui o código PHP e HTML que permite ligar ou desligar o dispositivo conectado ao soquete inteligente, passando comandos apropriados (valores de string) para o Photon. O consumo de energia do dispositivo conectado à tomada inteligente também é atualizado na mesma página. Ao controlar os aparelhos conectados à tomada inteligente a partir da página web, os usuários podem evitar o desperdício de energia e acompanhar o consumo de energia por meio de dispositivos plug-load de qualquer lugar e a qualquer hora.
Protótipo de soquete AC IoT inteligente baseado em fótons
Fig. 1: Protótipo de soquete AC IoT inteligente baseado em fótons
Componentes necessários –
Lista de componentes necessários para fazer soquete AC IoT inteligente baseado em fótons
Figura 2: Lista de componentes necessários para fazer soquete AC Smart IoT baseado em Photon
Diagrama de bloco –
Diagrama de blocos de soquete IoT inteligente baseado em fótons e monitor de energia

Fig. 3: Diagrama de blocos de soquete IoT inteligente baseado em fótons e monitor de energia

Conexões de Circuito –
O soquete inteligente projetado neste projeto é um dispositivo IoT. Ele é construído conectando um relé e um sensor de corrente ACS-712 ao Particle Photon. O relé é conectado ao Photon por um circuito de acionamento do relé enquanto o sensor de corrente está conectado a um dos pinos de entrada analógica da placa. O soquete se conecta à rede elétrica por meio do relé. O Photon possui modem Wi-Fi integrado, portanto não há necessidade de conectar nenhum shield ou modem externo.
Este dispositivo IoT baseado em Photon mede o consumo de energia do aparelho conectado à tomada inteligente e publica esses dados em uma página da web. A página web possui controles para ligar ou desligar o aparelho para otimizar o consumo de energia do aparelho conectado à tomada inteligente.
Imagem mostrando conexões de circuito de soquete IoT inteligente baseado em fótons e monitor de energia
Fig. 4: Imagem mostrando as conexões do circuito do soquete IoT inteligente baseado em fótons e do monitor de energia
O dispositivo IoT inteligente projetado aqui possui as seguintes conexões de circuito –
Particle Photon – Photon é uma placa IOT popular disponível na plataforma Particle. A placa abriga o microcontrolador STM32F205 120 MHz ARM Cortex M3 e tem 1 MB de memória flash, 128 Kb de RAM e 18 pinos de entrada e saída de uso geral (GPIO) de sinal misto com periféricos avançados. O módulo tem chip Cypress BCM43362 Wi-Fi integrado para conectividade Wi-Fi e banda única 2,4 GHz IEEE 802.11b/g/n para Bluetooth. A placa vem equipada com 2 SPI, um I2S, um I2C, um CAN e uma interface USB. O Photon de partículas tem a seguinte configuração de pinos –
Tabela de listagem de configuração de pinos de partículas fótons
Fig. 5: Tabela listando a configuração dos pinos do Particle Photon
Tabela de Listagem de Configuração de Pinos de Partículas de Fótons
Fig. 6: Tabela listando a configuração dos pinos do Particle Photon
Deve-se observar que 3V3 é uma saída filtrada utilizada para sensores analógicos. O pino 3V3 é usado aqui para fornecer alimentação CC ao sensor de corrente. Este pino é a saída do regulador integrado e está conectado internamente ao VDD do módulo Wi-Fi. Ao alimentar o Photon via VIN ou porta USB, este pino produzirá uma tensão de 3,3 V DC. Este pino também pode ser usado para alimentar o Photon diretamente (entrada máxima de 3,3 V DC). Quando usado como saída, a carga máxima em 3V3 é 100mA.
No circuito, um dos pinos de entrada analógica do Photon é usado para fazer a interface com o sensor de corrente e um dos pinos do GPIO é usado para fazer a interface com o circuito de acionamento do relé. O pino 3V3 e terra da placa são utilizados para alimentar o sensor de corrente.
Para controlar a placa pela internet, foi desenvolvida uma página web que utiliza Ajax e Jquery para enviar dados à placa utilizando o método HTTP POST. A página da web identifica a placa por um ID de dispositivo e se conecta ao Particle's Cloud Service por meio de um token de acesso.
Circuito de driver de relé – Os aparelhos de CA não podem ser controlados diretamente pelo Particle Photon. Há necessidade de um circuito de relé para controlar os aparelhos de CA por meio do Photon. Um relé de 12 V 2 A é usado para controlar o soquete inteligente e ligar ou desligar os aparelhos de CA neste circuito. O relé é conectado ao pino D0 do Particle Photon por meio do circuito de transistor BC547 conectado em uma configuração de emissor comum. O fio de fase da alimentação CA é fornecido no terminal COM do relé. Quando uma lógica ALTA é emitida pelo Photon para o pino interligado, o ponto COM muda de NC para o ponto NO, de modo que o relé causa um curto-circuito na fase com o fio neutro ligando a alimentação do aparelho. Um LED é conectado em paralelo ao circuito do relé com resistores pull-up em série. Este LED fornece uma dica visual do status ON/OFF do soquete.
Diagrama de circuito do driver de relé
Fig. 7: Diagrama de Circuito do Driver do Relé
Sensor de corrente ACS-712 – O Allegro ACS-712 fornece soluções econômicas e precisas para detecção de corrente CA ou CC em sistemas industriais, comerciais e de comunicação. O pacote do dispositivo permite fácil implementação pelo cliente. As aplicações típicas incluem controle de motor, detecção e gerenciamento de carga, fontes de alimentação de modo de comutação e proteção contra falha de sobrecorrente. O dispositivo não se destina a aplicações automotivas. O módulo ACS-712 foi projetado para ser facilmente usado com microcontroladores como o Arduino. Este sensor de corrente está disponível em classificações de corrente em escala real de 5 A, 20 A e 30 A. Para medir a corrente, o pino de saída do sensor é conectado ao pino A0 do fóton de partícula. O módulo do sensor de corrente vem com dois terminais para conectar a rede elétrica CA e três terminais para interface com os microcontroladores. Um dos terminais para conexão ao circuito CA é conectado ao fio ativo da rede elétrica no soquete e o outro terminal é conectado ao ponto NO do relé. O ponto NC do relé é conectado ao fio neutro da rede elétrica no soquete. Existem três terminais para interface do controlador – VCC, GND e Out. O terminal VCC é usado para fornecer alimentação DC ao ACS-712 IC. Ele é conectado ao pino 3V3 do Photon. O pino GND é conectado ao pino de aterramento do Photon (terra comum). O pino Out do módulo sensor é conectado ao pino de entrada analógica A0 do Photon.
Fonte de alimentação – Neste circuito, o Particle Photon e os módulos do sensor precisam de uma CC regulada de 5 V, enquanto o relé precisa de uma CC regulada de 12 V para sua operação. A rede CA é usada como fonte primária de energia. A alimentação da rede elétrica é reduzida por um transformador e retificada por um retificador de ponte completa. A saída retificada é regulada para 5V e 12V usando CIs 7805 e 7812. O pino 1 de ambos os CIs reguladores de tensão está conectado ao ânodo da bateria e o pino 2 de ambos os CIs está conectado ao terra. As respectivas saídas de tensão são extraídas do pino 3 dos respectivos CIs reguladores de tensão. Um LED junto com um resistor pull-up de 10K Ω também é conectado entre o terra comum e o pino de saída para obter uma dica visual da continuidade da alimentação.
Como funciona o circuito –
Quando o Particle Photon é ligado, o circuito de relé é inicialmente configurado para manter o soquete aberto em circuito da rede elétrica. O Photon se conecta com a conexão Wi-Fi disponível. As configurações de Wi-Fi são codificadas no código do Photon. O Photon se conecta com sua plataforma IoT com a ajuda do ID do dispositivo registrado e da chave de token de acesso. O usuário agora pode operar o soquete inteligente com a ajuda de uma página da web.
Esta página também se conecta à plataforma IoT do Particle e envia dados para a placa Photon cadastrada com a ajuda do ID do dispositivo e token de acesso. Os dados são enviados ao Photon por um formulário utilizando o método POST da pilha TCP-IP. A página da web é um código HTML/PHP simples com botões de opção para ligar ou desligar o dispositivo. Por padrão, o botão de opção OFF está selecionado. O usuário pode selecionar o botão de opção ON. Os botões de opção permitem selecionar qualquer um dos botões de opção de cada vez. Quando o usuário seleciona o botão de opção ON ou OFF, o status é enviado como uma consulta do método HTTP POST na URL que também contém o ID do dispositivo do Photon. O mesmo status é então passado da plataforma IoT para o Photon. O fóton lê o status acessando a plataforma conectando-se a um hotspot Wi-Fi. Se um comando 'ON' for lido, o Photon muda a saída em D0 para HIGH e liga o soquete inteligente. Caso contrário, mantém a saída em D0 para LOW, desligando assim a tomada inteligente.
O fotão também continua a ler a saída de tensão analógica do sensor ACS-712. O módulo sensor possui uma saída de tensão que é linearmente proporcional ao consumo de corrente.
Gráfico mostrando a tensão de saída e a respectiva corrente detectada
Fig. 8: Gráfico mostrando a tensão de saída e a respectiva corrente detectada
Como pode ser visto no gráfico acima (retirado da folha de dados do ACS-712), o sensor emite uma tensão de 2,5 V para 0 A. A saída de tensão do sensor permanece entre 2,5 V e 0,5 V para corrente até 20 A no sentido inverso enquanto permanece entre 2,5 V e 4,5 V para corrente de até 20 A no sentido positivo. Assim, a direção da corrente bem como o consumo de corrente podem ser detectados pela saída analógica do sensor.
Na maioria dos casos, a expressão da corrente CA estará em um valor conhecido como RMS. Para utilizar o sensor de corrente ACS712 para medir a corrente CA, é importante compreender como calcular um valor de corrente RMS a partir das leituras do dispositivo. O ACS-712 reporta medições de corrente com saída de tensão. A tensão RMS precisa ser calculada e algum fator de escala precisa ser aplicado para determinar o consumo real de corrente. A conversão para uma onda senoidal com deslocamento de zero volt (como sua rede elétrica ou linha de energia) pode ser feita da seguinte maneira –
1) Encontre a tensão pico a pico (Volts pico a pico).
2) Divida a tensão pico a pico por dois para obter a tensão de pico (Volts Peak).
3) Multiplique a tensão de pico por 0,707 para obter volts RMS (Volts RMS).
Tendo calculado a tensão RMS, é simplesmente uma questão de multiplicar pelo factor de escala do ACS-712 específico para obter o valor RMS da corrente que está a ser medida.
A tensão analógica detectada no sensor é convertida em um valor digital pelo canal ADC integrado do Photon. O Photon possui canais ADC longos de 12 bits, portanto o valor digital convertido varia de 0 a 4096 para tensões entre 0 a 5V. A partir do valor digitalizado, a saída de tensão real do sensor pode ser derivada, a partir da qual o valor RMS pode ser calculado e, portanto, o consumo de corrente RMS em amperes. O consumo de energia pode ser calculado multiplicando o consumo de corrente em amperes pela tensão da rede elétrica (220 V). O consumo de energia na tomada inteligente é detectado e enviado para a página web. Pelo consumo de energia na tomada inteligente, o usuário pode decidir desligar ou manter a tomada ligada.
Desta forma, o consumo de energia na tomada inteligente pode ser monitorado online e a tomada pode ser ligada ou desligada a partir da página web projetada. A página da web pode ser armazenada e carregada de qualquer dispositivo como PC, laptop ou smartphone.
Guia de programação –
O código do Photon começa com a declaração das variáveis ​​para armazenamento da leitura dos dados do sensor e das variáveis ​​que representam as conexões dos pinos do circuito do relé e do sensor de corrente com o Photon.
Captura de tela do código C usado para inicialização no código Photon para Smart Socket
Fig. 9: Captura de tela do código C usado para inicialização no código Photon para Smart Socket
Inicialização em código de fótons para Smart Socket
A função setup é chamada na qual os pinos do sensor conectados ao fóton da partícula são inicializados como pino de entrada e o pino conectado ao relé é configurado como pino de saída. A função setup é executada apenas uma vez durante o início do código.
Captura de tela do código C usado na função de configuração no código Photon para Smart Socket
Fig. 10: Captura de tela do código C usado na função de configuração no código de fótons para Smart Socket
Função de configuração no código de fótons para Smart Socket
A função loop é chamada e itera infinitamente. Na função loop a função getVPP é chamada para ler o valor do sensor. O valor lido do sensor é convertido em tensão que retorna ao circuito principal e convertido em corrente (em Amps) de acordo com as equações padrão.
Captura de tela do código C usado na função Loop no código Photon para Smart Socket
Fig. 11: Captura de tela do código C usado na função Loop no código Photon para Smart Socket
Função Loop no Código de Fótons para Smart Socket
O código em loop rastreia o valor recebido da página da web por meio da plataforma IoT para determinar a comutação do relé. Confira o código completo na seção de código e experimente.
Este projeto é desenvolvido como uma aplicação IoT para energia inteligente. É um dispositivo de baixo custo que pode ser facilmente montado e instalado em uma casa inteligente.

Código fonte do projeto

###



//Program to


// -----------------------------------

// Smart Socket and Energy Monitoring Device

// -----------------------------------


//Input pin for current sensor

const int Current_ip = A0;



// output pin for Relay

int Relay = D0;


//Indication LED pin

int led = D7;


//Variable Initialize for storing values of various data

double Voltage = 0;

double VRMS = 0;

double AmpsRMS = 0;

double mVperAmp = 185;


void setup 

{

   // Here's the pin configuration, which defines the mode

   pinMode(Relay, OUTPUT);

   pinMode(led, OUTPUT);

   pinMode(Current_ip, INPUT);


   // We are also going to declare a Particle.function so that we can turn the LED/Relay on and off from the cloud.

   Particle.function("led",RelayToggle);

   // This is saying that when we ask the cloud for the function "led", it will employ the function ledToggle  from this app.


   // For good measure, let's also make sure both Relay and lED are off when we start:

   digitalWrite(Relay, LOW);

   digitalWrite(led, LOW);


}


void loop 

{

   // calling the function to read the voltage value

    Voltage = getVPP ;

    //Formula to read the VRMS

    VRMS = (Voltage/2.0) * 0.707; 

    //coverting the VRMS to Ampere 

    AmpsRMS = (VRMS * 1000)/mVperAmp;

    //

      Particle.publish("Ampere", String(AmpsRMS));

       

  delay(2000);

}


// We're going to have a super cool function now that gets called when a matching API request is sent

// This is the ledToggle function we registered to the "led" Particle.function earlier.

int RelayToggle(String command) 

{

    /* Particle.functions always take a string as an argument and return an integer.

    Since we can pass a string, it means that we can give the program commands on how the function should be used.

    In this case, telling the function "on" will turn the Relay and LED on and telling it "off" will turn the Realy and LED off.

    Then, the function returns a value to us to let us know what happened.

    In this case, it will return 1 for the Relay and LED turning on, 0 for the Relay and LED turning off,

    and -1 if we received a totally bogus command that didn't do anything to the Relay.

    */


    if (command=="on") 

    {

        digitalWrite(Relay,HIGH);

        digitalWrite(led,HIGH);

        return 1;

    }

    else if (command=="off")

    {

        digitalWrite(Relay,LOW);

        digitalWrite(led,LOW);

        return 0;

    }

    else 

    {

        return -1;

    }

}


float getVPP 

{

  float result;

  

  int readValue;             //value read from the sensor

  int maxValue = 0;          // store max value here

  int minValue = 1024;          // store min value here

  

   uint32_t start_time = millis ;

   

   while((millis -start_time) < 1000) //sample for 1 Sec

   {

       readValue = analogRead(Current_ip)/4;


       // see if you have a new maxValue

       if (readValue > maxValue) 

       {

           //record the maximum sensor value

           maxValue = readValue;

       }

       if (readValue < minValue) 

       {

           //record the maximum sensor value

           minValue = readValue;

       }

   }

   // Subtract min from max and multiply with the reference voltage of ADC

   result = ((maxValue - minValue) * 3.3)/1024.0;

      

   return result;

 }

###

Diagramas de circuito

Diagrama de circuito baseado em fótons Smart-IoT-AC-Socket

Ficha técnica do projeto

https://www.engineersgarage.com/wp-content/uploads/2019/10/ACS-712-Datasheet-Particle-Photon-Based-Smart-IoT-Socket.pdf



Vídeo do projeto

Conteúdo Relacionado

Voltar para o blog

Deixe um comentário

Os comentários precisam ser aprovados antes da publicação.