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);
      //  }
    }
  }
}

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);
}
}
}

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";}