domingo, julho 19, 2009

sábado, junho 20, 2009

Monitorando Temperatura Ambiente com DS1820 & Linux

Época de frio, faremos um termômetro digital para monitorar a variação de temperatura do ambiente.

O grande desafio aqui é interfacear um sensor de temperatura com PC servidor, sem uso de circuitos complexos ou microcontroladores para conversão dos dados. Sensores de Temperaturas de uso comum disponível no mercado, como o LM35 , necessitam de filtros e conversores A/D para tratar o sinal por ele gerado, não queremos um hardware tão "complexo" assim.


Em uma pesquisa descobrimos que a Maxim-IC/Dallas Semicondutor fabrica um sensor 100% digital, o DS1820 (DS18S20 , DS18B20) que opera na faixa de -55 a +125 ºC com precisão de 0,5ºC nas faixas de 10 a 85ºC. Um grande problema é a dificuldade de encontrar esse sensor aqui no Brasil, além de seu preço ser um pouco mais salgado (+- R$20,00) se comparado com o LM35 (+-R$ 3,50).
Com muita luta, encontramos o mesmo na Sta. Efigênia em São Paulo.

Uma vez de posse de 2 sensores DS1820, o desafio de interfacear os meninos tem início. Pesquisas web nos levam aos mais diversos circuitos para interface, porém um projeto me chamou a atenção.
Monitor temperatures with Linux, Nagios, and DS1820

Com base neste desenvolvi o meu com 2 sensores. Note que este sensor utiliza barramento de dados de apenas 1 fio, 1-Wire Bus, usando transmissão estilo "Half-Simplex" ;-)
Ou seja, pelo mesmo fio, envia-se os comandos de busca, inicialização e conversão de temperatura para o sensor, e após 700ms temos o retorno do valor da temperatura pelo mesmo barramento. Num mesmo barramento podemos ter ate 255 sensores diferentes, estes são diferenciados através de seu endereço ROM únicos.

Uma característica legal do DS1820 é o modo parasita, se seu barramento de dados (DQ) fornecer corrente suficiente para o sensor, o mesmo NÃO precisa ser ligado em fonte externa, logo podemos excluir o pino Vcc do sensor, isso mesmo, utilizaremos apenas 2 pinos, o Data e o GND.

Material Necessário para confecção:

1 Conector DB9 + Capinha
1 Placa fenolite, grande o suficiente para montar o circuito e pequena o suficiente para ser acoplada dentro do conector DB9
1 Diodo Zener 3V9 - 1/4W (como alternativa pode usar 3V6 )
1 Diodo Zener 6V2 - 1/4W
2 Diodos 1N5819 - 1/4W (Diodos de alta velocidade)
1 Resistor 1K5 - 1/4W
1 metro cabo manga - 2 vias

o diagrama de ligações do circuito pode ser visto abaixo:

Note que não temos a conexão do pino Vcc do DS1820, este pino deve ser isolado e não utilizado.

Após a montagem temos algo parecido com



Na outra extremidade do cabo (não ligado ao circuito) faremos uma derivação paralela, logo teremos 2 terminais DQ e 2 terminais GND para os 2 sensores, observe que os 2 sensores permanecem ligados a um único ponto do circuito.

Acoplamos os sensores nessas extremidades e pronto. Temos o conversor 1-Wire -> RS232 pronto para o uso. O Trabalho final pode ser visto abaixo.


Uma vez que nossos sensores estejam devidamente montados, seguiremos agora para o software responsável pela comunicação PC -> DS1820 via Serial.

Utilizaremos o Digitemp, disponível para Linux & Windows. Maiores detalhes pode ser encontrado no site do projeto.

Abaixo a configuração passoa-a-passo utilizando Ubuntu 9.04

No terminal (alt+F2 -> xterm)

Instalação pacote digitemp
# sudo apt-get install digitemp

Após a instalação, o primeiro passo é descobrir os sensores que estão conectados através do comando
# digitemp_DS9097 -i -s /dev/ttyS0

onde ttySO (COM-1) é a porta serial onde está conectado nossos sensores.

Você deverá obter uma resposta como abaixo:DigiTemp v3.5.0 Copyright 1996-2007 by Brian C. Lane

GNU Public License v2.0 - http://www.digitemp.com
Turning off all DS2409 Couplers
..
Searching the 1-Wire LAN
10A427530108005F : DS1820/DS18S20/DS1920 Temperature Sensor
10BF4A5301080001 : DS1820/DS18S20/DS1920 Temperature Sensor
ROM #0 : 10A427530108005F
ROM #1 : 10BF4A5301080001


Note que o endereço da ROM é unico para cada sensor, isso torna possível diferenciar os vários sensores conectados aos mesmo barramento.
Uma vez que nossos sensores respondem corretamente, configuramos o digitemp para que não seja mais necessário ficar "descobrindo" os sensores antes de cada consulta de temperatura, para isto no terminal
# digitemp_DS9097 -i -c /etc/digitemp.conf -s /dev/ttyS0

Como resultado, temos
DigiTemp v3.5.0 Copyright 1996-2007 by Brian C. Lane
GNU Public License v2.0 - http://www.digitemp.com
Turning off all DS2409 Couplers
..
Searching the 1-Wire LAN
10A427530108005F : DS1820/DS18S20/DS1920 Temperature Sensor
10BF4A5301080001 : DS1820/DS18S20/DS1920 Temperature Sensor
ROM #0 : 10A427530108005F
ROM #1 : 10BF4A5301080001
Wrote /etc/digitemp.conf


Mostrando que o arquivo de configuração foi devidamente criado. A opção -c /etc/digitemp.conf cria um arquivo de configuração com as informações necessárias de cada sensor.

O passo final é fazer a consulta de temperatura, para isto basta executar o comando:
# digitemp_DS9097 -c /etc/digitemp.conf -a

O resultado obtido é a temperatura fornecida por cada um dos sensores. A opção -a indica que consultaremos todos os sensores.
DigiTemp v3.5.0 Copyright 1996-2007 by Brian C. Lane
GNU Public License v2.0 - http://www.digitemp.com
Jun 20 10:54:53 Sensor 0 C: 18.31 F: 64.96
Jun 20 10:54:55 Sensor 1 C: 18.44 F: 65.19


Para obtermos as temperaturas individualmente de cada sensor, basta executar
# digitemp_DS9097 -c /etc/digitemp.conf -t 0
onde o parâmetro -t indica o número do sensor. Neste exemplo para o sensor 0 temos a saida
DigiTemp v3.5.0 Copyright 1996-2007 by Brian C. Lane
GNU Public License v2.0 - http://www.digitemp.com
Jun 20 10:57:28 Sensor 0 C: 18.31 F: 64.96


Já para o sensor 1
# digitemp_DS9097 -c /etc/digitemp.conf -t 1
DigiTemp v3.5.0 Copyright 1996-2007 by Brian C. Lane
GNU Public License v2.0 - http://www.digitemp.com
Jun 20 10:57:31 Sensor 1 C: 18.44 F: 65.19


Note que temos as temperaturas em escalar ºC e F, parâmetros extras permitem obter apenas um tipo de escala, conforme abaixo:
# digitemp_DS9097 -c /etc/digitemp.conf -o "%C" -t 0

temos como resultado apenas a temperatura em ºC
# 18.312500

Viajando um pouco no shell, deixei uma madrugada inteira o PC capturando as temperaturas de 10 em 10 minutos, de tal forma a obter as variações de temperatura durante a madrugada.
# while [ 1 ] ; do digitemp_DS9097 -c /etc/digitemp.conf -o "%C" -t 0 | egrep '^[0-9]' >> /tmp/temp.txt && sleep 600; done


Com ajudinha do OpenOffice (pode-se usar o RRDTool também) temos o gráfico de variação da temperatura


É isso, solução fácil, rápido e de "baixo custo" para monitoramento de temperatura de Ambientes, Data-Center, ou até mesmo Aplicação Laboratoriais de medições.

domingo, junho 14, 2009

Utilizando Conky para monitorar seu Ubuntu 9.04

O Conky é um sistema que através de linguagem própria é capaz de obter informações do Sistema Operacional além de permitir ao usuário personalizar sua própria informação.
Ele também conta com comandos para exibição desses dados de forma amigável, através de gráficos, barras, gauges, além de contar com auto-incremento de variáveis.



Antes de tudo, vamos instalar o conky e o pacote lm-sensors para acesso aos sensores de seu pc.

Ubuntu 9.04 - Gnome

Abra o terminal

Alt + F2 -> xterm

Instale os pacotes

# sudo apt-get install conky lm-sensors

Durante a instalação do pacote lm-sensors dependendo de seu hardware será feita algumas perguntas para testes de detecção de sensores, aconselho aceitar todos as perguntas de testes, para que o maior número de informações possam ser coletadas de seu sistema.

após a instalação, execute o comando

# sensors

E observe os dados apresentados.

para executar o conky, ainda no terminal digite:

# conky &

em seu desktop, temos o conky padrão, note que este exibe informações básicas do sistema.
basta agora, você personalizar seu conky de acordo com seu sistema.

Para configurar, vá até a pasta home de seu usuário :

# cd /home/`echo $USER`

crie o arquivo com nome .conkyrc . Note que existe um ponto "." na frente do nome do arquivo, este é indispensável para o correto funcionamento, além de manter o arquivo oculto dentro de seu home.

neste arquivo você poderá personalizar quais as informações serão exibidas pelo conky, quando executado.

Noções de comandos do conky disponíveis para o script podem ser acessados AQUI.

Documentação Oficial para instalação e demais dúvidas AQUI

Alguns exemplos podem ainda ser obtidos no GNOME-Look.org

Abaixo meu desktop como exemplo e o respectivo arquivo .conkyrc AQUI.

sexta-feira, junho 05, 2009

Code::Blocks + Glade/GTK + Windows XP

Este artigo demostrará um exemplo de como desenvolver uma aplicação em C para Windows XP de tal forma a deixar o código fonte portável para plataforma Linux. Utilizaremos ferramentas Open Source para o desenvolvimento. Será um artigo breve, onde supomos que o leitor tenha familiaridade com programação. Opções avançadas não serão discutidas, apenas um exemplo básico.

A IDE de desenvolvimento utilizada aqui é o Code::Blocks, faça o download da versão que inclui o ambiente MinGW (contém compilador gcc para windows) AQUI.

Para desenvolvimento de uma interface gráfica amigável que não fique diretamente ligado ao sistema operacional, optamos pela GTK, que além de ser multi-plataforma, conta com o Glade-3, um "front-end" que facilita o designer gráfico de nossa interface, o desingner não será abordado no momento.

Iniciaremos com a instalação da GTK, para tal, obtenha o pacote DEV da mesma, que contém além da runtime, as bibliotecas para desenvolvimento. Disponível para download AQUI.
Durante sua instalação, não esqueca de marcar as opções para desenvolvimento (pacotes DEV). além da libglade-2.0, responsável pela interpretação do XML gerado pelo Glade-3 e construção da interface utilizando o GTK.

Utilizaremos aqui um exemplo já pronto de interface produzida com Glade-3, encontrado na internet, o arquivo example.glade. Maiores detalhes de como produzir uma interface com Glade-3 pode ser visto AQUI.

Tudo instalado, vamos colocar a mão na massa.

Abra o Code::Blocks e inicie um novo projeto do tipo GTK+ Project.


Defina um nome para o projeto e um diretório onde os arquivos serão salvos e gerados.


Agora vamos definir o caminho para o compilador encontrar o GTK em nosso sistema. Clique no local indicado


Preencha os campos conforme ilustrado abaixo. Se você instalou a GTK no diretório padrão os valores para os campos são:

Base -> C:\Arquivos de programas\Arquivos comuns\GTK\2.0
Include -> C:\Arquivos de programas\Arquivos comuns\GTK\2.0\include
Lib -> C:\Arquivos de programas\Arquivos comuns\GTK\2.0\lib



O próximo passo é escolher as opções de DEBUG e RELEASE em nosso projeto, para concluirmos


Antes de iniciarmos o desenvolvimento de nossa aplicação, é necessário informar ao Code::Blocks a localização da libglade-2.0 já instalada. Para tal acessamos via clique com botão direito, a opção Build Option de nosso projeto, conforme abaixo.


Na Aba Linker Settings, adicionaremos a linha libglade-2.0 no campo link libraries, logo abaixo das opções default da GTK. Atenção aos detalhes em vermelho na imagem abaixo


Agora na Aba Search Directories, na sub-Aba Compiler, adicione o local dos header da libglade-2.0, o caminho padrão de instalação é:
C:\Arquivos de programas\Arquivos comuns\GTK\2.0\include\libglade-2.0


Agora na sub-Aba Linker, adicionamos o local das bibliotecas da libglade-2.0, o caminho padrão de instalação é:
C:\Arquivos de programas\Arquivos comuns\GTK\2.0\lib\libglade\2.0


Pronto, agora o Code::Blocks está corretamente configurado.
Podemos agora desenvolver a aplicação.

Para ilustrar, segue abaixo um código exemplo encontrado na internet juntamente com sua respectiva interface desenvolvida em Glade-3. Este projeto completo está disponível para download AQUI.

É um programa que identifica o sistema operacional e as versões das bibliotecas GTK instaladas e exibe o resultado em uma janela simples.


Note que é importante o arquivo gerado pela Glade-3 estar no diretório do seu projeto (junto com main.c)

Alguns pontos importantes na hora de desenvolver qualquer aplicação utilizando Glade/GTK, estão comentados no código desta aplicação abaixo.

// Inclusão das bibliotecas gtk e libglade
#include
#include

// Arquivo interface grafica gerado pelo Glade-3
#define GLADE_FILE "example.glade"

// Principal
int main (int argc, char *argv[])
{
//Variáveis glade para tratar o xml
GladeXML *gxml;
//Variáveis GTK para manipulação da interface gráfica (botao por exemplo)
GtkWidget *window, *platform, *glib_version, *gtk_version;
GtkWidget *user_name, *home_dir;

// Diretivas de pre-processamento para identificação do sistema operacional.
// Apenas um exemplo de aplicação
#ifdef G_OS_WIN32
const gchar *os = "Windows";
#endif
#ifdef G_OS_UNIX
const gchar *os = "Unix";
#endif

//Inicializacao da GTK
gtk_init (&argc, &argv);
//Leitura do arquivo para parser xml
gxml = glade_xml_new (GLADE_FILE, NULL, NULL);

//Objetos GTK de nossa interface
window = glade_xml_get_widget (gxml, "window");
platform = glade_xml_get_widget (gxml, "platform");
glib_version = glade_xml_get_widget (gxml, "glib_version");
gtk_version = glade_xml_get_widget (gxml, "gtk_version");
user_name = glade_xml_get_widget (gxml, "user_name");
home_dir = glade_xml_get_widget (gxml, "home_dir");

//Definição das rotinas de callback
//quando ocorrer determinado evento na interface gráfica a GTK gera um sinal
// correspondente ao evento, e este é atendido pela rotina do usuário.
// A GTK disponibiliza rotinas básicas de tratamento, mais provavelmente voce
// fará a sua.

// Quando a interface gerar o sinal de window_destroy (fechar janela)
glade_xml_signal_connect (gxml, "on_window_destroy", G_CALLBACK (gtk_main_quit));

// ou quando o usuário clicar no X no canto da janela, a rotina gtk_main_quit será acionada
glade_xml_signal_connect (gxml, "on_close_button_clicked",
G_CALLBACK (gtk_main_quit));

//Uma vez que ja linkamos os objetos da interface, podemos desalocar o arquivo Glade
g_object_unref (G_OBJECT (gxml));

// Métodos ilustrativos da própria GTK para informar os dados abaixo:
//Sistema Operacional
gtk_label_set_text (GTK_LABEL (platform), os);

// Versao Glib
gtk_label_set_text (GTK_LABEL (glib_version), g_strdup_printf ("%d.%d.%d",
glib_major_version,
glib_minor_version,
glib_micro_version));

// Versao Gtk
gtk_label_set_text (GTK_LABEL (gtk_version), g_strdup_printf ("%d.%d.%d",
gtk_major_version,
gtk_minor_version,
gtk_micro_version));

//Nome do usuário que esta executando esta aplicacao
gtk_label_set_text (GTK_LABEL (user_name), g_get_user_name ());

//Diretório default
gtk_label_set_text (GTK_LABEL (home_dir), g_get_home_dir ());

//Exibe a interface gráfica
gtk_widget_show_all (window);

//Chama laço de execução da GTK responsavel por rodar a interface e gerar os
//eventos para as rotinas de callback. Quando clicamos em um botao, esta rotina
//identifica o click, gerando o sinal adequado para tal, este é tratado logo
//acima no código quando definimos as rotinas de callback.

gtk_main ();

return 0;
}

Agora você tem uma alternativa válida aos compiladores proprietários, para desenvolver aplicações para sistemas Windows e Linux.

Lembre-se de disponibilizar as dlls das bibliotecas utilizadas junto com sua aplicação compilada. Um pacotão das principais dlls pode ser obtido AQUI

Detalhes avançados sobre GTK e Glade são obtidos junto ao fabricante, google, etc.

sexta-feira, maio 22, 2009

Wolfram Alpha

Foi lançado recentemente o motor computacional de conhecimento da Wolfram.

Wolfram é uma compania internacional fabricante do software Mathematica, fundada pelo físico Sthepen Wolfram, conhecida pelo seu potencial em computações numéricas.

O novo motor, nada mais é que um site, que mistura um conceito de busca, bases de conhecimento atualizadas em tempo real e métodos numéricos para apresentar ao usuário um resultado mais "completo" sobre o conteúdo.

Um exemplo básico de consulta, é a previsão do tempo de uma cidade:
Por enquanto o motor só aceita entradas no idioma inglês, mais isso não é empecilho.

Para quem interessar, clique AQUI

quinta-feira, maio 21, 2009

Slackware 64 !

Sim, é isso mesmo senhores, agora é Oficial, Mr. Pat divulgou no dia 19 passado que a versão 13 de uma das mais famosas e estáveis distribuições de linux contará agora com suporte a processadores 64 bits.
Até então tinhamos projetos independentes como o Slamd64 que dedicavam a "recompilar" todo o sistema em 64 bits.
Com o suporte de Patrick esperamos que esta próxima versão venha novamente a concorrer com RedHat / Ubuntu para uso em servidores mais modernos, trazendo devolta o gostinho do slack porém com muito mais desempenho.

Mais informações : aqui

segunda-feira, maio 18, 2009

Code::Blocks + OpenCV + Ubuntu 9.04 for GCC Users

Segue abaixo um passo-a-passo de como instalar e configurar a IDE Code::Blocks utilizada para desenvolver aplicações em linguagem C/C++ . Será apresentado um passo-a-passo de como linkar e um exemplo utilizando a biblioteca OpenCV, para manipulação das imagens.
Já supomos que seu Ubuntu esteja com a instalação do gcc e demais ferramentas para compilação devidamente configuradas.

Instalando:
sudo apt-get install codeblocks libcv1 libcv-dev libcvaux1 libcvaux-dev libhighgui1 libhighgui-dev

Ao abrir o Code::Blocks ele automaticamente irá identificar seu compilador gcc.

Apenas confirme.


Crie um novo Projeto Console:

Selecione a linguagem C/C++

Defina um nome e diretório para seu projeto

Finalmente conclua


Agora configurando a OpenCV

Project -> Build Options -> Linker Settings
e insira os seguintes parâmetros para linkar as bibliotecas ao seu projeto ( -lcv -lcxcore -lhighgui ) conforme abaixo:

Project -> Build Options -> Search Directories -> Compiler e adicione o seguinte parâmetro conforme abaixo.
(Ubuntu se localiza em /usr/include/opencv os headers da biblioteca OpenCv)

Compile o novo projeto em Build -> Build workspace.

Pronto, click no simbolo de play para executar.


Com um procedimento rápido estamos pronto para o desenvolvimento.

A quem interessar, o source está disponivel aqui.


Espero que tenha ajudado.
[]'s

sexta-feira, abril 24, 2009

terça-feira, abril 21, 2009

Conhece o Mário ?

Oracle & Sun

Pois bem, após o anúncio...

"On April 20, 2009, Oracle announced it has entered into an agreement to acquire Sun Microsystems (Sun). The proposed transaction is subject to Sun stockholder approval, certain regulatory approvals and customary closing conditions. Until the deal closes, each company will continue to operate independently, and it is business as usual.

The acquisition combines best-in-class enterprise software and mission-critical computing systems. Oracle plans to engineer and deliver an integrated system—applications to disk—where all the pieces fit and work together so customers do not have to do it themselves. Customers benefit as their system integration costs go down while system performance, reliability and security go up. "

fonte.

3 perguntas :

# Quanto ganharei com as ações da SUN ?
# Começara a Oracle, vender soluções casadas ?
# Qual o destino do MySQL e Solaris ??

domingo, abril 19, 2009

Ubuntu 9.04

Seja Livre !!

quinta-feira, abril 09, 2009

PWM 8051

Pois bem, tempo sobrando resolvi modificar o pwm que controla o fan de 120mm de meu server.

Anteriormente era um circuito pwm analógico baseado em CI 555, ajustável por um POT na frente do gabinete.

Resolvi reaproveitar uma rotina de pwm para microcontrolador 89s52 que tinha a tempos (que achei na net tb), mesclando com bibliotecas básicas de controle de LCD (já descritas aqui anteriormente) e o que temos é um protótipo básico de controle digital e velocidade para o fan de meu server.

Abaixo segue vídeo demonstrativo.



A tensão de saida varia entre 1 a 11.7V com alimentação de entrada de 12V, duty cicle variando a 1%. com escala a cada 10%.

É isso, Abraços a todos.