Postagem em destaque

Controle PID de Potência em Corrente Alternada - Arduino e TRIAC - Parte I

Este post é o primeiro de uma série de seis que escrevi tratando de controle de potência e PID (controle proporcional, integral e derivativo...

domingo, 20 de abril de 2014

Raspberry & sensores: tacômetro efeito Hall

Seguindo com o projeto que começou a ser descrito nos posts aqui e aqui, vamos falar do uso de sensores digitais no RPi.

Foi dito no último post que os servo-motores de giro contínuo não têm uma referência, ou seja, eles não "sabem" a sua posíção quando a gente os liga.

Se queremos usá-lo para tracionar um carrinho, por exemplo, sem problema, porque normalmente a gente sabe onde o carrinho está (vendo-o ou com algum esquema de monitoramento, como um GPS) e o motor só precisa girar a roda obedecendo a comandos.

Mas se queremos usar um servo 360 para posicionamento, devemos dar a ele uma referência, ou seja, um modo de identificar uma determinada posição como "0". Aí ele pode se deslocar relativamente a esse ponto, e toda vez que perder essa referência ele pode procurá-la novamente, zerando a posição.

Existem muitos (mesmo!) jeitos de se fazer isso. Um dos mais comuns é usar um sensor de efeito Hall. Como conta no artigo do link o grande Newton C. Braga (de quem eu já lia os artigos quando era adolescente e me iniciava nos mistérios da eletrônica), o sensor Hall é um dispositivo que detecta a presença de um campo magnético. Por ser muito pequeno, barato e consumir pouquíssima energia, ele é muito utilizado em circuitos, estando presentes em todos os veículos carros fabricados, por exemplo.

Abaixo, imagens da montagem:

Sensor Hall A3144
 Para gerar o sinal magnético no sensor, coloquei um pequeno ímã no CD qu está preso ao motor. O suporte foi feito em alumínio, porque este material estava literalmente "na mão", se é que vocês me entendem... quem disse que ímã não gruda em metais não ferrosos não conhecia os poderes de uma boa fita dupla-face... ;)

Abaixo, imagens do sensor e do ímã, este último retirado do falante de um fone de ouvido.



Para testar a montagem, fiz um programa que implementa um tacômetro, ou seja, conta as voltas dadas pelo CD.

# -*- coding: utf-8 -*-
import RPIO
from RPIO import PWM
import time

# pino do sensor Hall (número GPIO)

pinHall = 4

# pino do servo
servoPin = 24

inputValue = True

servo = PWM.Servo()

# Define o pino do Hall como entrada (RPIO.IN) e seta
# o pullup (mais sobre isso nesse blog, dê uma pesquisada
# em pulldown.

RPIO.setup(pinHall, RPIO.IN, pull_up_down=RPIO.PUD_UP)

i = 0

# aciona o servo com velocidade alta

servo.set_servo(servoPin, 2000)
time.sleep(1)

while(True):

# O Raspberry retorna True para o sensor desativado,
# por causa do pullup. Quando fica False é que o ímã está
# passando pelo sensor. Assim, o while abaixo fica rolando
# até que o ímã passe pelo sensor. O comando RPIO.input
# lê o valor do sensor (ativado/desativado) e coloca
# em inputValue.

    while(inputValue):
        inputValue= RPIO.input(pinHall)        

# Saindo do while(imputValue) => passagem pelo sensor,
# ou seja, conta-se mais uma volta.

    i=i+1
    print(i)

# Para que o while de espera pela passagem do íma aconteca
# novamente...

    inputValue=True
 
Abaixo, por fim como usual neste blog, o vídeo da coisa funcionando.


É isso!

sexta-feira, 18 de abril de 2014

Acionando servo-motores de giro contínuo com o Raspberry Pi e Python

Agora vejamos como comandar um servo-motor com o Raspberry. Nesse post eu não vou entrar em muitos detalhes sobre o funcionamento de servos, nem sobre como usar o GPIO do Raspberry. Se precisar de mais detalhes, dê um Google sobre servos e leia o post Entendendo o Raspberry GPIO: piscando LED, neste blog.

Para acionar um servo precisamos de três fios: alimentação (5 a 6 Vcc), terra e dados. Como um servo, por menor que seja, usa muita corrente, vc deve usar uma fonte separada e não ligar o servo aos pinos 5V e terra do Raspberry, sob pena de queimá-lo. Pode-se usar por exemplo um conjunto com quatro pilhas, ou uma bateria como a que usei e que vcs verão em foto abaixo.

O terceiro fio receberá o sinal que comanda o servo. Para controlar um servo devemos enviar um sinal de pulsos com uma determinada frequência. Esses pulsos nada mais são do que um "liga/desliga", quer dizer, o Raspberry deve criar na sua porta um sinal que alterne 0V e 5V com um determinado intervalo de mudanças pré definido. No post anterior eu montei um circuito onde a frequência era 0,5 Hz, ou seja, o LED fica um segundo aceso e um segundo apagado, ou seja, cada ciclo dura dois segundos. Para controlar um motor de passo os pulsos são da ordem de milissegundos.

Existem dois tipos de servos que são mais utilizados por hobistas, que servem a propósitos diferentes e são comandados de forma diferente.

1) Servo com giro limitado a um determinado ângulo (geralmente 90° ou 180°): esse tipo de servo é posicional, ou seja, se a gente manda uma determinada frequência e ele se move para um determinado ângulo. Especificamente, na maioria dos servos, vc tem o seguinte comportamento:

Pulso      Ângulo
0.5 ms         0°
1.5 ms        90°
2.5 ms       180°

Em tese um único pulso posicionaria o motor no ângulo desejado. Porém, o que se faz na prática é mandar muitos ou ficar mandando continuamente, de maneira a dar tempo para que ele se posicione.

2) Servo de giro contínuo: esse tipo de servo não tem uma referência, ou seja, ele não "sabe" a sua posição. Assim, ele funciona como um motor normal, só que roda a uma velocidade reduzida e portanto tem mais torque que um motor CC de mesma potência.

Nesse caso também comandamos o servo com pulsos, mas o comportamento é outro:

Pulso     Direção
< 0.5 ms  Sentido anti-horário
1.5 ms    Parado
> 2.5 ms  Sentido horário

A velocidade aumenta, num sentido ou noutro, à medida em que nos afastamos de 1.5 ms de pulso. No motor que estou testando, qualquer pulso com duração entre 1.4 e 1.5 ms já para o servo. Já no sentido horário o motor já é acionado a partir de 1.53 ms. Ou seja, é testar prá ver no que dá.

Acontece que o Raspberry é um dispositivo multitarefa, ou seja, ele faz mais de uma coisa ao mesmo tempo. Isso significa que esses pulsos podem ser afetados se o processador for exigido por alguma outra tarefa que ele esteja rodando, o que pode fazer a velocidade variar ou mesmo inviabilizar o uso do servo. Quando precisamos de um controle preciso ou de comandar mais de um servo, é recomendado usar uma placa controladora de servos a ser comandada pelo Pi ou mesmo usar um Arduino, também comandado pelo Pi.

Abaixo, imagens do circuito montado:

Circuito
A fonte que "toca" o motor é essa bateria verde. Ela por sua vez está ligada a uma plaquinha que alimenta a protoboard. Se for um motor daqueles pequenininhos azuis, de aeromodelismo, dá prá ligar direto no Pi. Os fios vermelho, preto e branco saindo pela parte inferior estão conectado ao servo. O fio branco se conecta, através do dio verde, à porta GPIO17 do Raspberry.

Não se esqueça de ligar o terra da fonte ao terra do Pi, para que o circuito funcione.


Aqui a visão mostrando o motor também. Ele tem um CD acoplado em cima para servir de base a um troço que estou querendo montar depois.

Bom, agora o sofware. Moleza:

from RPIO import PWM
import time

servo = PWM.Servo()

servo.set_servo(17, 1530)
time.sleep(60)
servo.stop_servo(17)

Observem que eu usei uma biblioteca chamada RPIO. É uma biblioteca mais ou menos igual à RPi, mas como ela já tem um objeto servo, eu decidi usá-la. Ela também usa alguns artifícios para fazer com que os pulsos sejam bem estáveis, evitando perturbações de velocidade descritas anteriormente.

Para instalar a RPIO é simples. No terminal do RasPi, dar os comandos:

sudo apt-get install python-setuptools
sudo easy_install -U RPIO

Ao rodar o programa acima, o meu motor gira bem lentamente no sentido horário durante 60s. conforme vc pode ver abaixo:


É isso!

Entendendo o RaspBerry GPIO: Piscando LED

A primeira aplicação que se faz quando se aprende a programar é chamada Hello World. Se estivéssemos aprendendo a programar em Python seria algo assim:

print("Hello World!")

Ao executar o programa, o resultado na tela é (dãããã!):

Hello World!

Nas plaquinhas estilo Arduino etc, como a gente não tem um monitor prá escrever Alô Mundo, temos que arrumar uma outra solução. Normalmente se usa um programa que pisque um LED, então o Hello World do Arduino é o Blink:

int led = 13;

void setup() {                
  pinMode(led, OUTPUT);     
}

void loop() {
  digitalWrite(led, HIGH);   
  delay(1000);               
  digitalWrite(led, LOW);    
  delay(1000);               
}

No Raspberry Pi, como temos uma tela para usar, podemos rodar o Hello World do Python. Acontece que, para aprendermos um pouco sobre automação com o Python, podemos usar a ideia do Blink, e é o que faremos.

Primeiro, vamos entender como o Python conecta-se a dispositivos como LEDs e motores.

Essa conexão se dá através de um modelo chamado GPIO (General Purpose Iput Output,  Entrada e Saída de Uso Geral).

Quando dizemos que algo tem GPIO, queremos dizer que esse "algo" pode se conectar com outros dispositivos através de uma tecnologia que é de uso geral, ou seja: essa conexão pode ser feita de múltiplas formas.

Essa conexão se dá através de portas, que nada mais são do que lugares onde se podem transmitir ou receber sinais elétricos. Nos nossos micros, por exemplo, temos portas USB às quais ligamos impressoras, mouses etc. Aqui o conceito é o mesmo, ou seja, o Raspberry possui um conjunto de pinos de metal onde podemos ligar fios que por sua vez podem ser ligados a dispositivos, sacou?

No Raspberry as portas estão localizadas numa das bordas da placa, como na figura abaixo:

Portas GPIO Raspberry Pi

A conexão às portas GPIO do Raspberry é feita através dos pinos indicados pelo círculo vermelho na imagem acima. Abaixo, em detalhe:


Observe que já temos dois fios conectados ao GPIO. Outro nome para esse troço é "baramento GPIO".
Como o GPIO do Raspberry é constituído de pinos, para conectarmos coisas nele precisamos de fios fêmea, ou seja com um buraquinho para ser encaixado no pino. Tem também um cabo que serve para conectar o barramento a uma protoboard, facilitando o uso do GPIO em circuitos, mas eu me esqueci de comprá-lo... Pode-se improvisar um cabo com um desses cabos (flat cables) de HD de micro desktop, dizem.

O "circuitim" a ser montado é o mais simples possível: um LED em série com um resistor entre 100 e 300 ohms, ligados dessa forma:


O fio verde se conecta a uma das pernas do resistor. A outra, por sua vez, está ligada na perna negativa (mais curta) do LED. A outra perna do LED está ligada ao fio marrom. Para quem não tem a manha ainda com o uso de protoboards (essa placa branquinha onde estão ligados LED etc), sugiro clicar aqui

Os fios marrom e verde estão ligados ao Arduino. Para escolhermos qual porta usar, temos que entender como as portas estão organizadas no barramento GPIO. Eu vi alguns diagramas na net errados, outros muito confusos, foi preciso procurar bem até achar esse cá:


Quem trabalha já com Arduino imediatamente observa que os pinos não estão dispostos numa ordem muito clara, ao contrário do Arduino, onde eles estão agrupados de acordo com a função.

Os pinos "verdes" são os GPIO propriamente ditos. Os outros são terra e alimentação, 5 e 3,3V. 

Observação importantíssima: O GPIO do Raspberry trabalha com 3,3V, o que é diferente da maioria dos Arduinos, que trabalham com 5V. Existe uma tendência do uso cada vez mais da tensão 3,3V em vez de 5V, mas o fato é que a maioria do que existe pronto em automação hoje em dia é 5V. Devemos sempre levar isso em consideração quando formos conectar coisas ao RasPi, porque se vc ligar algo 5V numa de suas portas GPIO o que pode acontecer de melhor é queimar a porta.

Alguns pinos GPIO tem também outros usos, por exemplo os pinos GPIO10, GPIO09 e GPIO011 também servem para comunicação SPI, mas isso foge do nosso escopo de hoje.

Vamos usar para o nosso blink o pino GPIO24 (pino 18), que vc pode localizar na figura acima. Ligue esse pino à perna do resistor que não está ligada ao LED. Conecte o pino GND indicado acima à perna negativa do LED, ou seja, à mais curta. Abaixo, a bagaça montada.

Agora, a programação:

Para fazer o "pograminha" usei a linguagem Python. Ela é a "melhor linguagem de programação da última semana", e ainda por cima já vem instalada no seu RasPi. Para acessarmos as portas GPIO do Arduino precisamos baixar da net e instalar as bibliotecas (programas auxiliares) que proporcionam esse acesso. Siga as instruções para instalação abaixo. Elas servem para quem usa a interface gráfica "padrão" do Pi com Raspbian instalado. Se vc tem um ambiente diferente deste, pode ser necessária alguma adaptação.

1) Baixe o arquivo daqui em um diretório do seu RasPi. 

2) Em seguida, descompacte-o. Para isso, vc pode usar o File Manager do RasPi, clicando com o botão direto em cima do bicho e selecionando a opção Extract To.

3) Por fim, abra uma janela LXTerminal, vá para o diretório onde vc descompactou o arquivo e execute:

sudo python setup.py install

Isso feito, execute o IDLE, interface gráfica do Python. Se vc rodar o IDLE 3 o ambiente será a versão 3.x no Python, se rodar o IDLE será a versão 2.7. O programa que fiz roda nas duas.

Clique em File\New e ponha lá o seguinte código:

import RPi.GPIO
import time

# A instrução abaixo diz que usaremos no programa os números das
# portas GPIO e não os números de ordem dos pinos na placa.
# Para usar os números dos pinos na placa é só trocar o 
# BCM abaixo para BOARD.
# Nesse caso terí­amos que usar 18 no lugar de 24 no programa
# abaixo.
# Essa instrução é obrigatória.
RPi.GPIO.setmode(RPi.GPIO.BCM)
# Ativa a porta GPIO24 (pino 18)
RPi.GPIO.setup(24, RPi.GPIO.OUT)
# pisca GPIO24
while(True):
        # Liga pino
        RPi.GPIO.output(24,RPi.GPIO.HIGH)
        # Espera 1 segundo
        time.sleep(1)
        # Desliga pino
        RPi.GPIO.output(24,RPi.GPIO.LOW)
        # Espera outro segundo
        time.sleep(1)
        
Em seguida pressione F5 e o programa será primeiro salvo, depois rodará. Para interrompê-lo, aperte Ctrl+C.

Se tudo está certo, vc deve obter o seguinte efeito:


É isso! Qualquer dúvida, entre em contato pelos comentários.

domingo, 13 de abril de 2014

Fim de semana nérdico em São José dos Campos

Sexta-feira, acompanhando o voo do VANT...






Plano de voo cumprido!
























sábado cedo, Automação no Parque...




















à tarde, oficina de impressão 3D.






















Montando a impressora:



Aí, domingão de manhã, seletiva nacional de Magic, The Gathering:























É ou não é um fim de semana para nerd nenhum botar defeito?