Arduino Tutorial - Blynk Motor Speed Control ESP8266
by Crazy Taz Projects in Circuits > Arduino
2575 Views, 1 Favorites, 0 Comments
Arduino Tutorial - Blynk Motor Speed Control ESP8266
Olá pessoal bem vindos ao nosso canal e aos nossos tutoriais sobre o Arduino, neste tutorial vamos continuar a explicação sobre o funcionamento e características de mais alguns módulos que associados às várias placas de Arduino permitem criar imensos projectos.
Vamos então explicar uma montagem, onde será possível controlar a velocidade e sentido de rotação de um motor DC através do módulo HW-95 H-Bridge Driver. Este módulo permite controlar a velocidade de um motor através dos pinos de sinal digital com a funcionalidade PWM do Arduino, ficando este último protegido de picos de corrente eléctrica criados pelo funcionamento do motor.
A grande particularidade desta montagem será a realização deste controlo através de um qualquer "Smartphone", onde será instalada uma aplicação desenvolvida de forma a controlar equipamentos eléctricos através da Internet. Este tipo de aplicação ou sistema de controlo possibilita uma enorme diversidades de projectos, entre os quais sistemas de "Home Automation", robótica à distância e monitorização de sistemas à distância.
Além do controlo da velocidade do motor, esta montagem terá também a particularidade de permitir monitorização da velocidade real e instantânea a que o motor está a rodar, podendo assim através da aplicação alterar e ajustar a velocidade do motor à velocidade pretendida.
Desta vez o Arduino escolhido foi o Arduino MEGA tendo este sido falado no ultimo tutorial, onde o utilizamos juntamente com sensores e emissores IR de forma a controlar os vários equipamentos electrónicos espalhados por nossas casas, sendo assim possível controlar vários equipamentos com apenas um controlo remoto universal.
Arduino Tutorial - IR Universal Remote Control
https://www.instructables.com/id/Arduino-Tutorial-IR-Universal-Remote-Control/
Como mencionado no tutorial anterior o Arduino MEGA é um dos componentes com mais pinos de sinal digital e analógico, o que o torna bastante versátil e essencial em grandes projectos, mas além disso também é um dos Arduino com mais pinos de comunicação UART contendo até 4 conjuntos de pinos TX e RX (Ver imagem acima).
Esta característica será muito importante, pois na montagem deste tutorial serão utilizados 2 conjuntos deste tipo de pinos comunicação, sendo um conjunto para comunicar com o PC possibilitando a monitorização do processo comunicação através da rede de Wi-Fi entre o Arduino e o "Smartphone". Já o outro conjunto terá a função de comunicar com o modulo ESP8266, capacitando assim o nosso Arduino MEGA com a funcionalidade de comunicar através dessa mesma rede Wi-Fi.
Este é o principio de um os sistemas mais populares actualmente, sendo vulgarmente chamado de sistema IOT ou "Internet Of Things", neste momento existem vários tipos de placas que têm incorporados os módulos de comunicação Wi-Fi, no entanto, estes ainda são um pouco mais caros e ao serem novos equipamentos tornam os que já adquirimos desactualizados ou ultrapassados.
Quando passamos para os sistemas IOT e Wi-Fi são abertas tantas novas oportunidade e ideias, que já não voltamos mais para os velhinhos sistemas de comunicação por fios. Neste tipo de módulos de comunicação Wi-Fi encontramos o nosso modulo ESP8266 modelo ESP-01 (Ver imagem acima), tendo como grande vantagem o seu tamanho muito reduzido o que o torna bastante versátil (Ver datasheet abaixo).
O módulo ESP8266 modelo ESP-01 é constituído por:
Por um microcontrolador ESP8266 tendo um funcionamento muito idêntico aos instalados nos Arduino dispondo de 512Kb de "FLASH Memory" ou EEPROM e também de 64Kb de RAM.
Este está instalado numa módulo que contem apenas 2 pinos de alimentação, sendo que a tensão de VCC terá de ser obrigatoriamente de 3,3V, caso contrário este poderá ficar danificado.
Como mencionado anteriormente este permite a conectividade Wi-Fi IEE 802.AA B/G/N de 2,4GHz nos sistemas WEP, WPA ou WPA2 comunicando através de uma antena própria e incorporada.
Alem dos pinos de alimentação este módulo contem mais 2 pinos de controlo, sendo um denominado de "Reset" tendo como função reiniciar o módulo e consequentemente a sua programação, este é activado quando é colocado em nível baixo. O Outro pino denominado de CH_PD ou EN "Enable" activa o módulo apenas quando este está em nível alto, permitindo assim um modo de funcionamento identifico ao "StandBy".
Depois vêm os pinos de comunicação sendo através destes que é recebida e enviada a informação entre o Arduino e o nosso módulo tudo isto através do protocolo de comunicação UART, este são denominados através das siglas TX e RX à semelhança das placas Arduino.
Por fim, vêm apenas 2 pinos de funcionamento designados por GPIO0 e GPIO2, não sendo mais do que pinos de sinal digital podendo estes serem configurados como pinos de entrada ou saída sinal, bem como com a funcionalidade PWM.
Entre estes 2 pinos, o pino GPIO0 tem ainda a funcionalidade de activar o sistema de "Boot Mode", ou seja, caso o módulo seja ligado com este pino em nível baixo o sistema "Boot Mode" é activado, permitindo assim realizar "Upgrades" ao seu "Firmware".
O que é um sistema IOT:
Sendo a montagem deste tutorial muito simples, o seu principal objectivo é a iniciação aos sistemas IOT, desta forma o que é um sistema IOT?
Um sistema IOT tem como requisito a necessidade de que os equipamentos estejam ligados à Internet, podendo estes serem capazes de se identificar numa rede e de comunicar entre si, como também de poderem ser controlados por um utilizador à distância, seja esta delimitada por uma rede local e física através de cabos de rede ou até por um rede global como a "World Wide Web" e através de sistemas Wi-Fi ou GSM.
Para controlar um sistema IOT teremos de ter um interface onde o utilizador poderá alterar ou ajustar esse sistema, neste caso utilizaremos uma aplicação para "Smartphone" desenvolvida para ser editada e configurada à mediada das necessidades do utilizador e onde utilizamos a rede de Internet GSM ou Wi-Fi para realizar a comunicação entre esta aplicação e o Arduino.
Aplicação IOT utilizada - Blynk:
A aplicação Blynk é uma plataforma que pode ser instalada em qualquer "Smartphone" com os sistemas operativos iOS ou Android e compatível com todos os tipos de placas de Arduino, Raspberry Pi e outros tipos de equipamentos.
Esta permite criar um interface gráfico de forma fácil, intuitiva e adequada para cada projecto, bastando apenas ter acesso à rede de Internet, através de Ethernet, Wi-Fi ou GSM, para podermos controlar e obter informação de um dispositivo físico em qualquer altura e onde quer estejamos (Ver imagens acima).
Para utilizar a aplicação é necessário em primeiro lugar realizar o "Download" desta para Android ou IOS através do site da Blynk para assim depois instalarmos o aplicativo num "Smartphone" ou "Tablet" bastando apenas depois configura-la e liga-la à rede.
Blynk IoT Plataform site
O Módulo HW-95 H-Bridge Driver tem como função controlar a velocidade e o sentido de rotação de motores DC (Ver datasheet abaixo). Existem 2 formas de controlar a velocidade de um motor DC, uma delas consiste na variação da tensão aplicada nos seus terminais, no entanto, este método é muito pouco preciso. Outro método de controlar a velocidade é através de sinais modulados ou PWM sendo este o método utilizado pelo nosso módulo HW-95 H-Bridge Driver .
Apesar de já termos falado sobre sinais PWM em tutoriais anteriores, relembro apenas que este tipo de sinais modulados têm como principal característica apresentar-se com uma frequência, que pode ser alterada de forma a aumentar ou diminuir o tempo em que o sinal permanece em nível alto, que neste caso traduz-se em mais ou menos velocidade de rotação do motor (Ver imagem acima).
Arduino Tutorial - PWM Output - LED - Monitor Serial
https://www.instructables.com/id/Ardu%C3%ADno-Tutorial-PWM-Output-LED-Monitor-Serial/
Outra particularidade deste módulo é o controlo do sentido de rotação através de um circuito do tipo "H-Bridge", sendo a forma mas comum de o realizar. Este sistema normalmente é constituído por um circuito que contém 4 elementos de comutação, que vão alternando as ligações do motor à fonte a alimentação e dessa forma também a direcção da corrente eléctrica no motor e consequentemente o sentido de rotação, este circuito é assim denominado pois a sua configuração simplificada faz lembrar um H (Ver imagem acima).
As grandes vantagens deste tipo de módulo é conter 2 sistemas de controlo independentes dos motores,o que o torna indicado para projectos de robótica onde normalmente são necessários pelo menos 2 motores um esquerdo e outro direito, alem disto também a sua capacidade de funcionar com a tensão de alimentação superior a 5V, podendo ir até aos 35V sendo apenas necessário configurar um pequeno "Jumper".
Sensor de velocidade módulo HC-020K:
Medir a velocidade de rotação de um motor é bastante útil em projectos de robótica, principalmente se esses forem controlados à distância, para isso são utilizados sensores que permitem calcular as rotação de um motor um determinado espaço de tempo.
Este sensores podem ter vários tipos de funcionamento ou configurações no caso do módulo HC-020K da nossa montagem é constituído por um sensor do tipo opto-interruptor, tendo num dos lados um LED infravermelho e do outro um foto-transístor (Ver datasheet abaixo).
Assim quando este está em funcionamento o LED incide um feixe de luz infravermelha sobre o foto-transístor, colocando o pino de saída do módulo em nível baixo, já quando esse feixe é interrompido o pino de saída do módulo ficará em nível alto, sendo assim possível contabilizar o numero de vezes acontece esta situação num determinado espaço de tempo (Ver imagem acima).
Agora se no eixo estiver um disco com apenas um orifício por onde passa o feixe de luz infravermelha, significa que quando o pino de saída do modulo HC-020K é alterado de nível alto para nível baixo o seu eixo deu uma volta, mas se esse mesmo disco tiver mais que um orifício, o eixo do motor dará um volta quando este acontecimento se verificar na mesma quantidades vezes que o numero de orifícios (Ver imagem acima).
Montagem
Começamos a montagem com uma "Breadboard" onde colocarmos e distribuímos as alimentações do Arduino, depois colocamos na montagem também o nosso Arduino MEGA e os módulos que vamos falar neste tutorial sendo estes os componentes principais da nossa montagem (Ver montagem acima).
Material necessário:
- 1x Arduino MEGA;
- 1x Cabo USB;
- 1x Breadboard;
- 1x Módulo ESP8266 modelo ESP-01;
- 1x Botão (Push Button);
- 1x Módulo HW-95 H-Brigde Driver Motor;
- 1x Motor 5V DC FF-050SH;
- 1x Módulo de HC-020K Sensor de Velocidade;
- 1x Disco perfurado Sensor de Velocidade;
- 1x Smartphone;
- Internet por sistema Wi-Fi;
- Aplicação Blynk;
Instalação do Módulo ESP8266 modelo ESP-01 e Push Button:
A instalação deste componente na montagem é relativamente fácil, desde que tenhamos algumas precauções. Uma das precauções tem a ver com a sua disposição dos pinos, pois este componente não foi desenhado para ser inserido directamente numa "Breadboard", desta forma não vamos ligar este módulo através da "Breadboard", mas sim directamente no Arduino através de fios (Ver imagem acima).
Outra precaução a ter em atenção é relativa à sua alimentação, como referido anteriormente a alimentação deste módulo é de 3,3V e não de 5V, como estamos habituados a utilizar nos vários módulos falados nos nossos tutoriais. Logo, para facilitar iremos distribuir apenas as alimentação do módulo ESP8266 na "Breadboard", ou seja, a alimentação de 3,3V e GND.
Este procedimento apenas foi uma forma de organizar as alimentações para que estas nunca sejam trocadas, pois este módulo é muito sensível quanto às tensões de alimentação, uma outra razão para isto foi a instalação do botão do tipo "Push Button" que colocámos na "Breadboard" e ligamos-o a GND, para podermos reiniciar o módulo mais facilmente e assim consequentemente a ligação Wi-Fi caso seja necessário (Ver imagem acima).
Já as ligações dos pinos de comunicação RX e TX serão realizadas directamente na segunda linha de comunicação UART no Arduino MEGA, ficando o pino RX e TX do módulo ligado ao pino RX1 e TX1 do Arduino respectivamente.
Isto deve-se ao facto de o código do Arduino para a aplicação Blynk estar configurado para ocupar a primeira linha de comunicação UART com a funcionalidade Monitor Serial, para assim verificar e monitorizar o estado da ligação Wi-Fi da montagem durante o seu funcionamento.
Instalação do Módulo HW-95 H-Brigde Driver Motor:
Este módulo é constituído por 2 sistemas de controlo de motores DC independentes, no entanto para simplificar a montagem deste tutorial apenas vamos utilizar um desses sistemas, visto que são exactamente iguais (Ver imagem acima).
Apesar disso quando realizamos as suas ligações teremos de configurar um conjunto de "Jumpers", seleccionando assim que tipo de alimentação vai ser utilizada, como também o tipo de funcionamento queremos que este desempenhe.
Desta forma se formos utilizar uma tensão em VCC de superior a 12V teremos que remover o "Jumper" de cor amarela, permitindo assim activar o terminal +12V e o respectivo regulador de tensão incorporado no módulo, no entanto, esta tensão não poderá ser superior a 35V (Ver imagem acima).
Caso estejamos a utilizar um motor cuja a tensão de funcionamento é 5V, sendo este o caso do motor utilizado na nossa montagem, manteremos o respectivo "Jumper" colocado, mas agora alimentamos o módulo através do terminal +5V. Visto que este motor utiliza a mesma tensão de funcionamento que o Arduino será este ultimo que vai alimentar o módulo e por sua vez o alimenta o motor.
Para configurar os "Jumpers" selectores de função temos de ter em consideração que com estes colocados no módulo, apenas será permitido realizar a mudança do sentido dos motores, mantendo assim sempre motor na sua potência máxima não havendo a possibilidade de qualquer tipo de ajuste na velocidade de rotação.
Caso contrário se quisermos activar este ajuste apenas teremos de retirar esses mesmos "Jumpers" e ligar nos pinos ENA ou ENB um qualquer pino de sinal digital do Arduino com a funcionalidade PWM, ficando neste caso ligado ao pino ENA o pino de sinal digital D4 do Arduino, podendo agora através do código do Arduino alterar a frequência do sinal PWM e consequentemente a velocidade de rotação do motor (Ver imagem acima).
Já os pinos que ligam e seleccionam o sentido de rotação dos motores, encontra-se em conjuntos de 2 pinos, sendo os pinos IN1 e IN2 os que controlam a saída do Motor 1 e os pinos IN3 e IN4 que controlam os a saída do Motor 2. Os pinos IN1 e IN2 são então ligados aos pinos de sinal digital do Arduino D2 e D3 e serão controlados em conjunto através do código do Arduino (ver imagem acima).
Instalação do Motor e do Módulo HC-020K:
Este é um módulo constituído por 2 torres onde em uma delas se encontra um LED que emite um feixe de luz infravermelha, situado à frente desta torre encontramos uma outra torre onde se encontra um sensor de luz infravermelha, verificando assim desta forma se o feixe emito pelo LED está a se obstruído (Ver imagem acima).
Para transmitir essa informação este sensor utiliza 1 dos seus 3 pinos estando esse designado como OUT, os restantes são os pinos de alimentação GND e VCC sendo o seu valor de tensão de 5V.
O pino OUT do sensor é um pino de sinal digital que altera o seu estado de "LOW" para "HIGH" sempre que o feixe infravermelho é interrompido, logo este será ligado a um pino de sinal digital do Arduino, sendo neste caso seleccionado o pino D7 (Ver imagem acima).
Para conseguirmos calcular e determinar a velocidade do motor teremos então que acoplar um disco perfurado com uma ou mais ranhuras no eixo do motor e introduzir este disco entre as 2 torres do sensor. Será este disco que associado à rotação do motor, irá permitir que o feixe infravermelho apenas esteja visível ao sensor quando esses furos estiverem alinhados com o foto-transístor que consequentemente altera o estado no pino OUT (Ver imagem acima).
Configuração Da APP Blynk
Com a montagem finalizada vamos então virar a nossa atenção para a criação do projecto na aplicação Blynk, sendo através desta que será possível controlar o sentido e a velocidade de rotação como também visualizar a velocidade do motor em tempo real (Ver imagem acima).
Desta forma e como explicado anteriormente devem em primeiro lugar realizar o "Download" do aplicativo para o vosso "Smartphone" ou "Tablet", para depois instala-lo e criar na aplicação uma conta com o vosso respectivo email.
Após a aplicação estar instalada e criada a vossa conta será necessário configurar o nosso primeiro projecto. Depois será apresentado uma tela no ecrã com apenas uma faixa verde e um símbolo de construção, sendo nesse símbolo que antes de tudo iremos seleccionar entrando assim na página Project Settings (Ver imagem acima).
Configurar um novo projecto no aplicativo Blynk:
É nesta página que vamos configurar o nosso projecto em relação a sua aparência, conectividade, partilha e funcionalidades. Entre a várias possibilidades e alterações vamos focar-nos por agora nas opções de aparência e conectividade.
Em primeiro lugar atribuímos um nome ao nosso projecto o qual deve identificar bem o objectivo do projecto, pois esta aplicação permite criar vários projectos separadamente, tornar-se confuso caso forem criados muitos projectos.
Um pouco mais abaixo encontramos a opção Dark/Light esta opção permite escolher 2 tipos de visualização, estes modos de visualização apenas tornam a visualização da aplicação em tons de cor escura ou tons de cor clara.
Depois iremos seleccionar o equipamento que queremos ligar e controlar através da aplicação. Para isso selecciona-mos o separador Device entrando agora na página My Devices, aqui é possível adicionar e configurar todos os equipamentos utilizados no nosso projecto. Assim vamos então adicionar um equipamento, seleccionando em +New Device e abrindo a página Device Settings, sendo aqui que seleccionaremos o tipo de equipamento e a sua respectiva conectividade.
Como anteriormente, também aqui vamos atribuir um nome bem identificativo do nosso equipamento, pois também será possível adicionar vários equipamento diferentes, permitindo assim conectar-los todos em apenas um único projecto na aplicação (Ver imagem acima).
Agora só falta escolher o tipo de equipamento que vamos utilizar e o tipo de de conectividade desse equipamento. Entre esta grande lista de equipamentos podemos seleccionar vários tipos de placas de Arduino ou o próprio módulo ESP8266, como também outras placas como o NodeMCU que iremos com certeza falar em próximos tutoriais sendo estas desenvolvidas para funcionar com sistemas IOT.
No nosso caso como estamos a utilizar um Arduino MEGA como o equipamento principal, sendo este conectado à rede de "Internet" através do módulo ESP8266 modelo ESP-01, vamos então seleccionar a opção Arduino Mega e não a opção ESP8266.
Depois seleccionamos o tipo de conectividade que será a opção WiFi, pois como explicado anteriormente esta é a forma de comunicar do módulo ESP8266 modelo ESP-01, no entanto, caso tivéssemos instalado outro tipo de módulo de conectividade, como Ethernet ou Bluetooth, no nosso Arduino essas teriam ser as opção seleccionada.
Após adicionar-nos o equipamento é gerado um código denominado de AUTH TOKEN, este código é muito importante pois a sua função é atribuir uma autenticação ou confirmação entre o equipamento e o projecto que estamos a criar, não sendo possível controlar este equipamento através de outros projectos ou aplicações sem este tipo de código tornando assim seguro esta conectividade.
Para já apenas teremos de ter noção da sua existência e guardar bem este código AUTH TOKEN, alem de o podermos visualizar nesta página também é possível envia-lo para o nosso email ficando assim arquivado, bastando para isso apenas carregar no botão E-Mail (ver imagem acima).
E pronto o projecto está criado e configurado, caso queiram saber mais sobre estas e outras opções de configuração aconselho a visualização dos pequenos tutoriais do próprio sites da aplicação Blynk, através da ligação https://blynk.io/en/getting-started.
Adicionar funcionalidades ao novo projecto:
Agora vamos desenhar o nosso projecto, ou seja, adicionar os interfaces e atribuir-lhes funcionalidades ao nosso projecto de forma a controlar e visualizar o sentido e a velocidade de rotação do motor da nossa montagem.
Começamos então por adicionar os botões ao projecto, estes terão a funcionalidade de controlar o sentido de rotação do motor, assim vamos carregar no centro da tela do nosso projecto sendo aberto o menu Widget Box onde podemos escolher o interface mais adequado à função que queremos atribuir no projecto.
Adicionar os Button ao projecto:
Logo no topo desta lista de interfaces encontramos o Button, bastando assim apenas selecciona-lo para que este seja adicionado na tela, o passo seguinte será dimensiona-lo ao tamanho pretendido e depois carregando no próprio Button é aberta a sua página de configuração Button Settings.
Aqui vamos configurar vários parâmetros e funcionalidades entre as quais o seu nome ou legenda, este botão terá o nome de MOTOR CW ROTATION e depois escolhemos a sua cor carregando no circulo que se encontra ao lado várias vezes, outra configuração possível de alterar será o seu modo de funcionamento que poderá ser o modo Push e o modo Switch.
Se seleccionar o modo Push o botão terá um funcionamento idêntico a um "Push Switch", ou seja, apenas será ligado enquanto este estiver premido, o que já não acontece no modo Switch, que tem um funcionamento idêntico a um vulgar interruptor que ao ser premido ficará activado e assim permanecer continuamente até que este seja premido novamente.
Falta agora escolher onde vai ocorrer a acção quando este for premido, no caso da aplicação Blynk alem de esta permitir seleccionar qualquer um dos pinos de sinal digital do Arduino MEGA ficando assim este interface ligado directamente a esse pino, também permite seleccionar pinos virtuais (Ver imagem acima).
Os pinos virtuais têm como função assumir o estado em que o botão se encontra nesse momento, sem terem que ser utilizados os pinos físicos do Arduino, esta funcionalidade permite criar condições e sequências entre as vários interfaces, sendo apenas necessário colocar estas condições e sequências no código do Arduino.
No entanto, apesar desta característica não é possível seleccionar mais do que um dos pinos de sinal digital do Arduino ou dos pinos virtuais, assim para que o nosso motor rode no sentido dos ponteiros do relógio é necessário colocar os pinos IN1 e IN2 do módulo HW-95 H-Brigde Driver Motor na condição "LOW" e "HIGH" respectivamente e estando este ligados aos pinos do Arduino D2 e D3.
Logo para resolver esta situação, teremos de utilizar um dos pinos virtuais que será o pino V0 e depois colocar uma condição no código em que se o botão MOTOR CW ROTATION estiver em "ON", ou seja, o pino V0 em "HIGH", são colocados os pinos D2 e D3 nas condições de estado descritas acima e se estiver em "OFF" estes pinos ficaram ambos no estado de "LOW" desligando assim o motor (Ver imagem acima).
Depois adicionamos mais um Button que será nomeado como MOTOR CCW ROTATION, já neste será seleccionado o pino V1 e colocada uma condição no código que verifica se este botão está em "ON" colocando os mesmo pinos D2 e D3 do Arduino na condição de estado "HIGH" e "LOW" respectivamente, fazendo assim o motor rodar agora no sentido contrário ao dos ponteiros dos relógio (Ver imagem acima).
Adicionar o Slider ao projecto:
Para adicionar outro tipo de interface voltamos a entrar na página Widget Box, mas agora seleccionamos o interface do tipo Slide, este interface permite seleccionar um determinado valor que se encontra dentro de um intervalo de valores. Após adicionar este interface iremos dimensional-lo e depois configura-lo, sendo apenas também necessário carregar neste para abrir a sua página de configuração Slide Settings.
Nesta página iremos configurar e seleccionar várias opções que são muito idênticas às dos interfaces anteriores, entre estas são o seu respectivo nome, a cor do interface e o respectivo pino de acção. Desta vez o pino escolhido para o Slide será o pino de sinal digital do Arduino D4 que contêm a funcionalidade PWM, pois queremos que este interface interaja directamente com com o Arduino, onde será ligado posteriormente ao pino ENA do módulo HW-95 H-Brigde Driver Motor (Ver imagem acima).
Será então depois através do pino ENA do HW-95 H-Brigde Driver Motor que vamos controlar a velocidade do motor, bastando apenas deslizar o selector ao longo da barra do Slide alterando o valor PWM no pino do Arduino.
Agora como explicado em tutoriais anteriores o sistema PWM do Arduino consiste na alteração da modulação de sinal entre os valores de 0 a 255, logo ao alterarmos na barra do Slider um valor também estamos a alterar o valor do pino de acção escolhido.
Arduino Tutorial - PWM Output - LED - Monitor Serial
https://www.instructables.com/id/Ardu%C3%ADno-Tutorial-PWM-Output-LED-Monitor-Serial/
Para podermos saber qual o valor que estamos a seleccionar colocamos a opção Show Value em "ON", activando assim a indicação desse valor no canto superior direito do Slider, sendo assim agora mais fácil e preciso seleccionar o valor pretendido (Ver imagem acima).
Já a opção Send Values on Release Only será mantida em "OFF", permitindo que os valores sejam seleccionados instantaneamente durante o deslocamento do selector ao longo da barra do Slide e não apenas quando o selector é largado numa determinada posição, com esta opção desactivada é possível alterar assim a velocidade do motor de forma gradual.
Por ultimo, através da opção Decimal vamos seleccionar o numero de casas decimais que este valor irá ter, neste caso não será necessário casas decimais, pois a funcionalidade PWM não as utiliza, mas caso estivesse-mos a utilizar o Slide de forma a seleccionar por exemplo um valor de temperatura, poderíamos colocar uma casa decimal nesta opção (Ver imagem acima).
Adicionar o Labeled Value ao projecto:
Por ultimo vamos adicionar o Labeled Value ao nosso projecto, este interface tem como função representar valores numéricos e como em todos os interfaces anteriores vamos também atribuir-lhe um nome e escolher a cor que os seu caracteres irão ter, esta opção encontra-se no final desta página e está acompanhada por uma outra que permite alterar o tamanho desses mesmos caracteres.
Uma outra opção de apresentação dos caracteres é a opção Label, esta opção permite seleccionar o alinhamento dos caracteres à esquerda, à direita ou ao centro. Alem disto também contem uma caixa de texto que permite adicionar algum tipo de texto antes ou depois do valor, como por exemplo as suas unidades de medida (Ver imagem acima).
Agora vamos seleccionar o pino de acção, no entanto, desta vez este não será um pino de saída mas sim de entrada de sinal, que tanto poderá ser de sinal digital como de sinal analógico, assim será possível seleccionar qualquer pino tipo de pino do Arduino MEGA, tendo apenas a atenção ao tipo de sinal que queremos visualizar.
Apesar disto iremos seleccionar o pino virtual V2, a razão para isto é a necessidade de realizar cálculos de forma a determinar a velocidade do motor antes ainda da sua representação, pois o nosso sensor não realiza este processo automaticamente.
Para que esse valor final e calculado da velocidade seja representado no Labeled Value, será necessário criar um código que realize um cálculo com o sinal proveniente do sensor, sendo neste caso esse sinal inserido no pino D7 do Arduino e só depois o seu resultado final será inserido no pino virtual V2 permitindo assim a sua visualização.
Devido ao tempo de resposta de todo este processo é necessário colocar uma espécie de gatilho que realiza o refrescamento desta informação e que por sua vez irá actualizar o valor apresentado no Labeled Value. Este gatilho também é possível de ser seleccionado através da opção Refresh Interval, podendo assim ser escolhido um tempo de refrescamento em segundos, minutos, horas ou até quando o utilizador o requesitar (Ver imagem acima).
Iniciar e clonar projecto:
E pronto terminamos a criação do nosso projecto na aplicação Blynk, para finalizar e começar a interagir com este projecto, basta apenas carregar no botão de "Play" que se encontra no canto superior direito da aplicação.
Caso queiram adquirir este projecto já elaborado directamente, apenas terão de carregar no símbolo de QRCode que se encontra na página iniciar da aplicação e apontar a câmara do vosso "Smartphone" para o QRCode de clone deste projecto, copiando-o assim para o vosso "Smartphone" estando este já configurado e pronto a utilizar (Ver imagem cima).
Agora só falta construir e enviar o nosso código para o Arduino, sendo este o passo final para que finalmente possamos testar a aplicação e a respectiva montagem e controlar finalmente o nosso motor.
Código
Para que o Arduino possa comunicar com a aplicação Blynk, o código terá de conter bibliotecas e funções específicas para esse efeito e será nestas que vamos agora incidir na nossa atenção na explicação do código.
Mas antes, de irmos ao código teremos primeiro de preparar o módulo ESP8266 modelo ESP-01 de forma a que este tenha a ultima versão de "Firmware" para assim melhorar o seu funcionamento e também para termos a certeza que o módulo está completamente limpo, ou seja, que não tem gravado nenhum código.
No entanto, caso tenha sido inserido algum código anteriormente ou não tenha sido realizada a sua formatação correctamente, não será permito ao nosso Arduino controlar este módulo e consequentemente este não será conectado à rede Wi-Fi. Para teremos a certeza que este está nas condições anteriormente referidas teremos então de realizar um procedimento especifico, que consiste em utilizar uma montagem e um "Software" específicos para o efectuar.
Verificar a versão de Firmware do módulo ESP8266 modelo ESP-01:
Em primeiro lugar teremos de colocar o módulo ESP8266 modelo ESP-01 numa determinada montagem podendo ser utilizado qualquer tipo de Arduino. Neste caso foi utilizado um Arduino UNO e as ligações da montagem não são muito diferente das ligações realizadas na montagem para o nosso tutorial, no entanto, também existe o módulo adaptador Módulo Adaptador CH340G Driver, que torna este procedimento muito mais fácil de executar(Ver imagens acima).
Depois da montagem estar pronta iremos instalar o "Software" Termite no nosso PC, depois abrimos o programa Termite e carregamos no botão Settings, este irá abrir a página de configuração (Instalar ficheiro abaixo). Para configurar o programa de forma a comunicar com este tipo módulo termos de colocar as várias opções correctamente (Ver imagem acima).
Estando configurado o programa vamos então agora verificar se este consegue comunicar com o nosso módulo, para isso escrevemos na barra de texto deste programa o comando AT e o módulo terá de responder com a palavra "OK", caso não aconteça verifiquem as ligações e configurações do programa, pois pode por exemplo não estar seleccionada a porta de comunicação correcta.
Estando estes a comunicar escrevemos agora o comando AT+GMR e será respondida a informação sobre a sua versão de "Firmware". Caso esta não seja a versão mais actualizada, sabendo que temos a versão V1.54 que é a mais actual a quando da elaboração deste tutorial, deve então ser realizada a sua actualização através do procedimento seguinte.
Todos estes comandos e muitos outros que neste caso não são necessários, podem ser visualizados através de uma lista completa que disponibilizamos num pequeno ficheiro que se encontra abaixo.
Actualizar Firmware do módulo ESP8266 modelo ESP-01:
Para o actualizar o "Firmware" vamos então abrir um outro tipo de "Software" denominado de Flasher, este programa irá actualizar então o nosso módulo colocando os dados de um determinado ficheiro dentro deste. Neste caso o ficheiro que disponibilizamos é com a ultima versão que encontramos até à data deste tutorial, no entanto, aconselho a procura de um com uma versão mais actualizada (Ver ficheiros abaixo).
Depois de este abrir iremos então seleccionar um ficheiro de actualização de "Firmware" do tipo Bin carregando no botão com o mesmo nome. De seguida teremos de seleccionar a porta de comunicação à qual o Arduino está ligado.
Agora para que o módulo entre em modo de actualização de "Firmware" teremos de realizar um ultimo procedimento, que consiste em ligar o pino IO0 do módulo ESP8266 ESP-01 a GND e logo de seguida carregar no botão de "Reset" da montagem. Com isto o módulo irá reiniciar, no entanto já em modo de actualização ou Flasher, para finalizar este processo apenas termos de carregar no botão Download do programa e esperar que este termine.
Assim que o processo terminar voltamos a colocar o pino IO0 em aberto e carregamos novamente no botão "Reset" da montagem, retirando assim o módulo do modo Flasher e ficando este pronto para utilização novamente. Com a realização deste procedimento garantimos que alem de este ter a ultima versão de "Firmware" também garantimos que não tem qualquer código na sua memória e podemos então passar agora para a programação do nosso Arduino MEGA.
Programar o Arduino MEGA:
Estando os procedimentos anteriores concluídos vamos passar para a programação do nosso Arduino MEGA, sendo este o equipamento que será controlado e monitorizado através do projecto que desenvolvemos na aplicação Blynk. Para que possamos ter acesso ao Arduino MEGA através desta aplicação, teremos de carregar um código especifico para funcionar com esta aplicação, que permite o acesso e controlar por Wi-Fi o Arduino.
A estrutura do código poderá ser facilmente adquirido através da página de exemplos que a própria Blynk possui, nesta página é apresentado um código com as suas respectivas funções copiáveis para o Arduino IDE. Para programar o nosso Arduino teremos no entanto de seleccionar o tipo de placas e os módulos ou interfaces.
https://examples.blynk.cc/?board=ESP8266&shield=ESP8266%20WiFi&example=Widgets%2FTerminal.
Esta contem 4 caixas de texto onde seleccionamos e configuramos qual o tipo de montagem e de interfaces utilizados na aplicação, onde depois nos aparecerá a estrutura de um código tornando mais fácil e rápida a programação do Arduino (Ver ficheiro abaixo).
Com a estrutura do código constituída falta agora colocar as autenticações ou código AUTH TOKEN da nossa aplicação Blynk, sendo esta criada pela aplicação a quando sua elaboração. Esta é muito importante e caso queiramos que o nosso projecto seja pessoal, ou seja, se queremos ser os únicos a controlar a montagem e a nossa aplicação o código AUTH TOKEN terá de ser pessoal e intransmissível.
Alem desta também teremos de colocar as autenticações da nossa rede Wi-Fi colocando o nome da rede criada através do "Router" e a sua respectiva palavra passe de acesso se essa rede esteja protegida, caso contrário apenas teremos de colocar "".
Outro aspecto importante será verificar e colocar a velocidade da Communication Serial utilizada para comunicar com o ESP8266 com o valor de 115200 pois esta é a velocidade comunicação especificada para este tipo de módulo.
//Activa a Communication Serial entre a aplicação Blynk e Monitor Serial:
#define BLYNK_PRINT Serial
#include <ESP8266_Lib.h> //Importar a "ESP8266_Lib" library.
#include <BlynkSimpleShieldEsp8266.h> //Importar a "BlynkSimpleShieldEsp8266" library.
//Autenticação da nossa conta na aplicação Blynk.
char auth[] = "YourAuthToken"; //Colocar o AuthToken da nossa aplicação.
//Autenticação de acesso à rede Wi-Fi.
char ssid[] = "YourNetworkName";//Colocar o nome da rede Wi-Fi.
char pass[] = "YourPassword"; //Colocar a password do rede Wi-fi.
//Nota: Colocar "" caso seja uma rede Wi-Fi aberta.
//Activar a Communication Serial para o ESP8226 através de uma outra linha de comunicação:
#define EspSerial Serial1 //Selecciona a 2ª linha de Communication Serial.
#define ESP8266_BAUD 115200 //Velocidade da Communication Serial com o ESP8266 ESP-01.
ESP8266 wifi(&EspSerial); //Define a linha de comunicação seleccionada para o ESP8266 ESP-01.
//Correr a função SETUP apenas uma vez após ser pressionado Reset:
void setup() {
//Iniciar a Communication Serial a 9600b/s:
Serial.begin(9600);
//Iniciar a Communication Serial com o ESP8266 ESP-01 a velocidade seleccionada:
EspSerial.begin(ESP8266_BAUD);
//Atraso para o próximo passo.
delay(10);
//Iniciar a comunicação Wi-Fi:
Blynk.begin(auth, wifi, ssid, pass);
}
//A rotina de LOOP e executada repetidamente:
void loop() {
//Iniciar a comunicação com a aplicação Blynk:
Blynk.run();
//Colocar o restante código para o nosso projecto.
//Atraso para o próximo passo.
delay(10);
}Se estão recordados no capitulo anterior a quando da elaboração do projecto na aplicação Blynk foram utilizados 2 pinos virtuais para o controlo dos interfaces Button, isto deveu-se a não ser possível controlar 2 pinos de sinal digital do Arduino MEGA em simultâneo e directamente através dos interfaces Button que têm os nomes MOTOR CW ROTATION e MOTOR CCW ROTATION.
Desta forma atribuímos o valor do estado destes interfaces, que neste caso são os botões de controlo do sentido de rotação do motor na montagem, às variáveis do tipo integer criadas para este fim. Depois já na função Loop() iremos colocar as respectivas condições relacionando o estado desses botões à activação dos respectivos pinos de sinal digital D2 e D3, controlando assim o sentido de rotação do motor através do módulo HW-95 H-Brigde Driver Motor.
//Variáveis para atribuição dos estados dos botões de sentido de rotação do motor:
int Botao_Sentido_CW;
int Botao_Sentido_CCW;
//Definição dos pinos virtuais da aplicação Blynk e atribuição dos estados dos botões:
BLYNK_WRITE(V0) {
Botao_Sentido_CW = param.asInt(); //Atribuir o estado do pino virtual à variável.
}
BLYNK_WRITE(V1) {
Botao_Sentido_CCW = param.asInt(); //Atribuir o estado do pino virtual à variável.
}
//A rotina de LOOP e executada repetidamente:
void loop() {
//Iniciar a comunicação com a aplicação Blynk:
Blynk.run();
//Condição para ligar o motor no sentido de rotação do relógio:
if (Botao_Sentido_CW == HIGH) {
//Definição do estado dos pinos para sentido de rotação do Motor CW:
digitalWrite(Pino_Direccao_Motor_1, LOW);
digitalWrite(Pino_Direccao_Motor_2, HIGH);
}
//Condição para ligar o motor no sentido contrário da rotação do relógio:
else if (Botao_Sentido_CCW == HIGH) {
//Definição do estado dos pinos para sentido de rotação do Motor CCW:
digitalWrite(Pino_Direccao_Motor_1, HIGH);
digitalWrite(Pino_Direccao_Motor_2, LOW);
}
//Condição para desligar o motor:
else if (Botao_Sentido_CW == LOW && Botao_Sentido_CCW == LOW) {
//Definição do estado dos pinos para para o motor:
digitalWrite(Pino_Direccao_Motor_1, LOW);
digitalWrite(Pino_Direccao_Motor_2, LOW);
}
//Atraso para o próximo passo.
delay(10);
}Por ultimo falta apenas descrever a parte do código responsável pela leitura da velocidade de rotação do nosso motor, como se recordam do capitulo anterior para visualizar esta leitura foi adicionado um interface do tipo Labeled Value tendo-lhe sido atribuído também um pino virtual, no entanto, por razões diferentes dos interfaces Button que controlam o sentido de rotação.
Desta vez isto deveu-se à necessidade de realizar uma contagem pulsos enviados pelo módulo HC-020K e do seu respectivo cálculo para determinação das rotações por minuto do nosso motor. Assim só depois da realização destes processos é que iremos enviar então o valor no nosso interface Labeled Valeu para este ser representado na aplicação.
Como nesta montagem o disco do sensor de velocidade apenas tem uma única perfuração, significa que quando o motor executa uma rotação, este irá realizar apenas um pulso longo em nível altoe um curto de nível baixo, ou seja, apenas teremos de contabilizar o tempo que demoram ambos os pulsos nestes 2 estados.
Para realizar esta contabilização utilizamos a função pulseIn(), devolvendo assim o valor de tempo em que cada um destes pulsos estão em nível alto e nível baixo. Agora como este valor de tempo é fornecido pela função em microsegundos µSeg e queremos visualizar o valor em RPM teremos de converter o valor de µSeg em minutos (Ver cálculos acima).
Caso o disco do sensor de velocidade tenha mais que uma perfuração teremos de então de ajustar a leitura obtida ao numero de perfurações, bastando assim dividir o valor tempo pelo numero de perfurações do disco, obtendo assim o valor exacto em RPM.
//Variáveis para o pinos do Arduino de controlo do Motor e leitura do sensor RPM:
int Pino_Sensor_RPM = 7;
//Variável para os cálculos da leitura de RPM:
int Contagem_Pulsos = 0; //Variável para a contagem de pulsos.
int Leitura_RPM; //Variável para o cálculo da velocidade de rotação do motor.
int Disco_Num = 1; //Variável para designação do numero de perfurações do disco do Sensor RPM.
//A rotina de LOOP e executada repetidamente:
void loop() {
//Iniciar a comunicação com a aplicação Blynk:
Blynk.run();
//Contagem do tempo de duração de cada pulso em nível Alto e nível Baixo.
Contagem_Pulsos = (pulseIn(Pino_Sensor_RPM, HIGH) + pulseIn(Pino_Sensor_RPM, LOW));
//Contagem de numero de pulsos por segundo (1Seg = 1000000µSeg).
Leitura_RPM = 1000000/Contagem_Pulsos;
//Converte rotações por segundo (RPS) em rotações por minuto (RPM):
Leitura_RPM = Leitura_RPM * 60;
//Ajustar a leitura ao numero de perfurações do disco do sensor;
Leitura_RPM = Leitura_RPM / Disco_Num;
//Condição para que quando o motor está parado o valor seja 0 "zero":
if (Leitura_RPM < 0){
Leitura_RPM = 0;
}
else {
Leitura_RPM = Leitura_RPM;
}
//Escreve na legenda o valor de RPM calculado:
Blynk.virtualWrite(V2, Leitura_RPM);
//Atraso para o próximo passo.
delay(10);
}Bem o nosso tutorial já vai um pouco longo e para que possam programar o vosso Arduino mais facilmente basta copiarem o código completo fornecido onde apenas terão de configurar o tipo de placa de Arduino que estão a utilizar e a porta a que este está ligado (Ver ficheiro abaixo).
Para saber mais ou caso tenham dúvidas sobre estas e outras referências no código, vejam a sua explicação detalhada no site oficial do Arduino, através da ligação https://www.arduino.cc/en/Reference/HomePage e no site oficial do aplicação Blynk, através da ligação https://blynk.io/en/getting-started.
Procurem os nossos tutoriais acerca do Arduino, onde explicamos diversas montagens como também o funcionamento dos seus módulo e já agora visitem o nosso canal no Youtube, Instagram, Facebook ou Twitter.
Um grande abraço e bons projectos.