Software Timer - ESP8266
Software Timer
Em várias situações, é necessário de certa forma, a manipulação do tempo em micro controladores. O jeito mais fácil é pelas funções básicas (delay e derivados), porém, normalmente, estas funções travam o micro controlador, e com isto, você é incapaz de ler botões ou algo do tipo enquanto o delay não acabar. Isto além de gerar terríveis problemas nos mais variados projetos, não é uma pratica saudável. Neste tutorial, vamos aprender sobre o OS_TIMER do ESP8266, este timer é baseado no software do ESP8266 e o limite inferior é 1mS e máximo de ~2 horas. Este software timer não é aconselhado para projetos em que o tempo é crítico. Apesar de nossos testes darem certa confiança, por ele ser baseado em software, alguns fatores podem atrasa-lo em alguns mS, tome cuidado.
Demonstrando a diferença
Neste exemplo apenas para comparação do Software Timer, usaremos um exemplo que acende 3 LEDs a cada 1 segundo e enquanto isso, ficaremos enviando dados na Serial para mostrar o funcionamento do código. Antes de ir para o software timer, testem este código abaixo no ESP8266 e veja no Serial Monitor como é o recebimento de informações.
Neste código, estamos usando Delay para fazer o acionamento simples dos LEDs. Você perceberá que só irá aparecer mensagens a cada 4 Segundos.
long x;//Variavel para mostrar o desenvolvimento do codigo no Serial Monitor.
void setup()
{
pinMode(D1, OUTPUT);//Define D1 como Saida.
pinMode(D2, OUTPUT);//Define D2 como Saida.
pinMode(D3, OUTPUT);//Define D3 como Saida.
Serial.begin(9600);//Inicia a comunicaçao Serial para provar que o codigo nao trava.
}
void loop()
{
led();//Sub rotina para acender os LED`s.
Serial.println(x++);//Mostra no serial monitor o desenvolvimento do codigo.
}
void led()//Sub rotina para acender os LED`s.
{
digitalWrite(D1, 1);//Acende o led 1.
delay(1000);//Aguarda 1 segundo.
digitalWrite(D2, 1);//Acende o led 2.
delay(1000);//Aguarda 1 segundo.
digitalWrite(D3, 1);//Acende o led 3.
delay(1000);//Aguarda 1 segundo.
digitalWrite(D1, 0);//-
digitalWrite(D2, 0);//-
digitalWrite(D3, 0);//-Apaga os 3 leds.
delay(1000);//Aguarda 1 segundo.
}
Após ver que o ESP só pula para a linha debaixo da função led() a cada 4 segundos, percebe-se que o ESP fica travado durante 4 segundos apenas para acender os LEDs, inutilizando totalmente o seu uso para outras coisas.
Agora chega de papo e vamos ao Software Timer.
Normalmente, na maioria dos casos, as funções de delay travam o código até que o delay se acabe. Ao usar delay(60000), o micro controlador ficará travado por 1 Minuto nesta linha até que o tempo acabe e não fara mais nada. Se desejarmos acender um LED a cada 30 segundos, isto irá gerar muitos problemas usando delay, então, usaremos os Timer’s. O Timer gera uma interrupção no sistema a cada intervalo de tempo e voltara a fazer a sua rotina padrão após terminar suas instruções.
Lembre-se, A rotina de um timer (Interrupção) não pode conter comandos de Delay, Serial e vários outros. A rotina do ISR deve ser a mais breve possível e normalmente usamos flag’s armazenadas na RAM para agilizar o processo e evitar erros internos.
Mãos à obra
Componentes necessários
- 1 – ESP8266 (Usaremos o NodeMCU).
- 3 – LED's.
- 3 - Resistores de 220 Ω.
- Fios Jumpers.
Montando o projeto
Veja como ficou nossa montagem:
Código do projeto
#include <user_interface.h>;//Biblioteca necessaria para acessar os Timer`s.
os_timer_t tmr0;//Cria o Timer. Maximo de 7 Timer's.
volatile byte status;//Variavel armazenada na RAM para Status do LED.
long x;//Variavel para mostrar o funcionamento do Codigo.
void setup()
{
os_timer_setfn(&tmr0, led, NULL); //Indica ao Timer qual sera sua Sub rotina.
os_timer_arm(&tmr0, 1000, true); //Inidica ao Timer seu Tempo em mS e se sera repetido ou apenas uma vez (loop = true)
//Neste caso, queremos que o processo seja repetido, entao usaremos TRUE.
pinMode(D1, OUTPUT);//Define D1 como Saida.
pinMode(D2, OUTPUT);//Define D2 como Saida.
pinMode(D3, OUTPUT);//Define D3 como Saida.
Serial.begin(9600);//Inicia a comunicaçao Serial.
}
void loop()
{
leitura();//Sub rotina para processar os LED`s.
//O codigo irá funcionar normalmente sem que haja delays e acendendo os LED`s no intervalo definido.
//Para demonstraçao, abra o Serial monitor e voce vera que o codigo continua normalmente.
Serial.println(x++);//Print para provar que o codigo nao trava. Abra o Serial monitor e veja
//que o codigo continua rodando enquanto os LED`s piscam a cada 1 Segundo.
}
void leitura()//Sub rotina para processar os LED`s.
{
switch (status)
{
case(1)://Caso status seja 1, acenda o led 1.
digitalWrite(D1, 1);
break;
case(2)://Caso status seja 2, acenda o led 2.
digitalWrite(D2, 1);
break;
case(3)://Caso status seja 3, acenda o led 3.
digitalWrite(D3, 1);
break;
case(4)://Caso status seja 4, Apague os 3 LED`s.
digitalWrite(D1, 0);
digitalWrite(D2, 0);
digitalWrite(D3, 0);
break;
}
}
void led(void*z)//Sub rotina ISR do Timer sera acessada a cada 1 Segundo e mudara o status do LED.
{
if (status == 4)//Verifica se o maximo foi alcançado para resetar a contagem.
{
status = 0;
}
status++;
}
Entendendo a fundo
Hardware
As ligações são simples, apenas sendo necessário ligar o pino de cada LED em sua correspondente porta, não esquecendo o uso de resistores para limitar a corrente/tensão e também não queimar o LED. O outro pino do LED no GND. Este é o básico para um LED funcionar.
Software
-Função os_timer_setfn()
os_timer_setfn(&tmr0, led, NULL);
Esta função atribui uma função sua à rotina do Timer. Neste caso, definimos a nossa função led() ao timer tmr0, que criamos anteriormente.
-Função os_timer_arm()
os_timer_arm(&tmr0, 1000, true);
Com esta outra, é definido o tempo do timer e também se irá se repetir (loop). Neste caso, definimos ao timer tmr0, que entre na função anteriormente atribuída, a cada 1000mS. Se você não precisa que isso seja repetido, troque true por false, desativando o loop.
Finalizando
Comparando os dois códigos, podemos perceber claramente a diferença entre fazer tarefas com um Timer ou Delay. Enquanto o primeiro código só mostra a mensagem a cada 4 Segundos, o segundo mostra a mensagem diversas vezes ao mesmo tempo que gerencia os LEDs. Você pode usar isso em vários projetos em que é preciso fazer tarefas em tempos definidos, sem travar o resto do sistema com Delay. Dúvidas? Sugestões? Críticas? Comente abaixo!
Registrador de deslocamento
Registrador de deslocamento
Neste tutorial, você irá aprender a aumentar o número de portas do seu micro controlador (MCU) usando um registrador de deslocamento 74HC595 (Shift Register). Funciona com qualquer MCU: ATtiny85, Arduino, PIC, ESP8266, ESP32, Raspberry, Onion, etc. Usaremos neste tutorial um ATtiny85 para controlar 8 LEDs apenas com 3 pinos do MCU!
O que são?
Dentro de um registrador de deslocamento há diversos Flip-Flops interligados que de tal forma, consegue converter sinais de um tipo para outro (Serial-Paralelo/Paralelo-Serial) ou até mesmo para expansão de portas de um micro controlador.
Usaremos o 74HC595, um registrador de deslocamento Serial-Paralelo de 8bits, isto significa, que cada registrador irá controlar até 8 componentes. Também é possível liga-los em modo cascata, um após o outro. Com isto, podemos ligar diversos registradores e usando apenas 3 pinos, controlar 40, 80, 160 componentes e assim por diante. Este registrador tem apenas pinos de saída, caso seja necessário leitura de botões (input de dados), procure por outros, existem até alguns com comunicação I2C!
Para mais informações sobre registradores de deslocamento, clique AQUI.
As aplicações para um registrador de deslocamento são bem variadas, pode tanto fazer a conversão de dados Seriais para Paralelo, Paralelo para Serial, ou quando é necessário mais pinos para nosso MCU. Com 5 registradores de deslocamento de 8 bits em cascata, usamos 3 pinos do MCU para controlar até 40 componentes! Perfeito para matrizes de LED 3D ou robôs com vários atuadores.
Mãos à obra
Componente necessários
Para este tutorial, usaremos um ATtiny85, mas você pode usar qualquer MCU.
Montando o projeto
Agora vamos conectar os componentes do projeto. Monte seu circuito conforme a figura a seguir. Não se esqueça de ler a explicação do hardware logo abaixo.
Veja como ficou o nosso:
Código do projeto
/*
Pino 0 = Clock.
Pino 1 = Latch.
Pino 2 = Serial IN.
*/
void setup()
{
for (byte i = 0; i < 3; i++)//Declaração dos pinos de saida.
{
pinMode(i, OUTPUT);
}
int x = 1;
for (byte i = 0; i < 8; i++)//Ligamos um LED após o outro, permanecendo o estado do anterior.
{
s595(x);//Função que faz o gerencimento do registrador.
x = (x * 2) + 1;//Conta binaria que faz BitShift: 0b001 -> 0b011 -> 0b111...
delay(150);
}
}
void loop()
{
s595(random(0, 256));
delay(500);
}
void s595(byte data)//O argumento para acender os LEDs pode ser em binario
{
digitalWrite(1, LOW);//Fecha o Latch para input de dados.
shiftOut(2, 0, LSBFIRST, data);//Função própria da Arduino IDE.
digitalWrite(1, HIGH);//Abre o Latch para output dos dados.
}
Entendendo a fundo
Software
-Função s595()
void s595(byte data)
{
digitalWrite(1, LOW);//Fecha o Latch para input de dados.
shiftOut(2, 0, LSBFIRST, data);//Função própria da Arduino IDE.
digitalWrite(1, HIGH);//Abre o Latch para output dos dados.
}
Esta função criada faz todo o gerenciamento do registrador de deslocamento.
Primeiramente fechamos o Latch para a entrada de novos valores, após a entrada dos valores pelo shiftOut(), abrimos o Latch para que as saídas sejam iguais ao dados que definimos com a entrada anterior.
Para entender melhor sobre a função shiftOut(), clique AQUI.
O legal desta função é que podemos usar diretamente binário para representar os LEDs, por exemplo:
s595(0b11001100);
Com isto, os LEDs serão idênticos ao binário, respectivamente Q0 -> Q7. As saídas Q0, Q1, Q4 e Q5 estarão em HIGH e o restante em LOW.
Hardware
Pinos necessários para o registrador funcionar. Adicione MR ao Vcc e OE ao GND.
O nosso registrador de deslocamento usado, tem 3 pinos básicos: Serial data IN, Latch e Clock.
- Serial data IN: Aqui é adicionado os bit's para futuramente após o latch, virarem output.
- Output Enable (OE): Ativo em LOW.
- Latch: O latch funciona como se fosse um portão. quando em HIGH, o portão se abre, liberando os bit's que adicionamos anteriormente.
- Clock: O clock deve ser oscilado a cada bit de entrada, para que sejam armazenados corretamente.
- Master Reclear (MR): Ativo em LOW.
- Q7': Este pino é usado para a ligação em cascata de mais registradores de deslocamento.
- Q0 a Q7: São as saídas do registrador, use elas normalmente como se fossem pinos de saída, obedecendo os limites de tensão e corrente.
A figura abaixo mostra o efeito do Serial+Clock
Após a conclusão da entrada de dados, ao abrir o Latch, os pinos marcados com 1, ficarão em HIGH, e pinos com 0, em LOW. Então se usarmos "0b10010011", as saídas (Q0 até Q7) ficarão respectivamente: 1, 0, 0, 1, 0, 0, 1, 1.
Desafio
Primeiramente, veja qual LED acende com s595(0b10000000); e depois dentro da função s595(), troque "LSBFIRST" para "MSBFIRST", veja qual LED acende e nos conte porque isto acontece!
Finalizando
Em alguns projetos, como matrizes de LED 3D, é necessário o uso de MUX e registradores de deslocamento, uma vez que nosso MCU não tem pinos suficientes para fazer o controle de cada componente. Com este simples e eficiente componente, podemos controlar diversos outros com poucos pinos do MCU, deixando os outros pinos do MCU livres para tarefas mais complicadas.
Leitura da velocidade de ventoinha em RPM
O que vamos aprender?
Aprenderemos a ler as rotações por minuto (RPM) de uma ventoinha (Fan) com 3 fios. Usaremos o Arduino, mas pode ser feito com qualquer MCU.
Leitura de RPM
As ventoinhas com 3 ou 4 fios, tem embutido, um sensor Hall que detecta a variação do campo magnético gerado pela rotação da ventoinha. A maioria das ventoinhas tem dois pólos magnéticos, que quando rotacionado, aciona o Hall e conseguimos efetuar a leitura das rotações.
Como pode ser visto na Figura 1, após uma volta, o Hall ativou a saída duas vezes. Logo, precisamos dividir a contagem das rotações por 2 para se chegar em uma volta completa.
A leitura de RPM pode ser extremamente útil em casos em que é preciso controle da velocidade ou fluxo de vento em um determinado local, ou até mesmo determinar se a ventoinha esta funcionando corretamente, caso não, o sistema irá detectar e ativar um alarme, já que pode gerar super aquecimentos e até pegar fogo em componentes!
Mãos à obra
Componentes necessários
Montando o projeto
Faça as ligações simples e coloque o terceiro fio (normalmente amarelo ou branco) ao pino 2 do Arduino! Lembre-se da tensão e corrente de sua ventoinha, a usada no o tutorial é suficiente para o Arduino suprir, caso a sua seja "mais forte", será necessário uma fonte externa e divisores de tensão no 3 pino. Ficará parecido com o nosso:
Código do projeto
volatile uint32_t rpm;//Váriavel que armazena as rotações.
void setup()
{
Serial.begin(115200);//Inicia a Serial.
attachInterrupt(0, ctt, RISING);//Habilita a interrupção 0 no pino 2.
}
void loop()
{
delay(1000);//Aguarda um segundo.
Serial.println(rpm * 30);//Mostra o RPM.
rpm = 0;//Reseta a váriavel para proxima leitura.
//Como estamos lendo a cada UM segundo, usariamos RPM*60 para determinar as rotações por minuto,
//porém, como foi dito na explicação, é preciso dividir o valor por 2, por isto 30!
}
void ctt()
{
rpm++;//Incrementa a váriavel.
}
Colocando para funcionar
De acordo com o datasheet da ventoinha aqui testada, era de se esperar cerca de 13000 RPM (Fig 3). Após analisar com o Arduino, o valor variou entre 12000-15000 RPM (Fig 4), mostrando que esta correto!
Figura 3 - Datasheet
Entendendo a fundo
Software
-Função attachInterrupt()
attachInterrupt(0, ctt, RISING);
É configurado uma rotina de interrupção para a leitura dos pulsos altos gerados pela ventoinha. Foi usado a interrupção 0, que está ligada ao pino 2 do Arduino Uno.
-Mostrando os valores
Serial.println(rpm * 30);
Aqui esta a grande jogada da leitura. É feito a cada 1 segundo, a leitura da variável RPM, que foi modificada pela interrupção da ventoinha. Para converter as rotações por segundo, para rotações por minuto, é necessário multiplicar por 60, já que 1 minuto tem 60 segundos.
Entretanto, no inicio do tutorial, foi mostrado que deve-se dividir por 2 para chegar a uma rotação completa, por isso usamos 30!
-Resetando a variável
rpm = 0;
Após a leitura dos pulsos, é necessário resetar a variável, se não, irá interferir nas contas futuras.
Fechamento
Em vários cenários é necessário conhecer sobre o funcionamento de uma ventoinha, que caso venha a falhar, pode gerar terríveis danos ao sistema. Então, aprender a ler a RPM da ventoinha pode ser uma ótima maneira de descobrir se esta tudo correto. Dúvidas? Sugestões? Críticas? Comente abaixo!
Segurança de dados com AES
Segurança de dados
A segurança é algo essêncial em muitos projetos, principalmente nos conectados à Internet. Desde esconder senhas ou mensagens para que ninguém além do destino possa ler, a segurança faz parte do nosso cotidiano e iremos aprender a implementa-la nos Microcontroladores. Aprenderemos usar a criptografia AES (Advanced Encryption Standard) com foco em apenas sobre sigilo do dado, o download dela estará ao fim do tutorial. Esta biblioteca para criptografia com AES, funciona tanto para Arduino, quanto para ESP8266 ou ESP32.
Um pouco sobre segurança
Antes de entrar em detalhes sobre o AES, um resumo sobre a segurança de dados.
-Codificação
A codificação é possivelmente o método mais simples e antigo, trata-se da troca de uma linguagem, para outro padrão. É necessário conhecer os caracteres codificados para poder decodificar. O objetivo da codificação não é tornar a mensagem secreta. Exemplo: Morse(Fig 1), que converte os caracteres para pulsos elétricos, sons, luzes, etc.
-Criptografia simétrica
A criptografia simétrica faz o uso de uma chave privada que deve ser mantida em segredo, já que é usada tanto para encriptação, quanto para desencriptação. Esta é mais simples e leve que a criptografia assimétrica. Exemplo: AES, DES.
-Criptografia assimétrica
A criptografia assimétrica faz o uso de duas chaves, uma pública e outra privada. A pública pode ser usada para encriptação e a privada para desencriptação. Esta é mais pesada e lenta. Exemplo: RSA.
O uso delas é bem diferente e logo, a comparação direta não faz sentido. Por exemplo, a assimétrica permite autenticidade dos dados e pode garantir que o dado recebido é de uma pessoa autorizada e não de alguém re-enviando o dado.
-Hash
Hash é um algoritmo de uma via, ou seja, é irreversível. É muito usado com senhas da seguinte forma: Primeiramente é gerado um Hash da senha e este, será apenas comparado ao Hash armazenado no destino. Caso os Hash's sejam iguais, logo a senha é igual. Exemplo: MD5, SHA-1.
Clique AQUI para mais informações sobre Hash.
-AES
AES (Advanced Encryption Standard), é uma criptografia de blocos com chave simétrica (cifra de bloco) e será usado AES-128 no exemplo deste tutorial. AES trabalha com o sistema de blocos de 16 Bytes. É possível utilizar valores de entrada menores sem problemas, mas maiores será necessário dividir em blocos de 16B.
Imagine que você use dois micro controladores para transmissão de mensagens (Exemplo: Whatsapp, Facebook...), muito provavelmente você deseja que ninguém consiga ler as mensagens, isto pode ser feito com a encriptação, que irá cifrar (embaralhar) a mensagem e deixa-la ilegível para qualquer pessoa sem a chave, garantindo que apenas as pessoas com a chave, consigam ler.
Também pode ser usada para protocolos de comunicação entre dispositivos Wireless ou Wired, para preservar a integridade do mesmo e evitar "curiosos de plantão".
Mãos à obra
Código do projeto
#include <AES.h>//Biblioteca do AES.
AES aes;//Cria a classe aes.
byte key[16], out[16], inp[32];//Cria arrays (vetores) para a chave, input e output de dados.
const char pass[] = "abc";//Define a chave usada, neste exemplo usamos AES128, então precisa ser <= 16 Bytes.
void setup()
{
Serial.begin(115200);//Habilita a serial.
Serial.println();//Limpa o monitor.
enc128("vida de silicio", 1);//Faz a função de encriptação e retorna o HEX encriptado.
}
void loop()
{
}
void enc128(const char txt[], bool db)//Argumentos: (texto e debug)
{
if (strlen(pass) > 16)//Verifica se a chave tem o tamanho limite de 16 caracteres.
{
if (db == true)
{
Serial.println("Chave para AES128 <= 16 Bytes");
}
return;//Se a chave for maior, irá sair da função.
}
if (strlen(txt) > 16)//Verifica se o texto tem o tamanho limite de 16 caracteres.
{
if (db == true)
{
Serial.println("Frase/numero para AES <= 16 Bytes / bloco");
}
return;//Se o texto for maior, irá sair da função.
}
for (byte i = 0; i < strlen(pass); i++)//Adiciona a chave(pass) na array key.
{
key[i] = pass[i];
}
for (byte i = 0; i < strlen(txt); i++)//Adiciona o texto na array input.
{
inp[i] = txt[i];
}
//Adiciona a chave ao algoritimo.
if (aes.set_key(key, 16) != 0)//Verifica se a chave esta correta, caso nao, sairá da função.
{
if (db == true)
{
Serial.println("Erro ao configurar chave");
}
return;//Sai da função
}
//Faz a encriptação da array INPUT e retorna o HEXA na array OUTPUT.
if (aes.encrypt(inp, out) != 0)//Verifica se a encriptação esta correta, se não, sairá da função.
{
if (db == true)
{
Serial.println("Erro ao encriptar");
}
return;//Sai da função
}
if (db == true)//Se o debug estiver on (1), irá mostrar o HEXA no serial monitor.
{
for (byte i = 0; i < 16; i++)
{
Serial.print(out[i], HEX);
Serial.print(" ");
}
Serial.println();
}
aes.clean();//Limpa a chave e residuos sensiveis da encriptação.
}
Entendendo a fundo
Software
A função que desenvolvemos enc128() torna o uso muito simples, mas você deve estudar mais sobre o AES e a biblioteca usada para entender melhor o funcionamento. Aqui será mostrado apenas a encriptação, mas também é possível fazer a desencriptação da mesma forma, este será o desafio de vocês para aprendizado.
-Variaveis usadas
byte key[16], out[16], inp[32];
Criamos os vetores (Arrays) para alocar a CHAVE e mensagens de INPUT e OUTPUT do buffer AES.
-Definindo a chave
char pass[] = "abc";
Definimos a Key (chave) da nossa criptografia. Deve ter no mínimo 1 caractere, e no máximo 16 (AES 128). 0 < Key <= 16. Aqui usamos "abc", mas é aconselhado o uso de letras e números aleatórios.
Você deve usar chaves grandes e aleatórias. Sem isso, seu sistema estará em grandes riscos. Usamos uma chave simples para fácil entendimento.
-Função enc128()
enc128("vida de silicio", 1);
enc128(texto, debug);
A função criada para encriptação dos dados torna o processo bem fácil. Os parâmetros necessários para ela é o texto que deseja encriptar, e em seguida, o debug, que mostra no serial monitor possíveis erros e por fim, o HEX da encriptação.
O texto para encriptação deve estar entre aspas e ser menor que 17 caracteres (bytes). 0 < texto <= 16.
O debug é ativado com 1 e desativado com 0, aconselhamos a sempre usar 1 para caso aconteça erros.
-Função AES::set_key()
aes.set_key(key, 16);
Com esta função, é adicionado a nossa chave ao sistema de criptografia interno.
Obs: A chave para AES é 128/192/256b, porém, para ser didático, foi usado apenas 3 caracteres. Tome cuidado ao usar chaves de outros tamanhos, alguns lugares não aceitam!
-Função AES::encrypt()
aes.encrypt(inp, out);
Esta função, faz a encriptação dos dados que estão dentro do vetor INP, e retorna os valores dentro do vetor OUT.
Colocando para funcionar
Ao testar o código que foi mostrado aqui, será gerado exatamente este código em hexadecimal "4A 38 3A 94 FC FB C4 C6 E1 4F D2 5D 34 7B B5 80", este código hexadecimal é a nossa mensagem encriptada. Encontrei um site bem legal que faz a encriptação e desencriptação dos dados AES, usarei ele.
Coloquei a nossa chave "abc" e o código hexadecimal gerado pelo micro controlador. Após clicar para desencriptar, é mostrado a mensagem original, e como podemos ver, funcionou.
o AES permite vários métodos de encriptação, a mais simples é a ECB, a biblioteca usada no tutorial também permite a CBC que é mais segura, porém mais complicada.
Clique AQUI para ir ao site.
Desafio
O desafio para vocês é que façam a desencriptação de um código hex, estudem sobre o assunto e veja as funções da biblioteca! Vocês podem desencriptar o próprio hex gerado da sua encriptação, ou usar o site indicado anteriormente para obter um hex e ver se a desencriptação funciona. Lembrando que esta biblioteca funciona para Arduino, ESP8266 e ESP32.
Download da biblioteca: https://github.com/spaniakos/AES
Fechamento
A segurança é extremamente importante em IoT e nao deve ser esquecida. Sempre adicione caso seja necessário em seu projeto, e principalmente em produtos comerciais. Tem dúvidas? sugestões? críticas? Comente abaixo!
Controlando seu projeto usando Telegram - ESP
Controlando seu projeto com Telegram
Imagine uma automação ou projeto que permite você “conversar” com seu Microcontrolador (MCU) e também receber comandos, parece difícil, mas é bem simples. Aprenderemos a usar o Telegram para criar automações e projetos das mais diversas possibilidades e utilidades que estabelece uma comunicação amigável com o MCU. Para essa experiência usaremos o NodeMCU 8266, mas você pode fazer com outros ESPs, tal como os da linha ESP8266 e o ESP32.
[toc]
O Telegram
Podemos fazer desde simples controles de LEDs, ou até uma automação residencial controlada pelo Telegram, já que os BOTs permitem controle total de informações.
Usaremos o Telegram pois nos permite criar “BOTs”. Estes BOT's, são como robôs virtuais e com eles, conseguimos criar uma interface IHM (Interface Homem-Máquina). Este método, permite o fluxo de informações de ambos sentidos (Input e Output), então conseguimos controlar o sistema e também ser notificado pelo sistema.
Criando seu Bot no Telegram
1-) Pesquise pelo "BotFather" no menu de pesquisa do Telegram, entre nele e clique em "Começar ou Reiniciar".
2-) Pelo BotFater podemos criar novos Bots, configura-los e muito mais. Para criar, faça:
- Digite "/newbot".
- Digite o nome do seu novo Bot.
- Digite o usuário do Bot com a terminação "bot".
3-) Logo após a criação, o BotFater enviará uma mensagem com o link do Bot e logo abaixo o Token do Bot. Você pode clicar neste link para abrir a conversa com seu Bot ou pode pesquisa-lo futuramente.
Você precisa desse Token para inserir no código!
Mãos a obra
Componentes necessários
Para este projeto, usaremos o ESP8266 (versão NodeMCU). Entretanto, pode ser feito igualmente com o ESP32, sendo necessário alguns pequenos ajustes.
- 1x – ESP8266. (Usaremos o NodeMCU).
- 1x – Telegram no Celular.
- 1x - LED. (Usaremos o LED OnBoard da placa).
- Biblioteca utilizada
Clique AQUI para ir a pagina de download da biblioteca "UniversalTelegramBot" utilizada.
Alguns usuários relatam erro com a biblioteca "ArduinoJson". Caso aconteça com você, será necessário instalar a biblioteca na Arduino IDE.
Para isso vá em "Gerenciador de bibliotecas", procure pela biblioteca "ArduinoJson", instale-a e reinicie a Arduino IDE.
- Código do projeto
Não se esqueça de alterar as credenciais do WiFi e também o Token do seu Bot. Sem isso não irá funcionar.
Vários usuários relatam erro com a versão 2.5 do esp8266 (core) instalado na Arduino IDE, que é resolvido instalando a 2.4.0.
#include <ESP8266WiFi.h>
#include <WiFiClientSecure.h>
#include <UniversalTelegramBot.h>
#define BOTtoken "135924:AAErDKEJaQpEnqs_xj35asdGQ5kK6dQet4"//Define o Token do *seu* BOT
WiFiClientSecure client;
UniversalTelegramBot bot(BOTtoken, client);
String id, text;//Váriaveis para armazenamento do ID e TEXTO gerado pelo Usuario
unsigned long tempo;
void setup()
{
pinMode(D4, OUTPUT);//LED conectado à saida
WiFi.mode(WIFI_STA);//Define o WiFi como Estaçao
connect();//Funçao para Conectar ao WiFi
}
void loop()
{
if (millis() - tempo > 2000)//Faz a verificaçao das funçoes a cada 2 Segundos
{
connect();//Funçao para verificar se ainda há conexao
readTel();//Funçao para ler o telegram
tempo = millis();//Reseta o tempo
}
}
void connect()//Funçao para Conectar ao wifi e verificar à conexao.
{
if (WiFi.status() != WL_CONNECTED)//Caso nao esteja conectado ao WiFi, Ira conectarse
{
WiFi.begin("SUA REDE", "SUA SENHA");//Insira suas informaçoes da rede
delay(2000);
}
}
void readTel()//Funçao que faz a leitura do Telegram.
{
int newmsg = bot.getUpdates(bot.last_message_received + 1);
for (int i = 0; i < newmsg; i++)//Caso haja X mensagens novas, fara este loop X Vezes.
{
id = bot.messages[i].chat_id;//Armazenara o ID do Usuario à Váriavel.
text = bot.messages[i].text;//Armazenara o TEXTO do Usuario à Váriavel.
text.toUpperCase();//Converte a STRING_TEXT inteiramente em Maiuscúla.
if (text.indexOf("ON") > -1)//Caso o texto recebido contenha "ON"
{
digitalWrite(D4, 0);//Liga o LED
bot.sendMessage(id, "LED ON", "");//Envia uma Mensagem para a pessoa que enviou o Comando.
}
else if (text.indexOf("OFF") > -1)//Caso o texto recebido contenha "OFF"
{
digitalWrite(D4, 1);//Desliga o LED
bot.sendMessage(id, "LED OFF", "");//Envia uma Mensagem para a pessoa que enviou o Comando.
}
else if (text.indexOf("START") > -1)//Caso o texto recebido contenha "START"
{
bot.sendSimpleMessage(id, id, "");//Envia uma mensagem com seu ID.
}
else//Caso o texto recebido nao for nenhum dos acima, Envia uma mensagem de erro.
{
bot.sendSimpleMessage(id, "Comando Invalido", "");
}
}
}
Colocando para funcionar
Após a criação do BOT e upload do código, podemos ver funcionando. Veja o BOT respondeu como o esperado aos comandos:
Entendendo a fundo
Software
-Função UniversalTelegramBot::sendMessage()
bot.sendMessage(id, "LED OFF", "");
Com esta função, é feito o envio da mensagem para o determinado ID (referente ao ID de quem enviou a mensagem ao Bot). Logo ao iniciar seu BOT, automaticamente é enviado uma mensagem "/START", e nosso sistema irá responder com o seu ID do Telegram; você pode usar isso para aceitar apenas comandos de seu ID.
-Variável id
id = bot.messages[i].chat_id;
Toda vez que o Bot receber um novo update (mensagem), irá armazenar o ID da pessoa que enviou a mensagem na variável id.
-Variável text
text = bot.messages[i].text;
Toda vez que o Bot receber um novo update (mensagem), irá armazenar o texto na variável text.
A biblioteca do Telegram permite mais opções interessantes, como por exemplo obter o horário em que a mensagem foi enviada ao Bot! Dê uma olhada na referência da biblioteca.
-Função UniversalTelegramBot::getUpdates()
int newmsg = bot.getUpdates(bot.last_message_received + 1);
Esta função faz a verificação de novas mensagens, sempre será lido da última (mais recente), para a primeira (mais antiga) mensagem no buffer do Bot. Isto será feito até que se tenha lido todas as mensagens disponíveis então tome cuidado para não travar ou atrasar o resto do seu código!
Desafio
Qualquer pessoa que adicionar seu Bot (basta pesquisar), pode enviar comandos e controla-lo. Você terá que criar algum tipo de “cadeado” para aceitar apenas comandos de pessoas autorizadas. Cada usuário no Telegram tem um ID, então você pode usar isso à seu favor e fazer o sistema aceitar apenas comandos de algumas pessoas.
Fechamento
Podemos facilmente incluir este controle com o Telegram em diversos projetos, permitindo que o mesmo seja controlado à distancia e até mesmo que você seja notificado, como por exemplo um alarme para sua casa que mande mensagem para seu celular ao detectar movimento. As aplicações são imensas, dependendo apenas da sua criatividade. Dúvidas? Sugestões? Críticas? Comente!
O que é ESP8266 - A Família ESP e o NodeMCU
O que é ESP8266 - A Família ESP e o NodeMCU
Que tal conectar seu projeto à imensidão da internet de forma simples e barata? Essa é a proposta do ESP8266 que têm sido cada vez mais usado em projetos de automação e robótica para conectar as mais diversas ideais à internet. Neste tutorial você irá conhecer a família de microcontroladores ESP8266 que é tendência no mundo dos Makers e nos mais diversos exemplos de Internet das Coisas (IoT), e também aprenderá como funciona a sua programação e dar o primeiro upload. Entre eles: ESP-01 A, ESP-7, ESP-12E e NodeMcu
[toc]
O que é ESP8266?
É possível que você já tenha ouvido falar sobre o ESP8266, ele tem se tornado cada vez mais popular entre projetos de Internet das Coisas!
Os ESP8266's são microcontroladores que já possuem tudo que é necessário para se conectar a Internet. Ou seja, eles são como um Arduino com integração Wi-Fi.
Outro ponto importante é que eles são pequenos e isso viabiliza projetos pequenos.
Um exemplo é o ESP8266-01, esta minúscula placa, também chamado de "Módulo" por alguns, tem um potencial muito maior do que o aparenta, veja algumas especificações:
- CPU: 32bit RISC Tensilica Xtensa LX106 rodando à 80/160 MHz.
- RAM: 64 kB.
- FLASH: QSPI Externo - de 512 kB até 4 MB.
- WiFi: IEEE 802.11 - b/g/n.
Comparando diretamente com o Arduino, o ESP8266 tem um poder de processamento maior, porem há poucas GPIO's para usar nesta versão. Esta versão, conta apenas com 4 GPIO's para uso, sendo que dois são para comunicação Serial.
Para resolver esse problema de pinos insuficientes, existem versões mais robustas do ESP8266, como por exemplo, este ESP8266-12:
Este, é exatamente o mesmo que o anterior, mas conta com mais GPIO's disponíveis para uso geral.
APLICAÇÕES DO ESP8266
O uso para esse Micro controlador beira ao "Infinito", já que conta com poder de processamento e WiFi embutido. Com ele, também é possível ser usado como um "Módulo" com outros Micro controladores, isto pode ser feito através de comandos AT. Além disso, as versões menores, como o 01 ou 09, são muito usados como uma "Ponte Serial-WiFi", já que contam com poucos pinos; sendo assim, é possível receber dados por um aplicativo/WEB e enviar estes dados para um Arduino e acender uma lampada por exemplo! O oposto também é possível, enviar dados do Arduino para um aplicativo ou página WEB.
Algumas aplicações interessantes:
- Automação residencial.
- Rede de sensores.
- Robótica.
- Comunicação Wireless entre MCU's (Micro controller Unit).
- Aplicativos e Paginas WEB para controle geral.
- Monitoramento de Informações remotamente.
- E muito mais.
A Família ESP8266
Apresentaremos as principais características dos dois principais mais vendidos, que são: ESP8266-01 e o ESP8266-12 na versão NodeMCU.
ESP-01
Este pequeno ESP8266-01, conta com poucos pinos para uso geral, porém é muito usado por conta do seu tamanho como a "Ponte Serial-WiFi", segue a explicação dos pinos:
GND: Terra-GND.
Vcc: Alimentação de 3,3V.
RESET: Reset ativo quando em LOW.
CH_PD: Chip enable, deve estar em HIGH para funcionamento do MCU.
RXD: Receive data, usado para receber dados da comunicação de outros MCU's.
TXD: Tansmit data, usado para transmitir dados a outros MCU's.
GPIO0: GPIO (General Purpose Input/Output), este pino é para uso geral, tanto como Entrada/Saída e até Digital/PWM. Deve estar conectado ao GND para novos Upload's (Veja na Fig 4, Boot Modes).
GPIO2: GPIO para uso geral.
Para dar um novo upload à este carinha, você precisa de um conversor Serial (FTDI) para transmitir os dados até ele. As ligações são estas:
Lembrando que a alimentação deve ser feita com 3,3V, inclusive o Rx. Com isto, voce já sera capaz de dar upload de seus códigos.
NodeMCU
Esta versão do ESP8266-12 vem numa placa de desenvolvimento, chama-se de NodeMCU. Esta belezinha conta com conversor Serial e regulador de tensão próprio, não sendo necessário ambos como nas outras versões fora da placa. Também há pinos próprios para I2C, SPI, Analógico e outros.
GPIO's ESP8266:
Esta imagem, mostra todas definições de GPIO's do ESP8266, inclusive durante o boot, em que alguns pinos são mantidos em certos estados.
Mãos à obra
Este projeto é o "Hello world" no mundo de Microcontroladores. Você irá ensinar a dar o primeiro upload para piscar o LED_BUILTIN (LED OnBoard) do ESP8266-01 usando um FTDI externo. Pegue a pipoca e vamos la!
Componentes necessários
- 1 - ESP8266-01 ( ESP-01 A ).
- 1 - Módulo FTDI FT232RL - Conversor USB Serial.
- X - Jumper's.
As ligações ficarão parecidas com esta:
Estas são ligaçoes básicas, porém, para cada novo upload, é necessário colocar o GPIO0 em GND, como foi mostrado no esquema, GPIO0 já esta em GND. Não se esqueça dele sempre que for fazer um novo Upload!
Preparando a IDE Arduino
Usaremos a Arduino IDE, mas você pode programa-lo com LUA, ou até a propria SDK.
1-) Vá em Arquivos>Preferencias, e adicione este link em "URLs Adicionais...": http://arduino.esp8266.com/stable/package_esp8266com_index.json
2-) Vá em Ferramentas>Placa>Gerenciador de placas.
3-) Procure pelo ESP8266 e instale-o.
4-) Após instalar as placas do ESP8266, selecione-a em Ferramentas>Placa>Generic ESP8266 Module. (Estou usando o ESP8266-01, caso voce use por exemplo o NodeMCU, selecione NodeMCU...).
5-) Agora, é só configurar a placa, aconselho a usarem igual ao da foto. Testem primeiramente com o upload a 115200@bps, caso nao funcione, teste com outras velocidades! Não se esqueça de selecionar a porta que estiver seu FTDI.
Sua IDE esta pronta para funcionar com o ESP8266! Vamos ao código!
Código do projeto
void setup()
{
pinMode(LED_BUILTIN, OUTPUT);//Habilita o LED interno como Saida.
}
void loop()
{
digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));//Inverte o estado do LED de acordo com a leitura.
delay(250);
}
Entendendo a fundo
Software
-Função pinMode()
pinMode(LED_BUILTIN, OUTPUT);//Habilita o LED interno como Saida.
Esta função define um pino, como saída ou entrada. Neste caso, definimos o pino do LED_BUILTIN como saída.
-Função digitalWrite() e digitalRead()
digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));//Inverte o estado do LED de acordo com a leitura.
Aqui, estamos escrevendo um sinal lógico ao LED_BUILTIN. Neste caso, usamos a função digitalRead() que retorna o valor atual de um pino (1 para HIGH e 0 para LOW).
Usamos tambem um Inversor (NOT) "!" para inverter o estado de leitura, ou seja, caso o LED esteja ligado (1), invertemos para (0) e escrevemos isso à porta, assim, desligando-a.
-Função delay()
delay(250);
A função delay(), gera um atraso no código, fazendo com que o micro controlador trave naquela linha e fique até acabar o tempo. O tempo deve ser em mS, sendo que 1 Segundo = 1000mS.
De upload do codigo, e veja que o LED OnBoard (Azul) irá piscar a cada 250mS. Não se esqueça que para dar um novo upload, é necessário que o ESP8266 seja reiniciado com o GPIO0 em GND novamente.
Fechamento
Você aprendeu o que é este incrível microcontrolador e também como dar o primeiro upload à ele. Sinta-se à vontade para dar sugestões, críticas ou elogios. Lembre-se de deixar suas dúvidas nos comentários abaixo.
Você vai gostar de Conhecer o ESP32
Driver motor com Ponte H L298N - Controle de Motor DC com Arduino
Driver motor com Ponte H L298N - Controlando Motor DC com Arduino
Se você curte robótica, provavelmente deve estar louco para montar seu próprio robô. A ponte H é uma peça chave quando o assunto é robótica. Neste tutorial você aprenderá como controlar um motor DC usando o Driver motor L298n com um Arduino Uno. Esse tutorial é essencial para quem quer montar seu robô com Arduino.
[toc]
O que é uma Ponte H?
Na maioria das abordagens em robótica faz-se necessária a utilização de motores DC em diversos tipos de locomoção de robôs, movimentação de braços mecânicos, etc. Os motores DC (direct current ou corrente continua) são cargas indutivas que, em geral, demandam uma quantidade de corrente superior à que as portas do Arduino conseguem fornecer.
Sendo assim, não devemos ligar estes motores diretamente nas portas do Arduino pois se o motor demandar uma corrente acima de 40mA nas portas digitais (máxima fornecida pelo Arduino) pode queimar a porta e danificar a placa.
Para solucionar a questão da alta corrente poderíamos usar transistores, porem é importante que seja possível controlar o sentido de giro do motor, função que não se faz possível usando apenas um transistor já que para inverter o sentido de giro devemos inverter a polaridade da alimentação do motor (onde era positivo se põe negativo e vice versa). Um transistor só seria suficiente para ligar e desligar o motor.
Para resolver nosso problema utilizamos um famoso circuito conhecido como Ponte H que nada mais é que um arranjo de 4 transistores. Este circuito é uma elegante solução por ser capaz de acionar simultaneamente dois motores controlando não apenas seus sentidos, como também suas velocidades. Além de seu uso ser simples no Arduino.
Mas como funciona a Ponte H? Porque este nome?
As pontes H em possuem este nome devido ao formato que é montado o circuito, semelhante a letra H. O circuito utiliza quarto chaves (S1, S2, S3 e S4) que são acionadas de forma alternada, ou seja, (S1-S3) ou (S2-S4), veja as figuras abaixo. Dependendo da configuração entre as chaves teremos a corrente percorrendo o motor hora por um sentido, hora por outro.
Quando nenhum par de chaves está acionado, o motor está desligado (a). Quando o par S1-S3 é acionado a corrente percorre S1-S3 fazendo com que o motor gire em um sentido (b). Já quando o par S2-S4 é acionado a corrente percorre por outro caminho fazendo com que o motor gire no sentido contrário (c).
Circuito integrado Ponte H L2398N
O CI L298N é muito utilizado para o propósito de controle de motores, ele nada mais é que uma ponte H em um componente integrado. Uma das vantagens do uso desse CI é o menor espaço ocupado, a baixa complexidade do circuito e o fato de ele já possuir dois circuitos H, podendo assim, controlar dois motores. Na figura a seguir você pode conferir o diagrama de blocos do CI L298N retirado de sua folha de dados (folha de dados L298N) :
As funções dos principais pinos desse CI são descritas na tabela a seguir:
Outra vantagem do L298N é a resposta a sinais de PWM. Se no lugar de usar sinais lógicos TTL for usado sinais de PWM, é possível regular a tensão de saída, e dessa forma regular a velocidade dos motores.
O PWM, Pulse Width Modulation (Modulação por Largura de Pulso), consiste basicamente em aplicar uma onda quadrada de amplitude Vcc e frequência alta no lugar da tensão continua Vcc. Leia mais sobre PWM na postagem Grandezas digitais e analógicas e PWM.
Ao usar um sinal de PWM nas entradas IN1 e IN2, por exemplo, teremos uma tensão de saída nos pinos OUT1 e OUT2 em PWM que será igual à Duty Cycle*Vcc. Dessa forma, podemos regular a diferença de potencial média aplicada nos motores, controlando as suas velocidades.
Existem outras opções de CI's de ponte H no mercado, é importante consultar as especificações deles em suas folhas de dados(Datasheet) para saber qual irá lhe atender melhor. Veja algumas opções de ponte H:
- L293D Folha de Dados;
- LMD18200 Folha de dados.
Módulos Driver motor com Ponte H
Esses módulos são muito utilizados em aplicações de robótica. Esses módulos possuem dimensões pequenas e já possuem o circuito básico para o uso do CI, o que facilita na acomodação do módulo no robô ou em outros projetos e a sua utilização.
Existem varias opções disponíveis no mercado, com tamanhos e especificações diferentes. Algumas especificações são importantes ao escolher seu módulo, são elas:
- Especificação de potência máxima fornecida;
- Tensão máxima suportada;
- Corrente máxima suportada;
- Tensão lógica.
Um exemplo desses módulos é o oferecido em nossa loja, sua características são:
- Ci L298N;
- Tensão para os motores: 5 – 35V;
- Corrente máxima para os motores: 2A;
- Potencia máxima: 25W;
- Tensão lógica: 5V;
- Corrente lógica: 0-36mA;
- Dimensões: 43x43x27 mm
- Peso: 30g.
Módulo Driver motor com Ponte H L298N
Agora que já sabemos como a Ponte H funciona, vamos entender na prática como podemos usá-las em conjunto com o Arduino. Para isso iremos usar o Driver motor com Ponte H L298N.
Entradas e saídas
Para começa vamos entender função de cada pino bem como deve ser utilizado.
Motor A e Motor B: Conectores para os dois motores
-
- 6-35V: Porta para alimentação da placa com tensão entre 6 a 35V.
-
- Ativa 5V: Quando jumpeado, a placa utilizará o regulador de tensão integrado para fornecer 5v (na porta 5v) quando a porta 6-35V estiver sendo alimentada por uma tensão entre 6 e 35V. Neste caso, não se deve alimentar a porta 5V pois pode danificar os componentes. A tensão fornecida na porta 5V pode ser usada para alimentar o Arduino, por exemplo.
-
- 5v: Em casos de não haver fonte de alimentação com mais de 6V podemos alimentar a placa com 5V por esta porta.
-
- Ativa MA: Quando jumpeado aciona o motor A com velocidade máxima. Para controlar a velocidade do motor A basta remover o jumper e alimentar o pino com uma tensão entre 0 e 5v, onde 0V é a velocidade mínima (parado) e 5V a velocidade máxima.
-
- Ativa MB: Quando jumpeado aciona o motor B com velocidade máxima. Para controlar a velocidade do motor B basta remover o jumper e alimentar o pino com uma tensão entre 0 e 5v, onde 0V é a velocidade mínima (parado) e 5V a velocidade máxima.
-
- IN1 e IN2:são utilizados para controlar o sentido do motor A;
- IN3 e IN4: são utilizados para controlar o sentido do motor B;
Veja que agora, no lugar das chaves S1-S3 e S2-S4 temos os pinos IN1 e IN2. Onde IN1 corresponde às chaves S1-S3 e a IN2 às chaves S3-S4.
Para controlar o sentido, temos as seguintes combinações para o motor A(IN1 e IN2)
Para o motor B (IN3 e IN4), a tabela funciona da mesma forma.
Mãos à obra – Driver motor com Ponte H L298N - Controlando Motores com Arduino
Vamos fazer um exemplo para testar na pratica a ponte h. Neste primeiro exercício queremos testar o controle do sentido de giro dos motores A e B através do Arduino.
Componentes necessários
Para este exemplo, utilizaremos:
- Placa Arduino UNO ou similar
- Ponte H L298N - driver motor
- 2x Motores DC (pode ser feito com apenas 1)
- Fonte alimentação de 12V ou Fonte alimentação de 9V
Montando o projeto
Prossiga com a montagem conforme esquema abaixo. Caso você use apenas um motor, basta desconsiderar o motor B:
Garanta que seu Arduino e a fonte externa estejam desligados durante a montagem.
Conectando o Arduino ao computador
Conecte seu Arduino ao computador e abra a IDE Arduino.
Antes de carregar um programa, você precisa selecionar qual porta você deseja usar para fazer carregar o programa no Arduino (upload). Dentro do Arduino IDE, clique no menu Ferramentas (tools) e abra o submenu Porta(Port). Clique na porta que seu Arduino está conectado, tal como COM3 ou COM4. Geralmente aparece o nome da placa Arduino : “COM3 (Arduino/Genuino Uno)”.
Você também precisa garantir que o tipo de placa apropriado está selecionado em Ferramentas(Tools) no submenu Placa (Board).
Programando
Crie um programa (sketch) e salve com o nome de “exemplo1_ponteh”.
Em seguida, insira nele o código conforme escrito abaixo:
/*Pinagem do arduino*/
//motor_A
int IN1 = 2 ;
int IN2 = 3 ;
//motor_B
int IN3 = 4 ;
int IN4 = 5 ;
//Inicializa Pinos
void setup(){
pinMode(IN1,OUTPUT);
pinMode(IN2,OUTPUT);
pinMode(IN3,OUTPUT);
pinMode(IN4,OUTPUT);
}
void loop(){
/*Inicio dos Estados do motor A*/
//Sentido 1
digitalWrite(IN1,LOW);
digitalWrite(IN2,HIGH);
delay(5000);
//Freia Motor_A
digitalWrite(IN1,HIGH);
digitalWrite(IN2,HIGH);
delay(5000);
//Sentido 2
digitalWrite(IN1,HIGH);
digitalWrite(IN2,LOW);
delay(5000);
//Freia Motor_A
digitalWrite(IN1,HIGH);
digitalWrite(IN2,HIGH);
delay(5000);
/*Fim dos Estados do motor A*/
/*Inicio dos Estados do motor B*/
//Sentido 1
digitalWrite(IN3,LOW);
digitalWrite(IN4,HIGH);
delay(5000);
//Freia Motor_B
digitalWrite(IN3,HIGH);
digitalWrite(IN4,HIGH);
delay(5000);
//Sentido 2
digitalWrite(IN3,HIGH);
digitalWrite(IN4,LOW);
delay(5000);
//Freia Motor_B
digitalWrite(IN3,HIGH);
digitalWrite(IN4,HIGH);
delay(5000);
/*Fim dos Estados do motor_B*/
}
Após escrever o código, clique em Carregar (Upload) para que o programa seja transferido para seu Arduino.
Colocando para funcionar
Se tudo deu certo, teremos o motores fazendo os seguintes movimentos:
- Motor A gira em um sentido
- Motor A freia
- Motor A gira no sentido contrario
- Motor A freia
- Motor B gira em um sentido
- Motor B freia
- Motor B gira no sentido contrario
- Motor B freia
Entendendo a fundo
Entendendo o Software
Primeiro definimos os pinos que estão conectados à ponte H para controle de cada motor.
//motor_A int IN1 = 2 ; int IN2 = 4 ; //motor_B int IN3 = 6 ; int IN4 = 7 ;
Veja que temos 2 pinos para cada moto para controle de sentido de giro.
Movimentando o motor
Para fazer o motor se movimentar, primeiro temos que informar para que direção ele deve girar:
//Motor_A //Sentido 1 digitalWrite(IN1,LOW); //0V digitalWrite(IN2,HIGH); //5V
Para controlar o sentido, temos as seguintes combinações para o motor A(IN1 e IN2)
É importante ter em mente essas combinações:
//Sentido 1 digitalWrite(IN1,LOW); //0V digitalWrite(IN2,HIGH); //5V //Freia Motor_A digitalWrite(IN1,HIGH); //5V digitalWrite(IN2,HIGH); //5V //Sentido 2 digitalWrite(IN1,HIGH); //5V digitalWrite(IN2,LOW); //0V
Fechamento
Que tal agora aprender a controlar a velocidade de um motor DC usando um módulo de Ponte H?
Esperamos que tenham gostado, deixe seu comentário com duvidas, sugestões ou com a foto ou vídeo de seu projeto!! Compartilhe à vontade.
Referências Bibliográficas
[1] Guimarães, F. A. Desenvolvimento de Robô Móvel Utilizando para a Exploração de Ambientes Hostis – Dissertação de Mestrado em Engenharia de Processos Químicos e Bioquímicos, Escola de Engenharia Mauá do Centro Universitário do Instituto Mauá de Tecnologia, São Caetano do Sul, SP, Brasil, 2007.
Editado por Allan Mota e revisado por Ícaro Lobo
