Utilizar o NodeMCU - ESP8266

A board ESP8266 / NodeMCU permite ter um microcontrolador (como se fosse um arduino) com acesso direto à rede wireless 802.11 b/g/n por um preço muito atrativo (por cerca de 2,5€). [1] e [6]

Torna-se assim fácil criar projetos para a famosa IoT Internet of Things ou Internet das Coisas que podem registar informações (temperaturas, luminosidade, humidade, etc) ou efetuar operações (acionar iluminação, motores, bombas, etc), as opções estão limitadas apenas à imaginação e/ou capacidade técnica de cada um.

0 - Pré-requisitos

O óbvio será apenas um NodeMCU, cabo microUSB e computador.

Depois de algumas pesquisas sobre como se pode programar o NodeMCU, encontrei esta solução que me parece muito interessante e é a que mais me agrada.

Até aqui quando utilizava arduinos programava o código no Atom [2] e utilizava o Arduino IDE para fazer o upload do código para os Nano ou Uno.
Ao procurar formas de programar o NodeMCU encontrei algumas soluções que utilizam o arduino IDE [7] mas tropecei no PlataformIO [5] que permite dotar o Atom das ferramentas de compilar, upload, monitor de série, terminal, etc que funcionam de forma similar ao ambiente do arduino IDE. Simplesmente fantástico!

O PlatformIO permite também acrescentar os comandos de shell que permitem instalar e desinstalar bibliotecas e funcionalidades do PlatformIO.

Assim, para se começar a programar será necessário:

1. Instalar Atom [2]
2. Instalar PlatformIO [3]
3. Instalar Shell Commands [4]

1 - Colocar o NodeMCU a piscar

Neste domínio o projeto mais simples é o pisca-pisca.

Criar um novo projeto para NodeMCU (a lista é longa...) e indicar a pasta onde vai ficar guardado o projeto.

Criar o ficheiro main.cpp na pasta src com:

#include <Arduino.h>
// Esta função é executada apenas uma vez quando a placa é ligada
void setup() {
  pinMode(D0, OUTPUT); // Inicializar D0 como output
  Serial.begin(9600);  // Inicializar a interface série
}

// Esta função está sempre a executar em loop
void loop() {
  digitalWrite(D0, LOW);  // Ligar o led da placa (sim, com LOW)
  Serial.println("On");
  delay(1000);            // Esperar 1000ms=1 segundo
  digitalWrite(D0, HIGH); // Desligar o led da placa
  Serial.println("Off");
  delay(1000);            // Esperar 1000ms=1 segundo
}

De seguida deve utilizar-se o botão de Compilar para confirmar se está tudo correto e a compilação funciona sem problemas.

Depois deve ligar-se o NodeMCU por USB ao computador e utilizar o comando de Upload para enviar o projeto compilado anteriormente para a placa. Enquanto é programada a placa pisca rapidamente um led no módulo ESP-12 e, se tudo correr bem, passados alguns segundos o led do NodeMCU perto da porta miniUSB começa a piscar de segundo a segundo.

Ao abrir o Serial Monitor é possível observar que quando D0 está LOW o led acende e quando está HIGH o led apaga.

2 - Instalar suporte para outros componentes

Como referido anteriormente o PlatformIO permite adicionar diversas funcionalidades através de alguns comandos simples.

Abrindo o Terminal do PlatformIO é possível procurar bibliotecas (libraries), por exemplo, sobre o sensor DHT11:
platformio lib search dht11

Aparece depois uma lista que indica as bibliotecas que possuem DHT11 e é possível depois instalar uma ou várias dessas bibliotecas através da opção install seguida do número do pacote, por exemplo:
platformio lib install 849 

Neste caso vai ser instalada a biblioteca SimpleDHT por Winlin [8].

Instalar suporte para o sensor DS18B20
platformio lib install 54 

Neste caso, para além da biblioteca DallasTemperature desenvolvida por Guil Barros, Miles Burton, Rob Tillaart, Tim Newsome [9], será também instalada a biblioteca OneWire que permite a comunicação I2C utilizada pelo DS18B20.

Para desinstalar utiliza-se a opção uninstall seguida do número da biblioteca instalada.
platformio lib uninstall 123

Referências

[1] - http://nodemcu.com/index_en.html - Informações e documentação sobre o NodeMCU

[2] - https://atom.io - Informações e instruções de instalação do IDE Atom

[3] - http://platformio.org - Insformações e documentação sobre o PlatformIO

[4] - http://docs.platformio.org/en/latest/installation.html - Instalar shell commands do PlatformIO

[5] - https://www.losant.com/blog/getting-started-with-platformio-esp8266-nodemcu - Programar o NodeMCU através do PlatformIO

[6] - https://www.htlinux.com/esp8266-nodemcu/ - Informações gerais sobre o NodeMCU

[7] - https://oneguyoneblog.com/2017/01/17/esp8266-nodemcu-arduino-ide-linux/ - Programar o NodeMCU através do arduino IDE.

[8] - http://platformio.org/lib/show/849/SimpleDHT - Biblioteca do PlatformIO para o DHT11

[9] - http://platformio.org/lib/show/54/DallasTemperature - Biblioteca do PlatformIO para o DS18B20

Canon DSLR Time Lapse

Canon DSLR tem um jack de 2.5mm para fazer o disparo de fotografias.

Pinout das máquinas Canon (2.5mm):
ponta - obturador - shutter
anel - focus
malha - ground

Ao fechar o circuito entre ponta e malha é disparado o obturador e é capturada uma ou várias fotografias.
Ao fechar o circuito anel e malha a máquina faz a focagem (caso tenha AF autofocus)

Para efetuar capturas em Time-Lapse é possível utilizar um microcontrolador, neste caso um arduino nano, e algumas ligações para permitir o disparo automático num ritmo interessante.

Algumas informações sobre os intervalos de captura [1].

Esquema de Ligações

É nessário depois ligar um cabo stereo (com três condutores) à câmara (minijack 2.5mm stereo do lado da câmara).

Código para arduino

/***********************************************************
  T I M E  -  L A P S E
    by Mário Pinto @ 2017.03.24
    for CANON DSLR

    about:
    Code will autofocus once when it startups and then will release shutter
    after the number of seconds specified in DELAY.
    SHUTTER and FOCUS will define pins used for each of these camera functions.
    LED will define the pin to have a status led blinking.

    blink code:
      » startup: 4 quick blinks to autofocus
      » runtime: 1 blink each SHUTTER released

    tips:
      » Choose an interval that allows time for the camera to store the file
      before next capture, this way will ensure no frames are dropped.
      » It's advised to focus the lens before the captures start and set the
      lens to MF (manual focus) so it will always take the photos (regardless
      of focusing).
      » More great tips from Ryan at
      http://www.learntimelapse.com/how-to-select-a-time-lapse-interval/

      1 second
      Moving traffic
      Fast moving clouds
      Drivelapses

      1- 3 seconds
      Sunsets
      Sunrises
      Slower moving clouds
      Crowds
      Moon and sun near horizon (or telephoto)
      Things photographed with a telephoto[/one_fourth]

      15 – 30 seconds
      Moving shadows
      Sun across sky (no clouds) (wide)
      Stars (15 – 60 seconds)

      Longer
      Fast growing plants (ex vines) (90 – 120 seconds)
      Construction projects (5min – 15min)[/one_fourth_last]

************************************************************/
int DELAY   = 2;          // Intervalo entre capturas
int SHUTTER = 3;          // Pin para SHUTTER
int FOCUS   = 2;          // Pin para FOCUS
int LED     = 13;         // Pin para LED

// blink(LED)
void blink(int pin){              // Piscar o LED 50ms
  digitalWrite(pin, HIGH);        // Ligar LED
  delay(50);
  digitalWrite(pin, LOW);         // Desligar LED
}

// focus(FOCUS)
void focus(int pin){               // Focar durante algum tempo
  int n=3;
  digitalWrite(pin, LOW);
  while(n-- > 0){
    blink(LED);
    delay(500);
  }
  digitalWrite(pin, HIGH);
}

void setup(){
  pinMode(SHUTTER, OUTPUT);       // Definir o pin do SHUTTER como output
  digitalWrite(SHUTTER, HIGH);
  pinMode(FOCUS, OUTPUT);         // Definir o pin do FOCUS como output 
  digitalWrite(FOCUS, HIGH);
  pinMode(LED, OUTPUT);           // Definir o pin do LED como output
  digitalWrite(LED, LOW);
  focus(FOCUS);                   // Focar
}

void loop(){
  digitalWrite(LED, HIGH);          // Ligar LED
  digitalWrite(SHUTTER, LOW);       // Ativar SHUTTER
  delay(100);                       // Esperar um pouco para libertar
  digitalWrite(SHUTTER, HIGH);      // Desativar SHUTTER
  digitalWrite(LED, LOW);           // Deligar LED
  delay(1000 * DELAY);              // Esperar
}

Referências

[1] - http://www.learntimelapse.com/how-to-select-a-time-lapse-interval/

RF24 - Utilizar o nRF24L01+ para comunicações com Raspberry Pi e Arduino

O chip nRF24L01+ permite a comunicação sem fios na faixa dos 2.4GHz de forma económica [1] (menos de 1 euro, é questão de se procurar nos diversos sites).

Com dois desses chips é possível efetuar comunicações entre dois dispositivos eletrónicos, neste caso um Raspberry Pi 2 B e um arduino uno.

A primeira questão são so drivers necessários para ambas as plataformas. Existem diversas implementações, aqui será utilizada a RF24, fornecida por TMRh20 [2].

Ligações

nRF24L01+ possui oito pinos mas apenas se utilizam os primeiros 7.

pin	nRF24L01+	arduino UNO	RPi pin	RPi GPIO
1	GND	GND	25	GND
2	VCC	3.3V	17	3v3
3	CE	D7	15	GPIO22
4	CSN	D8	24	GPIO8
5	SCKL	D13	23	SCKL
6	MOSI	D11	19	MOSI
7	MISO	D12	21	MISO

É necessário efetuar as ligações de um nRF24L01+ ao arduino UNO e de outro nRF24L01+ ao Raspberry Pi.

Instalação do Software

arduino
Abrir o arduino IDE e ativar a biblioteca RF24 (testado em 1.6.5):
Sketch > Include Library > Manage Libraries...
Pesquisar por RF24 e clicar em Install

Obter o exemplo [3] fazer o upload para o arduino e abrir a consola CTRL+SHIFT+M, introduzir T para começar a enviar pings.

Raspberry Pi
No Raspbian garantir que o sistema está atualizado:
sudo apt-get update
sudo apt-get upgrade

Ativar o SPI
sudo raspi-config
Advanced > enable the SPI kernel module

Instalar as bibliotecas RF24 do TMRH20 [4]:
wget http://tmrh20.github.io/RF24Installer/RPi/install.sh
chmod +x install.sh
./install.sh

Depois resta entrar no diretório de exemplos para o RPi e experimentar:
cd rf24libs/RF24/examples_RPi
make
sudo ./gettingstarted

Depois é necessário pressionr 0 (zero) para receber os pings do arduino.

Referências

[1] - http://www.aliexpress.com/w/wholesale-nrf24l01.html
[2] - http://tmrh20.github.io/RF24/index.html
[3] - http://tmrh20.github.io/RF24/GettingStarted_8ino-example.html
[4] - http://tmrh20.github.io/RF24/RPi.html
[5] - Projeto com comunicação entre o Raspberry Pi e o arduino (em inglês): https://www.coconauts.net/blog/2014/09/03/send-readings-from-arduino-to-raspberry-via-radio/
[6] - Referências para o arduino e o nRF24L01+ (em inglês): http://playground.arduino.cc/InterfacingWithHardware/Nrf24L01
[7] - Projeto mais antigo para comunicação entre o Raspberry Pi e o arduino (em inglês): http://blog.the-jedi.co.uk/2013/10/07/nrf24l01-and-raspberry-pi/

Raspberry Pi - Ler valores do GPIO

A primeira experiência no âmbito da leitura de valores para o Raspberry Pi, é feita com base no tutorial proposto por Matthew Kirk aqui.

0. Material necessário

• Raspberry Pi
• Sensor Digital de temperatura DS18B20
• Resistência 4,7 kΩ

1. Esquema para sensor de temperatura

O sensor de temperatura utilizado é um DS18B20, que permite efetuar leituras digitais (9-bits a 12-bist) do valor da temperatura (em Celsius).

Esquema do sensor de temperatura DS18B20

Neste esquema a ligação ao Raspberry Pi efetuou-se atravé do pin7 do Raspberry Pi, correspondendo ao GPIO04.

Esquema de ligações dos componentes

2. Implementação do circuito

Novamente, muito cuidado ao ligar o circuito para não danificar o Raspberry Pi.

Breadboard com o circuito implementado e conectado ao Rpi

3. Carregar módulos necessários

A leitura da temperatura deste sensor pressupõe alguns passos iniciais de configuração, pois por defeito o Raspberry Pi não carrega os módulos que permitem a "conversa" com outros componentes.
Assim, é necessário ativar estes dois módulos:

$ sudo modprobe w1-gpio

$ sudo modprobe w1_therm

Após este passo é necessário verificar qual o número de série carregado para o sensor de temperatura.

$ ls /sys/bus/w1/devices/

28-0000025d1522  w1_bus_master1

É através deste número de série (único para cada sensor) que será possível obter a informação da temperatura do sensor.

4. Obter a temperatura

Para obter a temperatura atual basta ver o conteúdo do ficheiro:

$ cat /sys/bus/w1/devices/28-0000025d1522/w1_slave 

5c 01 4b 46 7f ff 04 10 a1 : crc=a1 YES

5c 01 4b 46 7f ff 04 10 a1 t=21750

Para ficar apenas com o valor é possível:

$ tail -n 1 /sys/bus/w1/devices/28-0000025d1522/w1_slave | tail -c 6

21875

5. Integração com PHP

Em PHP é muito fácil aceder ao ficheiro anterior e obter valor pretendido:

      if (isset($_GET['temp'])&&$_GET['temp']!=''){

        exec("sudo gpio -g mode 4 in"); // Iniciar GPIO04 = pin 7

        if ($_GET['temp']=='on'){

          // Ler do ficheiro

          $filename = '/sys/bus/w1/devices/28-0000025d1522/w1_slave';

          $mode = "r";

          $file = fopen($filename, $mode);

          if ($file){

            fgets($file); // Ler primeira linha e descartar

            $buffer = fgets($file); // Ler linha da temperatura

            fclose($file);

            $temp = substr($buffer, -6); // Obter os últimos 6 caracteres com a temperatura

            echo ""+$temp/1000+"ºC
"; // Converter para as unidades corretas

          }

        }

      }

Para executar basta aceder ao URL do ficheiro PHP e adicionar a variável temp com o valor on:

http://rpi/temp.php?temp=on

Eletrónica e Raspberry Pi

Para além da excelente vertente relativa ao Sistema Operativo e demais software possível de correr no Raspberry Pi, existe a Eletrónica.

1. Interface Eletrónica do Rpi

O Raspberry Pi possui uma interface com esta finalidade que se designa de GPIO (General Purpose Input Output).
Esta interface possui 26 pinos que podem ser: 5V, 3V3, GND ou de Input/Output.

Consoante o modelo do Rpi existem diferentes layouts destes pinos.

Uma boa fonte de informação sobre isto está no Raspberry Pi Spy (http://www.raspberrypi-spy.co.uk/2012/06/simple-guide-to-the-rpi-gpio-header-and-pins/).

GPIO Revision 2

2. Esquema para Pisca-Pisca controlado pelo Rpi

Atenção!

Algumas das chamadas de atenção existentes em diversos lados são relativas ao cuidado no desenho e, principalmente, implementação dos circuitos de forma a não "queimar" o Raspberry Pi, pois os pinos de IO do GPIO estão ligados diretamente ao chip da CPU.

Por isso, deve verificar-se sempre o circuito que se vai implementar!

A partir do site indicado anteriormente é possível aceder a inúmeros artigos de interesse.

Um dos mais interessantes para quem se inicia nestas lides é o relativo ao led Pisca-Pisca controlado pelo Raspberry Pi, que se encontra aqui.

Aquando da implementação do circuito numa breadboard convém confirmar tudo. Assim, convém confirmar as ligações do transistor T1 (neste caso um BC547C).

3. Implementação do circuito

Breadboard com o circuito ligado ao Rpi e LED aceso

• O LED deve ser ligado com o pino mais comprido à resistência R1 e o mais curto ao pino 1 do transistor T1.
• A resistência R2 deverá ser ligada ao pino 2 do transistor T1.
• O pino 3 do transistor T1 deverá ser ligado ao GND do Rpi (pino 6).
• A resistência R1 deve ligar também ao Rpi, neste caso no pino 1 (+3V3).
• A resistência R2 deve ligar também ao Rpi, neste caso no pino 26 (IO).

4. Python e o GPIO

Para se poder controlar o input e output dos pinos do GPIO através de código python é necessário instalar uma biblioteca, por exemplo: raspberry-gpio-python, disponível para download aqui.

Para saber qual a versão a utilizar é possível executar no terminal do Rpi:
$ python --version
Python 2.7.3

Neste caso será necessário descarregar a biblioteca para a versão 2.

Depois de descarregado o ficheiro, é necessário instalá-lo com:
$ sudo dpkg -i python-rpi.gpio_0.4.2a-1_armhf.deb

Após esta instalação é possível importar para o python a biblioteca que interage com o GPIO.

5. Código Pisca-Pisca em Python

Para testar resta agora criar um ficheiro, por exemplo led.py com o conteúdo:

import RPi.GPIO as GPIO

import time

# Use physical pin numbers

GPIO.setmode(GPIO.BOARD)

# Set up header pin 26 (GPIO7) as an input

pin=26

print "Setup Pin %i" % (pin)

GPIO.setup(pin, GPIO.OUT)

var=1

print "Start loop"

while var==1 :

  print "Set Output False"

  GPIO.output(pin, False)

  time.sleep(1)

  print "Set Output True"

  GPIO.output(pin, True)

  time.sleep(1)

Como o código tem que interagir com o GPIO, é necessário executá-lo com privilégios de root, ou seja:

$ sudo python led.py

Portátil com acesso ao Rpi por SSH e execução do código led.py