1. Tutorial

O problema

Imagine-se que se pretende controlar o estado dum LED ou detectar o estado dum botão a partir dum sistema computacional como um PC, tablet ou smartphone. Embora estes equipamentos sejam bastante poderosos, dificilmente cumpririam essa missão. Pelo contrário a sua interligação com periféricos mais sofisticados como por exemplo uma webcam ou impressora não apresentaria grande dificuldade.

hand-shake

O que torna então um LED e um botão, dispositivos tão difíceis de serem interligados aos modernos sistemas computacionais?

É que dada a sua simplicidade estes dispositivos não possuem qualquer interface standard presente nos modernos sistemas computacionais, como uma porta USB ou Ethernet, e muito menos ligações sem fios WiFi ou Bluetooth! Com efeito o controlo dum LED faz-se através dum simples sinal elétrico digital cujo valor lógico define se o LED acenderá ou não. No caso do botão, algo de semelhante acontecerá embora desta vez seja o botão (e o circuito em que ele se encontra) a definir o valor lógico do sinal digital.

A solução

Uma forma de contornar este problema é o uso de placas de desenvolvimento baseadas em pequenos microprocessadores ou microcontroladores que por um lado possuem as interfaces standard (e que por isso podem ser ligados aos sistemas computacionais) mas possuem igualmente uma interface de sinais genéricos de entrada/saída designada por isso de: GPIO – General Purpose Input/Output. Será por sua vez neste último interface, que o LED e o botão serão ligados. Nestas placas será depois necessário desenvolver um programa que faça a interligação com os interfaces anteriormente descritos.

boards

Exemplos dessas placas, e concretamente as duas que iremos aqui estudar, são as placas Raspberry Pi e Arduino. Trata-se de dois tipos de placas com características diferentes, cada uma com as suas vantagens de desvantagens tal como a seguinte tabela pretende mostrar:

Raspberry Pi B+ * Arduino UNO
Processador ARM1176 (32bits 700MHz) ATmega328P (8bits 16MHz)
Consumo 400mA <100mA
Realtime não sim
Linguagem Python (entre outras) C/C++
Interface Ethernet USB
Custo 45 euros 25 euros

* De facto, de entre as 12 placas, apenas 5 são da versão Raspberry Pi B+ enquanto que as restantes 7 são da versão Raspberry Pi 2. Atualmente existem outras versões como por exemplo a Raspberry Pi 3 e a Raspberry Pi Zero.

As placas Raspberry Pi possuem um processador mais poderoso que o usado nas placas Arduino. Com efeito o ARM1176 é um processador de 32 bits com uma frequência de relógio de 700MHz, ao contrário do processador ATmega328P que é só de 8 bits e corre a 16MHz.

Pela razão anterior, as placas Raspberry Pi são mais exigentes em termos de consumo (cerca de 400mA) em vez dos menos de 100mA requeridos pelas Arduino.

As placas Raspberry Pi correm os programas em cima dum sistema operativo baseado em Linux (o Raspbian) existente no seu cartão de memória, enquanto que as Arduino correm diretamente o programa que o utilizador coloca na sua memória flash. Se por um lado a primeira opção beneficia das funcionalidades facultadas pelo sistema operativo, esses programas podem padecer de alguma latência temporal devido às características de multiprocessamento do sistema operativo. Se se pretende um funcionamento mais em tempo real será preferível recorrer às placas Arduino (mesmo que de menor poder computacional).

Uma outra diferença prende-se com as linguagens possíveis de serem usadas na construção dos programas para estas placas. Se no caso das placas Arduino só poderá ser usada a linguagem C/C++ (ou uma plataforma a ela ligada designada de Wiring), no caso das placas Raspberry Pi todo um manancial de linguagens estão à disposição, embora neste tutorial seja usada simplesmente a linguagem Python.

Em termos de interfaces com os sistemas computacionais, as placas Raspberry Pi possuem uma porta Ethernet enquanto que as Arduino fazem-no por uma porta USB. Isto não invalida que outro tipos de ligações possam ser feitas, nomeadamente sem fios através de módulos/dongles a ligar a cada uma delas.

Por fim, e embora se trate de placas de baixo custo, as placas Raspberry Pi são um pouco mais dispendiosas do que as Arduino, tanto mais que exigem um conjunto adicional de acessórios como é o caso do cartão de memória onde residirá o sistema operativo.

Tutorial

Neste tutorial será mostrado como é que com o recurso a estas placas se pode controlar um LED (i.e. ligá-lo e desligá-lo) e saber o estado dum botão (i.e. se está ou não premido).

Para isso serão trocadas mensagens em modo texto entre o dispositivo computacional e a placa. No caso das placas Raspberry Pi será usada uma ligação de rede telnet, enquanto que no caso das placas Arduino será usada uma ligação série.

Protocolo

Como foi referido os comandos a enviar às placas não são mais do que mensagens texto que começam por uma letra (que identifica o comando) seguido eventualmente por um parâmetro adicional e terminam com o carácter 0x13 (carriage return) a que corresponde a tecla Enter do teclado.

Neste tutorial os comandos implementados são os seguintes:

  • v – pede a versão do programa
  • l1 – liga o LED
  • l0 – desliga o LED
  • b – pede o estado do botão

A este último comando a placa responde com uma mensagem que indica o estado do botão:

  • b1 – botão premido
  • b0 – botão não premido

De notar que quando o botão muda o seu estado, a placa toma a iniciativa de enviar uma destas mensagens informando sobre o novo estado do botão.

Para se enviar/receber estas mensagens a partir dos PCs presentes nas bancadas será usada uma aplicação Windows chamada PuTTY cujo processo de instalação, configuração e uso pode ser visto aqui.

Esta aplicação tanto pode ser usada para estabelecer uma ligação de rede (Telnet) com as placas Raspberry Pi, como uma ligação série (Serial) com as placas Arduino.

Raspberry Pi

O uso destas placas pressupõe a prévia instalação no cartão de memória do sistema operativo bem como a realização dum conjunto de configurações iniciais descritas aqui.

Embora estas placas possam ser ligadas a um monitor pelo porto HDMI, e a um teclado e/ou rato pelas suas portas USB, iremos fazer uma utilização remota através duma ligação SSH utilizando de novo a aplicação PuTTY. Esta forma de utilização é por isso conhecida de “headless“.

Para isso basta abrir a sessão SSH configurada pelo procedimento descrito aqui.

Programa de teste “Hello World”

Ao estabelecermos uma ligação SSH, a linha de comandos inicia-se na pasta home do utilizador pi, podendo ver-se o seu conteúdo através do comando:
ls

Sugere-se a criação duma pasta para esta unidade curricular através do comando:
mkdir edm

Por fim e para se criar um primeiro programa Python hello.py, bastará fazer:
cd ~/edm
nano hello.py

Nesse programa iremos simplesmente escrever:
print(“Hello World!”)
Saindo através do atalho Ctrl+x seguido de y+enter (para guardar o ficheiro).

Este programa pode depois ser executado fazendo:
python hello.py

Programa Raspi

Porque o programa de ligação com o LED e o botão é mais complexo iremos recorrer à clonagem dum repositório GitHub onde ele já está definido, fazendo:
cd ~/edm
git clone https://github.com/hsmptg/Raspi
cd Raspi
git checkout ledbut

Ainda antes de executar o programa é necessário efetuar as ligações do LED e do botão com determinados pinos do interface GPIO da forma como o seguinte esquemático Fritzing ilustra:

Raspberry_ledbut_bb

IMPORTANTE: As ligações com (n)a breadboard deverão ser realizadas com o máximo cuidado pois alguma troca poderá danificar a placa Raspberry Pi. Esteja nomeadamente atento ao LED vermelho que caso apague indicia a existência dum curto circuito!

Para correr o programa bastará agora executar o comando:
python ~/edm/Raspi/raspi.py

Por fim, resta abrir na aplicação PuTTY a sessão Telnet configurada pelo procedimento descrito aqui, e enviar os comandos anteriormente referidos.

Reboot e Shutdown

Sempre que fôr necessário rearrancar o sistema usar o comando:
sudo reboot

Para desligar por completo, usar o comando:
sudo shutdown -h now

Neste caso só se deve desligar a alimentação da placa quando o LED verde (que indica o acesso ao cartão) após alguma atividade apaga por completo ficando apenas o LED vermelho ligado. De outro modo corremos o risco de corromper o conteúdo do cartão impedindo a placa de voltar a arrancar.

Para rearrancar o sistema após um shutdown, é necessário desligar e ligar novamente a alimentação!

Eclipse

Ao contrário do programa hello.py, o programa de controlo do LED e botão apresenta uma maior complexidade (nomeadamente por ser composto por vários módulos) pelo que não é adequado ser visto/editado com o editor nano.

Em alternativa iremos usar um ambiente integrado de desenvolvimento (IDE) designado por Eclipse que está já acessível na pasta C:/Alunos/EDM do Windows presente nos PCs das bancadas. O processo de instalação deste ambiente pode ser visto aqui.

Embora esse IDE esteja situado nos PCs e não nas placas, ele pode editar remotamente os módulos Python que compõem o programa. Isso é possível graças ao plugin RSE (Remote System Explorer) juntamente com o plugin PyDev. É contudo primeiro necessário:

  • Abrir essa perspetiva: Window > Perspective > Open Perspective > Other… > Remote System Explorer
  • Criar uma nova ligação: Remote Systems < New > Connection… > SSH Only > Next
    • Hostname: 10.0.0.1XX (o IP da placa)
    • Connection name: RPi
    • Finish
  • Abrir a pasta edm no Raspberry Pi: Remote Systems < RPi > Sftp Files > My Home > edm
    • User ID: pi
    • Password: a palavra-passe fornecida na aula
    • Activar “Save user ID” e “Save Password” para não ser necessário repetir o processo numa próxima vez
    • OK 
  • É natural que no primeiro acesso seja:
    • apresentado um aviso (Warning) relativo à autenticidade a que devemos dizer Yes
    • pedida a indicação dum “Password hint“, que podemos ignorar respondendo No.

Torna-se assim possível ver/editar de uma forma mais amigável os módulos que compõem este programa.

Arduino

Caso se pretenda realizar a interligação ao LED e ao botão mas agora com uma placa Arduino começaremos por montar o seguinte circuito:

Arduino_ledbut_bb

Projeto Duino no Eclipse

Seguidamente vamos criar um projeto (chamado Duino) no nosso ambiente integrado de desenvolvimento Elipse. Para tal vamos mais uma vez usar um repositório do código fonte no GitHub:

  • Project Explorer < Import… > Git > Projects from Git > Next
  • Clone URl > Next
  • URl: https://github.com/hsmptg/Duino > Next
  • Next
  • Directory: C:\Alunos\EDM\workspace\Duino > Next
  • Import using the New Project wizard > Finish
  • Arduino > New Arduino sketch > Next
  • Project name: Duino
  • Location: C:\Alunos\EDM\workspace\Duino > Next
  • Board: Arduino/Genuino Uno
    Port: COMx*
  • Next
  • Select code: Default cpp file > Next
  • Finish
  • Apagar do projeto os ficheiros Duino.cpp e Duino.h (eles foram adicionados pelo template automático não fazendo parte do projeto)

* A porta série a escolher é aquela onde a placa se encontra. Trata-se duma porta COM (diferente da COM1), e que se pode determinar fazendo:
Computer < Mangae > Device Manager > Ports (COM & LPT) > Communications port (COMx)

Com o projeto selecionado no Project Explorer, é já possível compilar o projecto (carregando no botão verify) e programar a placa (carregando no botão upload). No processo é criado um ficheiro Duino.hex (dentro da pasta Release do projeto) que descreve o conteúdo da memória de programa a enviar para o microcontrolador ATmega328 da placa pela ferramenta avrdude.

PuTTY em modo “Serial”

A comunicação com a placa Arduino faz-se através da porta série (Serial) tal como foi explicado aqui.

Mesmo ainda não tendo as funcionalidades de controlo do LED e do botão, é possível testar a comunicação com a placa através do envio do comando v que solicita uma mensagem com a versão do programa.

Para colocar o projeto na versão de controlo do LED e do botão é necessário:

  • Project Explorer > Duino < Team > Show in History
  • Show All Branches and Tags
  • origin/ledbut < Checkout
  • Checkout as New Local Branch
  • Finish

Segue-se nova compilação (carregando no botão verify) e programação da placa (carregando no botão upload). Note que a programação só é possível caso a porta COM esteja disponível pelo que teremos que encerrar o PuTTY caso a ligação série (Serial) ainda esteja ativa.

Esta versão já inclui os comandos de controlo do LED (l0 e l1) e de pedido do estado do botão (b). Tal como no caso do Raspberry Pi, caso o botão mude de estado é enviada uma mensagem indicando-o (b0 ou b1).

Últimas considerações

1. Outros sistemas operativos

Embora todo o software de desenvolvimento usado neste tutorial tenha corrido em Windows, o software Eclipse e respetivos plugins existem igualmente para Linux e OS X.

Relativamente ao software de controlo, a ferramenta PuTTY existe também em Linux, e no caso do sistema OS X existem ferramentas equivalentes. Mesmo para o caso dos sistemas operativos usados nos dispositivos móveis (como os smartphones e/ou tablets), é possível encontrar alternativas:

2. Outros dispositivos a controlar

Embora neste tutorial se tenha controlado dispositivos simples como um botão e um LED, nada impede que se possa usar outros dispositivos de entrada/saída.

Em lugar dum botão poderia ser usado por exemplo um sensor de presença (PIR), um termóstato, em suma algo que fosse capaz de produzir a entrada digital para as placas.

No caso do dispositivo de saída, em vez do LED poderia ser usada uma eletroválvula, um eletrodoméstico, etc. De notar porém, que estes dispositivos requerem um nível de corrente/tensão incompatíveis com os dos pinos de saída das placas pelo que necessitam dum circuito de interface, em geral baseado num Triac ou Relé.

Neste tutorial será mostrado como se poderia controlar uma lâmpada de halogéneo de 220V a exemplo do que se fez para o caso do LED. O circuito em causa pode ser visto na seguinte imagem, sendo o sinal PWR o responsável por controlar o estado da lâmpada:

power

3. Outras formas de controlo

Por fim, nada impede que em vez do controlo se realizar com uma aplicação tipo PuTTY, onde os comandos/mensagens são enviados/recebidos na forma de texto, se possa antes desenvolver uma interface gráfica do utilizador (GUI – Graphical User Interface) costumizada para a funcionalidade em causa.

Porque é algo que extravasa claramente os objetivos deste tutorial, fica apenas a ideia de uma interface implementada na forma de aplicação Web que possa ser executada num qualquer browser presente em qualquer dispositivo computacional, seja ele um computador, tablet ou smartphone.

O resultado pode ser visto no endereço: http://10.0.0.100:3000

Deixe um comentário

O seu endereço de email não será publicado. Campos obrigatórios marcados com *