Impressora Registradora em Rolo de Papel

Um dos primeiros projetos no qual trabalhei quando cheguei na UFPB em 1978 foi um sistema de aquisição de dados. O sistema lia e registrava dados sobre a velocidade do vento e sobre a quantidade de água bombeada por um catavento.

Naqueles dias não havia Internet e nem computador pessoal. O trabalho do engenheiro era (e ainda é) de encontrar soluções para os problemas com o que está disponível. Nossa equipe resolveu imprimir os valores colhidos a cada 10 minutos em um rolo de papel. Naquele tempo era comum se utilizar um rolo de papel em maquinas registradoras para registrar compras em supermercados. Foi escolhido um modelo de calculadora Sharp que tinha as quatro operações e uma impressora de rolo (versão precursora, mais simples do que está na foto).

Usávamos um oscilador com divisor de frequência para conseguirmos um intervalo de 10 minutos. A cada 10 minutos imprimíamos a data e a hora, bem como os totais acumulados de vento, água bombeada, e outros parâmetros. Logo após a impressão dos dados zerávamos os contadores, para começar novo ciclo de contagem.

Para conseguir imprimir os valores obtidos, retiramos a parte mecânica das chaves (teclado) e utilizamos chaves analógicas CMOS (CD4053 -  Triple 2-Channel Analog Multiplexer / Demultiplexer) para fazer o fechamento eletrônico das chaves. Tínhamos que fechar a chave e manter fechado por um tempo determinado para que o circuito de "debounce" reconhecesse a chave fechada. Fechávamos cada chave sequencialmente até terminar os dados daquela linha, e a seguir fechávamos a tecla de totalização que por sua vez imprimia a linha no rolo de papel e avançava o papel.

Para utilizar esta calculadora impressora no campo, contornamos a fonte de 220V e injetamos 12V (vindo de uma bateria de automóvel) diretamente nos circuitos de baixa tensão.

Os dados tinham que ser formatados de uma maneira padrão para poder identifica-los posteriormente, pois a calculadora só tinha números (não tinha letras). Por ser uma calculadora, não aceitava qualquer sequencia de números e pontos, e a lista de símbolos era muito limitada.

Uma vez os dados registrados de dez em dez minutos durante alguns dias, o rolo de papel era recolhido e passado para uma secretária para dar entrada dos dados em um mainframe para gerar estatísticas e salvar a informação para estudos futuros.

Foi bastante gratificante trabalhar em um projeto tão arrojado naqueles dias.

PHP criando gráficos .png

Como já mencionamos em post anterior, PHP é uma linguagem de programação genérico, muito parecido com a linguagem C. Mas também tem muitas facilidades para utilizar na criação de páginas web.

Aqui vamos mostrar a facilidade de se utilizar o PHP para criação de gráficos, ou seja criação de imagem tipo PNG.

A primeira rotina a ser utilizada é a seguinte:
$im = imagecreatetruecolor ( int $width , int $height );
Esta rotina cria um apontador para uma imagem ($im) com largura ($width) e altura ($height); Não se esqueça de definir $width e $height antes de utilizá-los.

A segunda  rotina a ser utilizada define as cores que pretendemos utilizar no nosso gráfico:
$background = imagecolorallocate($im, 0, 0, 0);
Os parâmetros para esta rotina são o ponteiro que criamos na primeira rotina ($im) e os níveis de cada cor R, G, B ou seja Vermelho, Verde, e Azul. A primeira vez que esta rotina é chamada, define a cor do fundo da imagem. Neste exemplo, criei um fundo preto (zero vermelho, zero verde, e zero azul). A rotina retorna um ponteiro para a cor na palete de cores do gráfico. Esta rotina deve ser chamada diversas vezes para a definição das cores que pretendemos utilizar.
 $text_color = imagecolorallocate($im, 255, 255, 255);
 $line_color = imagecolorallocate($im, 0, 0, 255);
 $bar_color = imagecolorallocate($im, 0, 255, 0);
Assim criamos um gráfico com fundo preto, texto branco, cor da linha azul e cor da barra verde.

Após criarmos o ponteiro para a imagem e definirmos as cores que pretendemos utilizar, podemos desenhar segmentos de retas entre dois pontos utilizando a função:
imageline($im, $x1, $y1, $x2, $y2, $line_color);
onde $im é o ponteiro para o nosso gráfico, criado pela primeira rotina; $x1 e $y1 definem o ponto inicial da reta; $x2 e $y2 definem o ponto final da reta; e a variável $line_color aponta para a cor que desejamos na palete de cores que criamos com o segundo comando (neste exemplo, o azul).

O comando para acrescentar texto no nosso gráfico é a função:
 imagestring($im, $font_size, $x, $y, $text, $text_color);
onde $im é o ponteiro para o nosso gráfico; $font_size indica o tamanho da fonte de caracteres (pode variar de 1 a 5 para as fontes pre-definidas); $x e $y são as coordenadas onde o texto deve ser escrito; $text é a string de texto a ser escrito; e $text_color aponta para a cor que desejamos na palete de cores que criamos com o segundo comando (neste exemplo, o branco).

Tendo finalizado o nosso gráfico, utilizamos a rotina
imagepng($im);
para enviar a imagem pela saída padrão. Ou seja, este comando (se usado em uma página web) envia a imagem criada para o navegador do visitante.

A última rotina que devemos utilizar é:
imagedestroy($im);
que libera a memória reservada para o ponteiro pelo primeiro comando que mencionamos.

Observações importantes:
1) Para visualizar a imagem em uma página web, é necessário colocar
<img src="image.php" >
dentro do código HTML da página.

2) O arquivo image.php deve gerar a imagem desejada.

3) O arquivo image.php deve enviar ao navegador o seguinte texto, antes de enviar a imagem
 header("Content-type: image/png");
para indicar que os dados a seguir devem ser interpretados como uma imagem.

4) Na definição do espaço a ser utilizado pelo gráfico, a posição 0,0 é a do canto superior esquerdo. X na horizontal e Y na vertical.


Exemplos de gráficos que criei utilizando PHP podem ser vistos na minha página de estatísticas de banners.

Utilização de Sessão em PHP

Utilização de Sessão em PHP

Uma coisa que tenho utilizado nas minhas programações em PHP é o acesso restrito a certas páginas. Como mencionei no meu tutorial sobre Campos interessantes em um banco de dados MySQL, eu gosto de colocar um campo de "level" (nível) de usuário no banco de dados de membros. Assim fica fácil liberar ou restringir de acordo com o nível do usuário.

Na programação em PHP eu utilizo a variável $_SESSION para salvar informações sobre a pessoa que está visitando o site. Se o usuário não efetuou o login, não tem informações na variável $_SESSION. Se fez o login, eu salvo informações do usuário, tipo nome completo, nível e data da última visita.

No início de cada página PHP, é colocado o seguinte código:
if(session_id() == "") session_start(); # Isto garante que a sessão seja inicializada
if(!isset($_SESSION['user']) ) {
    if(isset($_POST['user']) && isset($_POST['password'])) {
        $row['user'] = $_POST['user'];
        $password = $_POST['password'];
        $crypt_password = crypt($password, $row['user']);
        $read = user_read($row);
        if(($read == 1) && ($row['password'] == $crypt_password)) {
            $_SESSION['user_level'] = $row['user_level'];
            if($row['user_level'] > 0) {
                $_SESSION['user_is_logged_in'] = true;
                $_SESSION['user'] = $row['user'];
                $_SESSION['full_name'] = $row['full_name'];
                $_SESSION['last_date'] = $row['last_date'];
            }
            $row[last_date] = date("Y/m/d");
            user_write($row);
        }
    }
}

Todo código após a primeira linha pode ser colocado em uma rotina, inclusive em um outro arquivo para ser acessado por todas as páginas do site.

Note que após a identificação do usuário, são salvos vários dados do usuário na variável $_SESSION. Também é importante observar que primeiro é salvo na variável $_SESSION o valor da última visita, depois é atualizado para o dia de hoje, no banco de dados.

Veja também que a função user_read($row) lê os dados do usuário do banco de dados, e a função user_write($row) escreve os dados do usuário no banco de dados.

Após a execução dos códigos acima, podemos executar códigos condicionais dependendo do nível do usuário, da seguinte maneira:
if($_SESSION['user_level'] >= 1) {
   echo("Usuário autenticado!");
}

Programando no MatLab

Programando no MatLab

Sou programador de C já faz um bom tempo (desde 1986). Recentemente fui apresentado ao MatLab de maneira meio por necessidade, e fiquei apavorado com a quantidade de arquivos pequenos que podem ser gerados, pois cada função tem que ter seu próprio arquivo ".m"

Se divido o meu fluxo de programa em sub-rotinas ou funções,  cada uma tem que ter seu próprio arquivo. Então a solução para manter o número de arquivos sob controle é colocar muitas coisas em uma única função. Para fazer isto de maneira ordenada no MatLab, que é uma linguagem interpretada, deve ser utilizado o comando "switch" com vários "case"s.

O MatLab permite passar um número variável de variáveis para uma rotina ou função. Então é viável utilizar algo desta maneira:

function [s1 s2] = faz_tudo(o_que, p1, p2, p3)
  switch o_que
    case 'plota'
        % p1 contém os dados a plotar, plot1 é a TAG do elemento onde deve ser plotado o gráfico.
         plot(handles.plot1, p1);
    case 'liste'
       % p1 contém a lista a ser mostrada
        % p2 é o "handle" que aponta para a matriz de elementos.
        set(p2.lista1, 'String', p1);
  end % fim do case
end  % fim da função.

Desta forma, cada pedacinho que seria uma função separada, fica dentro de um case. Basta chamar a função faz_tudo passando os parâmetros necessários para aquele "case".  Usa-se as primeiras variáveis (p1, p2, p3) e passa apenas a quantidade que precisar para cada caso ("case"). Desta forma só precisa de uma função faz_tudo, e cada "rotina" fica dentro do seu próprio "case", eliminando uma série de arquivos pequenos.

É claro que se a rotina crescer muito, poderá merecer o seu próprio arquivo, e não ser apenas um case no faz_tudo.

Utilizando a sugestão proposta acima, poderá ser criado uma espécie de biblioteca de funções úteis, tudo em um único arquivo. Cada função seria um case da função "biblioteca". Assim não será necessário re-escrever tudo (ou copiar diversos arquivos) para cada novo projeto. Basta copiar o arquivo "biblioteca" e já estará meio caminho andado para a conclusão de seu novo projeto.

Utilizando a interface gráfica do MatLab

MatLab GUI(de)

O uso básico da interface gráfica do MatLat (Matrix Lab) é relativamente simples de programar. Existem poucos campos que precisam ser configurados para integrar a interface gráfica aos seus programas.

A parte mais complicada é feita fora do ambiente MatLab. Inclusive deve ser feito preferencialmente fora do computador. Esta parte é o rascunho utilizando lápis e papel para definir o que vai aparecer em sua tela. Quais as plotagens que serão feitas, e onde vão aparecer? Quais os controles, quais os tipos de caixas interativas serão utilizadas e onde vão aparecer?

A interface gráfica do MatLab oferece diversos recursos para entrada de dados: Botão, Lista, Controle deslizante, caixa de entrada de texto, etc. Também oferece diversos tipos de saída como plotagem 2D, Saída de texto e painel.

Uma vez definindo o que vai aparecer na sua tela, e onde, então deve se partir para a implementação da interface utilizando o GUI(de). Pode ser chamado digitando GUI na linha do MatLab, ou escolhendo File->New->GUI no menu. Uma vez inicializado o editor gráfico, comece escolhendo no menu os botões, controles, e área de plotagem desejado. Ajuste o tamanho de cada elemento.

Existem basicamente dois elementos que necessitam ser definidos, para integrar com os seus programas: as propriedades e os callbacks.

No editor de propriedade você tem acesso a muitos elementos relativos a cada objeto. (Para acessar o editor de propriedades, clique no botão da direita, enquanto o mouse estiver sobre o elemento, e escolha "Property Inspector". Não fique assustado com a quantidade de propriedades, pois a maioria pode deixar como estar. A minha sugestão é alterar o mínimo possível, ou seja, uns 2 ou 3 elementos.

Veja que as diversas propriedades estão listadas em ordem alfabética. Procure o item chamado "Tag". Este é o nome que será chamado dentro do seu programa para interagir com este elemento (mais a este respeito será discutido abaixo). Sugiro que mude o TAG para alguma coisa fácil de lembrar a que se refere. Pode mudar o nome do primeiro plot para plot1 por exemplo. Uma outra propriedade que pode querer alterar é chamado de "String". Se for uma caixa de texto, este será o texto mostrado (até sera alterado) na caixa. Pode ser mudado para instruir o usuário do programa, ou pode ser deixado em branco. Se o elemento for texto, poderá alterar também o tamanho das letras, alterando o FontSize (inicialmente é definido como sendo 8).

Depois de definir as propriedades de cada elemento, é necessário definir a interação com o programa. Isso é feito usando "callback". Os callbacks são pequenas rotinas que são executadas quando acontece algum evento (clique do mouse, digitação de texto, etc). Cada elemento de sua interface gráfica tem os seus próprios callbacks. Deve ter um callback para a criação do elemento, outro quando deletar o elemento, e outro quando houver alguma intervenção do usuário (via teclado ou mouse). Estas funções devem conter o que fazer quando o usuário interage com o programa. Exemplo: quando o usuário altera alguma entrada, o gráfico deve ser plotado novamente. Se um valor for alterado, a variável deve ser atualizada.


A atualização de algum elemento é feito utilizando o comando "set".
set(handles.texto1,'String','Testando minha interface');
set(handles.temperatura1,'Value','25');
No primeiro "set" temos a "TAG" chamado de texto1, com o tipo String, cujo valor é "Testando minha interface". Veja que a variável "handles" é na realidade uma matriz com vários elementos e no exemplo só alteramos o elemento "texto1" que é a TAG de acesso ao elemento. No segundo "set" não temos uma "string" e sim um Value, onde será atribuido o valor de 25. A TAG que identifica o elemento neste caso é temperatura1. Cada elemento tem uma TAG que deve ser única no seu projeto. Esta TAG será usada para atualizar o elemento.

No caso de um botão, podemos obter o valor do botão utilizando o comando get.
a = get(handles.plot_type,'Value');
A variável "a" vai conter o valor da elemento cuja TAG é "plot_type".
Para ler um texto de um quadro de texto, cuja TAG é texto1, usamos:
str = get(handles.texto1, 'String');
A variável "str" conterá o texto associado.

Campos interessantes em um banco de dados MySQL

Campos Interessantes

Como mencionei em um post anterior eu gosto de colocar um id como primeiro campo em qualquer banco de dados. Isto facilita a indexação e a atualização (usando comando REPLACE) de cada ficha no banco de dados.

Outro campo que eu gosto de acrescentar, sempre que crio um banco de dados de pessoas (membros) é um campo de "nível" (level). Normalmente eu coloco com um inteiro, e uso como um conjunto de bits (8 ou 16), onde cada bit pode dar acesso a alguma coisa.

Normalmente crio uma área do site que todas as pessoas possam ter acesso. Uma área anônima, por assim dizer. Depois eu crio outra área que apenas as pessoas identificadas (pelo login) tem acesso. Outras áreas são restritas a gerentes e/ou pagantes, ou ao dono.

Cada área tem um bit associado no campo de nível. Se o bit estiver setado, o membro tem acesso. Se o bit estiver resetado, o membro não tem acesso. Acesso negado.

É claro que depende do caso, mas muitas vezes o acréscimo deste campo elimina a necessidade de ter outras tabelas apenas para administradores. No caso, o administrador é cadastrado normalmente, apenas com os bits de nível setados, para dar acesso a mais áreas do site.

Utilizando PHP para consultar um banco MySQL

Utilizando PHP para consultar um banco MySQL

Primeiramente uma advertência em relação aos dados de acesso ao banco de dados. Para acessar o banco de dados é necessário informar o nome do computador, do usuário, e sua senha. Minha sugestão em questão de segurança é não colocar estas informações diretamente nos programas PHP. Imagine o que acontece se o servidor web for ativado sem o interpretador PHP? Suas informações de nome e senha para acesso ao banco de dados serão vistos por todos que tentarem acessar suas páginas.

Uma forma bem mais segura é definir variáveis e coloca-las em um arquivo que fica fora da árvore do servidor web. Esse arquivo deve ser incluído (include("arquivo");) pelo PHP. Se o PHP não estiver funcionando, aparecerá nas páginas web apenas o nome das variáveis, mas não o seu conteúdo, preservando assim sua senha e seu login.

Os comandos mais comuns do PHP para acessar um banco de dados MySQL são os seguintes:

1. $link = mysql_connect ($host_name, $user, $password) or die ("Erro ao conectar ao banco de dados.\n");
2. mysql_select_db($banco_de_dados, $link) or die ("Erro ao selecionar banco de dados.\n");
3. $result = mysql_query ("CREATE TABLE IF NOT EXISTS `$tabela` ('id'  bigint(20) unsigned NOT NULL auto_increment, 'login' varchar(20) default NULL, 'nome' varchar(40) default NULL, 'senha'  varchar(20) default NULL, "PRIMARY KEY  (`id`) ) ");
4. $result = mysql_query ("SELECT * FROM $tabela WHERE id = '$id' ");
5. $quantidade = mysql_num_rows($result);
6. $ficha = mysql_fetch_array ($result);
7. $result = mysql_query ("INSERT INTO $tabela VALUES ('$id', '$login', '$nome', '$senha') ", $link);
8. $result = mysql_query ("REPLACE INTO $tabela VALUES ('$id', '$login', '$nome', '$senha') ", $link);

O primeiro comando faz a conexão com o servidor MySQL.
O segundo comando seleciona o banco de dados no servidor.
O terceiro comando é utilizado caso queira criar uma tabela no banco de dados.
O quarto comando seleciona dados do banco de dados onde o id da ficha é igual à variável $id.
O quinto comando seta a variável $quantidade igual ao número de fichas encontrado na busca
O sexto comando coloca na variável $ficha (como array de dados) todos os campos lidos da ficha de dados.
O sétimo comando cria uma nova ficha de dados no banco de dados previamente selecionado.
O oitavo comando substitui uma ficha de dados existente no banco de dados previamente selecionado.

Base de Dados MySQL

Base de Dados MySQL

Em algumas ocasiões é interessante fazer consulta a uma base de dados para prover algum conteúdo dinâmico, atualizado. Isso é muito fácil utilizando páginas em PHP.

Uma base de dados em MySQL é composto por tabelas, contendo fichas que contém diversos campos. Repetindo: cada tabela contém um grupo de fichas. Cada ficha é composto por diversos campos. A base de dados mais simples poderá ter apenas uma tabela.

Um exemplo típico de uma tabela é a que contém fichas de cadastro. Os campos na ficha poderão ser, por exemplo: id, login, senha, nome completo, rua, número, complemento, bairro, cep, cidade, estado, país, telefone, celular, nacionalidade, naturalidade, cpf, rg, sexo, conjuge, data de nascimento, etc. etc. conforme a aplicação.

Como pode ser observado, os diversos campos podem ser compostos por tipos de informação diferentes. Os tipos mais comuns são: int (usado para números inteiros), float (ponto flutuante), double (ponto flutuante dupla precisão), date (datas), var char (texto).

Uma dica que eu aprendi depois de criar várias bases de dados, é que fica mais fácil encontrar e editar os dados posteriormente se o primeiro campo for um índice numérico, auto-crescente.

Agora eu normalmente coloco um "bigint", "auto increment", como o primeiro campo, e depois utilizo este valor quando eu quero editar e salvar modificações na base de dados. Anteriormente eu utilizava um campo como o nome ou login para indexar a base. Mas em algumas ocasiões é conveniente modificar o login, e nestes casos, o comando de substituir ("REPLACE") não funciona mais, e acaba criando uma nova ficha. Se usarmos um índice auto-crescente, não podem existir 2 índices iguais, e podemos utiliza-lo para fazer a substituição.

PHP com formulário

Este post faz parte da série de programação em PHP.

Vamos fazer uma página de teste em PHP com uma simples contagem da quantidade de vezes que carregamos a página. Não se trata de um contador, pois se fecharmos a página e abrirmos novamente, a contagem volta ao zero. Mas é apenas para mostrar a flexibilidade dos formulários com PHP.

Crie uma página qualquer em PHP e coloque as linhas seguintes:

<html>
<head>
<title>Página de Teste</title>
</head>
<body>
<center><h2>
<?php
$conta=0;
if(isset($_REQUEST[conta])) $conta = $_REQUEST[conta];
echo("<form method=post>");
echo("<input type=submit value=soma>");
$conta++;
echo("$conta<br>);
echo("<input type=hidden name=conta value=$conta>");
echo("</form>");
?>
</h2></center>
</body>
</html>

Explicação do formulário utilizado no exemplo acima. Cria-se a página em PHP com título e corpo. O conteúdo do corpo é centralizado (utilizando o comando html <center> e </center> Depois é inicializado um trecho com programação em PHP.

O primeiro comando em PHP é o de inicializar uma variável chamada $conta, com o valor zero. Segundo comando é para recuperar o valor anterior desta mesma variável, caso tenha sido definido em carregamento anterior do formulário descrito abaixo. Para isso, é testado se existe definição da variável $_REQUEST[conta], caso positivo, seu valor é colocado na variável $conta. $_REQUEST é o nome do arranjo(array) com todas as variáveis definidas no formulário que chamou esta página.

O formulário tem um botão de submissão (submit), e um campo escondido (hidden) contendo o valor de $conta incrementado (adicionado) de um. Também ecoa o valor incrementado de $conta. Portanto na primeira vez que a página é carregada, o $conta começa em zero, e é incrementado por um antes de ser ecoado ao navegador do usuário. A cada vez que o formulário é submetido, o valor anterior é recuperado, incrementado por um e ecoado novamente. Um contador de quantas vezes o formulário foi carregado. Só não serve para contador de páginas, pois toda vez que é carregado no navegador, começa novamente no zero.

Introdução a PHP

Esta pequena introdução à linguagem PHP destina-se àqueles que já tem noções de programação, mas não conhecem o PHP, e querem aprender. Aqui dou algumas rápidas pinceladas, para que alguém possa começar a usar o PHP. Apenas lembro que o PHP tem muitas funções para diversas aplicações diferentes, e a minha sugestão é que consulte diretamente a página e documentação do PHP online, para outras funções interessantes.

PHP é uma linguagem de programação genérico, muito parecido com a linguagem C. Em ambientes Linux é possível usar diretamente na linha de comando, mas sua utilização mais frequente é integrado com o servidor web Apache.

Uma vez que o PHP esteja instalado, é muito fácil integrá-lo com as páginas web. Basta criar páginas com a extensão .php e invocar o PHP quando precisar, colocando o seguinte comando na página HTML:

<?php comandos_do_PHP ?>

Na linguagem PHP (como no HTML e em C) branco pode ser colocado em diversos lugares e não afeta o resultado. Portanto na maioria das vezes é possível fazer endentações para melhor visualização do código fonte, sem alterar as páginas geradas. Apenas em alguns casos específicos que não se pode acrescentar um espaço em branco.

Em PHP, todo comando termina com ponto-e-vírgula (;)

Um dos comandos mais usados do PHP é o echo, pois tudo que é ecoado, é enviado ao navegador cliente (se não for redirecionado).

O próprio comando echo pode ter diversos delimitadores. Por exemplo, as duas linha seguintes produzem o mesmo resultado:

echo "Primeira frase";
echo("Primeira frase");

É muito comum usar o comando echo para construir partes dinâmicas das páginas. O PHP permite variáveis dentro do echo, e arranjos de texto podem ser criados para depois serem ecoados.

Como exemplo, podemos criar uma variável (toda variável em PHP começa com $) tipo "string" e enviar isto para o navegador. As duas linhas a seguir tem o mesmo efeito de cada uma das duas acima:
$tmp = "Primeira frase";
echo("$tmp");
ou ainda
echo $tmp;

O comando sprintf (emprestado do C) também pode ser utilizado na formatação dos dados:
$tmp = sprintf("Primeira frase");
echo "$tmp";

Veja agora comandos para ajudar na estrutura de programação.