Registro de dados com hardware e software livre no setor de energia

Painéis solares, Arduino, PHP, MySQL e Flotr

Explore como monitorar condições climáticas simples com o Arduino no contexto de geração de energia solar. Especificamente, obtenha uma introdução ao sensoriamento básico de temperatura com o chip TMP36 e de luz com um diodo emissor de luz (LED), e armazene as informações para recuperação posterior. Em seguida, suavize os resultados selecionados e exiba-os em um gráfico, utilizando PHP como processador de dados, MySQL® como sistema autônomo e Flotr como biblioteca de gráfico.

Colin Beckingham, Researcher, Freelance

Colin Beckingham é pesquisador freelancer, escritor e programador. Ele mora na região leste de Ontário, no Canadá. Com diplomas da Universidade de Queen, em Kingston, e da Universidade de Windsor, atuou em uma grande variedade de áreas, incluindo o setor financeiro, horticultura, corrida de cavalos, ensino, serviço público e viagens e turismo. Autor de aplicativos de banco de dados, inúmeros jornais, revistas e artigos on-line. Seu interesse em pesquisa inclui programação de software livre, VoIP e aplicativos por controle de voz no Linux. É possível entrar em contato com Colin através do e-mail colbec@start.ca.



03/Ago/2011

Visão geral

À medida que a geração de energia passa a adotar fontes mais limpas e mais inteligentes, os conjuntos de painéis fotovoltaicos de pequena escala brotam em telhados e quintais. Algumas dessas instalações são sofisticados, com um alto nível de monitoramento e ajuste automático. Outras não têm autopercepção. No último caso, ainda é útil para o proprietário ter uma fonte boa e barata de dados operacionais básicos.

Queremos saber se nossos painéis estão funcionando de forma ideal, em vista das condições. Luz e temperatura, além da velocidade do vento e outros fatores, podem influenciar o rendimento do painel. Mais luz gera mais energia, mas à medida que mais energia é gerada as células esquentam, o que reduz sua eficiência. O fluxo de ar ajuda a dissipar o calor. O ideal é que haja condições de luz forte e frescor obtido por uma boa brisa ou algum resfriamento artificial.

O Arduino age como intermediário entre os sensores e seu armazenamento de dados. É uma questão simples fazer um registro permanente e exibir os dados conforme necessário. Este artigo analisa o registro de dados de temperatura usando o sensor de temperatura TMP36 e um diodo emissor de luz (LED) simples para a luz.


Arduino

O Arduino é um microprocessador de software livre barato, adaptável e programável, capaz de ler entrada de dados na forma de voltagem em seus pinos analógicos. Consulte Recursos para obter informações básicas sobre a unidade e uma boa apresentação do developerWorks para essa unidade em um contexto de jogos. Com os sensores conectados a pinos de entrada específicos, a unidade lê programaticamente os dados nesses pinos. O que ela faz com essas informações depende de como o hardware é configurado.

A maneira mais simples de obter os dados do Arduino é com a unidade conectada diretamente a uma interface USB (Universal Serial Bus) do computador host, lendo os dados como se fosse uma conexão serial. No entanto, o Arduino também pode atuar de forma independente de um computador se tiver uma fonte de alimentação e um canal de comunicação alternativo. É possível adicionar placas de extensão ("escudos") para que o Arduino armazene dados diretamente em um cartão de memória microSD, transmita dados por um cabo de rede cat5e através por meio de um servidor miniWeb ou até mesmo transmita dados por wireless para um receptor compatível.

A Figura 1 mostra um microprocessador Arduino com um escudo Ethernet instalado e cabos Ethernet e de alimentação cat5 conectados, o que lhe dá uma ideia do tamanho da unidade.

Figura 1. Arduino com escudo Ethernet
Arduino com escudo Ethernet

Alguns sensores têm seus próprios circuitos internos de suavização de dados. Os mais simples não têm. Portanto, surge a questão de se o Arduino deve fazer algum processamento necessário antes do armazenamento ou transmissão, ou se os dados deveriam ser simplesmente informados de forma bruta, como observados, para processamento posterior em outra máquina. Qualquer dos dois é perfeitamente aceitável. Este projeto simplesmente informa as observações brutas para processamento posterior. Isso fornece a opção de mudar o algoritmo para suavização a qualquer momento, se necessário. Quando um processo de suavização é aplicado, ele é integrado e provavelmente não é reversível. Em uma situação de dados em tempo real, onde os requisitos de suavização são bem compreendidos, faz mais sentido que o Arduino faça a suavização.


Sensores

Pode-se fazer uma grande variedade de sensores funcionar com o Arduino. Aqui, o TMP36 e um LED fornecem uma alternativa simples, barata e fácil de reproduzir.

O TMP36 é um transistor especialmente desenvolvido. Forneça-lhe uma voltagem e ele retorna outra voltagem que varia consistentemente com a temperatura ambiente em uma combinação diferente de conectores. Registre a voltagem de saída e execute aritmética simples para encontrar a temperatura em graus Celsius ou Fahrenheit, de acordo com a preferência. Consulte Recursos para obter ajuda com o chip e com o modo de conectá-lo ao Arduino.

Parece muito simples registrar dados de temperatura em um contexto de geração de energia solar, mas há alguns obstáculos a superar. O primeiro problema, relacionado à temperatura ambiente, é determinar onde localizar o sensor. Para evitar leituras falsas, coloque-o em um local em que não haja incidência de luz solar direta e que seja à prova de intempéries, mas que forneça ventilação suficiente. Em segundo lugar, um painel solar é composto por várias células não idênticas, cada uma das quais funciona em sua própria temperatura, nas mesmas condições ambientais. Em circunstâncias ideais, medimos todas as células e tiramos a média. Uma alternativa é testar várias delas para identificar uma célula média representativa e monitorá-la sozinha.

Um LED pode acender quando recebe determinada corrente em uma voltagem adequada e gerar uma voltagem quando exposto à luz (veja o artigo de Mike Cook em Recursos). Quanto maior a intensidade da luz, mais voltagem o Arduino vê no pino conectado. Diferentemente do sensor de temperatura, que é projetado para ser mapeável em uma escala de temperatura específica, é preciso experimentar para ver como a saída do seu LED se traduz em intensidade de luz em uma escala conhecida.

Configuração prática

Imagine que sua localização de painéis solares tem energia, não tem entrada para LAN (rede local) Ethernet, mas está dentro do alcance de um ponto de acesso wireless. A energia local pode disparar o ponto de acesso e o Arduino, com o Arduino e o escudo Ethernet plugados ao repetidor. Então, estão disponíveis os pinos analógicos 3 a 6 para a entrada do sensor; supondo que os pinos 1 e 2 estejam reservados para uso pelo escudo Ethernet (veja Recursos para saber mais sobre uso dos pinos). Quatro pinos significam que podemos ter quatro sensores, digamos dois sensores de temperatura, uma para o ambiente e outro para temperatura do painel, um sensor de luz e um sensor de velocidade do vento. Esse é um ótimo conjunto de dados para uma configuração de painel passiva.

Pode-se colocar a fiação real entre o Arduino e os sensores em distâncias curtas com cabo de telefone cat3 regular, que é um conjunto sem blindagem de dois pares de fios de calibre 24 AWG. Isso também lhe dá a opção de usar adaptadores e cabeamento de telefone facilmente disponíveis.

Trabalhando com a combinação de Arduino e escudo Ethernet não é tão fácil como um Arduino conectado apenas a USB/serial. Estes são alguns detalhes a levar em conta:

  • Normalmente não pesquisamos voltagens em pinos sem sensores conectados a eles.
  • Por meio de um conector de barril, o Arduino pode aceitar energia em um intervalo de voltagens diferentes (consulte Recursos para ver os detalhes). Leituras de voltagem de pino analógico parecem depender criticamente da voltagem da fonte de alimentação do Arduino. Certifique-se de fazer sua calibração de sensores com a mesma unidade de fonte de alimentação que pretende usar em campo. Usuários avançados usam o pino AREF (Analog Reference) para fornecer a voltagem de referência.
  • Conecte seu sensor de temperatura na parte de trás de uma célula solar. Fita adesiva parece funcionar muito bem para manter o sensor contra a célula, mesmo em condições quentes em curto prazo, mas certifique-se de que todos os fios ou conectores expostos estejam protegidos e isolados por uma boa fita isolante. Não é incomum que a temperatura de uma célula suba para uma temperatura normal de operação da célula (NOCT) de 50 °C (124 °F) com luz brilhante quando a temperatura ambiente é de 20 °C (69 °F) e sopra uma brisa constante.
  • O Arduino com escudo Ethernet consome bastante energia. Se usarmos um conjunto de pilhas tamanho AA totalmente carregadas para fornecer voltagem e corrente, elas duram apenas algumas horas. Os usuários avançados procuram os modos de hibernação disponíveis para controlar o uso de energia.

A Figura 2 mostra os sensores TMP36 conectados a um quadro e painel solar. À direita, sob a fita isolante preta, está um sensor de temperatura ambiente retirado do polo de metal. À esquerda há um segundo sensor conectado à parte traseira de uma célula solar com fita adesiva. A fita adesiva mantém aderência muito melhor do que a fita isolante comum, pelo menos em curto prazo.

Figura 2. Sensores no painel
Sensores no painel

A Figura 3 mostra um LED verde dentro de um tubo de ensaio invertido para proteção contra chuva.

Figura 3. Sensor de luz
Sensor de luz

O programa Arduino (ou rascunho, como o Arduino o chama) que permite acesso aos dados coletados é um servidor da Web simples que é acessado por meio de um navegador ou outro script (consulte a Listagem 1). O código básico é fornecido pelo Arduino como parte da coleção de exemplos e exige um pouco de edição para se adaptar aos seus requisitos (consulte Recursos).

Lista 1. Servidor da Web do Arduino
// based on example web server sketch from http://arduino.cc/
#include <SPI.h>
#include <Ethernet.h>
//
byte mac[] = { 0x!!, 0x!!, 0x!!, 0x!!, 0x!!, 0x!! };
byte ip[] = { 192,168,0,xxx };
Server server(80);
//
void setup()
{
  // start the Ethernet connection and the server:
  delay(10000);
  Ethernet.begin(mac, ip);
  server.begin();
}
//
void loop()
{
  // listen for incoming clients
  Client client = server.available();
  if (client) {
    // an http request ends with a blank line
    boolean currentLineIsBlank = true;
    while (client.connected()) {
      if (client.available()) {
        char c = client.read();
        // if you've gotten to the end of the line (received a newline
        // character) and the line is blank, the http request has ended,
        // so you can send a reply
        if (c == '\n' && currentLineIsBlank) {
          // send a standard http response header
          client.println("HTTP/1.1 200 OK");
          client.println("Content-Type: text/html");
          client.println();
	  //
          // output the value of each analog input pin
          for (int analogChannel = 3; analogChannel < 7; analogChannel++) {
            //client.print("analog input ");
            client.print(analogChannel);
            client.print(" : ");
            client.print(analogRead(analogChannel));
            client.println("<br />");
          }
          break;
        }
        if (c == '\n') {
          // you're starting a new line
          currentLineIsBlank = true;
        } 
        else if (c != '\r') {
          // you've gotten a character on the current line
          currentLineIsBlank = false;
        }
      }
    }
    // give the web browser time to receive the data
    delay(1);
    // close the connection:
    client.stop();
  }
}

A listagem 1 começa especificando as bibliotecas de cabeçalho necessárias, o endereço MAC (Controle de Acesso à Mídia) do escudo Ethernet e o endereço IP (protocolo da Internet) pelo qual se pretende conhecer o Arduino. Ela também configura um objeto do servidor e uma variável usados para armazenar um valor que pode ser posteriormente descartado. A sub-rotina setup() é executada só uma vez, na inicialização, e inicializa o servidor. A sub-rotina loop() entra em loops continuamente, aguardando uma solicitação HTTP (Protocolo de Transporte de Hipertexto) e, então, responde com os dados necessários. Em resposta a uma solicitação, ela envia um cabeçalho de resposta HTTP padrão, coleta leituras dos pinos relevantes e envia o pacote de dados em formato de texto. Nesse caso, os dados fornecidos são a voltagem experimentada no instante da solicitação nos pinos analógico 3, 4, 5 e 6. Não são enviados dados para os pinos 1 e 2, porque eles são usados pela interface entre a placa Arduino e o escudo Ethernet. Mude o intervalo de canais para somente leitura nos pinos usados.

A resposta será algo como a saída mostrada na Listagem 2.

Lista 2. Resposta do Arduino
3 : 292
4 : 288
5 : 286
6 : 280

Isso fornece o número do pino e o valor a partir de uma escala de 0 a 1023, os dois números separados por dois pontos. A saída pode ser mais específica do que apenas especificar o número de pino analógico, mas o número genérico permite flexibilidade porque não se liga a nenhum pino em qualquer tarefa.


Armazenamento de dados

A próxima coisa a levar em conta é como os dados são armazenados. Neste caso, estamos usando MySQL como backend, como mostrado na Listagem 3.

Lista 3. Tabela de backend
CREATE TABLE IF NOT EXISTS `readings` (
  `readid` int(11) NOT NULL AUTO_INCREMENT,
  `tstamp` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `pin` int(11) NOT NULL,
  `value` float NOT NULL,
  PRIMARY KEY (`readid`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;

Esse código cria uma tabela com um campo de ID, o registro de data e hora que usa como padrão a hora do sistema de entrada, o pino ao qual a leitura se refere e um campo para a leitura real, que, nesse caso, é armazenada como flutuante.


Coleta e suavização de dados

Com o backend definido, pode-se usar o PHP para consultar o Arduino, analisar a resposta e armazenar as observações no backend, como mostrado na Listagem 4.

Lista 4. Script de registro de dados em PHP
<?php
// reader for panel monitors
$fp = fopen("http://192.168.0.xxx","r");
$mysqli = new mysqli("$server",$username,$password,$mysolar);
while ($line = fgets($fp,32)) {
  $line = str_replace("
","",trim($line)); $key = substr($line,0,1); switch ($key) { case 3: // things to do break; case 4: // things to do break; case 5: // this is light from LED recorded as is $val = (int) substr($line,4); $sql = "insert into readings values(NULL,NULL,$key,$val)"; $result = $mysqli->query($sql); //echo "val = $val\n"; break; case 6: // temperature from a TMP36 attached to back of solar cell $val = (int) substr($line,4); $tmp = degc($val); // convert to Celsius/Centigrade $tmp -= 5; // calibration $sql = "insert into readings values(NULL,NULL,$key,$tmp)"; $result = $mysqli->query($sql); break; default: //echo "Found strange key $key!\n"; break; } } function degc($v) { $t = $v * (5/1024); $t -= 0.5; $t *= 100; return round($t,1); } ?>

Esse script começa abrindo a conexão com o Arduino em um ponteiro de arquivo para leitura. Depois, ele abre a conexão para o backend MySQL para saída de dados. Em seguida, ele aguarda a resposta do Arduino e entra em loop para ler as linhas relatadas. Cada uma das quatro linhas antecipadas contém uma tag de quebra de HTML (Linguagem de Marcação de Hipertexto), o que torna mais fácil de ler a saída em um navegador durante o teste. O script remove essa quebra. As linhas resultantes começam com o número do pino seguido pela voltagem encontrada. Concentrando-se no número do pino, ele vai então para uma estrutura switch que executa uma ação diferente dependendo de que sensor está conectado ao pino.

A calibração ocorre nessa etapa. Ou seja, se descobrirmos que um sensor superestima consistentemente por determinado valor, podemos subtrair esse valor antes de o valor final ser relatado. Existe uma função específica para a conversão dos milivolts medidos a partir do TMP36 em graus Celsius, passando de uma faixa de 0-1023 para 1 a 5, encontrando o ponto zero e escalando o resultado em 100. Por fim, ele armazena o valor limpo e arredondado no banco de dados. Como saber se o sensor precisa de correção? Uma maneira é medir uma célula que se comporta de forma semelhante usando um leitor de temperatura de emissividade do tipo de apontar e disparar.

A instrução SQL insert inicia com dois valores NULL , permitindo que o backend substitua o primeiro por um número de ID de incremento automático e o segundo por um registro de data e hora atual. Em seguida, ela conecta o número do pino e a leitura desse pino. Pode-se usar esse script a partir da sua lista crontab para o processamento regular ou executar conforme necessário a partir da linha de comando.


Exibição de gráfico

Com o backend enchendo de dados, a próxima tarefa é tornar os dados de fácil leitura. Há uma série de bibliotecas de gráficos disponíveis, cada qual com pontos fortes e fracos. Flotr (consulte Recursos) é um exemplo que usa JavaScript para exibir um gráfico em uma janela de navegador. O código mostrado na Listagem 5 lê os dados armazenados na tabela de leituras e apresenta os dados de temperatura e luz em gráficos separados.

Lista 5. Gerador de gráficos PHP usando Flotr
<?php
// read solar data and display in flotr chart
$doctype = "<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN'
    'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'>
<html xmlns='http://www.w3.org/1999/xhtml' xml:lang='en'>
<head>
<title>LOG reader</title>
<meta http-equiv='Content-Type' content='text/html;charset=UTF-8' />
<script language=\"javascript\" type=\"text/javascript\"
		src=\"../flotr/lib/prototype.js\"></script>
<script language=\"javascript\" type=\"text/javascript\" 
		src=\"../flotr/lib/base64.js\"></script>
<script language=\"javascript\" type=\"text/javascript\"
		src=\"../flotr/lib/canvas2image.js\"></script>
<script language=\"javascript\" type=\"text/javascript\"
		src=\"../flotr/lib/canvastext.js\"></script>
<script language=\"javascript\" type=\"text/javascript\" 
		src=\"../flotr/flotr.js\"></script>
</head><body>";
$mysqli = new mysqli($server,$username,$password,$dbname);
// get temp and light data and chart it
$sensors = array('Temp'=>6,"Light"=>5);
foreach ($sensors as $label=>$sensor) {
  $sql = "select tstamp,value from readings 
	    where pin=$sensor order by tstamp asc";
  $result = $mysqli->query($sql) or die($mysqli->error);
  $mydata1 = "[ ";
  while ($row = $result->fetch_array()) {
        $cfdoy = $row[0];
        $cfdoy = (strtotime($cfdoy)-(5*60*60))*1000;
        $cfamt = $row[1];
        $mydata1 .= "[ $cfdoy , $cfamt ] ,";
  }
  $mydata1 = substr($mydata1,0,-2)." ]";
  $leg = ($sensor == 18) ? "dC" : "mV";
  $title = ($sensor == 18) ? "Cell Temperature" : "Light";
  $conth .= "<div>$label</div>\n
      <div id=\"container$sensor\" style='width:600px; height:250px;'>
      <script type='text/javascript'>
          var f = Flotr.draw(
              $('container$sensor'), [
              { // => first series
                  data: ".$mydata1.",
                  label: '$leg',   
                  htmlText: false,
                  lines: {show: true}
              }],
              {  
                xaxis: {
                  title: 'Time',
                  mode:'time', 
                  noTicks: 10,
                  labelsAngle:45 
                },
                yaxis: {
                  title: '$leg',
                  noTicks: 8
                },
                title: '$title',
                selection: {
                  mode: 'x', 
                  color: '#B6D9FF',
                  fps: 20
                },
                mouse: {
                  track: true,
                  relative: true,
                  margin: 5,
                  trackFormatter: function(obj) { 
                      var dd = parseInt(obj.x);   
                      var d = new Date(dd);
                      return (d.getHours()+4) + ':' 
			  + d.getMinutes() + ' | ' + obj.y; 
                  },
                  position: 'sw',
                  lineColor: '#FF3F19',
                  trackDecimals: 1,
                  sensibility: 2,  
                  fillOpacity: 0.4 
                }
              }  
      );
        </script></div>";
}
echo "$doctype"."<html><body>".$conth."</body></html>";
?>

O código da Listagem 5 começa definindo uma cadeia de caractere que é o início da saída XHTML (Linguagem de Marcação de Hipertexto Extensível), incluindo referências às bibliotecas JavaScript Flotr. Em seguida, ele abre uma conexão com o servidor MySQL onde os dados estão armazenados e configura um array que contém os números dos pinos usados, passa pelos elementos de array que captam dados para o sensor relevante e os substitui no script JavaScript.

O script é configurado para tratar os dados do eixo X como valores de tempo no relógio de 24 horas para ambos os gráficos e contém instruções do mouse que permitem passar o mouse sobre a linha produzida e exibir as coordenadas relacionadas.

Durante a fase de exibição, poderíamos pensar em suavização. Pode ser o uso de uma média móvel ou outro esquema baseado em peso que faça a moderação de valores extremos.

Utilizando dados reais gerados a partir dessa configuração amostrados a cada cinco minutos, o script de gráficos produz a saída mostrada na Figura 4 sem suavização. As condições eram de sol em maio em Ontário, com nuvens ocasionais. Pode-se obter uma cópia dos dados na seção Download.

Figura 4. Saída de exemplo
Saída de exemplo

Conclusão

O Arduino de software livre é útil como processador simples e adaptável para dados de sensor em um contexto de geração solar. Está disponível uma grande variedade de sensores, e desde que o sensor produza uma voltagem de saída adequada, ou, como opção, uma saída digital que possa ser registrada de forma limpa pelo Arduino, ele pode coletar e relatar esses dados. O TMP36 e o LED como sensores são o mais básicos possível — usuários que levam o assunto a sério vão usar alternativas melhores.

Bons números do comportamento de painéis em diversas condições podem ser úteis para os gerentes de unidades fotovoltaicas porque, em vista do registro de dados, eles podem formar uma linha de base de observações. Os gerentes podem, então, fazer alterações de acordo com o raciocínio e as sugestões e depois avaliar se a manipulação posterior do painel teve um efeito positivo ou não.


Download

DescriçãoNomeTamanho
Data samplereadings.sql.zip1KB

Recursos

Aprender

Obter produtos e tecnologias

  • Arduino: Acesse o site principal.
  • MySQL community edition: Acesse uma versão com download grátis desse banco de dados de software livre.
  • PHP: Verifique o release mais recente dessa linguagem de script de uso geral.
  • Versão de teste do software IBM: inove o seu próximo projeto de desenvolvimento de software livre usando software para teste, disponível para download ou em DVD.

Discutir

Comentários

developerWorks: Conecte-se

Los campos obligatorios están marcados con un asterisco (*).


Precisa de um ID IBM?
Esqueceu seu ID IBM?


Esqueceu sua senha?
Alterar sua senha

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


A primeira vez que você entrar no developerWorks, um perfil é criado para você. Informações no seu perfil (seu nome, país / região, e nome da empresa) é apresentado ao público e vai acompanhar qualquer conteúdo que você postar, a menos que você opte por esconder o nome da empresa. Você pode atualizar sua conta IBM a qualquer momento.

Todas as informações enviadas são seguras.

Elija su nombre para mostrar



Ao se conectar ao developerWorks pela primeira vez, é criado um perfil para você e é necessário selecionar um nome de exibição. O nome de exibição acompanhará o conteúdo que você postar no developerWorks.

Escolha um nome de exibição de 3 - 31 caracteres. Seu nome de exibição deve ser exclusivo na comunidade do developerWorks e não deve ser o seu endereço de email por motivo de privacidade.

Los campos obligatorios están marcados con un asterisco (*).

(Escolha um nome de exibição de 3 - 31 caracteres.)

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


Todas as informações enviadas são seguras.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Software livre, Segmentos de mercado
ArticleID=749891
ArticleTitle=Registro de dados com hardware e software livre no setor de energia
publish-date=08032011