Very cheap resistor organizer !

List of Materials :

• Many envelopes (each one to resistor value);
• Binder wooden box;

Just print the resistor values on the top of envelope, put resistor inside, and put inside the box.

In my case, I used 100 envelopes, spent only R$15,00 (USD$ 6,00) and left space inside the box.

You can use the same ideia to store other kinds of components, such as capacitors, diodes, etc
Thanks to friend Rui to give me that ideia.

Integrating RaspberryPi + Xbee USB + Relays Shield

Well, this is my first post in english, just to try disseminate the knowledge about integration between Raspberry Pi and Xbee radio modules, using a USB/Serial card to interface the both.

The basic steps are showed bellow, the configuration steps aren't considered because it's not our focus.

Idea:

The main idea is schedule the time of remote relays that will be activated or not. In my case, will be used to controller the lights of my fish tank.

Using a linux crontab daemon to schedule the tasks, we can set the time to switch the states of lights (relays), like power on at 6 PM and shutdown at 10 PM automatically.

To me, the easy way to integrate the local Xbee module and Raspberry is using a USB/Serial Card to interface. We can use a Raspberry embedded serial port too, but in my case is being used.

So, the picture bellow show the USB card + Xbee module ready to connect in any computer, like my Raspeberry Pi.

Basic Steps:

In my case, the Raspbian distro installed on my Pi recognized the FT 232 automatically, creating a /dev/ttyUSB1 serial interface.

You can find the way to configure your Xbee modules on internet, I won't show here.

This local Xbee module was configured with following options:

MODE : ZIGBEE COORDINATOR API

(Node identifier) NI: Coordinator_bee
(Node Discovery Options) NO: 2

On the remote side, we are using another Xbee radio module, connected directly on a 4 Relays Shield supplied with 5V. Note that this board have a option to isolate the 5V and 3.3V between relay and data bus used by Xbee.

The schema of the connections between Xbee and Relay shield is simple like:

• Xbee Pin (D0) - Relay Pin (1);
• Xbee Pin (D1) - Relay Pin (2);
• Xbee Pin (D2) - Relay Pin (3);
• Xbee Pin (D3) - Relay Pin (4);

So, when the D0 pin change to UP, the relay number 1 will be closed, powering the load (aquarium lights).

On this way, we have a 4 different outputs controlled independently according data received by Xbee.

The relay side will be connected at 4 power outlets powered on 127 Vac.

This remote Xbee module was been configured with following options:

MODE : ZIGBEE ROUTER AT(Node identifier) NI: End_Device_bee
D0: 4 
D1: 4
D2: 4
D3: 4

The value 4 indicate that the pins D0..D3 are initialized with 0V. To enable the pin, just write a value 5 on this pin. 

Remember: Pin OFF = value 0x04 and Pin ON = value 0x05. 

Bellow you can see the wiring diagram:

where R1...R4 are the relays data pin (load).

Communication:

The communication between Xbee modules consist in a simple message, sending a packet data with the status of the 4 relays. If state = 1, relay will be activated, If state = 0, relay will be deactivated.

I choosed the perl language to write a simple script to send packet data from Raspberry using a local Xbee module to a remote Xbee that control the relays.

The script are divided in 2 main stages:

1 - Open serial port connection (Xbee USB Card) and send a discovery command to find the Xbee modules configured on the Bee network.

In my case, just 2 device are discovered as expect, 1 coordinator (local) and 1 remote.

After the remote Xbee was found, the next stage:

2 -  Check the script arguments and replicate the state in the relays, sending data packets to activate or not each Xbee pin (connected to pin of the relays). In our case, we need to send 4 data packets, containing the state of each relay.

To running the script manually, just type something like that:

 perl enable_relays.pl R1_status R2_status R3_status R4_status

 Ex.:  enable all pins  : perl enable_relays.pl 1 1 1 1  

       disable all pins : perl enable_relays.pl 0 0 0 0

       relays 1 and 3   : perl enable_relays.pl 1 0 1 0

To write this script, I used the Device::SerialPort and Device::Xbee::API perl modules existing on CPAN to create a serial port connection between Raspberry Pi and Xbee USB Card and, after that, create a connection between Local Xbee and Remote Xbee to send data.

At this point, I would like to thank's John, the developer of perl Xbee module that helped me on some issues involved to send a packet data using him api.

Here the perl source code:

#!/usr/bin/perl -w
# usage: perl enable_relays.pl status_pin1,…,status_pin4
# example: perl enable_relays.pl 1 0 1 0
#          perl enable_relays.pl 1 1 1 1
#   perl enable_relays.pl 0 0 0 0

use Device::SerialPort;
use Device::XBee::API;

# Autoflush
$|=1;

# Define Pin Status char
my $pin_on = pack( 'C', 5 ); 
my $pin_off = pack( 'C', 4 ); 

# Communication
my $rx =""; 
my $serialport ="/dev/ttyUSB1";

# Remote Xbee Node Parameters
my $high = 0x13A200;
my $low = 0x40744398;
my $ni = "Remote_NODE_NAME";

# Pins Status of Remote Xbee Node
# 1 = enable(ON) / 0 = disable(OFF)
my @dpins = (0,0,0,0);
$dpins[0]=$ARGV[0];
$dpins[1]=$ARGV[1];
$dpins[2]=$ARGV[2];
$dpins[3]=$ARGV[3];

# Configure the local serial port
my $serial_port_device = Device::SerialPort->new($serialport);
$serial_port_device->baudrate( 9600 );
$serial_port_device->databits( 8 );
$serial_port_device->stopbits( 1 );
$serial_port_device->parity( 'none' );
$serial_port_device->read_char_time( 0 );
$serial_port_device->read_const_time( 1000 );

# Create the API object
my $api = Device::XBee::API->new( { fh => $serial_port_device } ) || die $!;

# Send the ND API command
my $at_frame_id = $api->at( 'ND' );
die "Transmit failed" unless $at_frame_id;

# Wait receive the reply from nodes
while($rx = $api->rx_frame_id( $at_frame_id )){
# Received error ?
if ( $rx->{status} != 0 ) {
die "API error" if $rx->{is_error};
die "Invalid command" if $rx->{is_invalid_command};
die "Invalid parameter" if $rx->{is_invalid_parameter};
die "Unknown error";
}
# If remote node name founded, exit
if($rx->{ni} =~ /$ni/g){ 
# print $rx->{ni};
last;
}
}

# Foreach pin, commit pin status
# Check Pin D0 if ON/OFF
    if($dpins[0] == 1){ #ON
$at_frame_id = $api->remote_at( { sh => $high , sl =>  $low , apply_changes => 1}, D0,$pin_on);
}
else{ #OFF
$at_frame_id = $api->remote_at( { sh => $high , sl =>  $low , apply_changes => 1}, D0,$pin_off);
}

# Check Pin D1 if ON/OFF
        if($dpins[1] == 1){
$at_frame_id = $api->remote_at( { sh => $high , sl =>  $low , apply_changes => 1}, D1,$pin_on);
}
else{
$at_frame_id = $api->remote_at( { sh => $high , sl =>  $low , apply_changes => 1}, D1,$pin_off);
}

# Check Pin D2 if ON/OFF
    if($dpins[2] == 1){ #ON
$at_frame_id = $api->remote_at( { sh => $high , sl =>  $low , apply_changes => 1}, D2,$pin_on);
}
else{ #OFF
$at_frame_id = $api->remote_at( { sh => $high , sl =>  $low , apply_changes => 1}, D2,$pin_off);
}

# Check Pin D3 if ON/OFF
        if($dpins[3] == 1){
$at_frame_id = $api->remote_at( { sh => $high , sl =>  $low , apply_changes => 1}, D3,$pin_on);
}
else{
$at_frame_id = $api->remote_at( { sh => $high , sl =>  $low , apply_changes => 1}, D3,$pin_off);
}

exit 0;

To do the crontab daemon execute the script, you can add the following entries on your crontab:

## Aquarium Main Light ON (Relay 2) @ 18:00 & OFF @ 22:00
00 18 * * * /home/pi/Aquarium/enable_relays.pl 1 1 0 0 >> /dev/null 2>&1
00 22 * * * /home/pi/Aquarium/enable_relays.pl 1 0 0 0 >> /dev/null 2>&1

Now you have a simple script to send data and control the 4 Xbee pins (relays) remotely. 

My fish tank :-)

Cálculo Tensão Saída de um PWM

Pois bem, como comentei no forum tempos a tras (acho que em 2007 :-) tenho utilizado muito o método de PWM - Pulse width modulation (modulação por largura de pulso) para controlar e gerar tensões variadas. Deu vontade de explicar como funciona a matemática da bagaça....
Sabemos que de acordo com a largura do pulso, ou seja o tempo de ciclo de 1 pulso e a proporção que este pulso fica ligado (em alta) e desligado (em baixa) chamado de duty-cycle, teremos uma tensão de saída proporcional a tensão de entrada em relação ao duty-cycle escolhido.

Exemplificando:
Entrada = 5V
Duty-Cycle 50% temos Saída 2,5V
Duty-Cycle 100% temos Saída 5,0 V
Duty-Cycle 37% temos Saída 1,85V

Agora como calcular ? Simples, Use Vsaida = (E/T).tligado.

Mais como sei ? ....

Analisando a figura do pulso acima temos 4 variáveis, 3 em relação ao tempo do pulso e 1 em relação a tensão de entrada. São Elas:

TCiclo = tempo total de 1 ciclo. Chamamos de T.
tligado = tempo em alta
tdesligado = tempo em baixa
E = tensão de entrada

Primero preciso saber a frequência do sinal. Lembra do colégio ?
Frequência é o inverso do período, como temos um período T (TCiclo), expressamos a frequência por 1/T

Pois bem, mais neste mesmo periodo T meu sinal se decompõe em uma parte alta e outra parte em baixa, precisamos saber qual a parte exata do sinal está em alta ou baixa (lembra do duty-cycle ?), viajamos na integral parar isso. Note que devemos incluir a nossa frequencia 1/T no cálculo para termos a variacão final em relação a todo nosso período.

Temos então para 1 ciclo:


Note que a função f(t) é a variação da tensão de entrada, em alta ou baixa em relação ao tempo que a mesma passa em alta e em baixa. Note também que durante tligado, temos tensão = E. Já para o instante tdesligado temos tensão = 0, ou seja minha tensão na entrada vai variar de 0 (baixa) até E (alta).

Montamos a integral, lembre de separar os instantes que as tensões ocorrem...

A segunda parte da integral, temos uma tensão = 0V, desconsideremos esta parte.
Já primeira parte, o valor E é constante igual a tensão de entrada do circuito e esta não varia com o tempo, por exemplo baterias de 9V, Pilhas de 1,5V, etc. Chamamos apenas de E para não especificar.

Nosso limite de integração conta apenas com a parte positiva (ligada) do sinal, ou seja de 0 a tligado.
Calculando a integral com os limites acima temos:

Agora que podemos confiar na "formulinha" apresentada no início, calcularemos os exemplos apresentados acima.
Então para uma tensão de entrada = 5,0Vdc e duty-cycle iguais a 100%, 50% e 37% temos respectivamente:


Pronto...agora voce já sabe :-)
Bjo na bunda !

Manual de Sobrevivência das Forças Armadas

Variando um pouco o cardápio...



Aprenda a sobreviver… Baseado no mais qualificado manual de sobrevivência das Forças Armadas dos Estados Unidos.
Constituido de 6 volumes com as mais avançadas técnicas de sobrevivência das forças armadas americanas.
Saiba tudo sobre: primeiros socorros, criar abrigos e fazer fogo, como se proteger do frio, determinão de rumos, conhecimentos básicos de sobrevivência na floresta e muito mais.

* Nome do livro: Manual de Sobrevivência
* Autor: Jonh Boswell e George Reiger
* Ano de Lançamento: 1980
* Número de Páginas: 260
* Idioma: Português
* Edição: unica
* Editora: Publicações Europa-América
* Formato: PDF


* Tamanho: 6.81 Mb
http://www.megaupload.com/?d=A9B61FYX

Ubuntu 10.04

Periféricos & Interfaces

Clique no Link para visualizar ~24MB

CLICK AQUI

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.

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.

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.

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

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

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

Ubuntu 9.04 - Running

Ubuntu 9.04 - Gostei ;-)

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 ??

Ubuntu 9.04

Seja Livre !!

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.

O mUNDo MPn ?

Pois bem, no mundo de telecom, onde operadoras comem operadoras, eu como mero usuário e fantoche do sistema de telefonia celular, decidi aposentar meu velho celular Motorola C200, herdado de minha irmã (camarada ela), comprar um novo aparelho, com o detalhe essencial, aceitar 2 SIM Card's.

Deparei-me com 2 modelos:

Samsung D880 DUO, no mercado alternativo custa próximo de R$850,00.

Em momentos de crise e transportes públicos superlotados, andar com um equipamento destes no dia-a-dia acredito nao ser um bom investimento.

O Alto preço justifica-se pela inovação (embora copiado da china), a qualidade do equipamento.

Vamos ao que interessa, durante as pesquisas, encontrei um equipamento, que muitos chamam de "clones" do IPhone, o primo chinês.
Alguns modelos são réplicas completas do grande sucesso da apple, porém com a possibilidade de utilização de 2 SIM Card's ao mesmo tempo, me fez optar pela compra de um aparelho desses.
Sai em busca de um modelo relativamente simples, barato e que pudesse substituir ao mesmo tempo, meu mp3 player e celular.
Certo sábado, fui até a Santa Efigênia, e comprei um desses...conhecido como MP7 (virou zueira isso, acho que a contagem esta em 9), pois bem, discreto, e funcional, atendeu as minhas necessidades básicas e preços variando de 280 a 450 reais de acordo com os modelos e funções.
O modelo escolhido foi um JingSheng JC777s

Com um pouco mais de tempo comecei a explorar as funcionalidades desse novo brinquedo.
Apesar de rodar um aplicação, ao meu ver pesada, até agora não apresentou falha alguma.

Algumas funcionalidades deste aparelho podem ser vistos abaixo

Dual SIM, pode usar 2 chips ao mesmo tempo Quadriband 850/900/1800/1900
Camera digital 2.0mp com zoom
Grava vídeos no formato AVI com zoom
Dimensões 52.0 x 120.0 x 17.0 mm
Peso 115gr
Capta sinal de TV aberta Memória expansível até 4gb
Aceita 2 cartões de Memória de 2gb Acompanha 1 cartão memória 256mb
Bluetooth Display Touch screen ( acompanha caneta pen touch ) Viva voz, vibra call, Display TFT 3.0" de 262.144 cores 240x320
Rádio FM WAP, GPRS, agenda, jogos
Calculadora, calendário, despertador, lembretes Reproduz MP3, 3GP, MP4, WAV, AMR e MIDI Antena externa para TV Caneta pen touch Mensagens de texto SMS Mensagens multimídia MMS Duração da bateria de até 4 horas de conversação
Duração de 100 horas em stand-by

Certo, perfeito para meus propósitos, porém a falta de um manual de instruções, cd com drivers, ou qualquer outro tipo de ajuda para operar o telefone, impossibilitou o uso do mesmo como modem gprs.
Problemas como sincronização de agendas, musicas, ring-tones, entre outros, surgiram na sequência...

Usuário de Linux, infelizmente ainda sofre um pouco com os fabricantes, principalmente com os mais desconhecidos, resta apenas a boa alma escrever um modulo para o controlador do telefone.

Achei um solução para tal, em ambiente Ruindows, também uso ele, um software chamado PCSync, facilmente encontrado no google.

Vale lembrar que para o funcionamento, o driver do telefone deve instalar instalado, o modelo é MediaTek mt6228, o qual tambem é encontrado no google.

Pois bem, resumindo um pouco , hj tenho todos meus contatos sincronizados, viajo escutando minha música ou assistindo meu jogo, além de utilizar operadoras diferentes, de diferentes códigos de área, bem como substitui minha pendrive pelo SD do MP7.

Espero que dure tempo suficiente para compensar o investimento, até o momento tudo ok, inclusive navegando na internet via gprs, utilizando o proprio PCSync e Operadora TIM - Pre Pago (muito caro).

Basta saber agora, até quando o mercado criará novos significados baseado em nosso bom e velho codec MP3.

Processadores auto-refrigerados deverão aposentar coolers mecânicos

A empresa emergente Thorrn Micro Technologies apresentou um sistema para resfriamento de chips que não tem partes móveis e que produz vento suficiente para resfriar um laptop inteiro.

Cooler de estado sólido

O exaustor de estado sólido produz uma corrente de ar três vezes maior do que um "cooler" mecânico típico, mesmo tendo apenas um quarto do tamanho. Como não possui partes móveis, o dispositivo é silencioso, ultra-fino, apresenta baixíssimo consumo de energia e praticamente não requer manutenção.

Vento iônico

Batizado de RSD5, o cooler de estado sólido é formado por uma série de fios que produzem plasma em micro-escala - plasma é um gás ionizado que possui elétrons livres suficientes para transmitir eletricidade.

Os fios ficam no interior de superfícies meia-cana - equivalentes a um cano cortado na longitudinal. Uma placa não carregada eletricamente é posta sobre o conjunto, funcionando como uma espécie de tampa.

Quando os fios são submetidos a uma corrente elétrica, os íons do plasma resultante empurram as moléculas de ar do fio para a placa, gerando o vento. O fenômeno é chamado de vento corona.

Refrigeração miniaturizada

O projeto da superfície curva permitiu o controle das descargas em micro-escala até o nível de produção máxima de vento sem o risco de formação de arcos elétricos. O resultado é uma corrente de ar de 2,4 metros por segundo. O maiores coolers mecânicos produzem fluxos de ar entre 0,7 e 1,7 metros por segundo.

"A tecnologia tem potência para resfriar um chip de 25 watts utilizando um dispositivo de menos de 1 centímetro cúbico e um dia poderá ser integrada no silício para se produzir chips auto-refrigerados," diz Dan Schlitz, um dos criadores do exaustor de estado sólido.

Este lançamento comercial é resultado da pesquisa sobre motores de vento iônico mostrada na reportagem Motores de vento iônico farão resfriamento de chips, publicada em meados de 2007.


Fonte