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

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

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

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   

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

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.

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

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.