Mostrar mensagens com a etiqueta arduino. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta arduino. Mostrar todas as mensagens

sexta-feira, 26 de maio de 2017

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

domingo, 26 de março de 2017

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/

domingo, 8 de novembro de 2015

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.

pinnRF24L01+arduino
UNO
RPi
pin
RPi
GPIO
1GNDGND25GND
2VCC3.3V173v3
3CED715GPIO22
4CSND824GPIO8
5SCKLD1323SCKL
6MOSID1119MOSI
7MISOD1221MISO

É 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/