Estudo Custo/Benefício de um Frango Congelado

Bem, ultimamente na versão "mão de vaca", decidimos estudar se compensa comprar 1 frangão inteiro e picotar, ou comprar as partes no mercado, o resultado é positivo, porém decepcionante.

Para ilustrar os prós e contras, percentual de aproveitamento e estimativa da mão de obra + economia monetária, segue a tabela abaixo:

Abaixo fotos da pesquisa:

Sugestões para servir:
Filé de Peito Empanado:

Moelas e Figado ao molho com cebolas:

Conclusão: Da próxima vez, gaste R$ 1,00, economize trabalho e pague a "cervejinha" do funcionário :-)

Compact Genetic Algorithm Solve The OneMax Problem Using Arduino

This article presents how to solve the OneMax Problem, using a Compact Genetics Algorithms (CGA) executed on Arduino.

The Compact Genetic Algorithms are a evolutionary computing method, that use a probabilist distribution to solve a problem when the solutions are unknown.

More details in Goldberg.

To permit this, some parameters of CGA need to be configured, like the population size, and the maximum number of epochs.

To test that method, the OneMax problem is used to proof the concept.

The demonstration problem is a maximizing binary optimization problem called OneMax that seeks a binary string of unity (all '1' bits).

The objective function only provides an indication of the number of correct bits in a candidate string, not the positions of the correct bits. The algorithm is an implementation of Compact Genetic Algorithm that uses integer values to represent 1 and 0 bits in a binary string representation.

The individual represented here in the chromosome has 32 bits of length.
So the solution is represented by a individual with fitness value equal to 32, denoting the sum of all bits that contain the value 1.

More details in Clever.

To generate the random values used to initialize each chromosome, a LFSR Generator was used.

So that way, was implemented a C code to Arduino based on python code provided by previous link, that can solve the OneMax Problem.

The source code was divided in two pieces, the MyTypes.h file has the chromosome data structure, while the cga.ino file has the CGA source code to solve the OneMax.

The intefarce to control the algorithm is simple, using the serial port:

• To disable debug mode, just send 'd' char through the serial port. The debug mode print the best individual in each epoch.

• To run the code, just send 'r' char and wait the result.

The source code can be download HERE !

Bellow you can see a output from code executed.

Welcome do ACGA a Arduino Compact Genetic Algorithm.
Press 'r' to solve OneMax Problem.

Press 'd' to disable Debug Mode.
Running, please wait...

Iteration 0, BitString: 11110111010111101011011011111111 , Best Fitness: 25.00
Iteration 1, BitString: 11110111010111101011011011111111 , Best Fitness: 25.00
Iteration 2, BitString: 11110111010111101011011011111111 , Best Fitness: 25.00
Iteration 3, BitString: 11111111111101111011101011111111 , Best Fitness: 28.00
Iteration 4, BitString: 11111111111101111011101011111111 , Best Fitness: 28.00
Iteration 5, BitString: 11111111111101111011101011111111 , Best Fitness: 28.00
Iteration 6, BitString: 11111111111101111011101011111111 , Best Fitness: 28.00
Iteration 7, BitString: 11111111111111111111111001111101 , Best Fitness: 29.00
Iteration 8, BitString: 11111111111111111111111001111101 , Best Fitness: 29.00
Iteration 9, BitString: 11111111111111111111111001111101 , Best Fitness: 29.00
Iteration 10, BitString: 11111111111111111111111001111101 , Best Fitness: 29.00
Iteration 11, BitString: 11111111111111111111111001111101 , Best Fitness: 29.00
Iteration 12, BitString: 11111111111111111111111001111101 , Best Fitness: 29.00
Iteration 13, BitString: 11111111111111111111111001111101 , Best Fitness: 29.00
Iteration 14, BitString: 11111111111111111111111001111101 , Best Fitness: 29.00
Iteration 15, BitString: 11111111111111111111111001111101 , Best Fitness: 29.00
Iteration 16, BitString: 11111111111111111111111001111101 , Best Fitness: 29.00
Iteration 17, BitString: 11111111111111111111111001111101 , Best Fitness: 29.00
Iteration 18, BitString: 11111111111111111111111001111101 , Best Fitness: 29.00
Iteration 19, BitString: 11111111111111111111111001111101 , Best Fitness: 29.00
Iteration 20, BitString: 11011111111101111111111111111111 , Best Fitness: 30.00
Iteration 21, BitString: 11111111111111111111111111111111 , Best Fitness: 32.00
Done!
Best Solution = BitString: 11111111111111111111111111111111 , Best Fitness: 32.00

Enjoy !

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