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