Display 7 segmentos com Arduino

O display de 7 segmentos

fonte: próprio autor

Esse display possibilita que seja escrito números decimais de 0 a 9, além de outros símbolos comumente utilizados como sinais ou letras.

entre as tecnologias de fabricação existentes para fabricação desses componentes, o mais comum é o display a LED, onde cada segmento é composto por um LED e dividi-se em dois tipos denominados catodo comum e anodo comum.

Como o próprio nome diz, o display catodo comum é aquele que possui todos os catodos dos LEDs interligados, em comum, onde para o acionamento (acender), é necessário aplicar o nível lógico 1 no anodo. No anodo comum todos os anodos dos LEDs estão interligados, sendo necessário o nível lógico 0 para ser acionado.
Então para fazer funcionar alguns comando com Arduino basta acionar um led por saída do e combinar os acionamentos.

fonte: www.physics.udel.edu

Vamos precisar para esse simples tutorial:

1 Arduino Uno (ou compatível)
1 Display 7 segmentos
8 resistores de 220 ohms
1 resistor de 330 ohm
1 resistor de 10 k
1 chave pushbutton
1 protoboard
fios jumpers

Projeto 1 

Na primeira montagem vai ser demonstrado led a led acionando no display, testando as saídas digitais dos pinos 2 a 9.
*Atenção: em todos os projetos os estados altos (HIGH) ou baixos (LOW), vai depender do tipo de display que foi escolhido, catodo ou anodo em comum, alterações em algumas linhas dos códigos podem ser necessárias.

fonte: próprio autor

Utilize o código fonte para testar o programa, lembre-se de que a escolha do display anodo comum ou catodo comum fica conforme a disponibilidade do usuário, atentando-se sempre para a ligação.

/*-----------------------------------------------------------------------
Display LED 7 segmentos
Teste das portas
baseado no original de Just4Fun Media
*************************************************************************
www.mecatronizando.com.br
**************************************************************************
 */
void setup() {
 
for(int x = 2; x < 10; x++) {
  pinMode(x,OUTPUT);
}
}

void loop() {
 
for(int x = 2; x < 10; x++) {
  digitalWrite(x,HIGH);
  delay(1000);
  digitalWrite(x, LOW);
}
for(int x = 2; x < 10; x++) {
  digitalWrite(x,HIGH);
}
delay(1000);
for(int x = 2; x < 10; x++) {
  digitalWrite(x,LOW);
}
}

Projeto 2

Utilizando a mesma montagem do projeto anterior, carregue o código para ver valores crescentes de 0 a 9 no display.

fonte: próprio autor

/*-----------------------------------------------------------------------
Display LED 7 segmentos
Ciclo numerico 0-9
por Tony Emerson Marim 26/11/2016

**************************************************************************
www.mecatronizando.com.br
**************************************************************************
 */
void setup() {
  // put your setup code here, to run once:
for(int x = 2; x < 10; x++) {
  pinMode(x,OUTPUT);
}
}

void loop() {
  // put your main code here, to run repeatedly:
  //ZERO
    digitalWrite(2, LOW);
    digitalWrite(3, LOW);
    digitalWrite(4, LOW);
    digitalWrite(5, LOW);
    digitalWrite(6, LOW);
    digitalWrite(7, LOW);
    digitalWrite(8, HIGH);
    digitalWrite(9, HIGH);
    delay(1000);
  //UM
    digitalWrite(2, HIGH);
    digitalWrite(3, HIGH);
    digitalWrite(4, LOW);
    digitalWrite(5, HIGH);
    digitalWrite(6, HIGH);
    digitalWrite(7, LOW);
    digitalWrite(8, HIGH);
    digitalWrite(9, HIGH);
    delay(1000);
  //DOIS
    digitalWrite(2, HIGH);
    digitalWrite(3, LOW);
    digitalWrite(4, LOW);
    digitalWrite(5, LOW);
    digitalWrite(6, LOW);
    digitalWrite(7, HIGH);
    digitalWrite(8, LOW);
    digitalWrite(9, HIGH);
    delay(1000);
  //TRES
    digitalWrite(2, HIGH);
    digitalWrite(3, LOW);
    digitalWrite(4, LOW);
    digitalWrite(5, HIGH);
    digitalWrite(6, LOW);
    digitalWrite(7, LOW);
    digitalWrite(8, LOW);
    digitalWrite(9, HIGH);
    delay(1000);
  //QUATRO
    digitalWrite(2, LOW);
    digitalWrite(3, HIGH);
    digitalWrite(4, LOW);
    digitalWrite(5, HIGH);
    digitalWrite(6, HIGH);
    digitalWrite(7, LOW);
    digitalWrite(8, LOW);
    digitalWrite(9, HIGH);
    delay(1000);
  //CINCO
    digitalWrite(2, LOW);
    digitalWrite(3, LOW);
    digitalWrite(4, HIGH);
    digitalWrite(5, HIGH);
    digitalWrite(6, LOW);
    digitalWrite(7, LOW);
    digitalWrite(8, LOW);
    digitalWrite(9, HIGH);
    delay(1000);
  //SEIS
    digitalWrite(2, LOW);
    digitalWrite(3, LOW);
    digitalWrite(4, HIGH);
    digitalWrite(5, LOW);
    digitalWrite(6, LOW);
    digitalWrite(7, LOW);
    digitalWrite(8, LOW);
    digitalWrite(9, HIGH);
    delay(1000);
  //SETE
    digitalWrite(2, HIGH);
    digitalWrite(3, LOW);
    digitalWrite(4, LOW);
    digitalWrite(5, HIGH);
    digitalWrite(6, HIGH);
    digitalWrite(7, LOW);
    digitalWrite(8, HIGH);
    digitalWrite(9, HIGH);
    delay(1000);
   //OITO
    digitalWrite(2, LOW);
    digitalWrite(3, LOW);
    digitalWrite(4, LOW);
    digitalWrite(5, LOW);
    digitalWrite(6, LOW);
    digitalWrite(7, LOW);
    digitalWrite(8, LOW);
    digitalWrite(9, HIGH);
    delay(1000);
  //NOVE
    digitalWrite(2, LOW);
    digitalWrite(3, LOW);
    digitalWrite(4, LOW);
    digitalWrite(5, HIGH);
    digitalWrite(6, LOW);
    digitalWrite(7, LOW);
    digitalWrite(8, LOW);
    digitalWrite(9, HIGH);
    delay(1000);
  //"DEZ"
    digitalWrite(2, HIGH);
    digitalWrite(3, HIGH);
    digitalWrite(4, HIGH);
    digitalWrite(5, HIGH);
    digitalWrite(6, HIGH);
    digitalWrite(7, HIGH);
    digitalWrite(8, HIGH);
    digitalWrite(9, HIGH);
  }

Projeto 3

O próximo projeto faz uma integração do usuário com o display por meio do monitor serial do Arduino. O numero digital no teclado é exibido no display.

As ligações do circuito permanecem as mesmas anteriores.

/*-----------------------------------------------------------------------
Teste display 7 segmentos serial
Interface com monitor serial
baseado no original de Just4Fun Media
por Tony Emerson Marim 26/11/2016
*************************************************************************
www.mecatronizando.com.br
**************************************************************************
 */

void setup() {
  // put your setup code here, to run once:
  for(int x = 2; x < 10; x++) {
  pinMode(x,OUTPUT);
  Serial.begin(9600);
  while (!Serial) {
  ; // wait for serial port to connect. Needed for native USB port only
  }
  
}
}

void loop() {
  
  if (Serial.available()) {
    char Num = (Serial.read());
  switch (Num) {
    case '0':
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      digitalWrite(4, HIGH);
      digitalWrite(5, HIGH);
      digitalWrite(6, HIGH);
      digitalWrite(7, HIGH);
      digitalWrite(8, LOW);
      digitalWrite(9, LOW);
      Serial.write(Num);
      break;
  
  case '1':
    digitalWrite(2, LOW);
    digitalWrite(3, LOW);
    digitalWrite(4, HIGH);
    digitalWrite(5, LOW);
    digitalWrite(6, LOW);
    digitalWrite(7, HIGH);
    digitalWrite(8, LOW);
    digitalWrite(9, LOW);
    Serial.write(Num);
    break;
  
  case '2':
    digitalWrite(2, LOW);
    digitalWrite(3, HIGH);
    digitalWrite(4, HIGH);
    digitalWrite(5, HIGH);
    digitalWrite(6, HIGH);
    digitalWrite(7, LOW);
    digitalWrite(8, HIGH);
    digitalWrite(9, LOW);
    Serial.write(Num);
    break;
  
  case '3':
    digitalWrite(2, LOW);
    digitalWrite(3, HIGH);
    digitalWrite(4, HIGH);
    digitalWrite(5, LOW);
    digitalWrite(6, HIGH);
    digitalWrite(7, HIGH);
    digitalWrite(8, HIGH);
    digitalWrite(9, LOW);
    Serial.write(Num);
    break;
  
  case '4':
    digitalWrite(2, HIGH);
    digitalWrite(3, LOW);
    digitalWrite(4, HIGH);
    digitalWrite(5, LOW);
    digitalWrite(6, LOW);
    digitalWrite(7, HIGH);
    digitalWrite(8, HIGH);
    digitalWrite(9, LOW);
    Serial.write(Num);
    break;
  
  case '5':
    digitalWrite(2, HIGH);
    digitalWrite(3, HIGH);
    digitalWrite(4, LOW);
    digitalWrite(5, LOW);
    digitalWrite(6, HIGH);
    digitalWrite(7, HIGH);
    digitalWrite(8, HIGH);
    digitalWrite(9, LOW);
    Serial.write(Num);
    break;
  
  case '6':
    digitalWrite(2, HIGH);
    digitalWrite(3, HIGH);
    digitalWrite(4, LOW);
    digitalWrite(5, HIGH);
    digitalWrite(6, HIGH);
    digitalWrite(7, HIGH);
    digitalWrite(8, HIGH);
    digitalWrite(9, LOW);
    Serial.write(Num);
    break;
  
  case '7':
    digitalWrite(2, LOW);
    digitalWrite(3, HIGH);
    digitalWrite(4, HIGH);
    digitalWrite(5, LOW);
    digitalWrite(6, LOW);
    digitalWrite(7, HIGH);
    digitalWrite(8, LOW);
    digitalWrite(9, LOW);
    Serial.write(Num);
    break;
  
  case '8':
    digitalWrite(2, HIGH);
    digitalWrite(3, HIGH);
    digitalWrite(4, HIGH);
    digitalWrite(5, HIGH);
    digitalWrite(6, HIGH);
    digitalWrite(7, HIGH);
    digitalWrite(8, HIGH);
    digitalWrite(9, LOW);
    Serial.write(Num);
    break;
  
  case '9':
    digitalWrite(2, HIGH);
    digitalWrite(3, HIGH);
    digitalWrite(4, HIGH);
    digitalWrite(5, LOW);
    digitalWrite(6, HIGH);
    digitalWrite(7, HIGH);
    digitalWrite(8, HIGH);
    digitalWrite(9, LOW);
    Serial.write(Num);
    break;
    
  default:
    digitalWrite(2, LOW);
    digitalWrite(3, LOW);
    digitalWrite(4, LOW);
    digitalWrite(5, LOW);
    digitalWrite(6, LOW);
    digitalWrite(7, LOW);
    digitalWrite(8, LOW);
    digitalWrite(9, LOW);
    Serial.write(Num);
    break;
    
  }
  }
}

Projeto 4

Nesse quarto e último projeto, o display vai exibir números de 0 a 9 em ordem crescente. Conforme a necessidade do usuário um botão tipo pushbutton deve ser adotado e a velocidade de troca dos valores dos números exibidos dependem do toque no botão.
Nesse circuito vamos mudar as ligações em relação aos últimos circuitos e criar um esquema mais "enxuto". Basta seguir o desenho abaixo e copiar e colar o código na IDE do seu Arduino.

fonte: próprio autor

/*-----------------------------------------------------------------------
Teste display 7 segmentos com botão
por Tony Emerson Marim 26/11/2016
*************************************************************************
www.mecatronizando.com.br
**************************************************************************
 */

byte numbers[10] = {
B11111100, B01100000, B11011010, B11110010, B01100110,
B10110110, B10111110, B11100000, B11111110, B11100110};

void setup() {
for(int i = 2; i <= 8; i++) {
pinMode(i, OUTPUT);
}
pinMode(9, INPUT);
}
 
int counter = 0;
bool botao = true;
int valor_saida = LOW;
 
void loop() {
if(botao) {
int botao_saida = digitalRead(9);
if(valor_saida == LOW && botao_saida == HIGH) {
counter = (counter + 1) % 10;
}
valor_saida = botao_saida;
} else {
delay(1000);
counter = (counter + 1) % 10;
}
writeNumber(counter);
}
 
void writeNumber(int number) {
if(number < 0 || number > 9) {
return;
}
byte mask = numbers[number];
byte currentPinMask = B10000000;
for(int i = 2; i <= 8; i++) {
if(mask & currentPinMask) digitalWrite(i,HIGH);
else digitalWrite(i,LOW);
currentPinMask = currentPinMask >> 1;
  }
}

No vídeo abaixo é possível ver todos os projetos da página funcionando conforme os passos apresentados. Caso seja necessário, todos os arquivos podem ser baixados por esse LINK.

Gostou?
Curta nossa página no Facebook!
Assine o nosso canal no Youtube, curta e compartilhe para podermos estar sempre trazendo um pouco de programação.

Bons Estudos!

Referências:

Elementos de eletrônica digital

Capuano, Francisco Gabriel/ Idoeta, Ivan Valeije

Controle de acesso por meio do RFID

RFID - Identificão por rádio frequência

A identificação por rádio frequência ou Radio Frequency Identification, consiste em uma tecnologia que utiliza sinais de radio para leitura/gravação de uma tag (etiqueta). Dentro dessa tag uma série de informações estão gravadas e relacionadas com o serviço ou produto, para identificação ou acesso ou outras aplicações. Para ter uma ideia, hoje em dia é comum o uso do RFID no controle à acesso no sistema de transporte público ("Bilhete Único") e no controle sobre acesso em rodovias ("Sem Parar") e logística.

fonte: Wikipedia

No modulo RFID RC522, consegue ler e gravar tag em cartões tipo Mifare que operam na frequência 13,56 Mhz. Utiliza interfaec SPI para comunicação com o Arduino e sua ligação por meio dos pinos digitais de 9 a 13.

Para cada tag do leitor RFID existe uma identificação única que pode ser inserido na programação para definir acessos e prioridades.

fonte:http://rfidblog.com.br/tag/rfid

A pinagem para uma correta ligação do RFID com Arduino deve obedecer a seguinte ordem:

3,3V: Deve ser ligada ao pino de tensão 3,3V do Arduino
RST: Deve ser conectado ao pino 9 do Arduino
GND: GND
IRQ: Não Conectar
MISO: Conectar ao pino 12
MOSI: Conectar ao pino 11
SCK: Conectar ao pino 13
SDA: Conectar ao pino 10

Controle de nível de acesso RFID

O projeto consiste em um controle de acesso para simular uma situação onde as tags relacionadas determinam ao usuário se existe uma atribuição relacionada ao seu número.
Primeiro vamos elaborar um circuito que possibilite ao usuário descobrir os dados que estão gravados no seu cartão, assim poderemos identificar as tags que devem ser inseridas no código e definir as prioridades.

O esquema de ligação

Para começar demos realizar uma montagem conforme o esquema abaixo:

fonte: próprio autor

A ligação de alimentação do módulo deve ser de 3,3V para evitar efeitos prejudiciais à placa! 

O código

Antes de copiar e colar o código, é importante ressaltar que a biblioteca que estou usando pode ser baixado por este Link.

Agora copie e cole o código para ler as tags do seu cartão ou chaveiro RFID.

#include <SPI.h>
#include <MFRC522.h>
 
#define SS_PIN 10
#define RST_PIN 9
MFRC522 mfrc522(SS_PIN, RST_PIN);
 
void setup() 
{
  Serial.begin(9600);   // Inicia a serial
  SPI.begin();      // Inicia  SPI bus
  mfrc522.PCD_Init();   // Inicia MFRC522
}
 
void loop() 
{
  if ( ! mfrc522.PICC_IsNewCardPresent()) 
  {
    return;
  }
  if ( ! mfrc522.PICC_ReadCardSerial()) 
  {
    return;
  }
  delay(500);
  String conteudo= "";
  for (byte i = 0; i &lt; mfrc522.uid.size; i++) 
  {
     conteudo.concat(String(mfrc522.uid.uidByte[i] &lt; 0x10 ? " 0" : " "));
     conteudo.concat(String(mfrc522.uid.uidByte[i], HEX));
  }
  Serial.print("TAG LIDA: ");
  conteudo.toUpperCase();
  Serial.println(conteudo.substring(1));
}

fonte: próprio autor

O valor da Tag deve ser exibido por meio do monitor serial e informado a sequencia que pode ser utilizada no código de acesso ou não no projeto.

O projeto

Agora depois de descoberto as tags do cartão (ou chaveiro) vamos alterar o Código que vai executar o nosso projeto.
O projeto consiste na seguinte lógica, os cartões autorizados devem acessar o sistema indicando por meio de leds os funcionários que têm acesso e um pulso informa via internet, em um browser se o funcionário deu entrada  no local.
Para o projeto você deve ter em mãos:

1 Arduino Uno (ou compatível)
1 módulo RFID MC522
1 display LCD 16x2
1 protoboard
1 potenciômetro 10k 
2 leds (vermelho e verde)
2 resistores 220 ohm

Primeiro vamos montar o esquema abaixo em uma protoboard.

fonte: próprio autor

O código fonte do projeto

Feito toda a montagem, é hora de carregar o código no seu Arduino e testar, o projeto deve dar acesso às tags previamente autorizadas informando ao usuário a liberação por mensagem na LCD e acendendo um sinal visual por meio de um led verde, caso sua tag não esteja autorizada o usuário também recebe uma mensagem e um led vermelho pisca alertando-o.
Copie e cole o código para testar em seu circuito.
**a biblioteca utilizada pode ser baixada no link ao final do post!

// Programa : RFID - Controle de acesso / cancela
// Autor : Tony Emerson Marim
//basedo no original de Arduino e CIA
//www.mecatronizando.com.br

#include <SPI.h>
#include <MFRC522.h>
#include <LiquidCrystal.h>  //Carrega a biblioteca LCD 

#define SS_PIN 10
#define RST_PIN 9

// Definicoes pino modulo RC522
MFRC522 mfrc522(SS_PIN, RST_PIN); 

//Define os pinos que serão ligados ao LCD
LiquidCrystal lcd(6, 7, 5, 4, 3, 2);

// Leds indicadores acesso liberado ou negado
int led_liberado = 8;
int led_negado = 16;
 
char st[20];

void setup() 
{
  
  Serial.begin(9600); //Inicializa a serial
  
  pinMode (led_liberado, OUTPUT);
  pinMode (led_negado, OUTPUT);
   
  lcd.begin(16,2); //Inicializa LCD
  lcd.clear();     //Limpa o LCD
  
  // Inicia a serial
  Serial.begin(9600);
  // Inicia  SPI bus
  SPI.begin();
  // Inicia MFRC522
  mfrc522.PCD_Init(); 
  // Mensagens iniciais no serial monitor
  Serial.println("Aproxime o seu cartao do leitor...");
  Serial.println();
  lcd.begin(16,2);
  mensageminicial();
 }

void loop() 
{

  // Aguarda a aproximacao do cartao
  if ( ! mfrc522.PICC_IsNewCardPresent()) 
  {
    return;
  }
  // Seleciona um dos cartoes
  if ( ! mfrc522.PICC_ReadCardSerial()) 
  {
    return;
  }
  // Mostra UID na serial
  Serial.print("UID da tag :");
  String conteudo= "";
  byte letra;
  for (byte i = 0; i < mfrc522.uid.size; i++) 
  {
     Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
     Serial.print(mfrc522.uid.uidByte[i], HEX);
     conteudo.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " "));
     conteudo.concat(String(mfrc522.uid.uidByte[i], HEX));
  }
  Serial.println();
  Serial.print("Mensagem : ");
  conteudo.toUpperCase();
  
  // Testa se o cartao1 foi lido
  if (conteudo.substring(1) == "A5 76 7A 25")
  
  {
    digitalWrite(led_liberado, HIGH);
    Serial.println("Cartao1 - Acesso liberado !");
    Serial.println();
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("Ola USUARIO 1!");
    lcd.setCursor(0,1);
    lcd.print("ACESSO PERMITIDO !");
    delay(2000);
    digitalWrite(led_liberado, LOW);
    mensageminicial();
  }
    
      // Testa se o cartao2 foi lido
    if (conteudo.substring(1) == "3A 42 0F BB")   
  {

    digitalWrite(led_liberado, HIGH);    
    Serial.println("Cartao2 - Acesso liberado !");
    Serial.println();
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("Ola USUARIO 2!");
    lcd.setCursor(0,1);
    lcd.print("ACESSO PERMITIDO !");
    delay (2000);
    digitalWrite(led_liberado, LOW);
     mensageminicial();

    }
    
  // Testa se o cartao3 foi lido
  if (conteudo.substring(1) == "E5 77 17 53")
  {
    Serial.println("Cartao2 - Acesso negado !!!");
    Serial.println();
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("DESCONHECIDO !");
    lcd.setCursor(0,1);
    lcd.print("Acesso Negado !");
    delay (2000);
       
    // Pisca o led vermelho
    for (int i= 1; i<5 ; i++)
    {
      digitalWrite(led_negado, HIGH);
      delay(200);
      digitalWrite(led_negado, LOW);
      delay(200);
    }
      mensageminicial();
  }
  delay(500);
}
void mensageminicial()
{
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("MECATRONIZANDO");
  delay(2000);
  lcd.clear();
  lcd.print(" Aproxime o seu");  
  lcd.setCursor(0,1);
  lcd.print("cartao do leitor");  

}

No vídeo abaixo é possível ver o funcionamento do projeto.

Caso seja necessário todo o projeto pode ser baixado por esse link.
Gostou?
Faça parte da nossa Fan Page!
Inscreva-se no canal!

FTDI + ESP8266 + Controle via Blynk

IoT

FTDI + ESP8266 + Blynk

Nesse artigo abordaremos uma integração entre três componentes abordando um conceito de IoT (Internet of Things). Um acionamento de uma saída onde um módulo ESP8266 conectado na rede mundial (Internet) via wi-fi deve acender um led, como demonstração, mas antes devemos conhecer os principais equipamentos usados no projeto.

fonte: próprio autor

ESP8266

Desenvolvido pela Espressif, desde seu lançamento destaca-se pelo seu tamanho reduzido e pelo seu baixo custo (é possível encontrá-lo por menos que $5,00 dólares). Para explorar o conceito de Internet das Coisas - IoT, existem disponíveis no mercado um grande número de diferentes módulos, mas oque vamos utilizar é o modelo ESP8266 ESP-01.

Com a função primordial de receber comando via Serial (UART) interagindo com a rede Wi-Fi por meio de conexões TCP/UDT, inclusive operando em modo standalone, como microcontroladores no Wi-Fi.

No modelo que destaca-se nesse projeto vamos utilizá-lo como uma ponte Serial/Wi-fi e para isso necessita-se de um Arduino ou qualquer outro microcontrolador que tenha uma porta de comunicação serial.

fonte: http://www.keywordhut.com/cnN0IGZvcm0/

Pinagem básica:

• VCC: Tensão de alimentação 3,3V;
• GND: sinal de ddp;
• Tx: sinal transmissor do módulo;
• Rx: sinal recepstor do módulo;
• RST: sinal de restart do módulo;
• CH_PD: usado para gravação de firmware ou atualização, mantido em alto nível para operação normal;
• GPIO0: pode ser controlado pelo firmware, nível baixo para update ou nível alto para operação normal;
• GPIO2: I/O controlada pelo firmware
• Leds indicadores: vermelho para indicar funcionamento e azul para atividade.

Como citado anteriormente, o módulo pode ser usado em modo standalone, onde pode utilizar o GPIO0 e GPIO2 controlando entrada e saída, podendo ser configurado para leitura de sinais, acionamentos entre outras funções, e é  aí que entra nosso projeto.

fonte: próprio autor

FTDI 232

O conversor FTDI ( Future Technology Devices International) é um módulo conversor USB para TTL que foi baseado em FT232RL e permite a interface de dispositivos TTL via USB.

fonte: http://br-arduino.org 

fonte: próprio autor

Blink

Consiste em um conjunto de ferramentas disponíveis para o mundo da IoT (internet of things - internet das coisas), onde os usuários podem elaborar uma aplicação conforme sua necessidade. O Blynk é uma plataforma desenvolvida para realizar controle sobre as placas comerciais mais usadas atualmente por  inventores, professores, estudantes e hobbistas em todos os níveis de conhecimento, do básico ao avançado em qualquer tipo de projeto eletroeletrônico microcontrolado.
Proveniente de uma iniciativa financiada pela Kickstarter, foi um sucesso durante a campanha de criação.
O Blynk integra um aplicativo "montado" pelo usuário com hardwares, por meio da internet permitindo o controle das saídas digitais.
De funcionamento simples e sem a necessidade de programação, o usuário só tem que inserir uma chave (token) gerada pelo aplicativo para o reconhecimento em seu código fonte.
O aplicativo utilizado para que seu projeto seja executado pode ser encontrado na loja do seu sistema, seja Android ou iOS.

fonte: http://docs.blynk.cc/

O projeto

Então conhecidos os principais componentes do projeto vamos começar a montagem.

Para esse projeto vai ser necessário ter me mãos:

1 módulo FTDI 232

1 módulo ESP8266-01

1 fonte externa com tensão de 3,3V

1 protoboard

1 Led

1 resistor 220 ohm

fios Jumpers

fonte: próprio autor

Passo 1

O primeiro passo para realização do projeto é conectar o ESP8266-01 com o FTDI comforme o esquema abaixo.

fonte: próprio autor

CUIDADO!!! Tanto o módulo ESP8266 quanto o FTDI trabalham com tensão de 3,3V!

O módulo FTDI não fornece corrente suficiente para o módulo ESP8266 sendo necessário o uso de uma fonte externa de 3,3V

Passo 2

Na IDE do Arduino vá para: Arquivos > Exempos > Blynk > Boards Wi_Fi > ESP8266_Standalone.

fonte: próprio autor

fonte: próprio autor

Abra agora no seu celular o aplicativo Blynk e vá para: Criar um novo projeto (Create new project) > Dê um nome ao projeto e escolha a placa ESP8266 > clique em enviar auth token por email > Create.

fonte: próprio autor

 Agora ao clicar no aplicativo Blynk no ícone parecido com uma porca sextavada, é possível nomear seu projeto como preferir.

 fonte: próprio autor

Passo 3

Feito isso, o próximo passo é alterar o código que vamos usar, é necessário que em char auth [ ], o usuário insira o  auth token gerado pelo Blynk e enviado por email, em char ssid [ ] = " Inserir o nome de sua rede wi-fi" e em char pass [ ] = " Inserir a senha de sua rede wi-fi".

fonte: próprio autor

Na IDE do Arduino escolha, Ferramentas > placa Generic ESP8266 moule e mantenha as opções padrão.

fonte: próprio autor

Conecte o FTDI e ligue a fonte externa, feito isso é só descarregar o código, não esqueça de especificar a COM utilizada.

fonte: próprio autor

Depois de carregar o código, vamos colocar o ESP em Standalone e inserir um botão de controle no Blynk.

Passo 4

Pode-se tirar a ligação do FTDI, pois não vamos mais  precisar do módulo nas próximas etapas.

Então agora faremos as ligações a seguir.

fonte: próprio autor

Passo 5

Abrir o projeto iniciado no Blynk e inserir um botão. Clique no sinal de mais no alto á direita e escolha button, toque no botão para inserir as configurações necessárias. Em PIN selecione Digital e gp2 PWM > Continue. 

fonte: próprio autor

Toque o círculo ao lado do button para selecionar a cor do seu led > Altere o mode de PUSH para SWITCH.

fonte: próprio autor

Volte para a página principal e inicie o "play" do aplicativo.

fonte: próprio autor

No vídeo abaixo é possível ver uma demonstração do projeto em funcionamento.

Assim como costumo dizer, se acendo um led, inserindo uma eletrônica de potência posso acionar qualquer coisa....

Breve estarei postando um acionamento de dispositivos com diferentes tensões via Blynk/ Wi-Fi.

Gostou?

Curta nossa FanPage!

Assine o nosso canal!

Bons estudos!

Botões com múltiplas funções e trava - Arduino + 123D Circuits

Botões com múltiplas funções e trava

Nesse artigo vai ser apresentado uma aplicação onde explora um pouco mais a aplicação de entradas e saídas digitais do Arduino. Também vai ser apresentado uma nova ferramenta que ajuda muito o usuário durante a elaboração de um circuito, o 123D circuits da empresa Autodesk.

fonte: http://www.123dapp.com/circuits

Circuits.io

Pensando no desenvolvedores de projetos voltados especificamente para as áreas de automação e eletrônica, o 123D circuits é um software em nuvem, que permite que o usuário construa circuitos e simulem ensaios on-line na plataforma open source do Arduino.

Outro recurso que o software dispõe é a opção do usuário imprimir o circuito criado para uma impressora 3D a partir do app que a ferramenta já trás. E as vantagens não param por aí, o serviço é acessível a todos, o uso é gratuito, onde o usuário que ainda não tem uma conta no site da Autodesk, deve cadastrar-se e usufruir, tendo acesso a diversos componentes, chips além do Arduino.

Acessando o site da Autodesk, 123D circuits o usuário encontra uma plataforma de desenho semelhante ao ambiente do Fritzing, que é o mais utilizado para representar as ligações em um circuito eletrônico.

fonte: próprio autor

Criando uma aplicação com 123D Circuits

Vou fazer como demonstração um circuito simples com um código onde usarei dois botões que vão ser atribuídos mais de uma função à eles, teremos um botão para acionar ligação em diversos leds em sequência e outro botão para desligá-los também sequencialmente. Depois de simulado vou comparar a fidelidade da simulação com a situação prática do circuito.

Com todos os componentes selecionados a montagem do circuito deve ficar como o esquema demonstrado na figura abaixo.

fonte: próprio autor

Para essa montagem é necessário ter em mãos:

1 Arduino ou compatível;

1 protoboard

2 capacitores 1uF eletrolítico

2 chaves tipo push button

2 resistores 1kohm

6 resistores 220 ohm 

6 Leds de cores variadas

fios jumpers

Código fonte

Copie e cole o código fonte usado como exemplo que se encontra abaixo para verificar o funcionamento, consiste em uma sequência de leds sendo acionado um por vez em uma ordem "crescente" e depois sendo possível o desligamento obedecendo uma ordem "decrescente".

fonte: próprio autor

//** Elaborado por Tony Emerson Marim em 11/11/2016.
/** mecatronizei@gmail.com **/
/** Botão com multiplas funções */


void setup()
{
 pinMode(13, OUTPUT);
 pinMode(7, OUTPUT);
 pinMode(14, OUTPUT);
 pinMode(15, OUTPUT);
 pinMode(16, OUTPUT);
 pinMode(17, OUTPUT);
 digitalWrite(13, LOW);
 digitalWrite(7, LOW);
 digitalWrite(14,LOW);
 digitalWrite(15, LOW);
 digitalWrite(16, LOW);
 digitalWrite(17,LOW);
 
 pinMode(2, INPUT);
 pinMode(3, INPUT);
 
  
}

char cont = 0;
boolean flagb1 = 0, flagb2 = 0; 

void loop()
{
  boolean botao1 = digitalRead(2);
  boolean botao2 = digitalRead(3);
 
 if( (botao1 == 1) && (flagb1 == 0))
 {
   flagb1 = 1; 
 }
 
 if( (botao1 == 0) && (flagb1 == 1))
 {
   flagb1 = 0; 
   cont++;
 }
 
 if( (botao2 == 0) && (flagb2 == 0))
 {
  flagb2 = 1; 
 }
 
  if( (botao2 == 1) && (flagb2 == 1))
 {
  flagb2 = 0;
  cont--; 
 }
 
 if(cont > 6) cont = 6;
 if(cont < 0) cont = 0;
    
 leds(cont);
  
 delay(10);   
}

void leds(byte ledsCont)
{
 switch(ledsCont)
{
 case 0:
   digitalWrite(13, LOW);
   digitalWrite(7, LOW);
   digitalWrite(14,LOW);
   digitalWrite(15, LOW);
   digitalWrite(16, LOW);
   digitalWrite(17,LOW);
 break;
 case 1:
   digitalWrite(13, HIGH);
   digitalWrite(7, LOW);
   digitalWrite(14,LOW);
   digitalWrite(15, LOW);
   digitalWrite(16, LOW);
   digitalWrite(17,LOW);
 break;
 case 2:
   digitalWrite(13, HIGH);
   digitalWrite(7, HIGH);
   digitalWrite(14,LOW);
   digitalWrite(15, LOW);
   digitalWrite(16, LOW);
   digitalWrite(17,LOW);
 break;
 case 3:
   digitalWrite(13, HIGH);
   digitalWrite(7, HIGH);
   digitalWrite(14,HIGH);
   digitalWrite(15, LOW);
   digitalWrite(16, LOW);
   digitalWrite(17,LOW);
 break;
 case 4:
   digitalWrite(13, HIGH);
   digitalWrite(7, HIGH);
   digitalWrite(14,HIGH);
   digitalWrite(15, HIGH);
   digitalWrite(16, LOW);
   digitalWrite(17,LOW);
 break;
 case 5:
   digitalWrite(13, HIGH);
   digitalWrite(7, HIGH);
   digitalWrite(14,HIGH);
   digitalWrite(15, HIGH);
   digitalWrite(16, HIGH);
   digitalWrite(17,LOW);
 break;
 case 6:
   digitalWrite(13, HIGH);
   digitalWrite(7, HIGH);
   digitalWrite(14,HIGH);
   digitalWrite(15, HIGH);
   digitalWrite(16, HIGH);
   digitalWrite(17,HIGH);
 break;
}
 
}

Diferente da maioria dos softwares de simulação com a plataforma Arduino, o 123D circuits trabalha com o código escrito pelo usuário, utilizando as bibliotecas, sendo possível escrevê-los além da conhecida IDE do Arduino, então não há a necessidade do usuários localizar a pasta onde foi gerado o arquivo . HEX e importá-lo.

fonte: próprio autor

No vídeo que segue é possível ver o funcionamento simulado e o projeto montado, demonstrando a fidelidade do software.

Curtiu? Increva-se na nossa FanPage e Compartilhe!
Inscreva-se no nosso canal!

Baixe o projeto completo nesse Link!

Bons estudos!

Supervisório SCADA + Arduino

Sistemas supervisórios industriais

Em plantas industriais um sistema supervisório faz-se necessário para o acompanhamento de uma produção e um controle centralizado, sendo assim foram elaborados sistemas de interface amigável e eficiente.
O sistema SCADA (supervisory control and data aquisition) está entre os melhores sistemas de gerenciamento, informando o usuário em tempo real qualquer evento importante que venha a acontecer em uma planta. Um sistema assim pode ser implantando para atender tanto uma pequena unidade de produção, como grandes áreas industriais, integrando os sistemas lógicos da automação. Por meio de coleta de dados dos processos, onde por muitas vezes afastados geograficamente, as remotas industriais como CPs (controladores programáveis), formatam esses dados e apresentam ao operador em recursos gráficos elaborados, planilhas e gráficos.

Principais componentes de um sistema supervisório

Para que o operador obtenha todas informações que compõem uma planta industrial e assim poder acompanhar e controlar em tempo real de execução de uma tarefa, o sistema supervisório dependem de componentes físicos como sensores e atuadores, rede de comunicação, estações remotas e estação de monitoramento central.

fonte: Senai-RS

Sensores e atuadores

São dispositivos acoplados aos componentes que convertem parâmetros físicos (pressão, velocidade, temperatura...) em sinais analógicos e digitais, e os atuadores são componentes utilizados para acionar ou desacionar determinados equipamentos durante o processo industrial. 

Rede de comunicação

Plataforma de transmissão das informações, onde são considerados alguns requisitos do sistema e distância de transmissão dos dados, sendo feito sob análise e escolhendo o melhor meio de transmissão Ethernet, fibras óticas, rádio...

Estações remotas

Onde inicia-se o processo de aquisição e controle dos dados, fazendo leitura dos valores do dispositivo que podem ser digitais ou analógicos, de entrada ou de saída, controlando e atualizando os dados.

Rede de informação gerencial

Integra a rede de supervisão com a de controle, possibilitando ao supervisor da empresa a análise do desempenho da produção.

Rede de supervisão e controle

Reponde pelo funcionamento do sistema.

Redes de controle de campo

Responsável direta pelo processo de informações do controle em tempo real, podem ser inseridas nesse grupo todas as redes industriais, seja Fieldbus, Modbus, Profibus, Devicenet...

fonte: Senai-RS

Módulos de um sistema supervisório

Dividindo o sistema supervisório em módulos, suas tarefas se tornam mais flexíveis e robustas, ficando disponível conforme a necessidade do usuário.

De um modo geral, essas tarefas podem ser divididas em :

• núcleo de processamento;
• comunicação com CPs/ RTUs;
• gerenciamento de alarmes;
• interface gráfica;
• relatórios;
• banco de dados;
• histórico;
• lógica de programação interna ou controle;
• comunicação com outras estações;
• comunicação com sistemas externos.

O software supervisório Indusoft

No mercado atual existem diversos softwares SCADA que podem atender a necessidade de qualquer tipo de produção seja de uma pequena linha até grandes sistemas automatizados como Usinas Sucroalcooleiras, empresas dos mais diversos tipos de envases, empresas responsáveis pela geração de alimentos entre outras.

O software que vou abordar no artigo é o INDUSOFT. Esse software SCADA é de fácil integração e pode ser baixado gratuitamente direto do site: http://www.indusoft.com/br/. E outra facilidade é que no próprio software vem alguns drivers de comunicação que possibilitam a comunicação com sistemas remotos, no qual vamos destaca o Protocolo ModBus.

Protocolo ModBus

Desenvolvido pela Modicon na década de 70, trata-se de uma estrutura de mensagem aberta e utilizada para comunicação entre dispositivos mestre-escravo/ cliente-servidor. Vastamente utilizado como protocolo em equipamentos industriais, o protocolo ModBus está presente em: instrumentos e equipamentos de laboratórios, automação residencial e automação naval.

Sua simplicidade e facilidade de implementação faz com que sua utilização na automação industrial seja aplicada em diversos padrões de meios físicos como: RS-232, RS-485 e Ethernet TCP/IP, limitando-se a velocidade de comunicação de cada um desses padrões bem como comprimento e numero máximo de dispositivos conectados.

fonte: wikipedia

Protocolo ModBus no Arduino

Existem diversos de usuários que fazem uso do protocolo ModBus no Arduino, usando uma biblioteca originalmente desenvolvida por Juan Pablo Zometa, podendo ser alterada para suportar funções ModBus conforme a necessidade do usuário.

O código do drive ModBus pode ser baixado nesse LINK, ou no final do artigo, onde estarei disponiblizando o projeto completo para download.
O que facilita com que o Arduino possa comunicar com o Sistema SCADA é a comunicação RX/ TX que está no Atmega.

O projeto Indusoft + Arduino

Depois de carregar o código exemplo do protocolo ModBus, vamos começar a montar alguns componentes onde vai ser possível a monitoração em tempo real.
O circuito que devemos montar como exemplo é bem simples. Vamos demonstrar controle via Indusoft de um Arduino no protocolo de comunicação ModBus.

fonte: próprio autor

A elaboração de endereçamento no Indusoft requer um pouco de conhecimento em sistemas supervisórios, por isso estarei elaborando uma vídeo aula somente disso futuramente.

No vídeo abaixo está sendo demonstrado os três controles necessários para que seja inserido em qualquer tipo de controle, digital como emissor de sinal e receptor e controle analógico.

Aqui você pode baixar  projeto completo.

Curtiu? Compartilhe!

Assine o nosso canal! 

Bons estudos!