MEDIDOR DE ENERGIA ARDUINO: 10 etapas (com fotos)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:38

[Reproduzir vídeo]

Eu pertenço a uma vila de Odisha, na Índia, onde cortes de energia frequentes são muito comuns. Isso atrapalha a vida de cada um. Durante a minha infância, continuar os estudos após o anoitecer foi um verdadeiro desafio. Devido a esse problema, projetei um sistema solar para minha casa em caráter experimental. Usei um painel solar de 10 Watt, 6 V para acender alguns LEDs brilhantes. Depois de enfrentar muitas dificuldades, o projeto foi bem sucedido. Então decidi monitorar a tensão, corrente, potência e energia envolvida no sistema. Isso trouxe a ideia de projetar um MEDIDOR DE ENERGIA. Usei ARDUINO como o coração deste projeto porque é muito fácil escrever código em seu IDE e há um grande número de bibliotecas de código aberto disponíveis na internet que podem ser utilizadas de acordo com o requisito. Eu experimentei o projeto para um sistema solar de classificação muito pequena (10 Watts), mas isso pode ser facilmente modificado para uso em sistemas de classificação superior.

Você pode encontrar todos os meus projetos em:

Característica: Monitoramento de energia por 1. display LCD 2. via internet (upload Xively) 3. Registro de dados em um cartão SD

Você pode ver meu novo CONTROLADOR DE CARGA SOLAR ARDUINO MPPT instrutível (versão 3.0)

Você também pode ver meus outros instructables em

CONTROLADOR DE CARGA SOLAR ARDUINO (versão 2.0)

CONTROLADOR DE CARGA SOLAR ARDUINO (versão 1)

Etapa 1: Peças necessárias:

1. ARDUINO UNO (Amazônia) 2. ARDUINO ETHERNET SHIELD (Amazon)

3. LCD CHARACTER 16x2 (Amazon)

4. SENSOR DE CORRENTE ACS 712 (Amazon) 4. RESISTORES (10k, 330ohm) (Amazon) 5. POTENCIÔMETRO 10K (Amazon) 6. JUMPER WIRES (Amazon) 7. CABO ETHERNET (Amazon) 8. BREAD BOARD (Amazon)

Etapa 2: Força e energia

Potência: A potência é o produto da tensão (volt) e da corrente (Amp) P = VxI Unidade de potência é Watt ou KWEnergia: A energia é o produto da potência (watt) e do tempo (Hora) E = Pxt Unidade de energia é Watt hora ou quilowatt Hora (kWh) A partir da fórmula acima, é claro que para medir a energia precisamos de três parâmetros 1. Tensão 2. Corrente 3. Tempo

Etapa 3: Medição de Tensão

A tensão é medida com a ajuda de um circuito divisor de tensão. Como a tensão de entrada do pino analógico ARDUINO é restrita a 5 V, projetei o divisor de tensão de forma que a tensão de saída dele seja inferior a 5 V. Minha bateria é usada para armazenar o a energia do painel solar é avaliada em 6 V, 5,5 Ah. Portanto, tenho que diminuir essa tensão de 6,5 V para uma tensão inferior a 5 V. Usei R1 = 10k e R2 = 10K. O valor de R1 e R2 pode ser menor, mas o problema é que quando a resistência é baixa, maior fluxo de corrente através dela, como resultado, grande quantidade de energia (P = I ^ 2R) dissipada na forma de calor. Portanto, diferentes valores de resistência podem ser escolhidos, mas deve-se tomar cuidado para minimizar a perda de energia na resistência. Vout = R2 / (R1 + R2) * Vbat Vbat = 6,5 quando totalmente carregado R1 = 10k e R2 = 10k Vout = 10 / (10 + 10) * 6,5 = 3,25v que é inferior a 5v e adequado para ARDUINO pino analógico NOTA I mostramos uma bateria de 9 volts no circuito da placa descoberta é apenas, por exemplo, para conectar os fios. Mas a bateria real que usei é uma bateria de ácido de chumbo de 5,5Ah de 6 volts. Calibração de tensão: Quando a bateria está totalmente carregada (6,5 V), obteremos a Vout = 3,25v e valor inferior para outra tensão inferior da bateria. AEDUINO ADC converte o sinal analógico para a aproximação digital correspondente. Quando a voltagem da bateria é 6,5v, obtive 3,25v do divisor de voltagem e sample1 = 696 no monitor serial, onde sample1 é o valor ADC correspondente a 3,25vPara melhor compreensão, anexei a simulação em tempo real por 123D.circuito para medição de voltagem Calibração: 3,25v equivalente a 696 1 é equivalente a 3,25 / 696 = 4,669mv Vout = (4,669 * amostra1) / 1000 volts Tensão real da bateria = (2 * Vout) CÓDIGO voltARDUINO: // tirando 150 amostras do divisor de tensão com um intervalo de 2 segundos e, em seguida, calcule a média dos dados das amostras coletados para (int i = 0; i <150; i ++) {amostra1 = amostra1 + leitura analógica (A2); // ler a tensão do circuito divisor delay (2); } amostra1 = amostra1 / 150; voltagem = 4,669 * 2 * amostra1 / 1000;

Etapa 4: Medição de corrente

Para medição de corrente, usei um sensor de corrente de efeito Hall ACS 712 (20 A). Existem diferentes sensores de faixa de corrente ACS712 disponíveis no mercado, então escolha de acordo com sua necessidade. No diagrama da placa de pão, mostrei o LED como uma carga, mas a carga real é diferente. PRINCÍPIO DE TRABALHO: O efeito Hall é a produção de uma diferença de voltagem (a voltagem Hall) através de um condutor elétrico, transversal a uma corrente elétrica no condutor e um campo magnético perpendicular à corrente. Para saber mais sobre o sensor de efeito Hall, clique aqui. A folha de dados do sensor ACS 712 pode ser encontrada aqui na folha de dados 1. O ACS 712 mede 20Amps positivos e negativos, correspondendo à saída analógica 100mV / A 2. Nenhuma corrente de teste através da tensão de saída é VCC / 2 = 5v / 2 = 2,5V Calibração: a leitura analógica produz um valor de 0-1023, igualando a 0v a 5v Então leitura analógica 1 = (5/1024) V = 4,89mv Valor = (4,89 * valor de leitura analógica) / 1000 V Mas, de acordo com as planilhas de dados, o deslocamento é de 2,5 V (Quando a corrente zero você obterá 2,5 V da saída do sensor) Valor real = (valor-2,5) V Corrente em amp = valor real * 10 CÓDIGOARDUINO: // tirando 150 amostras de sensores com um intervalo de 2seg e, em seguida, calcule a média dos dados das amostras coletadas para (int i = 0; i <150; i ++) {sample2 + = analogRead (A3); // lê a corrente do sensor delay (2); } amostra2 = amostra2 / 150; val = (5,0 * amostra2) / 1024,0; actualval = val-2,5; // a tensão de deslocamento é 2,5 V amps = actualval * 10;

Etapa 5: medição do tempo

Para a medição do tempo não há necessidade de nenhum hardware externo, pois o próprio ARDUINO possui um temporizador embutido. A função millis () retorna o não dos milissegundos desde que a placa Arduino começou a executar o programa atual. CÓDIGO DEARDUINO: long milisec = millis (); // calcula o tempo em milissegundos long time = milisec / 1000; // converter milissegundos em segundos

Etapa 6: Como ARDUINO calcula potência e energia

totamp = totamp + amperes; // calcula o total de amps avgamps = totamps / time; // ampères médios amphr = (avgamps * time) / 3600; // amp-hora watt = voltagem * amps; // potência = tensão * energia atual = (watt * tempo) / 3600; Watt-seg é novamente convertido em Watt-Hr dividindo 1 h (3600 s) // energia = (watt * tempo) / (1000 * 3600); para leitura em kWh

Etapa 7: saída visual

Todos os resultados podem ser visualizados no monitor serial ou por meio de um LCD. Eu usei um LCD de 16x2 caracteres para exibir todos os resultados obtidos nas etapas anteriores. Para os esquemas, veja o circuito da breadboard mostrado acima. Conecte o LCD com ARDUINO conforme fornecido abaixo: LCD -> Arduino 1. VSS -> Arduino GND 2. VDD - > Arduino + 5v 3. VO -> Arduino GND pino + resistor ou potenciômetro 4. RS -> Arduino pino 8 5. RW -> Arduino pino 7 6. E -> Arduino pino 6 7. D0 -> Arduino - Não conectado 8. D1 -> Arduino - Não conectado 9. D2 -> Arduino - Não conectado 10. D3 -> Arduino - Não conectado 11. D4 -> Arduino pino 5 12. D5 -> Arduino pino 4 13. D6 -> Arduino pino 3 14. D7 -> Arduino pino 2 15. A -> Arduino Pino 13 + Resistor (energia da luz de fundo) 16. K -> Arduino GND (terra da luz de fundo) CÓDIGO ARDUINO: Para monitor serial:

Serial.print ("TENSÃO:"); Serial.print (voltagem); Serial.println ("Volt"); Serial.print ("ATUAL:"); Serial.print (amperes); Serial.println ("Amps"); Serial.print ("POWER:"); Serial.print (watt); Serial.println ("Watt"); Serial.print ("ENERGIA CONSUMIDA:"); Serial.print (energia); Serial.println ("Watt-hora"); Serial.println (""); // imprime os próximos conjuntos de parâmetros após um atraso de linha em branco (2000); Para LCD: Para display LCD, você deve primeiro importar a biblioteca "LiquidCrystal" no código. Para saber mais sobre a biblioteca LequidCrystal clique aqui Para tutorial de LCD clique aqui O código a seguir é um formato para exibir em LCD todos os cálculos de potência e energia #include lcd (8, 7, 6, 5, 4, 3, 2); luz de fundo int = 9; void setup () {pinMode (backLight, OUTPUT); // define o pino 9 como saída analogWrite (backLight, 150); // controla a intensidade da luz de fundo 0-254 lcd.begin (16, 2); // colunas, linhas. tamanho do display lcd.clear (); // limpa a tela} void loop () {lcd.setCursor (16, 1); // define o cursor fora da contagem de exibição lcd.print (""); // imprime atraso de caractere vazio (600); //////////////////////////////////////////////// imprimir potência e energia para um LCD / /////////////////////////////////////////////////// lcd.setCursor (1, 0); // define o cursor na 1ª coluna e na 1ª linha lcd.print (watt); lcd.print ("W"); lcd.print (voltagem); lcd.print ("V"); lcd.setCursor (1, 1); // define o cursor na 1ª coluna e na 2ª linha lcd.print (energia); lcd.print ("WH"); lcd.print (amperes); lcd.print ("A"); }

Etapa 8: upload de dados para Xively.com

Consulte as capturas de tela acima para melhor compreensão. Para o upload de dados para xively.com, a seguinte biblioteca deve ser baixada primeiro HttpClient: clique aquiXively: clique aqui SPI: Importar do IDE arduino (esboço -> Importar biblioteca…..) Ethernet: Importar do arduino IDE ((esboço -> Biblioteca de importação…..) Abra uma conta com https://xively.com (anteriormente pachube.com e cosm.com) Inscreva-se para uma conta de desenvolvedor gratuita em

Escolha um nome de usuário, senha, defina seu endereço e fuso horário, etc. Você receberá um e-mail de confirmação;

em seguida, clique no link de ativação para ativar sua conta. Depois de abrir a conta com sucesso, você será desviado para a página de dispositivos de desenvolvimento

• Clique na caixa + Adicionar dispositivo
• Dê um nome ao seu dispositivo e uma descrição (por exemplo, MONITORAMENTO DE ENERGIA) ·
• Escolha dados privados ou públicos (eu escolho privados) ·
• Clique em Adicionar Dispositivo

Depois de adicionar o dispositivo, você é redirecionado para uma nova página, onde muitas informações importantes estão lá

• ID do produto, segredo do produto, número de série, código de ativação ·
• Feed ID, FeedURL, API End Point (o ID do feed é usado no código ARDUINO)
• Adicionar canais (ICescolher ENERGIA e POTÊNCIA, mas você pode escolher de acordo com sua escolha) Dê unidade e símbolo para o parâmetro ·
• Adicione a sua localização ·
• Chaves API (usadas no código ARDUINO, evite compartilhar este número) ·
• Gatilhos (executar ping em uma página da Web quando um evento aconteceu, como quando o consumo de energia excede um determinado limite)

Etapa 9: Código Xively e ARDUINO

Aqui, anexei o código completo (versão beta) do medidor de energia, excluindo o registro de dados do cartão SD, que é anexado separadamente na próxima etapa. / ** Upload de dados de monitoramento de energia para xively ** / #include #include #include #include #define API_KEY "xxxxxxxx" // Insira sua chave de API Xively #define FEED_ID xxxxxxxxx // Insira seu ID de feed Xively // endereço MAC de seu Byte de blindagem Ethernet mac = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED}; // Pino analógico que estamos monitorando (0 e 1 são usados pelo escudo Ethernet) int sensorPin = 2; não assinado long lastConnectionTime = 0; // última vez que conectamos a Cosm const unsigned long connectionInterval = 15000; // atraso entre a conexão ao Cosm em milissegundos // Inicialize a biblioteca Cosm // Defina a string para nosso ID do fluxo de dados char sensorId = "POWER"; char sensorId2 = "ENERGIA"; Fluxos de dados XivelyDatastream = {XivelyDatastream (sensorId, strlen (sensorId), DATASTREAM_FLOAT), XivelyDatastream (sensorId2, strlen (sensorId2), DATASTREAM_FLOAT), DATASTREAM_FLOAT),}; // Envolva o fluxo de dados em um feed XivelyFeed feed (FEED_ID, fluxos de dados, 2 / * número de fluxos de dados * /); Cliente EthernetClient; XivelyClient xivelyclient (cliente); void setup () {Serial.begin (9600); Serial.println ("Inicializando a rede"); while (Ethernet.begin (mac)! = 1) {Serial.println ("Erro ao obter endereço IP via DHCP, tentando novamente…"); atraso (15000); } Serial.println ("Rede inicializada"); Serial.println (); } void loop () {if (millis () - lastConnectionTime> connectionInterval) {sendData (); // envia dados para xively getData (); // ler o fluxo de dados de volta xively lastConnectionTime = millis (); // atualiza o tempo de conexão para que esperemos antes de conectar novamente}} void sendData () {int sensor1 = watt; sensor interno 2 = energia; fluxos de dados [0].setFloat (sensor1); // fluxos de dados de valor de potência [1].setFloat (sensor2); // valor da energia Serial.print ("Read power"); Serial.println (datastreams [0].getFloat ()); Serial.print ("Ler energia"); Serial.println (datastreams [1].getFloat ()); Serial.println ("Enviando para Xively"); int ret = xivelyclient.put (feed, API_KEY); Serial.print ("PUT return code:"); Serial.println (ret); Serial.println (); } // obtém o valor do fluxo de dados de xively, imprimindo o valor que recebemos void getData () {Serial.println ("Lendo dados de Xively"); int ret = xivelyclient.get (feed, API_KEY); Serial.print ("Código de retorno GET:"); Serial.println (ret); if (ret> 0) {Serial.print ("Datastream é:"); Serial.println (feed [0]); Serial.print ("O valor da potência é:"); Serial.println (feed [0].getFloat ()); Serial.print ("Datastream é:"); Serial.println (feed [1]); Serial.print ("O valor da energia é:"); Serial.println (feed [1].getFloat ()); } Serial.println ();

Etapa 10: registro de dados em um cartão SD

Para armazenar dados em um cartão SD, você deve importar a biblioteca SD. Para o tutorial, clique aqui. Para saber mais sobre a biblioteca SD, clique aqui. O código para armazenar dados em um cartão SD é escrito separadamente, pois não tenho memória suficiente no meu ARDUINO UNO depois escrever código para o display LCD e enviar dados para xively.com. Mas estou tentando melhorar o código da versão beta para que um único código possa conter todos os recursos (display LCD, envio de dados Xively e armazenamento de dados em um cartão SD). O código para registro de dados está anexado abaixo. melhor codificar modificando meu código por favor compartilhe comigo. Este é meu primeiro técnico instrutível, se alguém encontrar algum erro nele, sinta-se à vontade para comentar.. para que eu possa me aprimorar. Se você encontrar áreas de melhoria neste projeto, por favor comente ou me mande uma mensagem, para que o projeto seja mais poderoso. Acho que será útil para os outros e também para mim.

Terceiro prêmio no Concurso de Circuitos 123D