você está aqui: Home
→
Arquivo de Mensagens
Gráficos usando GNUPlot e PHP
Colaboração: Rogério Acquadro
Data de Publicação: 04 de Janeiro de 2006
Recentemente tive que desenvolver uma pequena aplicação, responsável por capturar dados de leituras de temperatura e umidade relativa de salas climatizadas e fazer um tratamento estatístico dos dados. O software responsável pela captura das leituras (que não foi escrito por mim, é proprietário) gera um arquivo CSV, com atualização de hora em hora, com todos os dados de todos os sensores.
A dificuldade estava em automatizar, de uma maneira prática e simples, a geração dos gráficos e estatísticas para os dados em questão. Decidi que usar uma interface web seria a melhor opção. Não requer nenhum software instalado no cliente (como seria o caso de usar essa ou aquela planilha de cálculo).
Infraestrutura
São, no total, três computadores envolvidos nesta solução, obviamente todos ligados em rede. O primeiro deles é um computador velho, sucateado, que faz apenas a leitura dos dados. Trata-se de um Pentium 200, rodando Windows 95 e com o software proprietário de captura dos dados. Este computador está ligado via RS232 aos sensores e é dessa maneira que são feitas as leituras dos dados.
O segundo é o servidor da aplicação. Sua função é acessar o computador de captura, ler os últimos dados, registrá-los em um banco de dados e abrigar a aplicação web.
O terceiro computador é o cliente, que necessita apenas de um navegador de Internet. A observação é que o cliente pode ter qualquer navegador de internet com qualquer sistema operacional.
Softwares utilizados
Além do software proprietário que faz a captura dos dados, foram utilizados os seguintes softwares:
- Pequenos scripts em shell script para fazer o tratamento dos dados e a injeção no banco de dados;
- Samba para fazer a comunicação e transferência dos dados entre a o computador de aquisição de dados e o servidor;
- MySQL para armazenagem dos dados;
- PHP para desenvolvimento da aplicação;
- GNUPlot para geração dos gráficos;
- Um navegador de Internet no computador cliente.
Passo a Passo
O primeiro passo é fazer a captura dos dados. Para isso, foi escrito um pequeno script ("captura"):
1 #!/bin/bash 2 3 cd /tmp 4 mount -t smbfs -o username=acervo,password=acervo //terminal/c /mnt/extra 5 mv /mnt/extra/dados/dado.csv /tmp 6 umount /mnt/extra 7 /opt/climatizacao/gera_sql /tmp/dados.csv | mysql climatizacao 8 rm /tmp/dados 9 rm /tmp/*.bak
Analizando linha a linha, começamos com a linha 4 que faz a conexão com o computador de aquisição de dados via samba. A linha 5 copia o arquivo de dados para o diretório temporário (ele na verdade move o arquivo. Assim, na próxima vez que o software for escrever novos dados, criará um novo arquivo, sem que aja a duplicação de dados). A linha 7 invoca o segundo script que trata os dados do arquivo CSV e insere dentro do MySQL.
O segundo passo é fazer o tratamento do arquivo CSV e injetar os dados no banco de dados. Isso é feito utilizando o segundo script ("gera_sql"), invocado na linha 7 do script "captura":
1 #!/bin/bash
2
3 dos2unix -a $1
4 sed -e s/\;//g $1 | sed -e 's|/| |' | sed -e 's|/| |' |\
awk {'print "insert into traineis values \
(\"\"\, \"20"$3"-" $1 "-"$2"\"\, \""$4 "\"\,
\""$8 "\"\, \""$9 "\"\, \""$10 "\"\, \""$11"\"); \n\
5 insert into exterior values
(\"\"\, \"20"$3"-" $1 "-"$2"\"\,
\""$4 "\"\, \""$12 "\"\, \""$13 "\"\,
\""$14 "\"\, \""$15"\");\n\
6 insert into climatizada values
(\"\"\, \"20"$3"-" $1 "-"$2"\"\,
\""$4 "\"\, \""$16 "\"\, \""$17 "\"\,
\""$18 "\"\, \""$19"\");\n\
7 insert into sala_3 values
(\"\"\, \"20"$3"-" $1 "-"$2"\"\, \""$4 "\"\,
\""$20 "\"\, \""$21 "\"\, \""$22 "\"\,
\""$23"\");\n\
8 insert into audiovisual values
(\"\"\, \"20"$3"-" $1 "-"$2"\"\, \""$4 "\"\,
\""$24 "\"\, \""$25 "\"\, \""$26 "\"\, \""$27"\");\n\
9 insert into armario values
(\"\"\, \"20"$3"-" $1 "-"$2"\"\,
\""$4 "\"\, \""$28 "\"\, \""$29"\");\n\
10 insert into arcondicionado values
(\"\"\, \"20"$3"-" $1 "-"$2"\"\,
\""$4 "\"\, \""$30 "\"\, \""$31 "\"\,
\""$32 "\"\, \""$33 "\"\, \""$34"\");"'}
A linha 3 faz uma pequena conversão de formatos de arquivo texto (necessário dado o comando para quebra de linha ser diferente entre *NIX e Windows). A 4a. linha faz a separação dos dados (separados por vírgula). Mais do que isso, a 4a. linha faz ainda o tratamento da data (que é gerada do tipo dd/mm/aa e o SQL apenas reconhece aaaa-mm-dd). As linhas de 5 a 10 são as linhas de injeção de dados no SQL.
Injetados os dados no banco de dados, cabe ao aplicativo PHP fazer a leitura deles. Graças as funções estatísticas do MySQL, pode-se gerar rapidamente cálculos como média +- desvio padrão, máximos e mínimos, entre outros. A grande dificuldade está na geração do gráfico de umidade e temperatura.
Depois de muito pesquisar bibliotecas prontas para gerar gráficos em PHP (nenhuma me soou muito satisfatória), resolvi enfrentar o desafio de usar o GNUPlot (excelente ferramenta da qual já sou familiar há tempos) junto com o PHP.
Para isso, escrevi o programa graph.php, que passado o nome do sensor e as datas de início e fim, ele é capaz de gerar o gráfico de temperatura e umidade.
1 $sensor = $_GET['sensor'];
2 $limite1 = $_GET['limite1'];
3 $limite2 = $_GET['limite2'];
4 $size = $_GET['size'];
5 if (($limite1 != NULL) && ($limite2 != NULL))
6 $limite = "where data >= '$limite1' and data <= '$limite2'";
7 $filename = round(time() / 10 * rand(1,10));
8 $filename = "/tmp/".$filename;
9 if ($size == "small")
10 $term = "png size 640,480";
11 if ($size == "big")
12 $term = "png size 950,712";
13 $query = "select data, hora, temp, ur from $sensor $limite order by data, hora";
14 $result = mysql_query($query);
15 $rows = mysql_num_rows($result);
16 if ($rows > 720)
17 $passo = 10;
18 elseif ($rows > 360)
19 $passo = 5;
20 else
21 $passo = 1;
22 for ($i = $rows - 1; $i >= 0; $i = $i - $passo)
23 {
24
25 $x = mysql_result($result, $i, "data") . "-" . mysql_result($result, $i, "hora");
26 $y1 = mysql_result($result, $i, "temp");
27 $y2 = mysql_result($result, $i, "ur");
28 $command = "echo $x $y1 $y2 >> $filename";
29 exec ($command);
30 }
31 $command = "echo \"set ylabel \\\"Temperatura (celsius)\\\";
set y2label \\\"Umidade Relativa (%)\\\"; set xlabel \\\"Data\\\";
set grid; set y2tics; set term $term; set xdata time;
set timefmt \\\"%Y-%m-%d-%H:%M\\\";
plot \\\"$filename\\\" using 1:2 axis x1y1 title \\\"Temp\\\" with lines,
\\\"$filename\\\" using 1:3 axis x1y2 title \\\"UR\\\" with lines \" | gnuplot";
32 header("Content-type: image/png");
33 passthru($command);
34 $command = "rm $filename";
35 exec ($command);
As linhas de 1 a 4 fazem a leitura dos parâmetros. As linhas 7 e 8 geram um nome aleatório para o arquivo temporário de dados que será lido pelo GNUPLot. As linhas de 9 a 12 definem o tamanho do gráfico (em pixels). As linhas 13 e 14 fazem a conexão com o banco de dados. As linhas 16 a 21 fazem a triagem dos dados (dependendo do período que se deseja, o banco de dados possui mais de 3.000 pontos, o que deixava o programa um pouco lento. Como não havia necessidade de tantos pontos, o período foi dividido para que ficasse mais de acordo com o propósito do gráfico). As linhas de 22 a 30 fazem a leitura dos dados e a escrita deles no arquivo temporário. A linha 31 é o comando em sintaxe GNUPlot para que faça a formatação do gráfico, leitura dos dados e desenho dos pontos. A linha 32 envia ao navegador a informação que a saída será um arquivo PNG. A linha 33 faz a geração do gráfico (executa os comandos da linha 31). As linhas 34 e 35 apagam o arquivo texto temporário.
Para chamar o "grap.php", basta colocar em um arquivo HTML a chamada como se fosse um arquivo gráfico:
<img src=\"graph.php?sensor=$sensor&limite1=$limite1&limite2=$limite2&size=small\" title=\"Gráfico de temperatura e umidade relativa para $sensor\" border=\"0\">
O resultado deste software é brilhante. Um gráfico gerado em segundos, extremamente leve (o gráfico mais pesado que gerei não passa de 15 kbytes).