SDR - Software Definied Radio usando ISDB-T

Software Definied Radio - SDR são chips que podem ser configurados via software para poderem transmitir e enviar informações via rádio.

Quando a transmissão digital de sinal de TV iniciou no Brasil, foi uma febre a compra de dispositivos USB para poder receber o sinal digital e poder assistir os canais de TV no computador. Esses dispositivos são chamados de dongles USB. São bem baratos e utilizam o chip RTL2832U que possui uma interface de comunicação via software conhecida como RTL-SDR (RTL Software Defined Radio). Onde é possível configurar o dongle para qualquer faixa de frequência (dentro de seu limite) utilizando o tipo de modulação e encriptação desejado.

No caso do RTL2832U ele é um receptor, e assim me deu a ideia de me aventurar na radio escuta amadora, que descobri que possui o nome de "Coruja" (a pessoa que fica apenas ouvindo as transmissões nas diversas faixas).

Primeiro passo necessário foi instalar o driver do dongle na minha distribuição Linux (Debian 8 Jessie). O que para minha supresa foi bem simples, pois já existia pacote pronto para realizar a instalação (https://packages.debian.org/jessie/rtl-sdr). Então com apenas os comandos abaixo, foi possível realizar a instalação:

# apt-get update
# apt-get install rtl-sdr
 
Após a instalação do driver, ao plugar o dongle a porta USB o mesmo acendeu um LED, o que não fazia anteriormente.

Precisava agora de um software para ficar varrendo as frequências, a maioria das pesquisas na Internet apontavam para o software SDR# para Windows. Mais um pouco de search na Web e encontrei o site www.rtl-srd.com com várias informações úteis e uma lista de software compatíveis com o chip RTL2832U, entre eles me deparei com o GQRX para linux, interface gráfica gnome, e com pacote também disponível para minha distribuição (https://packages.debian.org/jessie/gqrx-sdr). Novamente com mais dois comandos, foi realizada a instalação com sucesso.

# apt-get update
# apt-get install gqrx-sdr

Instalou até no menu um item HAM Radio e dentro dele o GQRX, e ao abrir o aplicativo ele ativa o dongle e você já começa a ouvir a chiadeira pela placa de som de seu computador. Vai ajustando a frequência e tipo de modulação. Colocando, por exemplo, Filter width = Wide e Mode = WFM (stereo) você consegue recepcionar as radios FM locais. Para escuta de rádio em banda estreita, deve-se colocar Filter width = Normal e Mode = Narrow FM. E depois ficar alterando a frequência, de olho no gráfico das potências de sinal. Encontrando uma faixa em que a potência sobe e desce, dando picos altos de variação, ali pode estar havendo uma transmissão. Basta clicar com o mouse no ponto do gráfico onde está havendo essa variação, e ele automaticamente ajusta a frequência desse canal.

Como o processo de achar estava muito demorado, eu fiz uso de uma tabela que encontrei na internet (http://radiocomunicacaopxvhf.blogspot.com.br/2011/04/tabela-de-canais-e-suas-frequencias.html) e fiquei procurando próximo das faixas indicadas para radio amadores. E consegui localizar um canal 146.620 MHz, onde dois radio amadores estavam conversando.

O sinal estava bem fraco, estava usando apenas a antena embutida do dongle, irei futuramente tentar instalar uma antena externa. Mas o resultado foi bom, foi possível amplificar o sinal aumentando os DBs  via software, e a escuta foi clara. Fiquei com a curiosidade senão conseguiria montar um scanner com um script python, ou algo do gênero para me auxiliar na busca dos canais.

Acho que este será o próximo desafio, fazer um buscador de canais automático!!!

NodeMCU ESP8266 - Arduino Day 2017

Dia 1º de abril foi o Arduino Day, evento que ocorre mundialmente para comemorar o Movimento Maker principalmente na área de designers e eletrônica.

Aqui na região da baixada santista, tivemos o evento em 2016, e agora em 2017. O evento deste ano foi superior em quantidade de participantes, e também na qualidade das palestras. Maiores informações sobre o evento, podem ser obtidas no blog Engenheiro Caiçara.Tive a oportunidade de participar falando do NodeMCU ESP8266, e esse post fará um resumo do que foi apresentado lá.

ESP8266
 
É um SoC (System on a Chip) fabricado pela Espressif Systems, popularizado por volta de 2012, principalmente pela comunidade do mundo Maker devido seu baixo custo. Ele implementa toda a pilha TCP/IP e o padrão 802.11 b/g/n. Possui um microcontrolador interno. O primeiro módulo foi o ESP-01, ele era programado diretamente utilizando a linguagem LUA, ou através do Arduino UNO com suas bibliotecas.

ESP-01

Atualmente o encapsulamento do ESP8255 está no módulao ESP-12E, com o microcontrolador Tensilica L106 32-bit, com clock de 80 MHz, Spi, I2C, conexão serial RX/TX e 10 portas GPIO (sendo que 4 podem ser utilizadas como PWM). Continua sendo possível programá-lo diretamente, sem a necessidade do Arduino, somente através de um módulo FTDI para fazer a conexão USB.

ESP-12E

ESP-12E conectado através de módulo FTDI

NodeMCU ESP12-E
É uma plataforma de hardware Open-source de desenvolvimento para o ESP12-E. Além de programá-lo diretamente através da Linguagem Lua, é possível utilizar firmwares para diferentes linguagens como Espruino (JavaScript próximo ao Node.js), ESP-Open-SDK (Linguagem C), ESP-Open-RTOS (Linguagem C também), Micropyton (Python) e Arduino IDE (linguagem C++);

A vantagem em se trabalhar com o Arduino IDE está em aproveitar todas bibliotecas para se trabalhar com sensores já implementadas para o mundo Arduino. A única atenção que deve se ter é que o ESP8266 trabalha com 3V, e não 5V como o Arduino UNO, e isso talvez requeira algumas adaptações nas montagens eletrônicas dos módulos para Arduino.

NodeMCU ESP12-E

É necessário instalar a biblioteca referente ao ESP dentro do Arduino IDE. Isso é possível a partir da versão 1.6 do Arduino IDE. Um tutorial detalhado sobre como realizar essa instalação e implementação pode ser vista no blog FlipeFlop.

Para o Arduino Day realizei a montagem abaixo, com dois LEDs, e uma chave push button ligado a um resistor de 10K, conforme a imagem abaixo.

Sketch feito no Fritzing

Foi uma demonstração de como usar o NodeMCU como um "WebServer", onde é possível controlar a intensidade com que a Led vermelho pisca. O Led verde mostra o status da conexão WiFi, ele piscando demonstra que está tentando conectar no WiFi, ele ligado direto indica que dispositivo conectado no WiFi. O push button quando acionado faz com que o Led Vermelho pare de piscar. Pressionando-o novamente, ele volta a piscar.

O ESP retorna sempre uma página HTML com um botão de +, e outro botão de -. Quando pressionado um botão, ele envia uma requisição HTTP para o ESP com a string "more", quando o botão + é pressionado, e uma string "less" quando o botão - é pressionado.

O código trata a requisição recebida e altera o valor da variável "intensidade", fazendo com que o Led pisque mais rápido, ou mais devagar. O mesmo código do sketch de exemplo Blink do Arduino foi utilizado para fazer o Led piscar.

O código pode ser visto na minha página do github.

O próximo post espero fazer esse mesmo código com Mycropython!

Espero ter ajudado, até a próxima!

VM Linux para servir como Access Point

Tive uma necessidade em criar uma rede wifi fechada que seja compartilhada através de um notebook, com configurações específicas de DNS e DHCP, e que fosse distribuível para qualquer notebook ou computador.

Um colega realizou tentativas, utilizando aplicativos para rotear a Internet através do Windows 7, e até mesmo o roteamento nativo do Windows 10, porém a rede se demonstrou muito instável para a necessidade que tínhamos.

Então surgiu a ideia de criar uma Máquina Virtual Linux, e configurá-la para agir como um Access Point, ou seja, para que os dispositivos wi-fi se conectassem através dele.


A máquina virtual 

Escolhemos o Debian 8 como distribuição pela estabilidade e larga documentação pela Internet. Utilizamos também como gerenciador de Máquinas Virtuais o Virtual Box da Oracle.

Foi realizada a instalação do Debian, com o mínimo de pacotes e sem Interface Gráfica, para deixá-la como mínimo possível de capacidade (atualmente ocupa 3 GB no disco rígido), já que uma das necessidade é que seja distribuível para qualquer computador hospedeiro (independente de Sistema Operacional: Linux, Windows ou Mac OS).

Hardware a Placa de rede wifi nativa.

A primeira dificuldade foi fazer com que a Máquina Virtual reconhecesse a placa de rede wifi do computador hospedeiro, e esta dificuldade não foi superada. É impossível fazer com que a Máquina Virtual (VM) reconhecesse a placa de rede wifi do computador hospedeiro, pois ela cria uma placa de rede virtual do tipo ethernet, e não como alterar isso, pelo menos esse é comportamento utilizando o Virtual Box.

Utilizando Adaptador Wireless USB

A solução então foi utilizar um adaptador wireless USB. O adaptador USB deve ser instalado no computador hospedeiro, sendo instalado todos os drivers necessários para o funcionamento normal do adaptador wireless no hospedeiro. Verifique se o adaptador wireless funcionada perfeitamente no computador hospedeiro, antes de tentar instalá-lo na VM.

O próximo passo é fazer com que a VM reconhecesse o adaptador USB. Para tanto é necessário ir nas configurações da VM. Basta selecionar a VM e clicar no botão "Configurações", selecionar USB e adicionar o dispositivo USB que deseja que a VM reconheça.

Porém, não foi tão simples assim. Estava usando a versão 4.3 do Virtual Box, e ela não reconhecia o adaptador USB. Achei uma documentação dizendo que precisaria de um "Extension package", um pacote de extensão para o Virtual Box, mas mesmo instalando-o não reconhecia o dispositivo USB. Mais um pouco de documentação, e percebi que a USB 2.0 e 3.0 só funcionam a partir da versão 5 do Virtual Box.

Baixei então o Virtual Box 5.1 e seu respectivo "Extension Package". Removi a versão anterior do Virtual Box, guardei a VM criada com o Debian 8 no computador. Realizei a instalação do Virtuabol 5.1 e Extension Package. Importei a VM, e consegui realizar a configuração USB sendo reconhecido o dispositivo USB.

O caminho para fazer com que a VM reconheça um dispositivo USB, pode ser acessado nesse link aqui, no meu caso em um hospedeiro Linux, mas a parte da instalação do "Extension Pack" é igual para qualquer hospedeiro:

https://blog.butecopensource.org/dispositivos-usb-nao-sao-reconhecidos-pelo-virtualbox-host-linux/

Instalando os drivers do adaptador wifi na VM Debian 8
Após o adaptador USB wifi estar instalado e funcional na máquina hospedeira, e o adaptador também esteja visível através das configurações da VM no Virtual Box, é a vez de instalar os drivers na VM Linux Debian 8.

Primeiro é preciso descobrir o id do fabricante e do dispositivo, basta usar o comando, todos com permissão de root:

# lsusb
Bus 005 Device 001: ID 0000:0000
Bus 004 Device 006: ID 0a5c:2110 Broadcom Corp.
Bus 004 Device 001: ID 0000:0000
Bus 001 Device 001: ID 0000:0000
Bus 002 Device 001: ID 0000:0000
Bus 003 Device 001: ID 0000:0000

Localize o número Hexadecimal, onde os 4 primeiro dígitos é o fabricante, e os 4 após os "dois pontos" é o id do dispositivo.
Ex.: 0a5c:2110
0a5c ==> Fabricante
2110 ==> Dispositivo

Mais informações aqui na wiki do Debian

Após descobrir o id do fabricante e do dispositivo, localize o respectivo driver no nesta página da wiki do Debian. Onde é possível localizar o repositório do driver, ou baixá-lo diretamente.

No meu caso era um Realtek, e tive que usar apenas alguns comandos para atualizar via apt-get, em outros casos é necessário baixar o drivers e realizar a instalação manual.

Programa Hotspotd em python
Como o dispositivo USB funcionando na VM Debian 8, é a hora de instalar  os programas necessários para o funcionamento da VM como um access point. Resolvi usar, por escolha própria, um script em python que realiza essa tarefa. O script chama-se hotspotd, e pode ser obtido através do endereço abaixo:

https://pypi.python.org/pypi/hotspotd

Existe uma pegadinha aí na documentação do hostpotd presente no package index, pois antes de realizar a instalação do hotspotd, existe a dependência da instalação de dois pacotes do linux: hostapd e dnsmasq.

Dessa forma, antes de instalar o hotspotd é necessário instalar esses pacotes através do comando abaixo:

# apt-get install hostapd
# apt-get install dnsmasq

Após a instalação, é possível seguir a instalação do hotspotd, com os comandos:

# wget https://github.com/prahladyeri/hotspotd/raw/master/dist/hotspotd-0.1.4.tar.gz
# tar xvf hotspotd-0.1.4.tar.gz
# cd hotspotd-0.1.4/
# python setup.py install

Para iniciar a aplicação basta digitar

# python hotspotd.py start

A primeira vez será solicitada as configurações de SSID e senha, essas configurações serão salvadas, e o Access Point já aparece disponível na rede wifi.

Encontrei algumas falhas de autenticação, e resolvi deixar a rede aberta. Para isso deve-se alterar o arquivo:

 /usr/local/lib/python2.7/dist-packages/hotspotd/run.conf

Deixando como comentário todos as linhas referentes a autenticação, da linha

auth_algs=1

para baixo, colocando um # na frente.



Detalhes do código e funcionamento do hotspotd aqui.



VM Debian 8 iniciando com senha automática
Para que a VM inicie automaticamente e já inicie o hotspotd sem necessidade de autenticação de usuário e senha, foi necessário alterar o linux para autenticar automaticamente com um user. Para isso foi alterado o arquivo com os comandos abaixo:

# cd /etc/systemd/system
# nano getty.target.wants/getty\@getty\@tty1.service

Localize a linha:

ExecStart=-/sbin/agetty --noclear $TERM

Altere para:

ExecStart=-/sbin/agetty --noclear -a robo %I $TERM

Salve e saia pressionando CTRL+X

Isso fará com que o Debian inicie automaticamente com o user robo sem autenticação.

Para carregar e iniciar automaticamente o hotspotd, basta alterar o arquivo .bashrc do usuário, no caso usuário robo

# nano /home/robo/.bashrc

E ao final do arquivo a linha para iniciar o hotspotd, como encontrei intermitência com o adaptador USB, hora ele ficava ativo, hora fica inativo, antes de iniciar o hotspotd, eu ativo o adaptador wireless. Então as linhas ao final do .bashrc ficaram:

sudo ifconfig wlan0 up
cd /home/robo/hotspotd-0.1.6
sudo python hotspotd start

Apesar de se tratar de uma Máquina Virtual, as configurações aqui realizadas, principalmente a parte da instalação do adaptador wireless na Máquina Virtual Debian, o hotspotd e as customizações de inicialização do Debian, podem ser replicadas no Linux Raspbian (distribuição Debian para o Raspberry Pi), podendo transformar um Raspberry Pi em um Roteador WiFi.

Até a próxima.

Darth Vader Fm Mind Power

Resolvi unir dois hacks feitos anteriormente. O projeto piFM e o projeto de acender LEDs através da GPIO do Raspberry Pi.

Utilizei uma cabeça de Darth Vader de plástico, vendida na padaria que contém umas pastilhas (muito ruins por sinal), furei os olhos do Darth Vader e coloquei dois LEDs (infelizmente não tinha vermelho, somente azul).

Conectei os dois LEDs a pino 12 da GPIO em série com um resistor de 470 Ohms. Assim mandando um sinal alto na porta 12 ligo os LEDs com 3,3V de saída.

Baixei algumas falas do Darth Vader pelo torrent, e utilizei o ffmpeg para converter em um formato que o piFM entenda, dessa forma criei o shell script mp3player.sh

#!/bin/bash

ffmpeg -i $1 -f s16le -ar 22.05k -ac 1 - | sudo ./pifmlib/pifm -

O Darth Vader irá falar utilizando o seu poder da mente através de ondas FM em 103.3MHz.

Criei um script em python (vader.py) utilizando a biblioteca RPi.GPIO para enviar um sinal alto ao pino 12, fazendo ligar os LEDs, e enviando sinal baixo para desligar os LEDs, assim os LEDs acenderão quando o Darth Vader estiver se comunicando via FM.

import RPi.GPIO as GPIO
import PiFm2 as PiFm

def init_env():
 GPIO.setmode(GPIO.BOARD)
 GPIO.setwarnings(0)
 GPIO.setup(12,GPIO.OUT)

def eyes_on():
 GPIO.output(12,1)

def eyes_off():
 GPIO.output(12,0)

Alterei o código Python do piFM (piFM.py) incluindo a função playMp3 que na verdade invoca o script shell mp3player.sh, veja como ficou a função:

from subprocess import call

def playMp3( filename ):
   call(["./mp3player.sh", filename])

Assim é possível invocar o método playMp3 dentro do código vader.py, e então criei as funções das falas:

def power_darkside():
 eyes_on()
 PiFm.playMp3("./pifmlib/sounds/Darkside.mp3")
 eyes_off()

def breathing():
 eyes_on()
 PiFm.playMp3("./pifmlib/sounds/Vadrbrth.mp3")
 eyes_off()

Para ficar mais bacana e pensar em possíveis interações através de Web Services, criei um script python para responder a requisições HTTP, assim sendo possível acionar o Darth Vader através da Web. O VaderServer.py, utilizando a biblioteca BaseHTTPServer do Python. Um trecho do código que trata as requisições está abaixo:

import cgi
import sys
from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
import vader

class MainHandler(BaseHTTPRequestHandler):

   def do_GET(self):
   p = self.path.split("?")
   path = p[0][1:].split("/")
   params = {}
   if len(p) > 1:
     params = cgi.parse_qs(p[1],True,True)
     print params
     print params['vader'][0]
   if params['vader'][0]=='0':
     vader.power_darkside()
   if params['vader'][0]=='1':
     vader.breathing()
   if params['vader'][0]=='2':
     vader.dont_make_destroy()
   if params['vader'][0]=='3':
     vader.dont_fail()
   if params['vader'][0]=='4':
     vader.dont_comeback() 

  Para iniciar o servidor é necessário passar a porta como parâmetro:

sudo python VaderServer.py 8000 

E abrir o navegador, ou comando curl, ou wget com a seguinte url:

http\\ipdopi:8000?vader=0

Cada número passado de 0 a 4 corresponde a uma fala do DarthVader.

O resultado final está abaixo.

Espero ter ajudado, o código está no github (https://github.com/ferauche/VaderDemo)

Ferauche

Retropie

Meu filho mais velho está gostando de jogar video games, por incrível que parece gosta mais de jogar com controle do que no touch do tablet, ou no teclado do computador.

Resolvi então testar a distribuição Retropie, que é um Raspbian Customizado para executar vários emuladores de videogame.

Baixei a imagem de http://blog.petrockblock.com/download/retropie-project-image/

Gerei o SDCard como das vezes anteriores (Ver post anterior).

A primeira vez que você roda o Raspberry Pi com o Retropie ele não roda o raspi-config, ele apenas roda script para configurar os botões do controle do videogame (A,B, select, start e Setas), e não expande automaticamente o SDCARD.  Portanto, tem que sair do Retropie, com a Opção Exit, assim ele abrirá a linha de comando, e assim pode invocar o comando:

• sudo raspi-config

E aí com utilizar a primeira opção para expandir o tamanho do SDCARD. Isso é importante, uma vez que não vi opção para executar os jogos (roms) fora do SDCARD.

Baixe umas roms no meu notebook, do site  http://www.freeroms.com/, alguns jogos do Atari (River Raid e Hero), jogos do Master System (Shinobi), MegaDrive (Sonic) e PSOne (Crash Bandid Coot).

Inseri novamente o SDCARD no meu notebook para copiar os arquivos, uma vez que estou usando Linux (Debian) posso fazer isso, se estiver usando outro OS (Microsoft ou Mac) é capaz de não conseguir enxergar a partição expandida pois utiliza o Sistema de Arquivos ext4.

Copiei as roms para o diretório /Retropie/roms, e coloquei novamente o SDCARD no Raspberry Pi para ver funcionar.

Para minha surpresa só aparecia a opção IBM (Dos) e dois jogos para PC, que já vem com a imagem do Retropie.

Pesquisando, descobri que tem que executar um script para que ele instale os emuladores. Utilizei o comando abaixo:

• cd Retropi-setup
• sudo ./retropie-setup 

Ele executa  um programa, e pergunta se deseja instalar os emuladores da própria imagem, ou se deseja instalar da internet (mais atualizado). Como estava sem Internet no momento, instalei direto da imagem, porém o recomendado é fazer pela Internet, se possível como indicado aqui: https://github.com/petrockblog/RetroPie-Setup

Após a instalação, que demora aproximadamente uns 5 minutos, ele gera dentro do diretório /home/pi/Retropie/roms um subdiretório para cada emulador, onde deve ser copiados os jogos.

Coloquei novamente o SDCard no notebook, e copie os jogos em seus respectivos diretórios. SDCard novamente no Raspberry Pi, e agora outras opções apareceram no Menu, onde pude rodar os jogos sem problemas, com exceção do Crash Bandit Coot (no emulador do PSOne), que ficou extremamente lento.

Os dois videos abaixo foram de grande valia.

MediaCenter Raspbmc

Resolvi testar a customização do Raspbian para Media Center, o chamado Raspbmc.

Existem duas distribuições para media center, uma baseada no OpenElec e outra baseada no próprio Raspbian que é o Raspbmc. Como já havia mexido com o Raspbian anteriormente, achei mais prático utilizar o Raspbmc

Baixei a imagem de http://www.raspberrypi.org/downloads/

Gravei a imagem utilizando os comandos:

Com o SDCARD inserido:

• umount /dev/sdb1
• dd bs=1M if=~/Downloads/raspbmc-2014-06-13.img of=/dev/sdb
• sudo sync

Pronto, é só colocar o SDCARD no Raspberry PI e ligá-lo.

A primeira vez irá rodar o programa de configuração do Raspbian, que pode ser executado quando quiser através do comando

• sudo raspi-config

Nele é possível configurar informações de fuso horário, tipo de teclado, ativação de SSH e principalmente expandir o espaço do SDCARD, se o seu SDCARD for maior que 4 GB.

Não realizei testes de transferência de arquivos pela rede, resolvi copiar os arquivos dentro do próprio SDCARD, uma vez que estava com um SDCARD de 16 GB.

Coloquei novamente o SDCARD no notebook, e como uso Linux (Debian) pude copiar diretamente os arquivos para o SDCARD, o caminho onde devem ser colocados os arquivos é:

• /home/pi/.xbmc/playlist/video

Depois coloquei novamente o SDCard no Pi, e na opção de Videos, em Play List aparece os arquivos copiados. Nenhum era de alta resolução 1080p, mas mesmo assim gostei do teste realizado, apesar de ter usado uma TV de 21'' através da conexão RCA.

Tenho que fazer mais testes, mas acho que é um ótima opção para MediaCenter.  

 

IDE Arduino no Debian 7

Decidi realizar experiências com o famoso microcontrolador Open Source Arduino. Adquiri um Arduino UNO. Decidi pela versão UNO primeiro pelo custo, que é a versão mais barata, e segundo pela quantidade de tutoriais e experiências publicadas na Internet.

Placa de Desenvolvimento - Arduino UNO

Para quem não conhece, o Arduino é um microcontrolador, não um mini-computador, o que o difere bastante do Raspberry Pi. O Pi, como micro-computador, possui processador, memória RAM, memória sólida (SD-Card), e interfaces de entrada e saída (ETHERNET, USB, RCA, HDMI, áudio e GPIO). O Arduino, como microcontrolador, possui memória interna, e suas interfaces para o mundo externo (Saídas e entradas digitais de 3.3V a 5V, entradas analógicas e pinos para RX e TX).

O Arduino tem sua utilidade maior para a comunicação com o mundo externo, é mais performático que o Raspberry Pi através da GPIO. Exemplos como: controlar servo-motores e leitura de sensores mais sensíveis, são ótimas funcionalidade para o Arduino.

O casamento do Raspberry Pi, como cabeça pensante e comunicação através TCP/IP com a Internet, e o Arduino como olhos, braços e pernas para a interação com o mundo externo, é uma ótima opção para construção de solução de IoT.

Como usuário do Debian 7, resolvi relatar o que é necessário para instalar e configurar o Arduino IDE,

Instalando os pacotes
Para a instalação dos pacotes basta utilizar o apt-get conforme as linhas abaixo:

$ sudo apt-get update
$ sudo apt-get install arduino arduino-core

Os pacotes foram instaladas junto com suas dependências, e o Arduino IDE ficou disponível entre os Aplicativos.

Executando o Arduino IDE
Para executar o Arduino IDE, basta digitar na linha de comando:

$ arduino 

Ou então, clicar no ícone do Arduino IDE entre os Aplicativos instalados.
  
Na primeira tentativa de executar o Arduino IDE, apareceu uma mensagem avisando que é necessário adicionar o meu usuário ao grupo 'dialout' para realizar a comunicação com a USB, e um botão com a opção de 'Adicionar'.

Cliquei no botão, e inseri a senha de root como foi solicitado. Apareceu outra janela avisando que as alterações só surtiriam efeito após reiniciar o sistema. Reiniciei o sistema e a mesma mensagem apareceu. Achei estranho, e fui procurar informações no site do Arduino, onde achei:

http://playground.arduino.cc/Linux/All#Permission

Verifiquei o grupo do device USB do Arduino com o comando:

$ ls -la /dev/tty*

O Arduino é idenficado como ttyAXXX, no meu caso a saída foi:

crw-rw---T   1 root dialout   166,   0 Mar 25 23:22 ttyACM0

Adicionei meu usuário ao grupo dialout com o comando:

$ sudo usermod -a -G dialout $user

Após isso, reinicie o Debian. Abri novamente o Arduino IDE e não apareceu mais a mensagem.

Testando
O Arduino IDE vem como série de exemplo que podem ser encontrados em /usr/share/arduino/examples. Escolhi o diretório 01.Basics/Blink e abri o arquivo Blink.ino, que é um código para fazer um led piscar no pino 13. Abaixo segue o código:

int led = 13;

// the setup routine runs once when you press reset:
void setup() {               
  // initialize the digital pin as an output.
  pinMode(led, OUTPUT);    
}

// the loop routine runs over and over again forever:
void loop() {
  digitalWrite(led, HIGH);   
  delay(1000);           
  digitalWrite(led, LOW);
  delay(1000);
}

O código é transferido através do botão "Upload", e após colocar o Led no pino 13, ele começa a piscar. O vídeo abaixo é do Youtube, que demonstra a execução do código Blink.ino, para demonstrar o resultado que consegui.

Apesar de ser uma aplicação boba, ascender o LED foi o teste que o ambiente está configurado e funcional, e agora irei tentar fazer a comunicação Raspberry Pi e Arduino. 

Hack de Carnaval: PiFM

Descobri que é possível transmitir em FM com o RaspberryPi através de software, utilizando a GPIO4.

O Imperial Club Robotic Society, um clube de estudantes de robótica do Reino Unido, realizou uma competição, onde saiu o código chamado PiFm. O código em C, se utiliza da GPIO4 (saída para geração de clocks) uma vez que é possível programar essa saída para diferentes frequências (de 88 MHz a 108 MHz), é possível gerar um sinal em FM modulado através de software.

O único hardware adicional é um pedaço de fio, de cerca de 20 cm para funcionar como antena.

Basta baixar o software daqui, e agora através deste repositório do github em que copie, e fiz alguns testes.

Descompacte o arquivo, ou faça um clone do repositório do github, e já está pronto para utilizar.

Para realizar um teste, basta entrar no diretório do projeto executar o código binário "pifm", passando o arquivo .wav desejado e a frequência de transmissão.

# ./pifm sound.wav 100.3

ATENÇÃO: O arquivo wav deve ser de 16 bits e faixa de frequênciad e 22050 Hz. O código só trabalha nessas configurações de arquivo wave. Maiores informações neste fórum: http://www.element14.com/community/thread/25073/l/pifm--raspberry-pi-as-a-trasmitter--music-problem.

O projeto original já vem com um código em python chamado PiFm.py, que é uma função escrita em python de como invocar o arquivo binário escrito em C.

Fiz uma pequena alteração para fixar a frequência de 100.3 MHz, pois o rádio que estava utilizando para testes tinha dificuldades em sintonizar a frequência de 100 MHz que é a default do código escrito em C.

Depois criei um código exemplo, para demonstar que é possível chamar vários arquivos em sequência, e criei o myPiFm.py

Tudo bem simples, em questão de umas 2 horas foi possível realizar esse Hack. Mais uma façanha da plaquinha "bombril" Raspberry PI.

Fontes utilizadas:
http://www.icrobotics.co.uk/wiki/index.php/Turning_the_Raspberry_Pi_Into_an_FM_Transmitter

http://pplware.sapo.pt/linux/raspberry-pi/transforme-o-raspberry-pi-numa-emissora-fm-em-1-minuto/

http://www.hack4fun.com/raspberry-pi/turning-the-raspberry-pi-into-an-fm-transmitter-with-pifm/