O Display LCD TFT 2,4″ é um display Touch que atua como uma shield para ser utilizado juntamente com Arduino, possui encaixe rápido e fácil permitindo ser utilizado de forma imediata, também possui slot de cartão SD que permite o armazenamento de dados e imagens para exibição. Conta com uma excelente resolução com 4 led’s de iluminação e 18 bits de cores vivas.

É comumente utilizado em projetos que necessitam a interação do sistema com o usuário, sendo possível utilizar elementos gráficos e respostas ao toque. Como possui fácil interação com qualquer microcontrolador, é uma opção viável e com excelente custo-benefício para estudantes e hobbystas.

Acesse a página do produto em nossa loja clicando aqui!

Funcionalidades Suportadas

• Exibição de texto, formas geométricas e imagens BMP de 240×320 via cartão SD;
• Detecção de toque com coordenadas X/Y e pressão Z;
• Interface gráfica interativa (botões, slides, menus);
• Ideal para projetos como controle de acesso, painéis de status, jogos simples etc.

Dicas Importantes:

• Ao usar com Arduino Uno, quase todos os pinos ficam ocupados. Se tiver a necessidade de adicionar sensores ou outros módulos, o Arduino Mega é mais indicado.
• Evite que o conector USB do Uno encoste no Shield, pode causar curto.
• Para imagens estáveis, é melhor usar fonte externa do que só a USB do computador.

Projeto de Escrita/Desenho com Paleta de Cores:

Neste projeto foi utilizado o Arduino Uno, juntamente com o Display LCD TFT 2,4″ shield Touch para Arduino para a seleção de cores na paleta e ajuste da espessura do traço ao desenhar. Foram dispostos os botões para a seleção de cor (COLOUR), botão para limpar a tela (CLR), e para ajuste da espessura do traço (PENZISE).

Esse projeto é um ótimo exemplo para quem quer aprender:

• Manipulação gráfica: como desenhar formas, textos e cores na tela;
• Interação com o usuário: como capturar toques e responder a eles;
• Estrutura de menus: como criar interfaces com botões e navegação;
• Modularidade: o código está bem dividido em funções, o que facilita manutenção e expansão;
• Calibração de touchscreen: entender como mapear coordenadas físicas para coordenadas visuais;

Bibliotecas utilizadas:

• LCDWIKI_GUI – Biblioteca de Gráficos

• LCDWIKI_KBV – Biblioteca de Hardware Específico

/*************************************Eletrodex Eletronica**********************************************/

#include <TouchScreen.h> //Biblioteca de touch
#include <LCDWIKI_GUI.h> //Biblioteca de graficos
#include <LCDWIKI_KBV.h> //Biblioteca de Hardware especifico


LCDWIKI_KBV my_lcd(240,320,A3,A2,A1,A0,A4);//width,height,cs,cd,wr,rd,reset

#define YP A3  
#define XM A2  
#define YM 9   
#define XP 8   

//parametros de calibraçao
#define TS_MINX 124
#define TS_MAXX 906

#define TS_MINY 83  
#define TS_MAXY 893


TouchScreen ts = TouchScreen(XP, YP, XM, YM, 300);

#define  BLACK   0x0000
#define BLUE    0x001F
#define RED     0xF800
#define GREEN   0x07E0
#define CYAN    0x07FF
#define MAGENTA 0xF81F
#define YELLOW  0xFFE0
#define WHITE   0xFFFF

uint16_t color_mask[] = {0xF800,0xFFE0,0x07E0,0x07FF,0x001F,0xF81F}; //Seleçao de cor

#define COLORBOXSIZE my_lcd.Get_Display_Width()/6
#define PENBOXSIZE my_lcd.Get_Display_Width()/4

int16_t old_color, current_color,flag_colour;
int16_t old_pen,current_pen,flag_pen;
boolean show_flag = true;

void show_string(uint8_t *str,int16_t x,int16_t y,uint8_t csize,uint16_t fc, uint16_t bc,boolean mode)
{
    my_lcd.Set_Text_Mode(mode);
    my_lcd.Set_Text_Size(csize);
    my_lcd.Set_Text_colour(fc);
    my_lcd.Set_Text_Back_colour(bc);
    my_lcd.Print_String(str,x,y);
}

//Visualizaçao do menu de cores
void show_color_select_menu(void)
{
   uint16_t i;
   for(i = 0;i<6;i++)
   {
       my_lcd.Set_Draw_color(color_mask[i]);
       my_lcd.Fill_Rectangle(i*COLORBOXSIZE, 0, (i+1)*COLORBOXSIZE-1, COLORBOXSIZE/2-1);
   }  
   my_lcd.Set_Draw_color(GREEN);
   my_lcd.Fill_Round_Rectangle(109, 21, 138,39, 5);
   show_string("OK",113,23,2,RED, BLACK,1);
}

//Visualizaçao do menu da espessura da caneta
void show_pen_size_select_menu(void)
{
  uint16_t i;
  my_lcd.Set_Text_Mode(1);
  my_lcd.Set_Text_Size(2);
  my_lcd.Set_Text_colour(GREEN);
  my_lcd.Set_Text_Back_colour(BLACK);
  for(i = 0;i<4;i++)
  {
      my_lcd.Print_Number_Int(i+1, (PENBOXSIZE-50)/2+PENBOXSIZE*i, (COLORBOXSIZE/2-16)/2, 0, ' ',10);
  }
   my_lcd.Set_Draw_color(RED);
   my_lcd.Fill_Rectangle(24, 9, 54, 9);
   my_lcd.Fill_Rectangle(84, 8, 114, 10);
   my_lcd.Fill_Rectangle(144, 7, 174, 11);
   my_lcd.Fill_Rectangle(204, 6, 234, 12);
   my_lcd.Set_Draw_color(GREEN);
   my_lcd.Fill_Round_Rectangle(109, 21, 138,39, 5);
   show_string("OK",113,23,2,RED, BLACK,1);
}

//Visualizaçao do menu principal
void show_main_menu(void)
{
   my_lcd.Set_Draw_color(YELLOW);
   my_lcd.Fill_Round_Rectangle(5, 0, 84,39, 5);
   my_lcd.Fill_Round_Rectangle(145, 0, 234,39, 5);
   show_string("COLOUR",10,12,2,BLUE, BLACK,1);
   show_string("PENSIZE",149,12,2,BLUE, BLACK,1);
   my_lcd.Set_Draw_color(MAGENTA);
   my_lcd.Fill_Round_Rectangle(90, 0, 139,39, 5);
   show_string("CLR",98,12,2,WHITE, BLACK,1);
 }

void setup(void) 
{
  Serial.begin(9600);
  my_lcd.Init_LCD();
  Serial.println(my_lcd.Read_ID(), HEX);
  my_lcd.Fill_Screen(BLACK);
  show_main_menu();
  current_color = RED;
  current_pen = 0;
  pinMode(13, OUTPUT);
/*
  tft.fillRect(0, 0, BOXSIZE, BOXSIZE, RED);
  tft.fillRect(BOXSIZE, 0, BOXSIZE, BOXSIZE, YELLOW);
  tft.fillRect(BOXSIZE*2, 0, BOXSIZE, BOXSIZE, GREEN);
  tft.fillRect(BOXSIZE*3, 0, BOXSIZE, BOXSIZE, CYAN);
  tft.fillRect(BOXSIZE*4, 0, BOXSIZE, BOXSIZE, BLUE);
  tft.fillRect(BOXSIZE*5, 0, BOXSIZE, BOXSIZE, MAGENTA);
 
  tft.drawRect(0, 0, BOXSIZE, BOXSIZE, WHITE);
  currentcolor = RED;
 
  pinMode(13, OUTPUT);

 //tft.fillRect(0, 80, 240, 20, RED);
   tft.setCursor(0, 80);
  
  tft.setTextColor(RED);  tft.setTextSize(1);
  tft.println("Hello World!");
  tft.println(01234.56789);
*/
}

#define MINPRESSURE 10
#define MAXPRESSURE 1000

void loop()
{
comme:
  digitalWrite(13, HIGH);
  TSPoint p = ts.getPoint();
  digitalWrite(13, LOW);
  pinMode(XM, OUTPUT);
  pinMode(YP, OUTPUT);
  if (p.z > MINPRESSURE && p.z < MAXPRESSURE) 
  {
      if (p.y < (TS_MINY-5)) 
      {
          my_lcd.Set_Draw_color(BLACK);
          my_lcd.Fill_Rectangle(0, COLORBOXSIZE, my_lcd.Get_Display_Width()-1, my_lcd.Get_Display_Height()-1);
      }
      //p.x = my_lcd.Get_Display_Width()-map(p.x, TS_MINX, TS_MAXX, my_lcd.Get_Display_Width(), 0);
      //p.y = my_lcd.Get_Display_Height()-map(p.y, TS_MINY, TS_MAXY, my_lcd.Get_Display_Height(), 0);
      p.x = map(p.x, TS_MINX, TS_MAXX, 0, my_lcd.Get_Display_Width());
      p.y = map(p.y, TS_MINY, TS_MAXY, 0,my_lcd.Get_Display_Height());
         if(p.y < COLORBOXSIZE) 
         {
              if(((p.x>5)&&(p.x < 84))&&!flag_pen) //select color
              {
                flag_colour = 1;
                if(show_flag)
                {
                    my_lcd.Set_Draw_color(BLACK);
                    my_lcd.Fill_Rectangle(0,0,239,39);
                    show_color_select_menu();
                }
                show_flag = false;
                switch(current_color)
                {
                  case RED:
                  {
                    my_lcd.Set_Draw_color(WHITE);
                    my_lcd.Draw_Rectangle(0, 0, COLORBOXSIZE-1, COLORBOXSIZE/2-1);
                    break;  
                  }
                  case YELLOW:
                  {
                       my_lcd.Set_Draw_color(WHITE);
                       my_lcd.Draw_Rectangle(COLORBOXSIZE, 0, 2*COLORBOXSIZE-1, COLORBOXSIZE/2-1);
                       break; 
                  }
                  case GREEN:
                  {
                       my_lcd.Set_Draw_color(WHITE);
                       my_lcd.Draw_Rectangle(2*COLORBOXSIZE, 0, 3*COLORBOXSIZE-1, COLORBOXSIZE/2-1);
                       break; 
                   }
                  case CYAN:
                  {
                       my_lcd.Set_Draw_color(WHITE);
                       my_lcd.Draw_Rectangle(3*COLORBOXSIZE, 0, 4*COLORBOXSIZE-1, COLORBOXSIZE/2-1);
                       break;                 
                  }
                  case BLUE:
                  {
                       my_lcd.Set_Draw_color(WHITE);
                       my_lcd.Draw_Rectangle(4*COLORBOXSIZE, 0, 5*COLORBOXSIZE-1, COLORBOXSIZE/2-1);
                       break;   
                  }
                  case MAGENTA:  
                  {
                       my_lcd.Set_Draw_color(WHITE);
                       my_lcd.Draw_Rectangle(5*COLORBOXSIZE, 0, 6*COLORBOXSIZE-1, COLORBOXSIZE/2-1);
                       break;   
                  }
                  default:
                      break;
                }
             }
             if(flag_colour)
             {
                 if(p.y < COLORBOXSIZE/2)
                 {
                    old_color = current_color;
                    if (p.x < COLORBOXSIZE) 
                    { 
                        current_color = RED; 
                        my_lcd.Set_Draw_color(WHITE);
                        my_lcd.Draw_Rectangle(0, 0, COLORBOXSIZE-1, COLORBOXSIZE/2-1);
                    } 
                    else if (p.x < COLORBOXSIZE*2) 
                    {
                        current_color = YELLOW;
                        my_lcd.Set_Draw_color(WHITE);
                        my_lcd.Draw_Rectangle(COLORBOXSIZE, 0, 2*COLORBOXSIZE-1, COLORBOXSIZE/2-1);
                    } 
                    else if (p.x < COLORBOXSIZE*3) 
                    {
                        current_color = GREEN;
                        my_lcd.Set_Draw_color(WHITE);
                        my_lcd.Draw_Rectangle(2*COLORBOXSIZE, 0, 3*COLORBOXSIZE-1, COLORBOXSIZE/2-1);
                    } 
                    else if (p.x < COLORBOXSIZE*4) 
                    {
                        current_color = CYAN;
                        my_lcd.Set_Draw_color(WHITE);
                        my_lcd.Draw_Rectangle(3*COLORBOXSIZE, 0, 4*COLORBOXSIZE-1, COLORBOXSIZE/2-1);
                    } 
                    else if (p.x < COLORBOXSIZE*5) 
                    {
                        current_color = BLUE;
                        my_lcd.Set_Draw_color(WHITE);
                        my_lcd.Draw_Rectangle(4*COLORBOXSIZE, 0, 5*COLORBOXSIZE-1, COLORBOXSIZE/2-1);
                    } 
                    else if (p.x < COLORBOXSIZE*6) 
                    {
                        current_color = MAGENTA;
                        my_lcd.Set_Draw_color(WHITE);
                        my_lcd.Draw_Rectangle(5*COLORBOXSIZE, 0, 6*COLORBOXSIZE-1, COLORBOXSIZE/2-1);
                    }
                    if(old_color != current_color)
                    {
                        switch(old_color)
                        {
                            case RED:
                            {
                              my_lcd.Set_Draw_color(RED);
                              my_lcd.Draw_Rectangle(0, 0, COLORBOXSIZE-1, COLORBOXSIZE/2-1);
                              break;  
                            }
                            case YELLOW:
                            {
                                 my_lcd.Set_Draw_color(YELLOW);
                                 my_lcd.Draw_Rectangle(COLORBOXSIZE, 0, 2*COLORBOXSIZE-1, COLORBOXSIZE/2-1);
                                 break; 
                            }
                            case GREEN:
                            {
                                 my_lcd.Set_Draw_color(GREEN);
                                 my_lcd.Draw_Rectangle(2*COLORBOXSIZE, 0, 3*COLORBOXSIZE-1, COLORBOXSIZE/2-1);
                                 break; 
                             }
                            case CYAN:
                            {
                                 my_lcd.Set_Draw_color(CYAN);
                                 my_lcd.Draw_Rectangle(3*COLORBOXSIZE, 0, 4*COLORBOXSIZE-1, COLORBOXSIZE/2-1);
                                 break;                 
                            }
                            case BLUE:
                            {
                                 my_lcd.Set_Draw_color(BLUE);
                                 my_lcd.Draw_Rectangle(4*COLORBOXSIZE, 0, 5*COLORBOXSIZE-1, COLORBOXSIZE/2-1);
                                 break;   
                            }
                            case MAGENTA:  
                            {
                                 my_lcd.Set_Draw_color(MAGENTA);
                                 my_lcd.Draw_Rectangle(5*COLORBOXSIZE, 0, 6*COLORBOXSIZE-1, COLORBOXSIZE/2-1);
                                 break;   
                            }
                            default:
                                break;                        
                        }
                    }
                }
                else if(p.y < COLORBOXSIZE)
                {
                     if((p.x>109)&&(p.x<138))
                     {
                         my_lcd.Set_Draw_color(BLACK);
                         my_lcd.Fill_Rectangle(0,0,239,39);
                         show_main_menu();
                         flag_colour = 0;
                         show_flag = true;
                         goto comme;
                     }
                }
            }
            if(((p.x>145)&&(p.x < 234))&&!flag_colour) //select pen size
            {
                flag_pen = 1;
                if(show_flag)
                {
                    my_lcd.Set_Draw_color(BLACK);
                    my_lcd.Fill_Rectangle(0,0,239,39);
                    show_pen_size_select_menu();
                }
                show_flag = false;
                switch(current_pen)
                {
                   case 0:
                   {
                       my_lcd.Set_Draw_color(WHITE);
                       my_lcd.Draw_Rectangle(0, 0, PENBOXSIZE-1, COLORBOXSIZE/2-1);
                       break;
                   }
                   case 1:
                   {
                       my_lcd.Set_Draw_color(WHITE);
                       my_lcd.Draw_Rectangle(PENBOXSIZE, 0, 2*PENBOXSIZE-1, COLORBOXSIZE/2-1);
                       break; 
                   }
                   case 2:
                   {
                       my_lcd.Set_Draw_color(WHITE);
                       my_lcd.Draw_Rectangle(2*PENBOXSIZE, 0, 3*PENBOXSIZE-1, COLORBOXSIZE/2-1);
                       break;   
                   }
                   case 3:  
                   {
                       my_lcd.Set_Draw_color(WHITE);
                       my_lcd.Draw_Rectangle(3*PENBOXSIZE, 0, 4*PENBOXSIZE-1, COLORBOXSIZE/2-1);
                       break;                
                   }
                   default:
                       break;
                  }              
              }
              if(flag_pen)
              {
                   if(p.y < COLORBOXSIZE/2)
                   {
                      old_pen = current_pen;
                      if(p.x < PENBOXSIZE)
                      {
                          current_pen = 0;
                          my_lcd.Set_Draw_color(WHITE);
                          my_lcd.Draw_Rectangle(0, 0, PENBOXSIZE-1, COLORBOXSIZE/2-1);
                      }
                      else if(p.x < 2*PENBOXSIZE)
                      {
                          current_pen = 1;
                          my_lcd.Set_Draw_color(WHITE);
                          my_lcd.Draw_Rectangle(PENBOXSIZE, 0, 2*PENBOXSIZE-1, COLORBOXSIZE/2-1);
                       }
                       else if(p.x < 3*PENBOXSIZE) 
                       {
                           current_pen = 2;
                           my_lcd.Set_Draw_color(WHITE);
                           my_lcd.Draw_Rectangle(2*PENBOXSIZE, 0, 3*PENBOXSIZE-1, COLORBOXSIZE/2-1);
                       }
                       else if(p.x < 4*PENBOXSIZE)
                       {
                           current_pen = 3;
                           my_lcd.Set_Draw_color(WHITE);
                           my_lcd.Draw_Rectangle(3*PENBOXSIZE, 0, 4*PENBOXSIZE-1, COLORBOXSIZE/2-1);               
                       }
                       if(old_pen != current_pen)
                       {
                           switch(old_pen)
                           {
                                 case 0:
                                 {
                                     my_lcd.Set_Draw_color(BLACK);
                                     my_lcd.Draw_Rectangle(0, 0, PENBOXSIZE-1, COLORBOXSIZE/2-1);
                                     break;
                                 }
                                 case 1:
                                 {
                                     my_lcd.Set_Draw_color(BLACK);
                                     my_lcd.Draw_Rectangle(PENBOXSIZE, 0, 2*PENBOXSIZE-1, COLORBOXSIZE/2-1);
                                     break; 
                                 }
                                 case 2:
                                 {
                                     my_lcd.Set_Draw_color(BLACK);
                                     my_lcd.Draw_Rectangle(2*PENBOXSIZE, 0, 3*PENBOXSIZE-1, COLORBOXSIZE/2-1);
                                     break;   
                                 }
                                 case 3:  
                                 {
                                     my_lcd.Set_Draw_color(BLACK);
                                     my_lcd.Draw_Rectangle(3*PENBOXSIZE, 0, 4*PENBOXSIZE-1, COLORBOXSIZE/2-1);
                                     break;                
                                 }
                                 default:
                                     break;           
                           }      
                       }
                   }
                   else if(p.y < COLORBOXSIZE)
                   {
                       if((p.x>109)&&(p.x<138))
                       {
                          my_lcd.Set_Draw_color(BLACK);
                          my_lcd.Fill_Rectangle(0,0,239,39);
                          show_main_menu();
                          flag_pen = 0;
                          show_flag = true;
                          goto comme;
                       }  
                   }
              }
              if(((p.x>90)&&(p.x < 139))&&!flag_colour&&!flag_pen)
              {
                  my_lcd.Set_Draw_color(BLACK);  
                  my_lcd.Fill_Rectangle(0,COLORBOXSIZE,my_lcd.Get_Display_Width()-1,my_lcd.Get_Display_Height()-1);
              }
         }
      if (((p.y-current_pen) > COLORBOXSIZE) && ((p.y+current_pen) < my_lcd.Get_Display_Height()))  //drawing
      {
        my_lcd.Set_Draw_color(current_color);
       // if(1 == current_pen)
     //   {
      //      my_lcd.Draw_Pixel(p.x,  p.y);
     //   }
     //   else 
     //   {
          my_lcd.Fill_Circle(p.x,  p.y,current_pen);
      //  }
    }
  }
}

A Operação OR (OU) atua algebricamente como uma soma, tendo como resultante a soma de nível lógico imposto nas entradas. Assim Y=A+B (leia-se que a saída Y é igual a A OU B),e quando qualquer uma das entradas A ou B, estiverem em nível lógico Alto (High = 1), a saída Y será também uma saída com nível lógico Alto. A saída Y só será baixa (Low = 0), quando as duas entradas A e B estiverem com nível lógico baixo (Low = 0).

O teste efetuado, atua em cima do funcionamento das quatro portas OR presentes no CI. Assim, é feita a análise de resposta das saídas segundo a tabela verdade disponível a seguir, disponibilizada no datasheet do fabricante. O datasheet pode ser acessado clicando aqui!

O primeiro teste é feito na primeira porta OR, em que as entradas são compostas pelos pinos 1 e 2 referentes as entradas 1A e 1B, e a Saída é disponibilizada pelo pino 3, referente a 1Y. o circuito eletrônico montado para teste pode ser visto a seguir:

Assim a chave Dip Switch possui 2 chaves, sendo elas a Chave de número 1 referente a entrada 1A, e a a Chave número 2 referente a entrada 1B. O LED é referente a saída 1Y. Desse modo, quando qualquer uma das chaves 1A ou 1B, estiverem em posição ON com nível lógico alto, a saída 1Y receberá nível alto, acendendo o led; se as duas entradas estiverem em ON, a saída também estará em nível lógico alto acendendo também o LED. Como pode ser visto na tabela verdade, a única condição que coloca a saída em nível lógico baixo, é as duas entradas em nível lógico baixo (Low).  

O segundo teste é feito na segunda porta OR, em que as entradas são compostas pelos pinos 4 e 5 referentes as entradas 2A e 2B, e a Saída é disponibilizada pelo pino 6, referente a 2Y. o circuito eletrônico montado para teste pode ser visto a seguir:

Assim as duas chaves 1 e 2 dispostas na Dip Switch são referentes as entradas 2A e 2B respectivamente. o LED é referente a saída 2Y. Desse modo, quando qualquer uma das chaves 2A ou 2B, estiverem em posição ON com nível lógico alto, a saída 2Y receberá nível alto, acendendo o led; se as duas entradas estiverem em ON, a saída também estará em nível lógico alto acendendo também o LED. Como pode ser visto na tabela verdade, a única condição que coloca a saída em nível lógico baixo, é as duas entradas em nível lógico baixo (Low).  

O terceiro teste é feito na Terceira porta OR, em que as entradas são compostas pelos pinos 10 e 9 referentes as entradas 3A e 3B, e a Saída é disponibilizada pelo pino 8, referente a 3Y. o circuito eletrônico montado para teste pode ser visto a seguir:

Assim as duas chaves 1 e 2 dispostas na Dip Switch são referentes as entradas 3A e 3B respectivamente. o LED é referente a saída 3Y. Desse modo, quando qualquer uma das chaves 3A ou 3B, estiverem em posição ON com nível lógico alto, a saída 3Y receberá nível alto, acendendo o led; se as duas entradas estiverem em ON, a saída também estará em nível lógico alto acendendo também o LED. Como pode ser visto na tabela verdade, a única condição que coloca a saída em nível lógico baixo, é as duas entradas em nível lógico baixo (Low).  

O quarto teste é feito na quarta porta OR, em que as entradas são compostas pelos pinos 13 e 12 referentes as entradas 4A e 4B, e a Saída é disponibilizada pelo pino 11, referente a 4Y. o circuito eletrônico montado para teste pode ser visto a seguir:

Assim as duas chaves 1 e 2 dispostas na Dip Switch são referentes as entradas 4A e 4B respectivamente. o LED é referente a saída 4Y. Desse modo, quando qualquer uma das chaves 4A ou 4B, estiverem em posição ON com nível lógico alto, a saída 4Y receberá nível alto, acendendo o led; se as duas entradas estiverem em ON, a saída também estará em nível lógico alto acendendo também o LED. Como pode ser visto na tabela verdade, a única condição que coloca a saída em nível lógico baixo, é as duas entradas em nível lógico baixo (Low).  

Acesse o Produto em nosso site clicando aqui!

*Esse CI poderá ser vendido em outras variações de prefixo de acordo com o fabricante, como por exemplo HEF fabricante NXP, HCF fabricante ST, CD fabricante Texas Instruments, dentre outros. Ressaltamos que o prefixo refere-se apenas a marca, sendo eles equivalentes entre si, com funcionamento e dados técnicos iguais. Caso você tenha preferência, entre em contato antes de efetuar sua compra para averiguarmos a disponibilidade do item com prefixo desejado em nosso estoque.

Roteiro de Teste de Funcionamento do Módulo conversor TTL para RS485 Arduino

O Módulo conversor TTL para RS485 é um módulo utilizado para conversão de dados TTL para o protocolo RS485, ou RS485 para TTL. No contexto da utilização do módulo junto a embarcados como Arduino, o módulo se mostra bastante eficiente, permitindo a conexão de vários periféricos conectados ao sistema, podendo atuar com vários escravos em uma conexão, juntamente a uma alta velocidade de transmissão de dados. Além de atuar com grande performance em ambientes ruidosos e de longas distâncias.

O Módulo conversor TTL para RS485 Arduino é amplamente utilizado em aplicações em que são necessárias a transmissão de comunicação de um Arduino em linguagem TTL para um protocolo RS485, ou vice e versa, podendo atuar em aplicações de controle industrial e sistemas de automação.

Principais elementos que compõe o Módulo conversor TTL para RS485 Arduino

 Pino VCC – +5V Alimentação Positiva

 Pino B – Inversor da Entrada do Receptor e a Saída do Driver

 Pino A – Entrada do Receptor Não Inversor e Saída do Driver

 GND – Terra

 Borne Comum a A e B – Pontos A e B comum aos pinos A e B

 LED Indicador – Led Indicador de funcionamento

 DI – Entrada do Driver

 DE – Ativação da Saída do Driver

 RE – Habilitação de Saída do Receptor

 RO – Saída do Receptor

 Chip MAX485 – Chip conversor TTL para RS485, composto

Diagrama eletrônico dos Módulos conversores TTL para RS485, conectados como emissor e receptor respectivamente

Conexão Módulo Emissor

Pino VCC Módulo Emissor conectado ao 5V

Pino B Módulo Emissor conectado ao B do Módulo Receptor

Pino A Módulo Emissor conectado ao A do Módulo Receptor

Pino GND Módulo Emissor conectado ao GND

Pino RO Módulo Emissor conectado ao Pino 10 Arduino Emissor

Pino RE e DE do Módulo Emissor conectados ao Pino 3 Arduino Emissor

Pino DI Módulo Emissor conectados ao Pino 11 Arduino Emissor

Pino A0 Arduino Emissor conectado ao pino 1 do botão, o pino 2 do botão no GND

Conexão Módulo Receptor

Pino VCC Módulo Receptor conectado ao 5V

Pino B Módulo Receptor conectado ao B do Módulo Emissor

Pino A Módulo Receptor conectado ao A do Módulo Emissor

Pino GND Módulo Receptor conectado ao GND

Pino RO Módulo Receptor conectado ao Pino 10 Arduino Receptor

Pino RE e DE Módulo Receptor conectados ao Pino 3 Arduino Receptor

Pino DI Módulo Receptor conectados ao Pino 11 Arduino Receptor

Pino GND Arduino Receptor conectado ao GND Arduino Emissor

Compilação do código para o Emissor

Para utilização do Módulo conversor TTL para RS485 Arduino como Emissor, conecte o cabo de comunicação do Arduino Emissor com o computador, e em seguida copie o software “Emissor” disponibilizado na descrição do vídeo ou e em “Roteiro de Teste de funcionamento Módulo conversor TTL para RS485”; cole o software na IDE do Arduino e compile-o para o Arduino Emissor, como na imagem a seguir.

Abra o monitor Serial, e pressione o Botão para enviar os dados ao receptor. A mensagem “Botão pressionado. Enviando dados!” será exibida.

Compilação do código para o Receptor

Os dados de botão pressionado serão enviados ao receptor, porém, como ainda não compilamos o código para ele, nada será recebido. Para recebimento, iremos compilar o código “RECEPTOR” para o Arduino receptor, de modo que ele possa receber os dados por meio do Módulo Receptor conversor TTL para RS485.  Para isso, vamos alimentar o Arduino emissor com uma fonte externa. E colocaremos o cabo de interface entre o Arduino Receptor e o computador, para a transferência do software para o receptor, e análise do recebimento do sinal emitido pelo Botão.

Abra o monitor Serial do programa compilado para o Receptor, e pressione o Botão conectado ao emissor para enviar os dados ao receptor. A mensagem “Botão pressionado. Recebendo Dados” será exibida, comprovando a comunicação entre Emissor e Receptor, com atuação dos Módulos conversores TTL para RS485.

Softwares RECEPTOR e EMISSOR

Software RECEPTOR:
 

/*************** Eletrodex Eletrônica ******************
Teste Conversor TTL para RS485 Arduino - RECEPTOR
******************************************************/

#include

//Pinos de comunicacao serial do modulo RS485
#define Pino_RS485_RX 10
#define Pino_RS485_TX 11

//Pino de controle transmissao/recepcao
#define SerialTxControle 3

#define RS485Emissor HIGH
#define RS485Receptor LOW

//Define led 13 para mostrar atividade na comunicacao
#define Pin13LED 13

//Cria a serial por sofware para conexao com modulo RS485
SoftwareSerial RS485Serial(Pino_RS485_RX, Pino_RS485_TX);

//Armazena os dados que chegam pela serial
String inputString = "";
//Variavel de string completa
boolean stringComplete = false;

void setup()
{
//Inicializa a serial do Arduino
Serial.begin(9600);
Serial.println(" -------------- ELETRODEX ELETRÔNICA --------------");
Serial.println("Teste Módulo conversor TTL para RS485 Arduino");
Serial.println("Aguardando dados do Emissor...");
Serial.println("Pressione o Botão...");

pinMode(Pin13LED, OUTPUT);

pinMode(SerialTxControle, OUTPUT);

  //Coloca o modulo RS485 em modo de recepcao
  digitalWrite(SerialTxControle, RS485Receptor);

  //Inicializa a serial do modulo RS485
  RS485Serial.begin(4800);
}

void loop()
{
  //Recebe os dados do RS485 via porta serial
  if (RS485Serial.available())
  {
    while (RS485Serial.available())
    {
      //Recebe os dados e monta a string
      char inChar = (char)RS485Serial.read();
      inputString += inChar;
      
      if (inChar == 'n')
      {
        //Mostra no Serial Monitor a string recebida
        Serial.print(inputString);
        stringComplete = true;
        inputString = "";
      }
    }
  }
}

Software EMISSOR:

/*************** Eletrodex Eletrônica ******************
Teste Conversor TTL para RS485 Arduino - EMISSOR
******************************************************/

#include

//Pinos de comunicacao serial do modulo RS485
#define Pino_RS485_RX 10
#define Pino_RS485_TX 11

//Pino de controle Emissao/recepcao
#define SerialTxControle 3

#define RS485Emit HIGH
#define RS485Receber LOW

//Define led 13 para mostrar atividade na comunicacao
#define Pin13LED 13

//Cria a serial por sofware para conexao com modulo RS485
SoftwareSerial RS485Serial(Pino_RS485_RX, Pino_RS485_TX);

void setup()
{
//Inicializa a serial do Arduino
Serial.begin(9600);
Serial.println(" -------------- ELETRODEX ELETRÔNICA --------------");
Serial.println("Teste Módulo conversor TTL para RS485 Arduino");
Serial.println("Pressione o botao para enviar os dados...");

pinMode(Pin13LED, OUTPUT);
pinMode(SerialTxControle, OUTPUT);

//Inicializa a serial do modulo RS485
RS485Serial.begin(4800);

//Seta o pino A0 como entrada e habilita o pull up
pinMode(A0, INPUT_PULLUP);
}

void loop()
{
//Verifica se o botao foi pressionado
int valor = digitalRead(A0);
if (valor == 0)
{
Serial.println("Botao pressionado. Enviando dados!");

//Habilita o modulo para transmissao
digitalWrite(SerialTxControle, RS485Emit);

//Envia a string
RS485Serial.println("Botao pressionado. Recebendo Dados");

//Liga o led 13 para mostrar que ha conexao
digitalWrite(Pin13LED, HIGH);
delay(10);
digitalWrite(Pin13LED, LOW);

//Desabilita o modulo para transmissao
digitalWrite(SerialTxControle, RS485Receber);
while (digitalRead(A0) == 0)
{
delay(50);
}
}
}

O circuito 4053 é um multiplexador / demultiplexador analógico triplo, de 2 canais, controlado digitalmente que pode atuar tanto como conversor série paralelo, como paralelo série. Ele é composto por um circuito lógico comutador, responsável por receber e selecionar vários sinais de entrada e comutar para uma das saídas. O termo triplo provém dos 3 interruptores, sendo eles, A referente a comutação de X, B referente a comutação de Y e C referente a comutação de Z, responsáveis por ativar um dos dois canais 0 ou 1 de cada comutador X, Z ou Y.

Sua aplicação é voltada principalmente para atuação em circuitos de comunicação. É atuante também em equipamentos operados por bateria, sistemas de roteamento de sinal de áudio e vídeo, e sistemas de aquisição de dados de baixa tensão.

O 4053 possui uma ampla faixa de tensão analógica: VDD-VEE = 3V à 18V. Vale ressaltar que VEE deve ser ≦ VSS, e sendo assim, recomenda-se conectá-lo diretamente ao GND como demostrado na montagem do circuito de teste.

 Acesse a página do produto clicando aqui: 4053 – MuX/DemuX

Circuito interno do CI 4053 Multiplexador / Demultiplexador Analógico Triplo de 2 canais

 Conexão do circuito eletrônico de teste do 4053 Multiplexador / Demultiplexador Analógico Triplo de 2 canais

O Pino 1 do 4053 deve ser conectado ao Pino 3, ao Pino 13 e ao terceiro terminal do regulador de tensão de 5V; O primeiro terminal do regulador de 5V deve ser conectado diretamente ao VCC da fonte de alimentação de 17VDC, e o seu segundo terminal deve ser conectado ao GND da fonte.

O Pino 2 deve ser conectado ao Pino 12 e ao terceiro terminal do regulador de tensão de 15V; O primeiro terminal do regulador de 15V deve ser conectado diretamente ao VCC da fonte de alimentação de 17VDC, e o seu segundo terminal deve ser conectado ao GND da fonte.

O Pino 4 deve ser conectado a ponta positiva de medição do multímetro referente a medição Z dos canais Z0 e Z1. A ponta negativa de medição do multímetro deve ser conectado ao GND da fonte.

O Pino 5 deve ser conectado ao terceiro terminal do regulador de tensão de 8V; O primeiro terminal do regulador de 8V deve ser conectado diretamente ao VCC da fonte de alimentação de 17VDC, e o seu segundo terminal deve ser conectado ao GND da fonte.

Os Pinos 6, 7 e 8 devem ser conectados ao GND da fonte.

O Pino 9 deve ser conectado a um dos lados do resistor de 500 Ohms, e ao terminal OFF do interruptor A. O outro lado do resistor de 500 Ohms deve ser conectado ao anodo do Led A; e o catodo do Led A deve ser conectado ao GND da fonte.

O Pino 10 deve ser conectado a um dos lados do resistor de 500 Ohms, e ao terminal OFF do interruptor B. O outro lado do resistor de 500 Ohms deve ser conectado ao anodo do Led B; e o catodo do Led B deve ser conectado ao GND da fonte.

O Pino 11 deve ser conectado a um dos lados do resistor de 500 Ohms, e ao terminal OFF do interruptor C. O outro lado do resistor de 500 Ohms deve ser conectado ao anodo do Led C; e o catodo do Led C deve ser conectado ao GND da fonte.

O Pino 14 deve ser conectado a ponta positiva de medição do multímetro referente a medição X dos canais X0 e X1. A ponta negativa de medição do multímetro deve ser conectado ao GND da fonte.

O Pino 15 deve ser conectado a ponta positiva de medição do multímetro referente a medição Y dos canais Y0 e Y1. A ponta negativa de medição do multímetro deve ser conectado ao GND da fonte.

O Pino 16 deve ser conectado ao VCC da fonte.

O lado ON dos interruptores A, B e C devem ser conectados ao VCC da fonte.

OBS: O 4053 possui uma ampla faixa de tensão analógica: VDD-VEE = 3V à 18V. Vale ressaltar que VEE deve ser ≦ VSS, e sendo assim, recomenda-se conectá-lo diretamente ao GND como descrito acima.

Atuação dos canais Z0, Y0 e X0 com os interruptores A, B e C em nível lógico baixo

As chaves A, B e C estão setadas em OFF, com nível lógico baixo o que ativa os canais Z0, Y0 e X0.

O diagrama de simulação criado no Proteus, que pode ser visto a seguir, expõe de forma facilitada o circuito junto as conexões pino a pino, de modo a facilitar a visualização de atuação do multiplexador, comutando os canais e transmitindo o valor de tensão para os pinos X, Y e Z. Assim, é possível efetuar a resposta comutada em Z de 8V, referente a tensão do canal Z0, a resposta em Y de 15V referente a tensão do canal Y0, e a resposta em X de 15V referente a tensão do canal X0.

Atuação dos canais Z0, Y0 e X1 com os interruptores A em nível lógico alto, B e C em nível lógico baixo

A chave A está setada em ON com nível lógico alto, e as chaves B e C estão setadas em OFF, com nível lógico baixo o que ativa os canais Z0, Y0 e X1.

O diagrama de simulação criado no Proteus, que pode ser visto a seguir, demonstra a resposta comutada em Z de 8V, referente a tensão do canal Z0, a resposta em Y de 15V referente a tensão do canal Y0, e a resposta em X de 5V referente a tensão do canal X1.

Atuação dos canais Z0, Y1 e X0 com O interruptor A em nível lógico baixo, B em nível lógico alto e C em nível lógico baixo

A chave A está setada em OFF com nível lógico baixo, a chave B está em ON com nível lógico alto e a chave C em OFF, com nível lógico baixo o que ativa os canais Z0, Y1 e X0.

O diagrama de simulação criado no Proteus, que pode ser visto a seguir, demonstra a resposta comutada em Z de 8V, referente a tensão do canal Z0, a resposta em Y de 5V referente a tensão do canal Y1, e a resposta em X de 15V referente a tensão do canal X0.

Atuação dos canais Z0, Y1 e X1 com os interruptores A e B em nível lógico alto e C em nível lógico baixo

As chaves A e B estão setadas em ON com nível lógico alto, e a chave C em OFF, com nível lógico baixo o que ativa os canais Z0, Y1 e X1.

O diagrama de simulação criado no Proteus, que pode ser visto a seguir, demonstra a resposta comutada em Z de 8V, referente a tensão do canal Z0, a resposta em Y de 5V referente a tensão do canal Y1, e a resposta em X de 5V referente a tensão do canal X1

Atuação dos canais Z1, Y0 e X1 com os interruptores A e B em nível lógico baixo e C em nível lógico alto

As chaves A e B estão setadas em OFF com nível lógico baixo, e a chave C está setada em ON com nível lógico alto o que ativa os canais Z1, Y0 e X0.

O diagrama de simulação criado no Proteus, que pode ser visto a seguir, demonstra a resposta comutada em Z de 5V, referente a tensão do canal Z1, a resposta em Y de 15V referente a tensão do canal Y0, e a resposta em X de 15V referente a tensão do canal X0.

Atuação dos canais Z1, Y0 e X1 com A em nível lógico alto, B em nível lógico baixo e C em nível lógico alto

A chave A está setada em ON com nível lógico alto, a chave B está em OFF com nível lógico baixo e a chave C está setada em ON com nível lógico alto o que ativa os canais Z1, Y0 e X1.

O diagrama de simulação criado no Proteus, que pode ser visto a seguir, demonstra a resposta comutada em Z de 5V, referente a tensão do canal Z1, a resposta em Y de 15V referente a tensão do canal Y0, e a resposta em X de 5V referente a tensão do canal X1.

Atuação dos canais Z1, Y1 e X1 com os interruptores A, B e C em nível lógico alto

Todas as chaves A, B e C estão setadas em ON com nível lógico alto, o que ativa os canais Z1, Y1 e X1.

O diagrama de simulação criado no Proteus, que pode ser visto a cima, demonstra a resposta comutada em Z de 5V, referente a tensão do canal Z1, a resposta em Y de 5V referente a tensão do canal Y1, e a resposta em X de 5V referente a tensão do canal X1.

Produtos utilizados:

• Módulo Driver p/ Motores Ponte-H Dupla L298
• Arduino UNO R3 + Cabo USB
• Motor DC 5,9V RF-300CA

Figura 1 : Apresentação do Módulo Driver p/ Motores Ponte-H Dupla L298

• Motor A e Motor B : Os bornes de Motor A e Motor B são referentes a conexão dos motores, podendo ser dois motores de corrente contínua (DC) ou um motor de passo que atue dentro da tensão máxima imposta pela placa de 12V.
• 5VEN: O Módulo Driver p/ Motores Ponte-H Dupla L298 possui um regulador de tensão que permite ao driver uma operação segura sem risco de sobretensões, e permite também a alimentação de outros componentes dependendo da configuração escolhida:
• 5VEN atuando na configuração 5V: A configuração de “5VEN” com alimentação 5V, só é indicada para controle de motores de até 5V. Deve-se manter o Jumper referente à “5VEN” conectado para o funcionamento do módulo como no teste de funcionamento demonstrado no vídeo “Teste básico do Módulo Driver p/ Motores Ponte-H Dupla L298, com dois motores DC”. Para visualização do vídeo com o teste de funcionamento do módulo utilizando essa configuração clique aqui! O demonstrativo do esquema eletrônico de 5VEN atuando na configuração 5V, pode ser visto na figura 2.
• 5VEN atuando na configuração 12V: Na configuração com alimentação em 12V, deve-se manter o Jumper referente à “5VEN” conectado para que seja ativado o regulador de tensão. Esse regulador de tensão atua regulando a tensão de entrada de 12V para a tensão de alimentação lógica suportada pelo chip (≤ 7Vdc), impedindo que ocorram danos  por sobretensão; além de proporcionar uma saída regulada de 5V  no pino “5VEN” para que o mesmo possa alimentar outros componentes. Um demonstrativo do esquema eletrônico de 5VEN atuando na configuração 12V, pode ser visto na figura 3.

ENA e ENB: Os pinos referentes a ENA e ENB podem ser utilizados juntamente com os pinos PWM do arduíno se necessário. Eles são responsáveis pelo controle  PWM dos motores, e estão interligados diretamente aos 5V. Para efetuar o controle de velocidade, deve-se retirar os Jumperes.

Entradas IN: O Módulo Driver p/ Motores Ponte-H Dupla L298 possui um barramento de 4 entradas sendo elas IN1, IN2, IN3 e IN4. Essas entradas são referentes a rotação dos motores A e B, sendo as entradas IN1 e IN2 referente ao Motor A, e IN3 e IN4 referente ao Motor B.  As tabelas à seguir demontram os comandos de ativação dos motores A e B por meio dos pinos de entrada:

Esquema eletrônico do Módulo Driver p/ Motores Ponte-H Dupla L298, nas configurações 5V e 12V:

• Esquema eletrônico na configuração de 5V:

Figura 2: Demonstrativo do esquema eletrônico de 5VEN atuando na configuração 5V.

• Esquema eletrônico na configuração de 12V:

Figura 3: Demonstrativo do esquema eletrônico de 5VEN atuando na configuração 12V.

Software de funcionamento Módulo Driver p/ Motores Ponte-H Dupla L298 :

• 
/*
_____________________________________________________________________________________________________
****************************************Eletrodex Eletrônica**************************************Teste básico do Módulo Driver p/ Motores Ponte-H Dupla L298, com dois motores DCFuncionamento do programa Primeiro o motor A é ativado girando no sentido horário, logo depois o motor A é pausado, e o Motor B gira no sentido horário e pausa. Em seguida, o motor A é ativado girando no sentido anti-horário, e logo o mesmo é pausado, e o motor B inicia sua rotação em sentido anti-horário e pausa. Assim, o processo fica em Loop entre os dois motores, indo de sentido horário para freio e ativação do sentido anti-horário. *///Pinos do Arduino ligados a entrada da Ponte H
  int IN1 = 4;
  int IN2 = 5;
  int IN3 = 6;
  int IN4 = 7;void setup()
  {
  //Definindo os pinos como saida
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);
  }void loop()
  {
  //Gira o Motor A no sentido horário
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, LOW);
  delay(2000);
  //Freia o motor A
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, HIGH);
  delay(500);
  //Gira o Motor B no sentido horário
  digitalWrite(IN3, HIGH);
  digitalWrite(IN4, LOW);
  delay(2000);
  //Freia o motor B
  digitalWrite(IN3, HIGH);
  digitalWrite(IN4, HIGH);
  delay(500);//Gira o Motor A no sentido anti-horário
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, HIGH);
  delay(2000);
  //Freia o motor A
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, HIGH);
  delay(500);
  //Gira o Motor B no sentido anti-horario
  digitalWrite(IN3, LOW);
  digitalWrite(IN4, HIGH);
  delay(2000);
  //Freia o motor B
  digitalWrite(IN3, HIGH);
  digitalWrite(IN4, HIGH);
  delay(500);
  }

Descrição dos Pinos:

GPIO (GPB0 à GPB7) e (GPA0 à GPA7) – São pinos multifunção, podendo ser configurados como INPUT ou OUTPUT individualmente

CS – Chip Select (habilitar transferência de dados)

SCK – Relógio Serial (sinal do relógio do microcontrolador)

SI: MOSI – Saída Mestre, Entrada Escravo (saída do microcontrolador, entrada MCP23S17)

SO: MISO – Entrada Master, Saída Slave (entrada do microcontrolador, saída MCP23S17)

INTA – Pino de interrupção do barramento A

INTB – Pino de interrupção do barramento B

A2, A1 e A0 – Pinos de configuração do endereço do dispositivo.

 A transferência de dados é feita via linhas MOSI e MISO, sendo a linha MOSI utilizada para a transferência de dados do microcontrolador para o expansor de porta, enquanto a linha MISO é utilizada para transferência de dados do expansor de porta para o microcontrolador. O microcontrolador inicia a transferência de dados quando o pino CS é colocado em nível baixo (0) enviando um sinal de clock (SCK).

 

 

Teste de Funcionamento do MCP23S17 – Módulo Expansor Bidirecional 16 bits:

Acesse a página do produto clicando aqui: MCP23S17 – Módulo Expansor Bidirecional 16 bits

 Diagrama eletrônico do teste de funcionamento do Módulo MCP23S17-E/SO com Arduino

Conexões Módulo MCP23S17-E/SO ao Arduino:

Pino VCC do Módulo MCP23S17 = 5V podendo ser alimentado com o próprio VCC ou 5V do Arduino UNO

Pino GND do Módulo MCP23S17 ao GND Arduino UNO

Pino CS do Módulo MCP23S17 ao SPI CS (Uno 10)

Pino SCK do MCP23S17 ao SPI SCK (Uno 13)

Pino SI do Módulo MCP23S17 ao SPI MOSI (Uno 11)

Pino SO do Módulo MCP23S17 ao SPI MISO (Uno 12)

Pino A0, A1, A2 do Módulo MCP23S17 ao GND

Pino RESET do Módulo MCP23S17 através de um resistor de ~10kohm a VCC

Pino A0 (GPA0) do Módulo MCP23S17 ao botão, o outro lado, ao terra

A0 é o pino 0 do barramento A para programação

Pino A1 (GPA1) do Módulo MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

A1 é o pino 1 do barramento A para programação

Pino A2 (GPA2) do Módulo MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

A2 é o pino 2 do barramento A para programação

Pino A3 (GPA3) do Módulo MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

A3 é o pino 3 do barramento A para programação

Pino A4 (GPA4) do Módulo MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

A4 é o pino 4 do barramento A para programação

Pino A5 (GPA5) do Módulo MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

A5 é o pino 5 do barramento A para programação

Pino A6 (GPA6) do Módulo MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

A6 é o pino 6 do barramento A para programação

Pino A7 (GPA7) do Módulo MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

A7 é o pino 7 do barramento A para programação

Pino B0 (GPB0) do Módulo MCP23S17 ao botão, o outro lado ao terra 

BO é o pino 8 do barramento B para programação

Pino B1 (GPB1) do Módulo MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

B1 é o pino 9 do barramento B para programação

Pino B2 (GPB2) do Módulo MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

B2 é o pino 10 do barramento B para programação

Pino B3 (GPB3) do Módulo MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

B3 é o pino 11 do barramento B para programação

Pino B4 (GPB4) do Módulo MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

B4 é o pino 12 do barramento B para programação

Pino B5 (GPB5) do Módulo MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

B5 é o pino 13 do barramento B para programação

Pino B6 (GPB6) do Módulo MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

B6 é o pino 14 do barramento B para programação

Pino B7 (GPB7) do Módulo MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

B7 é o pino 15 do barramento B para programação

 Diagrama eletrônico do teste de funcionamento do Circuito Integrado MCP23S17-E/SO com Arduino

Conexões CI MCP23S17-E/SO ao Arduino:

Pino Vdd MCP23S17 = 5V podendo ser alimentado com o próprio VCC ou 5V do microcontrolador Arduino

Pino nº 9 (Vdd) do MCP23S17 ao VCC ou 5V do microcontrolador Arduino UNO

Pino nº 10 (Vss) do MCP23S17 ao GND do microcontrolador Arduino UNO

Pino nº 11 (CS) do MCP23S17 ao SPI CS (Uno 10)

Pino nº 12 (SCK) do MCP23S17 ao SPI SCK (Uno 13)

Pino nº 13 (SI) do MCP23S17 ao SPI MOSI (Uno 11)

Pino nº 14 (SO) do MCP23S17 ao SPI MISO (Uno 12)

Pino nº 15, 16 e 17 (A0,A1,A2) do MCP23S17 ao GND

Pino nº 18 (RESET) do MCP23S17 através de um resistor de ~10kohm a Vcc

Pino nº 21 (GPA0) do MCP23S17 ao botão, o outro lado ao terra

GPA0 é o pino 0 do barramento A para programação

Pino nº 22 (GPA1) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

GPA1 é o pino 1 do barramento A para programação

Pino nº 23 (GPA2) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

GPA2 é o pino 2 do barramento A para programação

Pino nº 24 (GPA3) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

GPA3 é o pino 3 do barramento A para programação

Pino nº 25 (GPA4) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

GPA4 é o pino 4 do barramento A para programação

Pino nº 26 (GPA5) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

GPA5 é o pino 5 do barramento A para programação

Pino nº 27 (GPA6) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

GPA6 é o pino 6 do barramento A para programação

Pino nº 28 (GPA7) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

GPA7 é o pino 7 do barramento A para programação

Pino nº 1 (GPB0) do MCP23S17 ao botão, o outro lado ao terra

GPB0 é o pino 8 do barramento B para programação

Pino nº 2 (GPB1) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

GPB1 é o pino 9 do barramento B para programação

Pino nº 3 (GPB2) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

GPB2 é o pino 10 do barramento B para programação

Pino nº 4 (GPB3) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

GPB3 é o pino 11 do barramento B para programação

Pino nº 5 (GPB4) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

GPB4 é o pino 12 do barramento B para programação

Pino nº 6 (GPB5) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

GPB5 é o pino 13 do barramento B para programação

Pino nº 7 (GPB6) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

GPB6 é o pino 14 do barramento B para programação

Pino nº 8 (GPB7) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm

Para mais informações, acesse o datasheet clicando aqui!

Software de funcionamento:

/* ===================================================================================================================== 

                                      ELETRODEX ELETRÔNICA  Teste MCP23S17 

   ===================================================================================================================== 

   Para funcionamento definimos como entrada os pinos 0 e 8, sendo o 0 o acionamento por botão 

   do banco A e o 8, o acionamento por botão do Banco B. 

    Pino Vdd MCP23S17 = 5V podendo ser alimentado com o próprio microcontrolador (Vcc) 

   Pino nº 9 (Vdd) do MCP23S17 a Vcc (alimentação do IC) 

   Pino nº 10 (Vss) do MCP23S17 ao terra (terra do IC) 

   Pino nº nº 11 (CS) do MCP23S17 ao SPI CS (Uno 10) 

   Pino nº 12 (SCK) do MCP23S17 ao SPI SCK (Uno 13) 

   Pino nº pino nº 13 (SI) do MCP23S17 ao SPI MOSI (Uno 11) 

   Pino nº pino nº 14 (SO) do MCP23S17 ao SPI MISO (Uno 12) 

   Pino nº pinos 15, 16 e 17 (A0,A1,A2) do MCP23S17 ao terra 

   Pino nº pino 18 (RESET) do MCP23S17 através de um resistor de ~10kohm a Vcc 

   Pino nº pino 21 (GPA0) do MCP23S17 ao botão, o outro lado ao terra | GPA0 é o pino 0 do barramento A para programação 

   Pino nº pino 22 (GPA1) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm | GPA1 é o pino 1 do barramento A para programação 

   Pino nº pino 23 (GPA2) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm | GPA2 é o pino 2 do barramento A para programação 

   Pino nº pino 24 (GPA3) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm | GPA3 é o pino 3 do barramento A para programação 

   Pino nº pino 25 (GPA4) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm | GPA4 é o pino 4 do barramento A para programação 

   Pino nº pino 26 (GPA5) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm | GPA5 é o pino 5 do barramento A para programação 

   Pino nº pino 27 (GPA6) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm | GPA6 é o pino 6 do barramento A para programação 

   Pino nº pino 28 (GPA7) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm | GPA7 é o pino 7 do barramento A para programação 

   Pino nº pino 1 (GPB0) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm | GPBO é o pino 1 do barramento B para programação 

   Pino nº pino 2 (GPB1) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm | GPB1 é o pino 2 do barramento B para programação 

   Pino nº pino 3 (GPB2) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm | GPB2 é o pino 3 do barramento B para programação 

   Pino nº pino 4 (GPB3) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm | GPB3 é o pino 4 do barramento B para programação 

   Pino nº pino 5 (GPB4) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm | GPB4 é o pino 5 do barramento B para programação 

   Pino nº pino 6 (GPB5) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm | GPB5 é o pino 6 do barramento B para programação 

   Pino nº pino 7 (GPB6) do MCP23S17 ao cátodo do LED, o outro lado ao Vcc através do resistor de 470ohm | GPB6 é o pino 7 do barramento B para programação 

   Pino nº pino 8 (GPB7) do MCP23S17 aao botão, o outro lado ao terra | GPA0 é o pino 8 do barramento B para programação 

*/ 

#include           // Arduino SPI library 

#include      // Majenko MCP23S17 Library 

 

const uint8_t chipSelect = 10; 

MCP23S17 BancoA(&SPI, chipSelect, 0);    // usando endereço padrão 0 

MCP23S17 BancoB(&SPI, chipSelect, 0);    // usando endereço padrão 0 

 

//=================================================================================================================== 

//  Iniciando 

//=================================================================================================================== 

  void setup() { 

  BancoA.begin();            // usando endereço padrão 0 

  BancoB.begin();            // usando endereço padrão 1 

  BancoA.pinMode(0, INPUT_PULLUP);  // Botão de entrada entrada 

  BancoB.pinMode(8, INPUT_PULLUP);  // Botão de entrada entrada 

  BancoA.pinMode(1, OUTPUT); // LED1 de saída 

  BancoA.pinMode(2, OUTPUT); // LED2 de saída 

  BancoA.pinMode(3, OUTPUT); // LED3 de saída 

  BancoA.pinMode(4, OUTPUT); // LED4 de saída 

  BancoA.pinMode(5, OUTPUT); // LED5 de saída 

  BancoA.pinMode(6, OUTPUT); // LED6 de saída 

  BancoA.pinMode(7, OUTPUT); // LED7 de saída 

  BancoB.pinMode(9, OUTPUT); // LED8 de saída 

  BancoB.pinMode(10, OUTPUT); // LED9 de saída 

  BancoB.pinMode(11, OUTPUT); // LED10 de saída 

  BancoB.pinMode(12, OUTPUT); // LED12 de saída 

  BancoB.pinMode(13, OUTPUT); // LED13 de saída 

  BancoB.pinMode(14, OUTPUT); // LED14 de saída 

  BancoB.pinMode(15, OUTPUT); // LED15 de saída 


 Serial.begin(9600); 

 Serial.print(" TESTE MCP23S17 "); 

} 


void loop() { 

  int BotaoA = 0; 

  int BotaoB = 8; 

 
 BotaoA = BancoA.digitalRead(0); 

 BotaoB = BancoB.digitalRead(8); 

 
//CONDIÇÃO BANCO A 

  if (BotaoA == 0)  // Se botão pressionado 

   { BancoA.digitalWrite(1, LOW);  // Acende LED 1 

    //Serial.println("LED1 LIGADO"); 

    BancoA.digitalWrite(2, LOW);  // Acende LED 2 

    //Serial.println("LED2 LIGADO"); 

    BancoA.digitalWrite(3, LOW);  // Acende LED 3 

    //Serial.println("LED3 LIGADO"); 

     BancoA.digitalWrite(4, LOW);  // Acende LED 4 

    //Serial.println("LED3 LIGADO"); 

     BancoA.digitalWrite(5, LOW);  // Acende LED 5 

    //Serial.println("LED3 LIGADO"); 

     BancoA.digitalWrite(6, LOW);  // Acende LED 6 

    //Serial.println("LED3 LIGADO"); 

     BancoA.digitalWrite(7, LOW);  // Acende LED 7 

    //Serial.println("LED3 LIGADO"); 

    Serial.println("Botão Banco A pressionado, LED's Banco A acionados"); 
  
    } 

  else 

   { BancoA.digitalWrite(1, HIGH); // Apaga LED 1 

   //Serial.println("LED1 APAGADO"); 

   BancoA.digitalWrite(2, HIGH);  // Apaga LED 2 

   //Serial.println("LED2 LIGADO"); 

   BancoA.digitalWrite(3, HIGH);  // Apaga LED 3 

   //Serial.println("LED3 LIGADO"); 

   BancoA.digitalWrite(4, HIGH);  // Apaga LED 4 

   //Serial.println("LED4 LIGADO"); 

   BancoA.digitalWrite(5, HIGH);  // Apaga LED 5 

   //Serial.println("LED5 LIGADO"); 

   BancoA.digitalWrite(6, HIGH);  // Apaga LED 6 

   //Serial.println("LED6 LIGADO"); 

   BancoA.digitalWrite(7, HIGH);  // Apaga LED 7 

   //Serial.println("LED's Banco A Apagados"); 

   delay(100);} 
 
//CONDIÇÃO BANCO B 

      if (BotaoB == 0)  // Se botão pressionado 

   { BancoB.digitalWrite(9, LOW);  // Acende LED 1 

   BancoB.digitalWrite(10, LOW);  // Acende LED 2 

   BancoB.digitalWrite(11, LOW);  // Acende LED 3 

   BancoB.digitalWrite(12, LOW);  // Acende LED 4 

   BancoB.digitalWrite(13, LOW);  // Acende LED 5 

   BancoB.digitalWrite(14, LOW);  // Acende LED 6 

   BancoB.digitalWrite(15, LOW);  // Acende LED 7 

   Serial.println("Botão Banco B pressionado, LED's Banco B acionados");} 

   else{ 

   BancoB.digitalWrite(9, HIGH); // Apaga LED 1 

   BancoB.digitalWrite(10, HIGH); // Apaga LED 2 

   BancoB.digitalWrite(11, HIGH); // Apaga LED 3 

   BancoB.digitalWrite(12, HIGH); // Apaga LED 4 

   BancoB.digitalWrite(13, HIGH); // Apaga LED 5 

   BancoB.digitalWrite(14, HIGH); // Apaga LED 6 

   BancoB.digitalWrite(15, HIGH); // Apaga LED 7 

   //Serial.println("LED's Banco B Apagados");    

      } 

} 

Confira o vídeo com o teste de funcionamento do SCT-013 – Sensor de Corrente não Invasivo
100A clicando aqui!

O SCT-013 é um excelente sensor para medições de corrente alternada de forma não invasiva, podendo assim, ter contato direto com os fios elétricos para aferição da variação do campo magnético. O SCT-013 possui capacidade de medição de até 100A, e é uma ótima opção para medições de forma segura, e de fácil instalação, sendo necessário apenas a inserção do fio pelo sensor.

O sensor SCT-013 é amplamente utilizado em desenvolvimento de projetos de automação residencial, comercial e projetos didáticos com a utilização de microcontroladores como o Arduino, atuando na medição de corrente elétrica dos mais diversos sistemas.

Conexão de montagem para teste do SCT-013 Sensor de Corrente não Invasivo 100A

Conexão do SCT-013

• Insira dois fios (colocamos um amarelo e um laranja) em um conector Jack J2 para cabo, que pode ser encontrado clicando aqui
• Conecte o Plug do Sensor SCT-013 ao conector Jack J2
• O fio amarelo deve ser conectado juntamente com o terminal positivo do capacitor de 100uf, um dos terminais de cada um dos dos dois resistores de 10 KOhms (Marrom, Preto, Laranja, Dourado), e um dos terminais de 330 Ohms (Laranja, Laranja, Marrom, Dourado) também devem ser conectados ao fio amarelo.
• O outro lado de um dos resistores de 10 KOhms deve ser conectado ao negativo do capacitor e o outro lado do resistor de 10 Kohms deve ser conectado ao positivo 5VCC do arduino
• O fio laranja deve ser conectado no outro terminal do resistor de 330 Ohms juntamente com o Pino A0 do arduino

Conexão do Display LCD

• Pino 1 (VSS) – Conectado ao GND do Arduino
• Pino 2 (VDD) – Conectado ao 5V+ do Arduino
• Pino 3 (V0) – Conectado ao pino 2 do potenciometro, o pino 1 do potenciômetro deve ser conectado ao GND e o pino 3 do potenciômetro deve ser conectado ao pino 3.
• Pino 4 (RS) – Conectado ao pino 12 do Arduino
• Pino 5 (RW) – Conectado ao pino GND do Arduino
• Pino 6 (E) – Conectado ao pino 13 do Arduino
• Pino 11 (D4) – Conectado ao pino 7 do Arduino
• Pino 12 (D5) – Conectado ao pino 6 do Arduino
• Pino 13 (D6) – Conectado ao pino 5 do Arduino
• Pino 14 (D7) – Conectado ao pino 4 do Arduino
• Pino 15 (A) – Conectado ao pino 5V do Arduino
• Pino 16 (K) – Conectado ao pino GND do Arduino

Circuito de medição de corrente utilizado para teste do SCT-013 Sensor de Corrente não Invasivo 100A

Após efetuada a montagem, basta inserir o sensor no circuito para a medição de corrente. O teste efetuado foi feito utilizando um ferro Hikari SC-50 de 42W, conectado diretamente a rede elétrica. Para facilitar a medição fizemos uma extensão com fios paralelos para medição de apenas um dos fios, (para a medição correta de corrente do circuito, deve-se utilizar apenas um dos fios). Foi inserido no circuito um alicate amperímetro de modo a comprovar a eficácia de medição do sensor SCT-013.

Software utilizado para teste do SCT-013 Sensor de Corrente não Invasivo 100A, mensurando corrente e potência

Após efetuada a montagem, faça a exportação da biblioteca “EmonLib-master” disponibilizada na descrição do vídeo ou na descrição do anúncio do produto, para dentro da IDE do Arduino, e compile o”Software utilizado para teste do SCT-013 Sensor de Corrente não Invasivo 100A, mensurando corrente e potência”, para o Arduino.

/*********************************************** Eletrodex Eletrônica*********************************************

****************** Teste SCT-013 Sensor de Corrente não Invasivo 100A **************

***************************************************************************/

 

#include "EmonLib.h"

#include <LiquidCrystal.h>

EnergyMonitor SCT013;

LiquidCrystal lcd(12, 13, 7, 6, 5, 4); // Pinagem do LCD

 

int pinSCT = A0;   //Pino analógico conectado ao SCT-013

int tensao = 127;

int potencia;

int correntea;

 

void setup()

{

SCT013.current(pinSCT, 6.0606);

Serial.begin(9600);

lcd.begin(16, 2);

lcd.clear();

lcd.setCursor (0,0);

lcd.print("----Eletrodex---");

lcd.setCursor (1,1);

lcd.print("Sensor  SCT013");

delay(6000);

lcd.clear();

 

 

}

void loop()

{

double Irms = SCT013.calcIrms(1480);   // Calcula o valor da Corrente

 

 

potencia = Irms * tensao;   // Calcula o valor da Potencia Instantanea

Serial.print("Corrente = ");

Serial.print(Irms);

Serial.println(" A");

 

Serial.print("Potencia = ");

Serial.print(potencia);

Serial.println(" W");

 

delay(200);

Serial.print(".");

delay(200);

Serial.print(".");

delay(200);

Serial.println(".");

delay(200);

 

lcd.clear();

lcd.setCursor(1, 0);      // 2 = 2 colunas para a direita. 1 = Segunda linha

lcd.print("Corrente");

lcd.setCursor(10, 0);

lcd.print(Irms);

lcd.print("A");

lcd.setCursor(2, 1);

lcd.print("Potencia");

lcd.setCursor(11, 1);

lcd.print(potencia);

lcd.print("W");

delay(1000);
}

No monitor serial é possível a visualização da medição de corrente e potência efetuadas pelo sensor SCT-013.

O sensor de cores utiliza o chip TCS3200 para detectar os níveis de luzes RGB dos objetos através do envio de dados para um microcontrolador, como o Arduino, Rasbperry, Pic, entre outros. Esse chip tem 64 fotodiodos, sendo com 16 filtros para a cor vermelha, 16 para a verde, 16 para a azul e 16 sem filtro, permitindo a criação de sistemas detecção de cores eficientes. Também possui quatro LEDs brancos para iluminação e oito pinos de conexão.

O vídeo com o demonstrativo de funcionamento do Sensor de Cores TCS3200 pode ser acessado clicando aqui

Materiais Utilizados:

• Sensor de Cores TCS3200
• LED RGB – OSTAPA5B3AA – Alto brilho Anodo Comum 30°
• Display Pinagem Superior 16×2 – 1602A-ELE – Azul
• Arduino Uno

Como o Sensor de Cores TCS3200 funciona?

Os 64 fotodiodos que estão distribuídos de forma uniformemente no sensor, são responsáveis por captar a luminosidade, filtrar as cores recebidas e gerar na saída do sensor um sinal de onda quadrada que traz informações sobre a intensidade das cores RGB (Red, Green, Blue). Ele atua efetuando uma análise do comprimento de onda de cada uma as cores RGB, e torna essas informações disponíveis para verificação de qual cor foi identificada. Além disso, com a identificação dos valores RGB lidos, pode-se efetuar também mudanças no código de programação, de modo que sensor reconheça não só as cores RGB, mais também as demais cores.

Descrição de pinagem do Sensor

Tabela de Nível Lógico disponibilizada no Datahseet do chip TCS3200

Conexão de montagem para teste do sensor de Cores TCS3200 utilizando LED RGB na exibição do reconhecimento das cores RGB

Conexão Sensor de Cor:

 Pino GND do sensor: Conectado ao GND do Arduino

Pino OE do sensor: Não conectado

Pino S0 do sensor: Conectado ao pino 9 do Arduino

Pino S1 do sensor: Conectado ao pino 10 do Arduino

Pino S2 do sensor: Conectado ao pino 11 do Arduino

Pino S3 do sensor: Conectado ao pino 12 do Arduino

Pino OUT do sensor: Conectado ao pino 8 do Arduino

Pino VCC do sensor: Conectado ao 5V do Arduino

Atenção:  Devido as diferentes variações de LED RGB Anodo Comum disponíveis no mercado, pode-se haver a inversão dos pinos G e B. É aconselhável a efetuação do teste pino a pino para averiguação da ordem das cores, de modo a garantir o correto funcionamento do sistema de exibição de reconhecimento da cor.

Conexão LED RGB:

 Pino 1 do LED (R – Vermelho): Conectado ao pino 2 do Arduino, e ao resistor

de 150 ohms, o outro lado do resistor deve ser conectado ao GND do Arduino.

Pino 2 do LED (Anodo Comum): Conectado ao VCC do Arduino.

Pino 3 do LED (B – Azul): Conectado ao pino 3 do Arduino, e ao resistor de

100 ohms, o outro lado do resistor deve ser conectado ao GND do Arduino.

Pino 4 do LED (G – Verde): Conectado ao pino 4 do Arduino, e ao resistor

de 100 ohms, o outro lado do resistor deve ser conectado ao GND do Arduino.

Após efetuada a montagem, como demonstrado acima, compile o código “teste do sensor de Cores TCS3200 utilizando LED RGB na exibição do reconhecimento das cores RGB” disponibilizado no fim do roteiro, para o microcontrolador Arduino como demonstrado abaixo, e faça o teste de reconhecimento das cores

Conexão de montagem para teste do sensor de Cores TCS3200 utilizando Display LCD na exibição do reconhecimento das cores

Conexão Sensor de Cor:

Pino GND do sensor: Conectado ao GND do Arduino

Pino OE do sensor: Não conectado

Pino S0 do sensor: Conectado ao pino 9 do Arduino

Pino S1 do sensor: Conectado ao pino 10 do Arduino

Pino S2 do sensor: Conectado ao pino 11 do Arduino

Pino S3 do sensor: Conectado ao pino 12 do Arduino

Pino OUT do sensor: Conectado ao pino 8 do Arduino

Pino VCC do sensor: Conectado ao 5V do Arduino

Conexão Display:

Pino 1 do Display: Conectado ao GND do Arduino

Pino 2 do Display: Conectado ao 5V do Arduino

Pino 3 do Display: Conectado ao pino 2 do Potenciômetro

Pino 4 do Display: Conectado ao pino 2 do Arduino

Pino 5 do Display: Conectado ao pino GND do Arduino

Pino 6 do Display: Conectado ao pino 3 do Arduino

Pino 11 do Display: Conectado ao pino 4 do Arduino

Pino 12 do Display: Conectado ao pino 5 do Arduino

Pino 13 do Display: Conectado ao pino 6 do Arduino

Pino 14 do Display: Conectado ao pino 7 do Arduino

Pino 15 do Display: Conectado a dois resistores de 220 Ohms, o outro lado dos resistores vai no 5V do Arduino

Pino 16 do Display: Conectado ao GND do Arduino

Conexão Potenciômetro:

Pino 1 Potenciômetro: Conectado ao GND do Arduino

Pino 2 Potenciômetro: Conectado ao pino 3 do Display

Pino 3 Potenciômetro: Conectado ao 5V do Arduino

Após efetuada a montagem, como demonstrado acima, compile o código “teste do sensor de Cores TCS3200 utilizando Display LCD para reconhecimento das cores” disponibilizado no fim do roteiro, para o microcontrolador Arduino, e faça o teste de reconhecimento das cores, como demonstrado no vídeo. Vale ressaltar que o teste efetuado foi feito em um laboratório com luminosidade ambiente, sofrendo interferência direta da iluminação externa. Para uso do sensor utilizando esse software, indicamos uma proteção ao sensor contra luminosidade externa, garantindo assim uma fiel leitura do sensor sem variações de iluminação pois a variação de iluminação afeta diretamente no reconhecimento e definição das cores pelo reconhecimento utilizando o código disponibilizado.

Com o código compilado para o Arduino, abra o monitor serial, ou analise no próprio Display LCD os valores lidos. Inicialmente aparecerá “Sem cor detectado!”, com os valores de Vermelho, Verde e Azul no monitor serial, ou R, G e B no display.  Como demostrado a seguir:

Adicione o cartão com a cor a ser detectada, e analise novamente os valores lidos. Os valores lidos são os valores referentes a cor a ser detectada, assim, no campo “readRGB” do software, edite esses valores para o range dentro dos valores lidos.

Como exemplo, falaremos sobre a leitura efetuada da cor Vermelho. Os valores lidos, como pode ser visto no display da primeira amostragem de cor, foi R=10, G=21 e B=17; sendo assim, vamos editar os valores da linha da cor vermelho, colocando os valores dentro do range, dando um pequeno intervalo entre os valores. A variável R (Vermelho) possui valor de 10, então colocamos como mínimo > 8, e como máximo <12 garantindo um range de 9 a 11.  Na variável G (Verde) colocamos como mínimo > 19, e como máximo <23 garantindo um range de 20 à 22, e Na variável B (Azul) colocamos como mínimo > 15, e como máximo <19 garantindo um range de 16 à 18, assim, a leitura dentro do intervalo dos valores setados retorna a leitura da cor Vermelho.

Para detecção das demais cores, efetuamos a leitura dos valores referentes a cada cor, e reconfiguramos os intervalos dos valores na linha da respectiva cor, assim como efetuamos com vermelho.
Efetuado a reconfiguração de todas as cores, recompilamos o código e testamos as cores como se segue, sendo as cores detectadas com êxito, comprovando assim, a aprovação do sensor de cores.

Vale ressaltar que, como o teste efetuado não foi feito em um ambiente controlado, a cada mudança externa do clima como o clarear ou o escurecer do dia chuvoso em que efetuamos o teste, foi-se necessário refazer a reconfiguração dos valores das cores. Para a solução desse problema pode-se implementar uma função filtro no código de programação, ou garantir uma proteção contra a luminosidade externa ao sensor. 

SOFTWARES utilizados para Teste:

SOFTWARE 1: Utilizando LED RGB

/********************* Eletrodex Eletrônica *************************
********* Teste do Sensor de cor TCS3200 utilizando LED RGB ************
************ na exibição do reconhecimento das cores RGB *************
****************************************************************/
//Definicão de conexão dos pinos do módulo ao Arduino
const int s0 = 9;
const int s1 = 10;
const int s2 = 11;
const int s3 = 12;
const int out = 8;
//Definicão de conexão dos pinos do LED RGB ao Arduino
int pinoledverm = 2;
int pinoledverd = 4;
int pinoledazul = 3;
 
//Variaveis cores
int red = 0;
int green = 0;
int blue = 0;
 
void setup()
{ //Definicão de entradas e saídas
  pinMode(s0, OUTPUT);
  pinMode(s1, OUTPUT);
  pinMode(s2, OUTPUT);
  pinMode(s3, OUTPUT);
  pinMode(out, INPUT);
  pinMode(pinoledverm, OUTPUT);
  pinMode(pinoledverd, OUTPUT);
  pinMode(pinoledazul, OUTPUT);
  Serial.begin(9600);
  digitalWrite(s0, HIGH);
  digitalWrite(s1, LOW);
}
 
void loop()
{
  //Deteção de cores
  color();
  //Exibição dos valores das cores no serial monitor
  Serial.print("Vermelho :");
  Serial.print(red, DEC);
  Serial.print(" Verde : ");
  Serial.print(green, DEC);
  Serial.print(" Azul : ");
  Serial.print(blue, DEC);
  Serial.println();
 
  //Verifica se a cor vermelha foi detectada
  if (red < blue && red < green && red < 100)
  {
    Serial.println("Vermelho");
    digitalWrite(pinoledverm, LOW); //Acende o led vermelho
    digitalWrite(pinoledverd, HIGH);
    digitalWrite(pinoledazul, HIGH);
  }
 
  //Verifica se a cor azul foi detectada
  else if (blue < red && blue < green && blue < 1000)
  {
    Serial.println("Azul");
    digitalWrite(pinoledverm, HIGH);
    digitalWrite(pinoledverd, HIGH);
    digitalWrite(pinoledazul, LOW); //Acende o led azul
  }
 
  //Verifica se a cor verde foi detectada
  else if (green < red && green < blue)
  {
    Serial.println("Verde");
    digitalWrite(pinoledverm, HIGH);
    digitalWrite(pinoledverd, LOW); //Acende o led verde
    digitalWrite(pinoledazul, HIGH);
  }
  Serial.println();
 
  //Delay para reiniciar o processo
  delay(50);
  digitalWrite(pinoledverm, HIGH);
  digitalWrite(pinoledverd, HIGH);
  digitalWrite(pinoledazul, HIGH);
}
 
void color()
{
  //Rotina que lê o valor das cores
  digitalWrite(s2, LOW);
  digitalWrite(s3, LOW);
  //count OUT, pRed, RED
  red = pulseIn(out, digitalRead(out) == HIGH ? LOW : HIGH);
  digitalWrite(s3, HIGH);
  //count OUT, pBLUE, BLUE
  blue = pulseIn(out, digitalRead(out) == HIGH ? LOW : HIGH);
  digitalWrite(s2, HIGH);
  //count OUT, pGreen, GREEN
  green = pulseIn(out, digitalRead(out) == HIGH ? LOW : HIGH);
}

SOFTWARE 2: Utilizando Display LCD

/********************* Eletrodex Eletrônica ********************
********* Teste do Sensor de cor TCS3200 utilizando ************
************ Display LCD para reconhecimento das cores *********
****************************************************************/


#include 
LiquidCrystal lcd(2, 3, 4, 5, 6, 7);

#define outPin 8
#define s0 9
#define s1 10
#define s2 11
#define s3 12

boolean DEBUG = true;

// Variáveis
int Vermelho, Verde, Azul;
String cor ="";
long startTiming = 0;
long elapsedTime =0;

void setup(){
  Serial.begin(9600);
  
  pinMode(s0, OUTPUT); //Definição de entrada e saída dos pinos do arduino
  pinMode(s1, OUTPUT);
  pinMode(s2, OUTPUT);
  pinMode(s3, OUTPUT);
  pinMode(outPin, INPUT); 

  // Configurando a escala de frequência para 100% em nível alto
  digitalWrite(s0,HIGH);
  digitalWrite(s1,HIGH);

  lcd.begin(16, 2);
  lcd.clear();
  lcd.setCursor (1,0);
  lcd.print("---Eletodex---");
  lcd.setCursor (1,1);
  lcd.print("Sensor de cor");
  delay(6000);  
  lcd.clear();  
  startTiming = millis();
}

void loop(){
  getcor();
   
  if(DEBUG)printData(); 
  elapsedTime = millis()-startTiming; 
  if (elapsedTime > 1000) {
     showDataLCD();
    startTiming = millis();
  }
}

/* Leitura RGB */
void readRGB(){
  Vermelho = 0, Verde=0, Azul=0;
  
  int n = 10;
  for (int i = 0; i < n; ++i){ //Leitura do vermelho digitalWrite(s2, LOW); digitalWrite(s3, LOW); Vermelho = Vermelho + pulseIn(outPin, LOW); //leitura do verde digitalWrite(s2, HIGH); digitalWrite(s3, HIGH); Verde = Verde + pulseIn(outPin, LOW); //leitura do azul digitalWrite(s2, LOW); digitalWrite(s3, HIGH); Azul = Azul + pulseIn(outPin, LOW); } Vermelho = Vermelho/n; Verde = Verde/n; Azul = Azul/n; } /************************************************************** Mostrando os dados da leitura dos valores RBG no Serial Monitor ***************************************************************/ void printData(void){ Serial.print("Vermelho= "); Serial.print(Vermelho); Serial.print(" verde= "); Serial.print(Verde); Serial.print(" Azul= "); Serial.print(Azul); Serial.print (" - "); Serial.print (cor); Serial.println (" detectado!"); } /*************************************************** Mostrando os dados da leitura dos valores RBG no LCD ****************************************************/ void showDataLCD(void){ lcd.clear(); lcd.setCursor (0,0); lcd.print("R"); lcd.print(Vermelho); lcd.setCursor (6,0); lcd.print("G"); lcd.print(Verde); lcd.setCursor (12,0); lcd.print("B"); lcd.print(Azul); lcd.setCursor (0,1); lcd.print("cor: "); lcd.print(cor); } void getcor(){ readRGB(); if(Vermelho>3  && Vermelho<12 && Verde>19 && Verde<23 && Azul>15 && Azul<19) cor = "Vermelho"; else if(Vermelho>14 && Vermelho<18 && Verde>10 && Verde<15 && Azul>6  && Azul<10) cor = "Azul"; else if(Vermelho>13 && Vermelho<17 && Verde>11 && Verde<15 && Azul>11 && Azul<16) cor = "Verde"; else if(Vermelho>24 && Vermelho<29 && Verde>30 && Verde<35 && Azul>24 && Azul<28) cor = "Preto"; else if(Vermelho>6  && Vermelho<10 && Verde>7  && Verde<11 && Azul>5  && Azul<9) cor = "Branco"; else if(Vermelho>5  && Vermelho<8 && Verde>7  && Verde<10 && Azul>10  && Azul<14) cor = "Amarelo";
else  cor = "Sem cor";}

O sensor de Nível de água com mini boia horizontal atua na detecção de nível de líquidos por meio do sensor magnético embutido internamente, que é acionado com a elevação da boia horizontal. Ao detectar o líquido o sensor fecha o seu contato NA, de modo que o sinal possa ser enviado a um relé ou ao microcontrolador permitindo assim, o acionamento de dispositivos sinalizadores, bombas entre outros atuadores de modo automatizado.

Aplicações do Sensor de Nível de Água com mini Boia Horizontal:

• Detectar o nível de líquido em um tanque; pode ativar uma bomba, um indicador, um alarme ou outro dispositivo
• Pode ser usado com hidroponia, aquário de água salgada, água doce, jardinagem, aquários para controle da cabeça de energia, tigelas de estimação, tanques de peixes, filtragem, aquecimento
• Certificar que seu projeto não Contém mercúrio antes de usá-lo.

Conexão do Sensor de Nível de Água com mini Boia Horizontal ao sistema de detecção de nível de líquidos, atuante junto a mini bomba RS-385 12V

Materiais utilizados:

• Sensor de Nível de Água com mini Boia Horizontal;
• Mini Bomba de água p/ Arduino com motor RS-385 12V
• AZ1R – Rele de Potência 10A – AZ1RC2 12VDC
• Chave Alavanca 2 Posições MTS – MTS101 – 2T ON/OFF

Conexão:

• Um dos fios do sensor de nível deve ser conectado a um dos lados da bobina do Relé AZ1RC2 12V;
• O outro fio do sensor de nível deve ser conectado a Normal Fechado (NF) do relé, junto a um dos pinos da chave alavanca MTS101
• O outro pino da chave alavanca deve ser conectado ao positivo da fonte de 12VDC
• O negativo da fonte de 12VDC deve ser conectado ao terminal negativo da mini bomba RS-385 12V com o outro lado da bobina do Relé AZ1RC2 12V
• O terminal positivo da mini bomba RS-385 12V deve ser conectado ao comum do Relé AZ1RC2 12V

Funcionamento:

O sistema de detecção de nível de água, atua por meio do acionamento da chave alavanca ON/OFF que ativa o sistema por meio do sensor de nível com mini boia.

Assim, quando acionada a chave, é feita a ativação da bomba até que o nível da água seja suficiente para levantar a boia do sensor de nível, fechando assim, o contato magnético, indicando o enchimento do recipiente até o nível desejado.

Quando o contato magnético do sensor é acionado, é enviado um sinal ao relé, que comuta o estado com um dos seus contatos, de NF para NA, finalizando a operação de bombeamento da mini bomba.

Organização do roteiro:

• Teste do Módulo Bluetooth HC-05 Master/Slave por meio do acionamento de Led’s via celular, demonstrando a atuação no modo de Comunicação. (PÁG 1)
• Teste do Módulo Bluetooth HC-05 Master/Slave por meio do demonstrativo da ativação dos modos AT e Comunicação. (PÁG 4)
• Software de ativação dos modos AT e Comunicação no Módulo Bluethooth HC-05 Master/Slave. (PÁG 5)
• Software de acionamento de Led’s via celular utilizando o Módulo Bluetooth HC-05 Master/Slave. (PÁG 6)

O vídeo com o demonstrativo de funcionamento das duas formas de teste pode ser acessado clicando aqui!

Teste do Módulo Bluetooth HC-05 Master/Slave por meio do acionamento de Led’s via celular, demonstrando a atuação no modo de Comunicação.

Para o acionamento de Led’s via celular utilizando o Módulo Bluetooth HC-05 Master/Slave serão necessários para a montagem do circuito:

1 Arduíno Uno

1 Módulo Bluetooth HC-05 Master/Slave

7 Led’s

7 Resistores de 220 Ohms (vermelho, vermelho, marrom dourado)

1 Resistor de 1K Ohms (marrom, preto, vermelho e dourado)

1 Resistor de 2,2K Ohms (vermelho, vermelho, vermelho dourado)

Esquema eletrônico do acionamento de Led’s via Módulo Bluetooth HC-05 Master/Slave:

Após a montagem como no esquemático acima, deve ser feito o pareamento do bluetooth do seu aparelho smartphone com o módulo HC-05. Para isso, basta ativar o bluetooth do celular e selecionar “Parear novo dispositivo”, a procura irá retornar o bluetooth do módulo, geralmente de nome HC-05; ao seleciona-lo, uma senha será requisitada, essa senha geralmente é 0000, ou 1234. Digite 1234 e clique em OK.

Agora, faça o download do software de comunicação Bluetooth na loja play store em seu smartphone. O aplicativo de comunicação Bluetooth utilizado nesse teste foi o Bluetooth SPP Manager, demonstrado a seguir:

Após a instalação do aplicativo, deve-se fazer upload da programação de funcionamento para o arduíno. A programação efetuada está disponibilizada na descrição desse módulo, em Software de acionamento de Led’s via celular utilizando o Módulo Bluetooth HC-05 Master/Slave.

Funcionamento do projeto:

Abra o aplicativo Bluetooth SPP Manager; na aba Devices selecione o Device:HC-05 e aguarde até que a conexão seja estabilizada. Será exibido connecting referente a conectando, e se tudo ocorrer como o esperado, a conexão será estabilizada exibindo connection established como a seguir:

Com a conexão estabilizada, na aba Bt Messenger Digite as letras maiúsculas de “A” à “G” para acender o led referente a ele. Como nos exemplos a seguir, “A” acende o último LED, “B” acende o penúltimo e assim por diante.

A imagem a seguir demonstra o comando enviado com todas as letras maiúsculas referente a todos os leds, acionando assim, todos os 7 led’s.

Digite as letras minúsculas para apagar o led referente a ele. Como nos exemplos a seguir, “a” apaga o último LED, “b” apaga o penúltimo e assim por diante.

Já para o desligamento de todos os leds basta enviar o comando minúsculo de todas as letras de “a” à “g” referente a todos os leds, assim, todos os 7 led’s serão apagados juntamente, como pode ser visto a seguir:

Teste do Módulo Bluetooth HC-05 Master/Slave por meio do demonstrativo da ativação dos modos AT e Comunicação.

Organização do roteiro de Teste do Módulo Bluetooth HC-05 Master/Slave por meio do demonstrativo da ativação dos modos AT e Comunicação. 

• Detalhamento MODO AT.
• Acesso a tabela de comandos AT, e ao vídeo explicativo.
• Esquema eletrônico de conexão para ativação do modo AT no Módulo Bluetooth HC-05 Master/Slave.
• Software de ativação dos modos AT e Comunicação no Módulo Bluethooth HC-05 Master/Slave.

__________________________ Detalhamento MODO AT _________________________

No monitor serial, em taxa de transmissão, os campos de modo de dados e velocidade devem estar Ambos, NL e CL; e 9600 selecionados inicialmente para utilização da programação disponibilizada. Caso necessite modificar a velocidade de transmissão de 9600 para 38400 no código, essa modificação também deve ser feita no monitor serial, se não a frase “Digite os comandos AT:” não será impressa corretamente, exibindo apenas caracteres sem sentidos.

1.Como chegar ao modo AT.

Modo 1: Retire o fio de alimentação 5V que sai do Arduino para o VCC do módulo, pressione o botão de reset do módulo bluetooth por 5 segundos e ainda segurando o botão, conecte novamente o fio referente ao pino VCC do módulo, no 5V do arduino. O led piscará com intervalo de 2 segundos indicando que o módulo entrou no moto AT.

Modo 2: Retire o fio de alimentação 5V que sai do Arduino para o VCC do módulo, coloque o pino EN (KEY) do módulo em nível baixo. Conecte novamente o fio referente ao pino VCC do módulo, no 5V do arduino. Coloque o Pino EN (KEY ou PIN34) em nível alto. O led piscará com intervalo de 2 segundos indicando que o módulo entrou no moto AT.

Modo 3: Coloque o pino EN(KEY) em nível baixo. Retire o fio de alimentação 5V que sai do Arduino para o VCC do módulo, aguarde por 5 segundos. Conecte o pino EN(KEY) ao PIN 3.3V. Em seguida reconecte o fio de alimentação 5V que sai do Arduino para o VCC do módulo. O módulo entrará no modo AT. Mas neste momento, a taxa de velocidade é 38400. Desta forma, o usuário deve alterar a taxa de transmissão no arduino e no monitor serial.

 2. Como voltar ao modo de comunicação:

Modo 1: Insira o nível baixo (LOW) no EN(KEY), em seguida Insira o nível alto (HIGH) no EN(KEY). Assim o módulo entrará no modo de comunicação e pode ser usado para emparelhamento.

Modo 2: Insira o nível baixo (LOW) no EN(KEY), em seguida retire a alimentação VCC, pressione o botão por 3 segundos, e com ele ainda pressionado, conecte novamente o fio referente ao pino VCC do módulo, no 5V do Arduino.

3.Notas.

(1) Os comandos do HC-03 e HC-05 devem terminar com “\r\n”. Significa que quando você terminar a programação, você deve clicar em (“ENTER” ou “0x0d 0x0a”). Já os módulos HC-04 e HC-06 não precisam desse comando final.

(2) Os comandos mais comuns para HC-03 e HC-05 são: AT+NAME (para visualizar ou modificar o nome do módulo), AT+VERSION (para visualizar a verão do firmware), AT+ROLE (set master–slave), AT+CMODE(para definir pareamento de endereços), AT+PSWD (para definir senha). Se você deseja que o módulo mestre tenha a função de conectar com algum módulo escravo em específico e que ele atue sempre sob esse pareamento, o mais maneira simples é: Primeiro, defina AT+CMODE=1. Faça o pareamento do módulo mestre com o módulo escravo. Segundo, defina AT+CMODE=0. Então o módulo mestre só poderá fazer par com aquele módulo escravo especificado.

(3) Quando o pino EN(KEY) mantém o nível alto, todos os comandos podem ser usados. Caso contrário, apenas alguns deles podem ser usados.

2.

_________________ Acesso a tabela de comandos AT, e ao vídeo explicativo_______________

• Para acessar todos os comandos disponíveis no modo AT acesse “Tabela de comandos AT Módulo HC-05” disponibilizada na descrição desse anúncio do Módulo Bluetooth HC-05 Master/Slave, ou clique aqui!
• Para visualizar o vídeo explicativo de todos os passos a serem seguidos clique aqui!

3.

Esquema eletrônico de conexão para ativação do modo AT no Módulo Bluetooth HC-05 Master/Slave 

Software de ativação dos modos AT e Comunicação no Módulo Bluethooth HC-05 Master/Slave

/* --------------------------------------------- Eletrodex Eletrônica ----------------------------------------------------

Software de ativação dos modos AT e Comunicação no Módulo Bluethooth HC-05 Master/Slave

---------------------------------------------------------------------------------------------------------------------------------*/

 

 

#include <SoftwareSerial.h>

 

SoftwareSerial BTSerial( 10, 11); // RX | TX

 

void setup()

{

pinMode(9, OUTPUT); // este pino puxará o pino 34(EN ou KEY) do HC-05 (pino chave) HIGH para mudar o módulo para o modo AT

digitalWrite(9, HIGH);

Serial.begin(9600);

Serial.println("Digite os comandos AT:");

BTSerial.begin(38400); // Velocidade padrão do HC-05 no comando AT more

}

 

void loop()

{

 

// Continue lendo do HC-05 e envie para o Arduino Serial Monitor

if (BTSerial.available())

Serial.write(BTSerial.read());

 

// Continue lendo do Arduino Serial Monitor e envie para HC-05

if (Serial.available())

BTSerial.write(Serial.read());

}

Software de acionamento de Led’s via celular utilizando o Módulo Bluetooth HC-05 Master/Slave

/* --------------------------------------------- Eletrodex Eletrônica ----------------------------------------------------

Software de acionamento de Led’s via celular utilizando o Módulo Bluetooth HC-05 Master/Slave

---------------------------------------------------------------------------------------------------------------------------------*/

 

#include <SoftwareSerial.h>

#define bluetooth Serial

SoftwareSerial mySerial(0, 1); // pinos para comunicação serial

// Conecte o pino RX do módulo no 1(TX) do arduíno uno, e o TX do módulo no pino 0(RX) do arduíno

void setup()

{

pinMode(2, OUTPUT); // Definindo o pino 2 do arduíno como saída de sinal para acionamento do led

pinMode(3, OUTPUT);

pinMode(4, OUTPUT);

pinMode(5, OUTPUT);

pinMode(6, OUTPUT);

pinMode(7, OUTPUT);

pinMode(8, OUTPUT);

pinMode(9, OUTPUT);

pinMode(10, OUTPUT);

pinMode(11, OUTPUT);

pinMode(12, OUTPUT);

pinMode(13, OUTPUT);

bluetooth.begin(9600);

mySerial.begin(9600); // Estabelecendo a comunicação

delay(1000);

}

void loop()

{

char dato= bluetooth.read(); // "dato" é o nome da variável que armazena o valor digitado no celular.

 

switch(dato) //As letras maiúsculas acendem os Leds, e as letras minúsculas apaga os Leds.

{

case 'A': // Se a letra A for digitada, o pino 2 fica em nível alto e o led referente a ele acende.

{

digitalWrite(2, HIGH); // colocando o pino 2 em alto e acendendo o led referente a ele.

break;

}

case 'a': // Se a letra a for digitada, o pino 2 fica em nível baixo e o led referente a ele apaga.

{

digitalWrite(2, LOW); // colocando o pino 2 em baixo e apagando o led referente a ele.

break;

}

 

case 'B':

{

digitalWrite(3, HIGH);

 

break;

}

case 'b':

{

digitalWrite(3, LOW);

 

break;

}

case 'C':

{

digitalWrite(4, HIGH);

break;

}

case 'c':

{

digitalWrite(4, LOW);

break;

}

case 'D':

{

digitalWrite(5, HIGH);

break;

}

 

 

 

case 'd':

{

digitalWrite(5, LOW);

break;

}

case 'E':

{

digitalWrite(6, HIGH);

break;

}

case 'e':

{

digitalWrite(6, LOW);

break;

}

case 'F':

{

digitalWrite(7, HIGH);

break;

}

case 'f':

{

digitalWrite(7, LOW);

break;

}

case 'G':

{

digitalWrite(8, HIGH);

break;

}

case 'g':

{

digitalWrite(8, LOW);

break;

}

 

}

}