Sensor Raspberry Pi e controle do atuador

Normalmente, como um programador, você trabalhará com dados no disco e, se tiver sorte, fará desenhos na tela. Isso contrasta com a computação física, que permite que você, como programador, trabalhe com dados detectados do mundo real e controle dispositivos que se movem no mundo real.

Meta

Use um Raspberry Pi para ler o valor do acelerômetro e controlar um servo motor.

Definições

• Raspberry Pi
  • Pequeno computador Linux de $ 35 com 2 portas USB, saída HDMI, Ethernet e, o mais importante ...
• Pins GPIO
  • Pinos de entrada / saída de uso geral
  • Este é o componente que realmente permite a “computação física”. Você, como programador, pode definir a tensão alta ou baixa em cada pino, que é como você falará com os atuadores. Você também pode ler qual é a tensão atualmente em cada pino. É assim que os sensores irão responder a você. É importante notar que cada pino representa um estado binário, você só pode imprimir 0 ou 1, nada no meio.

Neste artigo, examinarei quatro projetos básicos do Python para demonstrar os recursos de hardware do Raspberry Pi. Esses projetos são:

• Pisque um LED.
• Leia uma panela.
• Transmita dados.
• Controle um servo.

Pisca um LED.

Um LED é um diodo emissor de luz. Um diodo é um elemento de circuito que permite que a corrente flua em uma direção, mas não na outra. Emissão de luz significa ... ele emite luz. Seu LED típico precisa de corrente na faixa de 10-30 mA e cairá cerca de 2-3 volts. Se você conectar um LED diretamente ao GPIO do seu Pi, ele fornecerá muito mais do que 30 mA e provavelmente fritará o seu LED (e possivelmente o seu Pi). Para evitar isso temos que colocar um resistor. Se você quiser fazer matemática, pode calcular a resistência apropriada usando a seguinte equação:

 R =(Vs - Vd) / I 

Mas se você não quiser fazer matemática, escolha um resistor entre 500-1500 ohms. Depois de reunir todos os elementos do circuito (LED e resistor)

O código também é bastante simples. Mas primeiro você precisa instalar RPi.GPIO. (Pode vir pré-instalado no seu sistema operacional).

 import timefrom itertools import cycleimport RPi.GPIO as ioio.setmode (io.BCM) io.setup (12, io.OUT) o =cycle ([1, 0]) enquanto True:io.output (12, o .next ()) time.sleep (0,5) 

As linhas importantes são basicamente:

 io.setup (12, io.OUT) io.output (12, 1) 

Essas linhas de código configuram o pino 12 como uma saída e, em seguida, produzem um 1 (3,3 volts). Execute o código acima conectado ao circuito e você verá seu LED piscando a cada meio segundo.

Leia uma panela.

Um potenciômetro é a abreviação de potenciômetro, que é um resistor variável. Esta é apenas uma palavra chique para botão. Basicamente, girando o botão, você afeta a resistência, que afeta a voltagem no potenciômetro. ( V =IR , lembrar?). Mudar a tensão em relação a algum valor físico é como muitos sensores funcionam, e esta classe de sensor é conhecida como um sensor analógico . Lembra quando eu disse que os pinos GPIO só podem representar um estado binário? Teremos que pedir ajuda a mais silício para converter esse valor de tensão analógica em um fluxo binário de bits que nosso Pi pode controlar.

Esse pedaço de silício é conhecido como Conversor Analógico-Digital (ADC). O que eu gosto se chama MCP3008, tem 8 canais de 10 bits, o que significa que podemos ler 8 valores de sensores com resolução de 1024 cada (2 ^ 10). Isso mapeará nossa tensão de entrada de 0 - 3,3 volts para um número inteiro entre 0 e 1023.

Transformei o Pi em rótulos amarelos efêmeros para simplificar o diagrama

Para falar com o chip, precisaremos de um pacote python chamado spidev. Para obter mais informações sobre o pacote e como ele funciona com o MCP3008, confira esta excelente postagem no blog

Com o spidev instalado e o circuito construído, execute o seguinte programa para ler os valores do sensor em tempo real e imprimi-los em stdout.

 import spidev import timespi =spidev.SpiDev () spi.open (0,0) def readadc (adcnum):se não 0 <=adcnum <=7:return -1 r =spi.xfer2 ([1, ( 8 + adcnum) <<4, 0]) adcout =((r [1] &3) <<8) + r [2] return adcoutwhile True:val =readadc (0) imprimir val time.sleep (0,5) 

As partes mais importantes são estas duas linhas:

 r =spi.xfer2 ([1, (8 + adcnum) <<4, 0]) adcout =((r [1] &3) <<8) + r [2] 

Eles enviam o comando de leitura e extraem os bits retornados relevantes. Veja a postagem do blog que vinculei acima para obter mais informações sobre o que está acontecendo aqui.

---

Transmita dados.

Para transmitir dados pela rede, usaremos a biblioteca de rede ØMQ e implementaremos o padrão REQUEST / REPLY. ØMQ torna super simples configurar um cliente e servidor em Python. A seguir está um exemplo de trabalho completo.

Servidor

 import zmqcontext =zmq.Context () socket =context.socket (zmq.REP) socket.bind ('tcp:// *:1980') while True:message =socket.recv () imprimir mensagem socket.send ("Estou aqui") 

Cliente

 import zmqcontext =zmq.Context () socket =context.socket (zmq.REQ) a ='tcp://192.168.1.6:1980'socket.connect (a) para solicitação no intervalo (10):socket. send ('Você está em casa?') message =socket.recv () imprimir mensagem 

Agora podemos usar traits e enaml para fazer uma bela IU no lado do cliente. Confira a demonstração acc_plot no repo do github para ver um exemplo dos dados de streaming de Pi pela rede a serem plotados por um cliente.

---

Controle um servo

Os servos são motores (geralmente pequenos) que podem ser acionados em determinadas posições. Por exemplo, para um determinado servo, você pode definir o eixo de transmissão de 0 a 18o graus, ou em qualquer ponto intermediário. Como você pode imaginar, isso pode ser útil para muitas tarefas, incluindo a robótica.

A rotação do eixo é controlada pela Modulação por Largura de Pulso (PWM), na qual você codifica informações na duração de um pulso de alta tensão nos pinos GPIO. A maioria dos servos de hobby segue um significado de largura de pulso padrão. Um pulso de 0,5 ms significa ir para a posição mínima e um pulso de 2,5 ms significa ir para a posição máxima. Agora repita este pulso a cada 20 ms e você está controlando um servo.

A largura de pulso é muito mais crítica do que a frequência

Esse tipo de sincronismo não é possível com Python. Na verdade, eles não são realmente possíveis com um sistema operacional moderno. Uma interrupção pode ocorrer a qualquer momento em seu código de controle, causando um pulso mais longo do que o desejado e um jitter em seu servo. Para atender aos requisitos de tempo, temos que entrar no mundo divertido dos módulos do kernel. ServoBlaster é um módulo de kernel que faz uso dos blocos de controle DMA para contornar totalmente a CPU. Quando carregado, o módulo do kernel abre um arquivo de dispositivo em / dev / servoblaster onde você pode escrever comandos de posição.

Eu escrevi uma pequena camada orientada a objetos em torno disso que torna o servo-controle mais simples. Você pode encontrar minha biblioteca aqui:

https://github.com/jminardi/RobotBrain

Simplesmente conecte o servo a 5v e aterre em seu Pi e então conecte o fio de controle ao pino 4.

O código python é bastante simples:

 import timeimport numpy as npfrom robot_brain.servo import Servoservo =Servo (0, min =60, max =200) para val em np.arange (0, 1, 0,05):servo.set (val) time.sleep ( 0.1) 

Tudo que você precisa fazer é instanciar um servo e chamar seu set () método com um valor de ponto flutuante entre 0 e 1. Confira a demonstração servo_slider no github para ver o servo controle implementado na rede.

Para mais detalhes:Sensor Raspberry Pi e controle do atuador