16 dezembro 2015

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

18 julho 2014

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.  

 

25 março 2014

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. 

04 março 2014

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/



20 julho 2013

IP estático para conexão crossover - ArchLinux Raspberry PI

O Archlinux já vem configurado para configuração de IP via DHCP. Dessa forma basta conectá-lo no roteador doméstico, que ele receberá um IP.

Mas nem sempre, você possui esse roteador doméstico, às vezes é interessante fazer uma conexão direta entre seu computador e seu Raspberry PI. Antes de escrever a solução que adotei, é bom informar que o computador está com o Debian 7, e Raspberry PI com Arch Linux e a você precisará de um cabo de rede categoria 5 crossover.

No computador com Debian 7:
- Verifique o IP da sua rede para que você configure o Raspberry PI na mesma rede

$ sudo ifconfig eth0

- Caso seja um notebook, como o meu caso, e você não está utilizando a placa ethernet, apenas a placa wi-fi, você deve setar um IP estático que desejar:

$ sudo ifconfig eth0 10.2.1.100 netmask 255.255.255.0 up

No Raspberry PI, com ArchLinux
- Tive que instalar o pacote netctl, que substituiu o pacote netcfg na distribuição ArchLinux

# pacman -S netctl

- Dentro do diretório /etc/netctcl/examples copie os arquivos ethernet-dhcp e ethernet-static para o diretório /etc/netcl. O arquivo ethernet-dhcp não é necessário mexer, altere apenas o ethernet-static, colocando um IP da mesma rede de seu computador. Os arquivos são simples e autoexplicáveis.

- Para deixar automático e autodetectável, ou seja, ao colocar o cabo no PI ele deve tentar primeiro uma configuração DHCP e depois setar o IP estático, deve-se utilizar a sequencia de comandos abaixo:

# systemctl enable netctl-auto@interface.service 
# systemctl enable netctl-ifplugd@interface.service  

Pronto, basta reinicar o PI e verificar se funcionou.

Linsk utilizados:
https://wiki.archlinux.org/index.php/Netctl

13 julho 2013

Raspberry PI GPIO - Parte Final (RPi.GPIO lendo dados)

Nos posts anteriores foi possível mostrar como fazer para ativar pinos de saída com a biblioteca RPi.GPIO. Este post agora é para demonstrar como fiz para ler pinos de entradas, ou seja, como ler pinos que receberão sinais lógicos 0 ou 1.

Acho que seria bom explicar como funciona o hardware utilizado. Pois bem, nada mais é do que o pino 1 da GPIO, que representa 3,3V constantes, ligado em série a um resistor de 10K a um terminal de um botão (push button), esse mesmo terminal está conectado a um pino utilizado como entrada (pinos 15, ou 16, ou 18, ou 19), e o outro terminal do botão conectado ao pino 6 que é o terra (GND) da GPIO.

Pino 1 (3.3V)
|
|
R10K
|__________________ Pino 19 (input)
|
_/    (chave do tipo push-button)
|
|
Pino 6 (GND)


Dessa maneira quando a chave estiver aberta o pino receberá 3.3V (nível lógico alto), quando estiver fechada receberá 0V (GND, nível lógico baixo). Resumidamente:
- chave não pressionada = 1
- chave pressionada = 0

Pois bem, agora que entendemos quais os sinais serão recebidos, vamos falar da RPi.GPIO. Bem simples, como sua utilização para pinos de saída. Primeiramente deve-se setar qual o modo de representação dos pinos, numeração da placa (GPIO.BOARD) ou numeração do chip BCM2830 (GPIO.BCM). Depois quais os pinos que serão de usados como entrada. Acabei criando duas funções para isso:

import RPi.GPIO as GPIO

def init_env():
        GPIO.setmode(GPIO.BOARD)
        GPIO.setwarnings(False)

def init_pin():
        GPIO.setup(15,GPIO.IN)
        GPIO.setup(16,GPIO.IN)
        GPIO.setup(18,GPIO.IN)
        GPIO.setup(19,GPIO.IN)


Para ler a entrada, a maneira mais simples seria fazer um loop e invocar a função input() da biblioteca RPi.GPIO, passando qual o pino será ligo. Exemplo:

entrada = print(GPIO.input(19))
while(entrada):
        entrada = GPIO.input(19)

Para testar os botões do meu hardware fiz um código que exibe os estados dos pinos de entrada (15,16,18 e 19) durante 5 segundos, e a medida que pressiono os botões, o programa exibe 0 no pino da chave que pressionei.

Em uma aplicação mais real, essa abordagem mais simples causa problemas, pois a leitura do pino somente será realizada quando o programa encontrar a instrução com o método input, o que ocasiona certo atraso. A biblioteca RPi.GPIO possui mecanismo de tratamento de evento, percebendo alterações de nível de sinais, o que é chamado de alterção de bordas em eletrônica digital. Isso quer dizer que algum código pode ser invocado através de chamadas de interrupções, quando for percebido uma alteração de subida (GPIO.RISING) de 0 para 1, ou uma alteração de descina (GPIO.FALLING) de 1 para 0, ou para ambos os casos (GPIO.BOTH).

É bem simples, basta adicionar um evento com função RPi.GPIO.add_event_detect(pino, alteração de sinal, func) onde func é uma função que você pode criar que será chamada quando for percebido uma alteração de sinal, em um determinado pino de entrada. Exemplo:

def callback_exit(channel):
        print("Botão pressionado no pino ",channel)
        print("Saindo do programa.")
        quit()


GPIO.add_event_detect(18, GPIO.FALLING, callback_exit)

Com o exemplo acima, um programa enquanto estiver sendo executado, poderá ser interrompido quando o sinal do pino 18 cair de 1 para 0.

Para terminar a brincadeira resolvi utilizar a função system() para desligar o Raspberry PI quando pressionado um botão. Abaixo segue uma representação do trecho do código:

def callback_off(channel):
        print("Botão pressionado no pino ",channel)
        print("Desligando o Raspberry PI")
        os.system("shutdown -h now")


GPIO.add_event_detect(19, GPIO.FALLING, callback_off)

Colocando um loop infinito no final do programa, e exibindo em tela duas opções, para pressionar o botão do pino 18 para sair do programa, ou pressionar o botão do pinto 19 para sair do programa.

Com isso seria possível colocar algumas funções de teclado através da GPIO.

Para os códigos completos, inclusive dos posts anterior, podem ser encontrados no endereço abaixo do github:

https://github.com/ferauche/gpiodk

Aliás, foi bem fácil instalar o cliente git pelo pacman, e fazer o clone, depois o push para o servidor github, tudo isso diretamente pelo Pi.

Link utilizado:
http://code.google.com/p/raspberry-gpio-python/wiki/Inputs

12 julho 2013

Raspberry Pi GPIO - Parte II (Instalando RPi.GPIO)

Para acessar a GPIO via programação em python, fiz uso da biblioteca RPi.GPIO, disponível em: https://pypi.python.org/pypi/RPi.GPIO

Para o Raspbian é possível instalá-lo via apt-get, porém como citei no post anterior, o ArchLinux parece ser a distribuição mais indicada para quem quer trabalhar com a GPIO, e notei que não existe instalação via pacman.

Mas foi apenas baixar o fonte da biblioteca python, e instalá-lo com o setup install do python, abaixo a sequencia de comando que utilizei:

# wget https://pypi.python.org/packages/source/R/RPi.GPIO/RPi.GPIO-0.5.3a.tar.gz
# tar zxf RPi.GPIO-0.5.3a.tar.gz
# cd RPi.GPIO-0.5.3a
# python setup.py install

Testei se a biblioteca foi devidamente instalada através do Shell do python, importando a biblioteca RPi.GPIO sem apresentar erros:

Python 3.3.2 (default, May 24 2013, 01:55:36)
[GCC 4.7.2] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import RPi.GPIO as GPIO
>>>

Pronto, agora pude começar a criar alguns códigos para testar as saídas, acendendo os LEDs. Conheci como utilizar a biblioteca em http://code.google.com/p/raspberry-gpio-python/wiki/BasicUsage

É bem simples, primeiro deve-se setar se a referência ao canal da GPIO será feita pela numeração de pinos da placa do Raspberry PI, ou pela numeração do chip BCM2835 que controla a GPIO, então a primeira deve definir isso, utilizando os parâmetros GPIO.BOARD ou GPIO.BCM:

import RPi.GIO as GPIO

GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(false)

 A função setwarnings(false) é para que não sejam exibidos avisos, como se tal porta já está sendo utilizada ou não.

Depois disso é só setar qual pino será saída, e qual será entrada. Abaixo um exemplo de como setar um pino como saída, e como colocá-lo em nível baixo (0).

GPIO.setup(10,GPIO.OUT)
GPIO.output(10,0)

Tudo bem simples, e facilmente consegui fazer os LEDs acenderem, deu até para fazer um efeito super-máquina (para quem tem minha idade e lembra do seriado do carro que falava huahauh).

Próximo post pretendo falar um pouco de como funcionam as entradas, também divulgar os exemplos que fiz através de um link do github.

Links consultados:
http://code.google.com/p/raspberry-gpio-python/w/list
https://pypi.python.org/pypi/RPi.GPIO




10 julho 2013

Raspberry PI GPIO - Parte I (Hardware para testes)

Antes do último post, o que desejava mesmo era apenas programar em python para acessar a GPIO e realizar alguma experiência. Eu iria precisar de algum hardware para realizar a experiência. Pensei em projetar algum circuito eletrônico em uma protoboard mesmo, mas eis que ao fazer uma limpeza em casa, acho uma montagem eletrônica que fiz a mais de 10 anos atrás, quando desenvolvia (para estudo) periféricos para a porta-paralela de PCs.




Sim é um cartucho antigo de Atari, o jogo acho que era H.E.R.O., e como podem notar o circuito é simples, apenas resitores, LEDs e chaves do tipo push-bottom, tudo isso muito mal soldado, diga-se de passagem, a um conector DB-25 fêmea, e utilizando um pedacinho de papelão para evitar curtos ;-) .

Mais tarde tentarei fazer um post explicando melhor o circuito, mas resumidamente são 8 LEDs, cada um ligado a um resistor de 1 K e ligado a um pino (pinos de 2 a 9) do conector DB-25, que serve para testar saídas, todos os LEDs estão ligados no pino 25 que era o terra da porta-paralela. Quando um nível lógico alto é setado a um pino que está ligado ao LED, este acenderá.

O pino 1 do DB-25 é ligado nas chaves, ele deve estar setado em nível lógico alto. Cada chave é ligada a um resistor também de 1 K que é ligado a 1 pino (pinos de 10 a 13) do DB-25, a outra extremidade da chave é ligada ao terra, pino 25 do DB-25. Dessa forma todos os pinos de entrada recebem nível lógico alto, quando a chave é fechada ficam em nível lógico baixo.

Verifiquei que a GPIO em seu pino 1, é uma saída constante em 3.3V. Como não sabia se essa coisa (a fita do Atari) ainda funcionava, e também porque ela foi feita para trabalhar com 5V da porta-paralela, apenas liguei o Raspberry PI, e com a ajuda de alguns fios conectei o pino 1 da GPIO, ao pino 2 do DB-25, e o pino 6 (terra) da GPIO ao pino 25 do DB-25 e o LED acendeu.




O que me deixou muito feliz, pois não precisaria fazer um circuito para programar a GPIO. Porém, teria que arranjar um jeito de fazer um cabo DB-25 para os pinos do GPIO. Daí achei na caixa de tranqueiras, uns flat cables de IDEs antigos, e resolvi me aventurar com o ferro de solda, como antigamente.

Abaixo a correlação de pinos DB-25 e GPIO:


DB25    x    GPIO
1    ------------    1

2    ------------    10
3    ------------    11
4    ------------    12
5    ------------    13
6    ------------    21
7    ------------    22
8    ------------    23
9    ------------    24

10  ------------      15
11  ------------      16
12  ------------      18
13  ------------      19

25  -------------      6


Abaixo algumas fotos de como ficou o cabo, e de como eu continuo sendo muito ruim com o ferro de solda :)






Depois de todas essa trabalheira, percebi que o pino 1 da GPIO fica para o lado de fora da placa, o que impede de conectar o conector do flatcable de IDE, porque ele é de 40 pinos, e a GPIO é de 26 pinos, e não tem espaço suficiente no interior da placa, por que logo em seguida vem a saída de video RCA. Eu teria que soldar tudo novamente, e então decide cortar o conector do flat, transformando-o em um conector de 26, que na verdade fico 26,5 ... cortei bem em cima do pino 27 e 28 rs. Mas o importante é que funcionou.



Acima é uma foto já de um código python executado dentro do interpretador para testar o cabo. O próximo post descreverei como foi feita a configuração e instalação do RPi.GPIO, a biblioteca python, e como utilizá-la para comunicação com a GPIO do Raspberry Pi.

[]s

Links utilizados:
http://openmicros.org/index.php/articles/94-ciseco-product-documentation/raspberry-pi/218-2-raspberry-pi-gpio-inputs-in-python
http://www.rpiblog.com/2012/09/using-gpio-of-raspberry-pi-to-blink-led.html
http://code.google.com/p/raspberry-gpio-python/wiki/BasicUsage

ArchLinux Raspberry Pi

Minha experiência de meio do ano foi realizar alguns testes com a GPIO. Eu tinha uma imagem já montado do Raspian Whezzy em um SD de 2G, e ao tentar instalar a biblioteca Ri.GPIO através do apt-get, começaram a surgir alguns problemas de dependência de pacote. O que já era esperado, pois a imagem não estava atualizada desde de abril.

Quanto tentei atualizar para resolver o problema de dependência, tive problemas de espaço, pois 2G é o mínimo recomendado, e o Wheezy vem com vários pacotes (inclusive interface gráfica) que não utilizaria nessa experiência.

Dessa maneira optei por tentar uma nova distro para o Raspberry PI, e escolhi o ArchLinux, por ser bem mais enxuto e por ter já o ssh ativado (no Wheezy era necessário alterar alguns arquivos de configuração dentro da imagem, ou então realizar um primeiro boot com monitor e teclado e ativar o ssh), o que para mim era vantagem pois queria acessar tudo via ssh.

Baixei a versão de 06-06-2013, o procedimento de montagem do SD é o mesmo do post anterior. Depois foi só colocar o SD e iniciar o Raspberry PI.

Fui surpreendido com a velocidade do boot, com apenas 10 segundos.

Atualizei o sistema com os comandos abaixo:

# pacman-key --init 
# pacman -Syu 

Baixou aproximadamente uns 170 MB, demorou alguns minutos (aprox. 10 min) para finalizar a instalação.

Instalei o python3 e o compilador gcc com os comandos abaixo:

# pacman -S python
# pacman -S gcc

Necessito desses dois pacotes para realizar a programação da GPIO utilizando o python.

Estou gostando do ArchLinux, creio que para o uso que pretendo do Raspberry PI (controle de periféricos e robótica) seja a distribuição mais indicada.

Links utilizados:
http://elinux.org/ArchLinux_Install_Guide
http://www.raspberrypi.org/downloads   

20 janeiro 2013

Nem todos os sdcards são compatíveis com o Raspberry PI

Vivendo e aprendendo.

Participo de uma lista de um grupo chamado GCC-SD (Grupo de Compartilhamento de Conhecimento - Santos do Dumont), reuni pessoas interessadas em assuntos como software livre, e assuntos correlatos.

Recentemente temos conversado sobre o Raspberry PI, e eis que um integrante do grupo adquiriu um Raspberry e não estava conseguindo iniciá-lo. Montou a imagem pelo Windows, depois pelo Linux, e nada.

Fiquei intrigado, será a qualidade da placa não é boa? Será que o produto chegou com defeito para ele? Eis que descobri no site official do Raspberry PI, que não são todos os sdcards que funcionam nele. Existe uma lista de sdcards compatíveis e não-compatíveis. Pode acessra a lista aqui.

Caso o seu sdcard esteja funcionando ou não, e não está na lista, por favor atualize a wiki.

Não sei se foi o caso do colega do GCC-SD, mas é sempre bom verificar a compatibilidade do sd-card.

[]s

Ferauche

07 janeiro 2013

Minha proteção para o Raspberry PI

Não me atrevi a chamar de case, pois é muito simples, e nem tão pouco estético. O objetivo era fazer algo que proteja a placa e que não precise ficar manuseando seus componentes para plugar os cabos.

No post anterior relatei a breve pesquisa que fiz sobre as chamadas 'cases' para Raspberry PI, e o meu interesse particular sobre o último projeto DIY que achei.

Porém não estava com muito tempo, nem tão pouco tinha os materiais indicados pelo projeto, e resolvi, no maior estilo Mr. Maker (programa infantil da Discovery Kids) utilizar o que tinha em mãos, e em 30 minutos construir algo para proteger a placa.

O que tinha em mãos eram restos de um tupperware quebrado, parafusos de gabinetes de PCs, e precisava de algo para utilizar de hastes, e resolvi usar o tubo de uma caneta esferográfica.
Não tinha tempo para imprimir o mapa da placa Modelo B, e resolvi fazer eu mesmo um molde, medindo a olho o tamanho da placa, suas furações e fazendo um corte para deixar as portas GPIO livres. Coloquei o molde sobre o tupperware e com um estilete cortei as placas.

Tubo de caneta já cortado, parafusos de gabinetes e placa de plástico cortada
Para fazer os furos aqueci os parafusos na boca do fogão e coloquei em contato com as placas, da mesma maneira fiz para fixá-los nos tubos de canetas e na placa base. Por fim, peguei restos de EVA de uma lembrança de aniversário de um dos colegas de meu filho e fiz 3 pés na placa base. O resultado está abaixo.





Como disse anteriormente não é estético, mas atinge o objetivo de proteger a placa, e tudo feito facilmente em 30 min, com um detalhe: tomando conta de duas crianças também ;-) .

Pretendo fazer uma outra mais para frente, achei um tanto quanto chato trabalhar com o plástico, e ao colocar os pés de EVA acho que poderia utilizar mais desse material para fazer uma caixa quase que toda de EVA.

Raspberry PI Cases

O Raspberry PI quando comprado não vem com um caixa (case), você pode trabalhar com a placa diretamente, ela é bem resistente, porém não me agrada muito ficar pegando em seus componentes toda a vez que tenho que plugar o cabo de alimentação, ou o cabo de rede, ou o adaptador USB, etc.

É possível comprar cases bem bacanas, mas todos importados, abaixo segue uma relação de alguns que achei interessantes:

Pibow feito de acrílico, é um kit que você monta.

Biz's LEGO Case

Vários outros cases são vendidos, um site interessante para isso, e também para vários acessórios para o Raspberry PI é o ModMyPi.

Como não queria esperar para importar um case, e não estava contente em ficar manuseando a placa diretamente, resolvi procurar por projetos DIY (Do It Yourself), ou seja, faça você mesmo e encontrei alguns abaixo:

Punnet, é possível baixar em PDF, imprimir e fazer o case de papel.

Case utilizando um cartucho de videogame


Feito de acrílico e uma espécie de tubo de plástico

O projeto que me chamou a atenção foi o último, pela sua simplicidade, porém não tenho o material disponível, e não me agradou a forma como a placa é presa (através dos cantos da placa).

Como adquiri o modelo B do Raspberry que já possui dois furos na placa para sua fixação, resolvi adaptar o projeto anterior para utilizar os próprios furos da placa, e achei um link interessante onde é possível baixar uma planta em PDF da placa.

Planta da Raspberry PI Model B

Com isso é possível moldar qualquer case para utilizar os orifícios do Modelo B. No próximo post tentarei detalhar como fiz o meu primeiro case.

05 janeiro 2013

Manual do Raspberry PI

Professores do Reino Unido criaram em conjunto um manual do Raspberry PI, com alguns tutoriais utilizando Scratch e Python. Muito interessante para ser usado como base para disciplinas de Lógica Computacional e também para inciantes do PI.

O Manual é licenciado pela liçenca Creative Commons, que permite sua utilização desde de que mantida a autoria do Manual. Pode ser baixado e distribuído gratuitamente.

O link para download é: http://www.raspberrypi.org/archives/2965

03 janeiro 2013

SSH e XSSH com o Raspberry PI

Realizei um teste acessando o Raspberry PI via SSH, foi muito fácil e tranquilo, porém alguns detalhes a serem lebrandos:

1- Ativei o ssh no primeiro boot que realizei com o Raspberry PI conectado a uma TV, teclado e mouse. É possível realizar a configuração sem ser no primeiro boot (http://www.slblabs.com/2012/08/16/rpi-ssh-ip/)

2- A exportação do ambiente gráfico também foi simples, basta incluir o parâmetro -X no comando ssh (ssh -X pi@192.x.x.x) , o Raspbian já vem pré-configurado para exportar o ambiente gráfico. (Utilizei uma estação Linux, se estiver utilizando Windows precisará instalar alguns aplicativos)

3- Pela placa wireless a exportação do ambiente gráfico ficou bem lenta, talvez seja algum problema de configuração da mesma. Pelo cabo ficou muito boa a velocidade.

31 dezembro 2012

Reiniciando com o Raspberry Pi

Durante 2012, eu e o meu colega de trabalho Carlos Romel, nas conversas de café, trocamos ideias sobre desenvolvimento de sistemas embarcados, e o Romel me contava sobre suas peripécias com o Arduino.

Há uns 4 anos atrás, já havia me aventurado no desenvolvimento de sistemas embarcados utilizando microcontroladores da família PIC, cheguei até a adquirir um kit de desenvolvimento da 2ei (http://www.2ei.com.br/). Meu interesse sempre foi, e ainda é, de um passa-tempo, ou quem sabe a utilização destes sistemas em alguma pesquisa acadêmica. Na época fiz alguns códigos utilizando uma pilha de bibliotecas para o kit de desenvolvimento, e o que me deixava frustrado era a dificuldade de compartilhar os projetos, pois tinha uma forte dependência com o kit, assim como os demais kits existentes para PIC.

Nas conversas de café, o Arduino me chamou a atenção por ser uma espécie de padrão de hardware a ser utilizado, no entanto ainda seria necessário utilizar a linguagem C e conhecer suas bibliotecas de hardware para poder desenvolver algum projeto, o que não me motivava muito.

Eis que um dia meu amigo Romel me mostra o Raspberry Pi (http://www.raspberrypi.org/), uma placa que é um computador inteiro, com saída de áudio, video (inclusive HDMI), armazenamento em um cartão SD, entradas USB, um processador ARM e 512 MBytes de RAM, onde é possível executar vários sabores de Linux, e o mais interessante possui um conjunto de pinos específico para interface I/O (conhecida como GPIO).

Fiquei bem interessado, no entanto ainda meio relutante em comprar uma vez que teria que importar, e a espera era de aproximadamente 5 meses. Mas uma coisa que contribuiu também para o meu interesse foi a possibilidade de desenvolver para embarcados utilizando a linguagem Python, que tive contato com a necessidade de escrever alguns scripts para automatizar algumas tarefas, e também em algumas experiências com o GoogleAppEngine. Achei Python bem simples, e utilizá-lo para controlar dispositivos seria ótimo.

No final de 2012, após assistir uma palestra do desenvolvimento JAVA para o Raspberry Pi no JAVA ONE 2012 em São Paulo, decidi definitivamente adquirir a placa, e tive a grata surpresa de encontrar uma distribuidora nacional (http://www.farnellnewark.com.br/). Paguei R$ 50,00 a mais do que se importasse, porém chegou em 3 dias, e não em 5 meses.

Peguei um SD-Card de 2 GB de um celular antigo que estava parado, baixei o Raspbian (versão Debian customizada para o Raspberry Pi) e gravei sua imagem no cartão (http://n00blab.com/how-to-create-raspberry-pi-sd-card/), conectei a placa na entrada de video da TV (CRT) que tenho na sala, com um mouse e teclado USB e realizei o primeiro boot. Fantástica a sensação de utilizar um computador na sala, em uma TV de tubo de ráios catódicos, parecia que voltava no tempo, na época do MSX e TK-90.

Muitas ideias para a utilização desta placa, muitos menosprezam o poder computacional que pode ter um processador ARM com 512 MB de RAM conectado na Internet. Aliás este é o próximo passo, configurar a rede, e o adaptador USB wireless para que a placa fique conectada na Internet.

Toda essa emoção, e também para demonstrar o poder computacional dessa placa que decide reativar meu blog, que estava parado desde 2010, para compartilhar essas experiências e trocar informações. Vamos ver com qual frequencia, e até quando consigo alimentar este blog.

Até a próxima postagem ...