Nesse projeto, que faz parte da elaboração de um kit didático dedicado para práticas em laboratório, o objetivo da proposta contava com uma situação de funcionamento em que, os motores de passo Nema 17 fossem todos acionados simultaneamente, que pudessem sofrer paradas independentes e contassem com uma redução de velocidade que pudesse ser acionada a qualquer momento.
Desafio aceito e finalmente depois de alguns dias ficou pronto e funcionando conforme a necessidade!
Nas figuras a seguir é possível visualizar o projeto finalizado.
Fonte: próprio autor
Fonte: próprio autor
Fonte: próprio autor
Fonte: próprio autor
Fonte: próprio autor
Fonte: próprio autor
O vídeo apresentado na sequência demonstra o funcionamento dos motores, as paradas independentes e a redução de suas velocidades.
O
LED RGB proporciona um acionamento onde pode-se conseguir por meio das diferentes
tensões de alimentação, trabalhar com as cores primarias, vermelha, verde e
azul.
Com
a plataforma Arduino é possível além de conseguir as cores primarias, variar a
intensidade de cada uma para conseguir tonalidades variantes para a aquisição
de outras cores.
Nesse tutorial vamos realizar uma demonstração com projetos onde é possível adquirir o controle das cores desse componente de forma que venha a atender uma necessidade conforme o usuário desejar.
Vamos conhecer um pouco das características desse componente. O LED
RGB possui características físicas que devem ser consideradas. Cada terminal
possui um tamanho, onde o terminal mais longo pode atender a característica
comum para seu funcionamento (o usuário adquire conforme sua necessidade, anodo
comum ou catodo comum).
Características do componente
Projeto 1: Variando as cores com o Arduino
Para esse primeiro projeto, o usuário deve ter em mãos:
Placa microcontrolada Arduino (UNO ou similar)
Resistores 330Ω
LED RGB (catodo comum)
Cabos jumpers
Protoboard
Circuito 1:
fonte: próprio autor
Código 1:
/*
* CORES DO LED RGB
*/
int redpin=9; //Pin 9
int greenpin=10; //Pin 10
int bluepin=11; //Pin 11
int var=0;
int var1=0;
void setup(){
}
void loop(){
for(var=250;var<255;var++){
analogWrite(redpin,var); //RED
analogWrite(greenpin,0);
delay(500);
analogWrite(redpin,0); //GREEN
analogWrite(greenpin,var);
delay(500);
analogWrite(greenpin,0); //BLUE
analogWrite(bluepin,var);
delay(500);
analogWrite(bluepin,0);
delay(500);
}
for(var1=250;var1<255;var1++){
analogWrite(redpin,var1); //YELLOW
analogWrite(greenpin,var1);
delay(500);
analogWrite(redpin,0);
delay(500);
analogWrite(greenpin,var1); //CYAN
analogWrite(bluepin,var1);
delay(500);
analogWrite(greenpin,0);
delay(500);
analogWrite(bluepin,var1); //MAGENTA
analogWrite(redpin,var1);
delay(500);
analogWrite(bluepin,0);
delay(500);
analogWrite(bluepin,var1);
analogWrite(redpin,var1);
analogWrite(greenpin,var1);
}
}
Projeto 2: Variando
as cores do LED RGB com potenciômetro
Componentes:
Placa microcontrolada Arduino (UNO ou similar)
Resistores 330Ω
Resistores 10 KΩ
Botões de pressão
Potenciômetro 10 KΩ
LED RGB (catodo comum)
Cabos jumpers
Protoboard
Circuito 2:
fonte: próprio autor
Código 2:
/*
* VARIANDO CORES DO LED RGB COM O POTENCIÔMETRO
*/
// Define as conexões para cada cor do RGB
const int R = 11;
const int G = 9;
const int B = 10;
// Armazena os valores para cada cor entre (0-255)
int ValorR = 255;
int ValorG;
int ValorB;
// Define as conexões dos botões seletores
const int botR = 2;
const int botG = 4;
const int botB = 7;
// Define a conexão do potenciômetro
const int pot = A1;
void setup()
{
// Define Monitor Serial (visualização de dados)
Serial.begin(9600); // taxa de comunicação entre Arduino e PC
// Indica que os pinos dos botões são de SAÍDA do Arduino
pinMode(R, OUTPUT);
pinMode(G, OUTPUT);
pinMode(B, OUTPUT);
// Indica que os pinos são ENTRADA do Arduino
pinMode(botR, INPUT);
pinMode(botG, INPUT);
pinMode(botB, INPUT);
pinMode(pot, INPUT);
}
void loop()
{
//Verifica se os botões seletores estão acionados
while (digitalRead(botR) == HIGH) // enquanto o botão R estiver acionado
{
ValorR = map(analogRead(pot),0,1023,0,255);
analogWrite(R,ValorR);
analogWrite(G,0);
analogWrite(B,0);
// Chama a função para mostrar na tela
monitorSerial();
}
while (digitalRead(botG) == HIGH) // enquanto o botão G estiver acionado
{
ValorG = map(analogRead(pot),0,1023,0,255);
analogWrite(R,0);
analogWrite(G,ValorG);
analogWrite(B,0);
// Chama a função para mostrar na tela
monitorSerial();
}
while (digitalRead(botB) == HIGH)// enquanto o botão G estiver acionado
{
ValorB = map(analogRead(pot),0,1023,0,255);
analogWrite(R,0);
analogWrite(G,0);
analogWrite(B,ValorB);
// Chama a função para mostrar na tela
monitorSerial();
}
// Atualiza o led RGB com a cor da mistura
analogWrite(R, ValorR);
analogWrite(G, ValorG);
analogWrite(B, ValorB);
}
void monitorSerial()
{
//mostra os valores no PC - Monitor Serial valor do potenciômetro
Serial.print("R = ");
Serial.print(ValorR);
Serial.print(" | G= ");
Serial.print(ValorG);
Serial.print(" | B= ");
Serial.println(ValorB);
delay(50);
}
Projeto 3: Variando as cores do LED RGB com Bluetooth
Deixando o projeto um pouco mais interessante, no próximo código, vamos fazer um acionamento remoto das cores do LED RGB, por meio de um aplicativo do celular. Para que isso possa ocorrer, é necessário instalar o aplicativo "RGB Led Control", que pode ser encontrado por esse LINK da Playstore.
fonte: Google play
Componentes:
Placa microcontrolada Arduino (UNO ou similar) Módulo Bluetooth HC-05 ou HC-06
LED RGB (catodo comum)
Cabos jumpers
Protoboard
Circuito 3:
fonte: próprio autor
Código 3:
//Baseado no original de vandenbrande
#include <SoftwareSerial.h>
#include <Wire.h>
SoftwareSerial mySerial(10,11); //Definição do pino11 e pino12 como RX e TX
int PIN_RED = 3;
int PIN_GREEN = 5;
int PIN_BLUE = 6;
String RGB = "";
String RGB_Previous = "255.255.255";
String ON = "ON";
String OFF = "OFF";
boolean RGB_Completed = false;
void setup() {
pinMode (PIN_RED, OUTPUT);
pinMode (PIN_GREEN, OUTPUT);
pinMode (PIN_BLUE, OUTPUT);
Serial.begin(9600);
mySerial.begin(9600);
RGB.reserve(30);
}
void loop() {
while(mySerial.available()){
char ReadChar = (char)mySerial.read();
if(ReadChar == ')'){
RGB_Completed = true;
}else{
RGB += ReadChar;
}
}
if(RGB_Completed){
Serial.print("RGB:");
Serial.print(RGB);
Serial.print(" PreRGB:");
Serial.println(RGB_Previous);
if(RGB==ON){
RGB = RGB_Previous;
Light_RGB_LED();
}else if(RGB==OFF){
RGB = "0.0.0";
Light_RGB_LED();
}else{
Light_RGB_LED();
RGB_Previous = RGB;
}
RGB = "";
RGB_Completed = false;
}
}
void Light_RGB_LED(){
int SP1 = RGB.indexOf(' ');
int SP2 = RGB.indexOf(' ', SP1+1);
int SP3 = RGB.indexOf(' ', SP2+1);
String R = RGB.substring(0, SP1);
String G = RGB.substring(SP1+1, SP2);
String B = RGB.substring(SP2+1, SP3);
Serial.print("R=");
Serial.println( constrain(R.toInt(),0,255));
Serial.print("G=");
Serial.println(constrain(G.toInt(),0,255));
Serial.print("B=");
Serial.println( constrain(B.toInt(),0,255));
analogWrite(PIN_RED, (R.toInt()));
analogWrite(PIN_GREEN, (G.toInt()));
analogWrite(PIN_BLUE, (B.toInt()));
}
No vídeo abaixo é possível ver o funcionamento dos três projetos sendo executado.
Bom estudo à todos!
Nesse tutorial, vamos demonstrar como criar caracteres especiais para aplicação em projetos com microcontroladores.
Os conceitos aplicados podem ser adotados em qualquer modelo de placa que o usuário tiver mais afinidade em usar, levando sempre, em consideração as diferenças e particularidades entre elas.
No caso estarei demonstrando com o módulo Node MCU.
A aplicação de caracteres especiais podem ser necessários em aplicações onde, muitas vezes precisa-se inserir na tela do LCD uma aplicação exclusiva.
No tutorial também estarei usando um módulo I2C para display. Esse módulo tem a praticidade de utilizar somente 4 fios de ligação, 2 para alimentação e 2 para dados.
Deve ser feita a ligação dos componentes conforme o esquema.
fonte: próprio autor
Para melhor entendimento do funcionamento do display LCD deve-se ter o conhecimento de que o display é dividido da seguinte maneira: quando em sua especificação denomina-se 16x2 quer dizer que a tela está dividida em 16 colunas e 2 linhas.
fonte: blog baú da eletrônica
Em cada divisão das colunas com as linhas existem segmentos que numa visão ampliada divide-se em outro segmentos de 5 colunas e 8 linhas.
fonte: próprio autor
Para formar a figura que atenda a necessidade do programador, o caractere pode ser feito na divisão dos segmentos ou em vários segmentos e serem agrupados no display.
O programa (LCDv1.0) pode auxiliar na organização dos seguimentos para formar caracteres mais complexos.
fonte: próprio autor
O programa facilita, cabendo ao usuário inserir os bits conforme os caracteres necessários.
Código fonte
O código exibido abaixo é um exemplo utilizado, que pode ser visto melhor no vídeo, ao final desse tutorial.
//Caracteres Display LCD 16 x 2
//Autor: Tony Emerson Marim
//===http://www.mecatronizando.com.br===
#include <Wire.h> //INCLUSÃO DE BIBLIOTECA
#include <LiquidCrystal_I2C.h> //INCLUSÃO DE BIBLIOTECA
LiquidCrystal_I2C lcd(0x3F, 16, 2); //FUNÇÃO DO TIPO "LiquidCrystal_I2C"
// copiar para aqui o codigo fornecido pela aplicação de criar caracteres
// caracter 1
byte punho[8] = {
B00000,
B00000,
B11111,
B11111,
B11111,
B11111,
B11111,
B00000
};
// caracter 2
byte mao[8] = {
B10000,
B11000,
B11111,
B11111,
B11111,
B11111,
B11111,
B11111
};
// caractere 3
byte youtube[8] = {
B11111,
B11111,
B01111,
B00111,
B00111,
B01111,
B11111,
B11111
};
byte youtube2[8] = {
B11111,
B11110,
B11110,
B11110,
B11110,
B11110,
B11110,
B11111
};
void setup()
{
lcd.init(); // INICIALIZA O DISPLAY LCD
lcd.backlight(); // HABILITA O BACKLIGHT (LUZ DE FUNDO)
lcd.createChar(1, punho);
lcd.createChar(2, mao);
lcd.createChar(3, youtube);
lcd.createChar(4, youtube2);
lcd.begin(16, 2); //inicializa o LCD 16x2
lcd.setCursor(0, 0); //aponta para coluna 0, linha 2
lcd.write(1); //escreve o caracter
lcd.setCursor(1, 0); //aponta para coluna 0, linha 2
lcd.write(2); //escreve o caracter
lcd.setCursor(2, 0);
lcd.print(" ****CURTA****");
lcd.setCursor(1, 1); //aponta para coluna 0, linha 2
lcd.write(3); //escreve o caracter
lcd.setCursor(0, 1); //aponta para coluna 0, linha 2
lcd.write(4); //escreve o caracter
lcd.setCursor(2,1);
lcd.print(" -INSCREVA-SE- ");
}
void loop()
{
}
fonte: próprio autor
Para elaborar os mais diferentes caracteres que atenda a função do usuário é só deixar a imaginação fluir.
Esse tutorial vai ser destinado ao usuário que pretende realizar uma ligação entre o NodeMCU e um display LCD com I2C.
As informações exibidas no display deverão aparecer de forma estática, onde são trocadas depois de um período e de maneira em que rolam da direita para a esquerda.
A ligação do circuito é bastante simple, para ligar o display LCD ao NodeMCU, foi utilizado somente duas portas digitais do módulo D1 e D2, além do VCC e GND.
O módulo I2C torna o projeto ainda mais prático, pois otimiza o uso de pinos e sua conexão é direta com o display.
fonte: próprio autor
Com as ligações feitas é necessário carregar os códigos na IDE do Arduino e testar o projeto.
Selecione a placa utilizada, NodeMCU e a porta COM. Caso seja iniciante no uso dos módulos relacionados, acesse o tutorial de uso pelos atalhas NodeMCU e I2C.
Código 1
Nesse código as informações exibidas no NodeMCU trocam conforme o delay especificado, de forma estática.
//Tony Emerson Marim em 15/06/2017.
/** mecatronizando@gmail.com **/
/** Display LCD **/
#include <Wire.h> //INCLUSÃO DE BIBLIOTECA
#include <LiquidCrystal_I2C.h> //INCLUSÃO DE BIBLIOTECA
LiquidCrystal_I2C lcd(0x3F, 16, 2); //FUNÇÃO DO TIPO "LiquidCrystal_I2C"
void setup()
{
lcd.init(); // INICIALIZA O DISPLAY LCD
lcd.backlight(); // HABILITA O BACKLIGHT (LUZ DE FUNDO)
}
void loop()
{
lcd.clear();
lcd.setCursor(2, 0);
lcd.print("Mecatronizando"); // EXIBE O TEXTO DA PRIMEIRA LINHA
lcd.setCursor(0, 1);
lcd.print("ESP8266 nodeMCU"); // EXIBE TEXTO DA SEGUNDA LINHA
delay(5000);//TEMPO EM QUE PERMANECE EXIBINDO
lcd.clear();// LIMPA O DISPLAY
lcd.setCursor(0, 0);
lcd.print("Tutoriais"); // EXIBE O SEGUNDO TEXTO NA PRIMEIRA LINHA
lcd.setCursor(0, 1);
lcd.print("CompartilheCURTA"); // EXIBE O SEGUNDO TEXTO NA SEGUNDA LINHA
delay(5000);
}
Código 2
No segundo exemplo, os textos a serem exibidos devem rolar da direita para esquerda, exibindo constantemente.
//Tony Emerson Marim em 15/06/2017.
/** mecatronizando@gmail.com **/
// Baseado no programa original de Nishant Arora
/** Display LCD_2 **/
#include <Wire.h> //INCLUSÃO DE BIBLIOTECA
#include <LiquidCrystal_I2C.h> //INCLUSÃO DE BIBLIOTECA
LiquidCrystal_I2C lcd(0x3F, 16, 2); //FUNÇÃO DO TIPO "LiquidCrystal_I2C"
//line1 = TEXTO DA ROLAGEM SUPERIOR
String line1 = "Mecatronizando: www.mecatronizando.com.br/ curta / inscreva-se / compartilhe";
//line2 = TEXTO DA LINHA INFERIOR
String line2 = "-MECATRONIZANDO-";
// REFERENCE FLAGS
int stringStart, stringStop = 0;
int scrollCursor = 16;
int tamanho =0;
void setup()
{
lcd.init(); // INICIALIZA O DISPLAY LCD
lcd.backlight(); // HABILITA O BACKLIGHT (LUZ DE FUNDO)
}
void loop()
{
lcd.setCursor(scrollCursor, 0);
lcd.print(line1.substring(stringStart,stringStop));
lcd.setCursor(0, 1);
lcd.print(line2);
delay(200); //TEMPO DE TRANSPOSIÇÃO DA ROLAGEM
scroll_sup(); //ROTINA DA ROLAGEM
//VERIFICA TAMANHO DA STRING
tamanho = line1.length();
if (stringStart == tamanho)
{
stringStart = 0;
stringStop = 0;
}
}
//ROTINA DE ROLAGEM
void scroll_sup()
{
lcd.clear();
if(stringStart == 0 && scrollCursor > 0)
{
scrollCursor--;
stringStop++;
} else if (stringStart == stringStop){
stringStart = stringStop = 0;
scrollCursor = 16;
} else if (stringStop == line1.length() && scrollCursor == 0) {
stringStart++;
} else {
stringStart++;
stringStop++;
}
}
No vídeo abaixo possível ver o funcionamento do projeto.
Pesquisando pela internet esse dias encontrei um artigo bastante interessante no site ao qual acompanho e admiro (https://www.embarcados.com.br/) um artigo elaborado por Daniel Madeira ao qual mostrava a integração do Excel com Arduino e que devido a grande utilidade estarei usando-o como base para esse post.
Dentro do pacote Microsoft Office do Windows, o Excel é uma das ferramentas mais poderosas que o compõe. A variante do Visual Basic ao qual faz parte no Excel, o VBA (Visual Basic for Appication), tem suas aplicações específicas, mas é como um sistema de controle de acionamentos e desacionamentos dos pinos digitais da plataforma Arduino é que vamos trabalhar nesse post.
Vamos iniciar o passo a passo da interface.
A planilha de desenvolvimento
Primeiramente, abra um novo arquivo (pasta de trabalho) dentro do Excel.
Nomeie conforme sua preferência, chamarei minha planilha de Mecatronizando.
Normalmente as planilhas do Excel não vêm com a opção de ferramentas de desenvolvedor habilitadas, sendo necessário fazer isso. O caminho é > acesse o menu > Arquivo > Opções.
Uma janela vai abrir de opções do Excel, então deve selecionar Personalizar faixa de opções e selecionar a guia Desenvolvedor.
fonte: próprio autor
Com uma nova guia inserida o modo Desenvolvedor passa a fazer parte das opções do Excel, podendo agora ser iniciado a inserção dos componentes necessários para a configuração da planilha.
fonte: próprio autor
Acessando a Porta COM
Depois de estar habilitado para inserir as ferramentas de desenvolvedor, o próximo passo é elaborar o acesso à Porta COM ao qual a plataforma Arduino vai estar conectada.
Vamos fazer a inserção de dois botões ao qual poderemos ligar e desligar a comunicação com a Porta COM selecionada.
Selecione Inserir na aba Desenvolvedor > Botão
fonte: próprio autor
Antes de prosseguir, formate a célula da planilha em mais ou menos altura: 50 e largura: 30, nessa primeira configuração vamos deixar as células com bastante espaço e depois elaborar uma planilha, mais apresentável, estilo um supervisório.
fonte: próprio autor
Selecione a área onde deve ser inserido o botão conforme sua escolha. Clique e arraste para fixar o botão, antes de finalizar vai abrir uma aba, onde deve ser inserido o código de função do botão.
Para atribuir uma macro, clique em novo e insira o código.
fonte: próprio autor
Sub Botão1_Clique()
com$ = UCase(Cells(1, 1)) 'variável do tipo string que vai informar a linha e coluna onde vai ser informado a porta em COM em uso
baud$ = UCase(Val(Cells(2, 1))) 'variável tipo string que informa em qual linha e coluna vai ser informado a taxa de comunicacao com a porta COM
ReturnValue = Shell("mode.com " + com$ + " baud=" + baud$ + " parity=n data=8 stop=2 to=off xon=off dtr=off rts=off") 'parâmetros da porta COM
Application.Wait TimeSerial(Hour(Now()), Minute(Now()), Second(Now()) + 2) 'tempo de espera para segurança
Open com$ For Binary Access Read Write As #1 'termo responsável pela abertura da porta COM
End Sub
fonte: próprio autor
O segundo botão deve seguir os mesmos procedimentos, no entanto sua função deve ser de fechar a comunicação com a Porta COM.
fonte: próprio autor
Sub Botão2_Clique()
Close #1 'Fechar a porta COM
End Sub
* Lembrando que #1 está relacionada com a porta COM da nossa interface"
fonte: próprio autor
Acessando aos pinos do Arduino
Para um primeiro exemplo, devemos testar nossa interface, então vamos usar o LED do Arduino do Pino 13 para verificarmos o acionamento.
Deve ser inserido na planilha de controle mais dois botões para ligar e desligar o LED no teste.
fonte: próprio autor
O Arduino deve ler a instrução que chega até ele por meio da porta serial e executar a função de maneira correta.
O código abaixo deve ser atribuído ao botão responsável por ligar o LED.
Clique com o botão direto e acesse o atribuir macro para inserção do código.
fonte: próprio autor
No código abaixo está a função encarregada de colocar uma determinada saída em nível alto na planilha do usuário.
Sub Botão3_Clique()
Put #1, , "a" ' caractere de referencia a porta COM
Sheets("Mecatronizando").Range("d5") = "HIGH" 'planilha e celula ao qual serao incluidas funcoes
End Sub
fonte: próprio autor
O meso procedimento deve ser feito com o botão desliga LED, que deve ser responsável para deixar a saída digital em nível baixo.
fonte: próprio autor
Sub Botão4_Clique()
Put #1, , "b" 'caractere de referencia a porta COM
Sheets("Mecatronizando").Range("d5") = "LOW"
End Sub
fonte: próprio autor
Código fonte do Arduino
Agora vamos incluir um código fonte para que o Arduino consiga reconhecer as funções à ele atribuídos.
Vamos criar um código onde é possível que o Arduino Uno (ou similar), seja acionado para acender o LED que está no pino 13.
Copie o código e cole na IDE do seu Arduino, e faça upload para a plataforma.
/** Código **/
//Baseado no original de daniel madeira**/
//Tony Emerson Marim em 23/04/2017.
/** mecatronizando@gmail.com **/
/** Interface Excel **/
char comando;//variável que armazena a informacao do Excel
void setup() {
Serial.begin(9600);//define comunicacao serial
pinMode(13,OUTPUT);//define pino 13 como saída
}
void loop() {
if (Serial.available()>0)
{
comando = Serial.read();
switch (comando)
{
case 'a':
digitalWrite(13, HIGH);
break;
case 'b':
digitalWrite(13,LOW);
break;
}
}
}
Indicador de estado do pino de saída
E para finalizar, vamos elaborar um indicador, onde por meio da leitura da planilha é possível observar o acionamento da saída digital ao qual está sendo acionada.
Estaremos fazendo somente com o pino de saída ao qual escolhemos acionar o LED, mas se for necessário que o usuário utilize mais saídas, é só acrescentar repetindo os passos.
Os códigos citados anteriormente ao qual estavam ligados a função HIGH/LOW nos botões encarregados por ligar e desligar o LED, estavam atribuídos uma posição linha e coluna relacionada a uma célula do Excel. Essa célula vai ser exatamente onde deve ser apresentado o estado do LED para o usuário.
Formule as regras acessando Página inicial > Formatação condicional > Nova regra
fonte: próprio autor
Depois declare o texto ao qual estará atribuído quando no acionamento do LED a cor da célula vai ser alterada, no exemplo o funcionamento vai se dar da seguinte forma, LED 13 ligado = cor verde, LED 13 desligado = cor vermelha.
fonte: próprio autor
O procedimento para a célula relacionada ao estado LOW, deve ser o mesmo.
fonte: próprio autor
O usuário deve sempre lembrar que se houver necessidade de inserir novo indicadores na planilha, deve ser atribuídos dentro da função do botão, na declaração da Range onde está localizada a célula ao qual estará alterando os estados.
Depois de todos os passos, basta testar e se for necessário configurar a planilha conforme a necessidade ou o gosto do usuário.
fonte: próprio autor
No vídeo abaixo é possível ver o funcionamento completo da planilha e seu acionamento na plataforma Arduino.
Está precisando adquirir Boards e Shields? Acesse AQUI!
