DC-UFRPE/Licenciatura Plena em Computação/Educação à Distância/2019.2/Wemos

Programa da Disciplina

Objetivo:

Este tutorial tem como objetivo de apresentar uma placa de internet das coisa (IoT), compatível com a IDE Arduíno. Esta placa se torna uma opção, considerando do fato que ela já vem integrada com o modulo Wifi de fábrica, ou melhor dizendo o próprio microcontrolador baseado no esp8266. Vou explicar melhor, na verdade o modulo de wifi esp8266, desses que encontramos facilmente em qualquer mercado livre da vida, é um microcontrolador do fabricante chinês Espressif com a capacidade de se conectar na rede através do wifi local. Ou seja, este é mais que apenas um modulo. Neste guia irei demostrar características interessantes e compará-lo com o Arduíno uno, ao qual o wemos d1 foi baseado. Para ter ideia de tal semelhança, os furos dos parafuso se encontram na mesma disposição do Arduíno uno, você simplesmente pode remover o Arduíno uno e parafusar um wemos d1(Não me refiro aqui a wemos d1 mini ) que ele ira encaixar perfeitamente . Além da configuração da IDE Arduíno para usar com wemos d1, demostrarei o seu uso em um simples tutorial, que consiste na intalação configuração da IDE e carregaremos um programa , que consiste em um pisca pisca de um led integrado a placa.

Características:

Na tabela abaixo é mostrada algumas das características da placa wemos d1 esp8266 e do Arduíno uno.


Característica	wemos d1	Arduíno uno
Microcontrolador usado	ESP8266-12E	Atmega328
CPU (velocidade)	80 Mhz à 160 MHz	16 MHz
Pinos de IO(Input Output)	11 digitais e 1 analógico	14 digitais e 6 analógicos.
Nível logico de operação	3.3 v	5 v
Conversor integrado	sim	sim
WiFi	WiFi nativo padrão 802.11b/g/n	não
Qunt. mem. p/ instruções	64Kb	32KB
Qunt. mem. p/ dados	96kb	4k
Memoria Flash	4Mb	256k
Compatível com sensores Arduíno	sim	sim
Compatível com módulos Arduíno	sim	sim
Compatível com ide Arduíno	sim	sim
Comunicação serial nativa	sim	sim

Pode-se facilmente perceber pela tabela, que a velocidade de processamento da placa Wemos é superior ao do Arduíno. Também observamos, que o numero de entradas da placa wemos é menor em relação a do Arduíno uno, de 1 entrada analógica contra 6 do Arduíno, nada que um projetista experiente passa contornar utilizando de alguns artifícios para sanar esta falta. em compensação a quantidade de armazenamento da wemos é maior, podendo assim desenvolver programas mais complexos.

Existe um grande quantidade de IDEs e linguagens que podem ser utilizada para programar a placa Wemos. Entre elas podemos destacar as linguagens Lua com o NodeMcu , Python através do micropython que, consiste em instalar uma maquina python no microcontrolador e enviar scripts para ser interpretada na placa Wemos, C/C++ através da ide da própia Espressif , ou pela IDE Arduíno, onde os programas podem ser escritos como se fosse uma placa Arduíno, claro que nesse cita de configurar a ide para trabalhar com Wemos.

Mapa da placa:

A - Botão de reset.

B - Entradas e saídas digitais.

C - Conversor Rs232/USB (UART0).

D - Entrada microUSB.

E - Conector power jack(Para bateria de 9v).

F - Regulador de tenção.

G - Esp8266.

H - Entrada analógica e saídas de 5v 3.3v voltagem de entrada e terra.

Pinagem:


Porta	Função	Pino	PULL_UP
GPIO0	Input/Output	D8	Sim
GPIO1	TX	D1
GPIO2	TX1	D9	Sim
GPIO3	RX	D0
GPIO4	SDA	D4/D14
GPIO5	SCL	D3/D15
GPIO12	MISO	D6/D12
GPIO13	MOSI	D1/D7
GPIO14	SCK	D5/D13
GPIO15	SS	D10
GPIO16	Input/Output	D2
GND	Terra comun
A0	Entrada analógica

Apesar de apenas ter os portos GPIO16 e GPIO0 como entrada e saída representada na tabela, por estas portas não ter função especial, Todas as outras portas podem ser programada como entrada e saída.Logo abaixo há uma descrição das funções dos pinos.

TX e RX: Transferência e recepção de dados assincrona. Estes pinos são da comunicação serial. Faz a comunicação entre a placa e o computador, utilizando como intermediação um modulo RS232/USB, contido na própia placa Wemos d1. Também responsável por carregar o programa na placa.

TX1: Pino de comunicação de transferência serial por software (UART1).

A0: Entrada analógica. A tenção de leitura não pode ser maior que 1 Volts, correndo risco de danificar a placa se ultrapassar este valor. A maneira mais segura de medir tenções maiores que 1V serial o uso de divisores de tenção.

MOSI: Master Output Slave input. Mestre sáida escravo entrada.

MISO: Master Input Slave Output. mestre entrada escravo saída.

SS: Select slave. Seleção do dispositivo escravo.

SCK: Clock serial.

SDA e SDL: Para protocolo de comunicação I2C.

Tutorial:

Este tutorial demostrará a instalação da Ide Arduíno e a configuração da mesma para usar a placa Wemos, em seguida carregaremos um programa para a placa que ira fazer um led já integrado a placa piscar. Todo o tutorial foi realizado com os sistema operacional Ubuntu 19, Mas retirando a parte da instalação da Ide Arduíno de resto é o mesmo processo a ser seguido no windons, por a interface da Ide são a mesmas.

Instalação:

Vamos agora instalar a IDE Arduíno.

Baixe a ide através desta pagina oficial da ide Arduíno https://www.arduino.cc/en/guide/linux

em seguida descompacte o conteúdo em um local de sua preferencia.

no meu caso foi na are de trabalho.

Abra no termial a pasta que voçc acabou de extrair. e digite ./arduino e precione enter.

Depois da instalação abra a IDE e vá até preferências.

Copie este link http://arduino.esp8266.com/stable/package_esp8266com_index.json
e cole no campo Url adicionais para gerenciamento de placas.

Depois click em ok.k.

Vamos agora selecionar a placa wemos no menu ferramentas, vá até placa e selecione a placa Wemos D1 R1.

O caminho é ferramentas->placa->Gerenciador de placas.

Irá aparecer a seguinte janela.

Depois digite para pesquisar esp8266 e clique em instalar.

Aguarde enquanto baixa as definições da Wemos.

Depois selecione a porta de comunicação /dev/ttyUSB0 em Ferramentas->Porta->/dev/ttyUSB0, que foi o meu caso de apenas ter uma porta serial instalada no PC. No Windows a seleção é na porta com1, utilizando o mesmo caminho.

Plugue a placa Wemos D1 com o PC através de um cabo usb. A porta serial ttyUSB0 Só vai ficar visível após conectar a placa no pc.

Pronto já está tudo configurado para usar a plaquinha wemos d1. Fácil, Não é?

Executando código:

Agora vamos colocar a mão na massa . No menu arquivos abra a aba de exemplos e selecionamos Exenplos->basics->Blink.

Carregue o sketch Clicando em Blink.

Em seguida clique no botão de carregar.

Espere até que a IDE faça o upload na placa.

após carregar a placa é resetada, então o led que esta ligado ao GPIO2 irá piscar.

Explicando o código:

Lodo abaixo vemos o código de exemplo Blink, fornecido pela propia IDE Arduíno, que acabamos copilar e carregar na plaquinha. Vamos agora discutir um pouco sobre o código.

/*
  Blink

  Turns an LED on for one second, then off for one second, repeatedly.

  Most Arduinos have an on-board LED you can control. On the UNO, MEGA and ZERO
  it is attached to digital pin 13, on MKR1000 on pin 6. LED_BUILTIN is set to
  the correct LED pin independent of which board is used.
  If you want to know what pin the on-board LED is connected to on your Arduino
  model, check the Technical Specs of your board at:
  https://www.arduino.cc/en/Main/Products

  modified 8 May 2014
  by Scott Fitzgerald
  modified 2 Sep 2016
  by Arturo Guadalupi
  modified 8 Sep 2016
  by Colby Newman

  This example code is in the public domain.

  http://www.arduino.cc/en/Tutorial/Blink
*/

// the setup function runs once when you press reset or power the board
void setup() {
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(LED_BUILTIN, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
  digitalWrite(LED_BUILTIN, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);                       // wait for a second
  digitalWrite(LED_BUILTIN, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);                       // wait for a second
}

Em primeiro, vemos duas funções, void setup() e a void loop(), que já vem por padrão quando abrimos um novo skect na IDE. A função void setup() é responsável pelas configurações iniciais que vão ser carregada na placa. Estas configurações são apenas executadas apenas uma vez. Enquanto na função void loop(), tudo que tiver dentro desta função vai ser sempre executado, enquanto a placa tiver energizada. Vamos analisar o conteúdo de cada uma a seguir.

void setup() {
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(LED_BUILTIN, OUTPUT);
}

Aqui esta sendo definido o pino GPIO2 como saida, sendo referenciado como LED_BUILTIN pela IDE.

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);                       // wait for a second
  digitalWrite(LED_BUILTIN, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);                       // wait for a second
}

Este bloco é o que vai ficar sendo executado senpre. Aqui é onde vai ser manipula o pino GPIO2. O comando digitalWrite(LED_BUILTIN, HIGH), é responsável por colocar o pino antes pré definido em nível alto. O delay(1000), responsável por criar um atraso na execução do programa, o parametro desta função deve ser enviado em milissegundos, ou seja se colocarmos 2000 como parâmetros teremos um atraso de 2 segundos. O comando digitalWrite(LED_BUILTIN, LOW), é responsável por colocar o pino antes pré definido em nível baixo. Assim fazendo o LED piscar em um intervalo de 1 segundo.

Este é uma explanação sobre este assunto, que abrange muitos outros tópicos. Demostrando como é simples usar esta pequena placa, que tem diversas aplicação, e também uma substituta (Para mim melhor que o Arduíno) para o Arduíno uno r3. Aqui temos os passos iniciais para começar a brincar com a internet das coisas, onde a limitação dos seus projetos só irá depender da sua criatividade.