quinta-feira, 8 de novembro de 2018

Projeto - Controle de motores de passo

Controle de motores de passo




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.




sábado, 2 de junho de 2018

LED RGB

LED RGB com Arduino

fonte:https://www.environmentallights.com 

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!


sábado, 17 de junho de 2017

Criando caracteres especiais no display LCD

Caracteres especiais no LCD



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.

Componentes

Módulo NodeMCU
Módulo I2C
Display LCD 16x2
Fonte de protoboard 5 Vcc/ 3.3 Vcc
Protoboard e cabos jumpers

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.



Gostou? Curta e Compartilhe a FanPage!
Assine o canal!
Adquira seus componentes!

Caso seja necessário, os arquivos apresentados podem ser baixados por esse LINK!

Bons estudos!

quinta-feira, 15 de junho de 2017

Conectando display LCD ao NodeMCU

Conectando display LCD ao NodeMCU


fonte: próprio autor

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.

Para esse projeto vai ser utilizado:


Esquema

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.



Se necessário, por meio deste LINK é possível baixar os arquivos e bibliotecas relacionadas ao projeto.

Curta! Compartilhe e Inscreva-se no Canal!

Todos os componentes utilizados podem ser adquiridos por esse LINK!


Bons estudos!

domingo, 23 de abril de 2017

Acionando o Arduino por meio do Excel

Interface Arduino/Excel 

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!

Todos os arquivos relacionados ao post podem ser baixados por esse LINK!

Bons estudos!