DANIEL MADEIRA BUENO - Embarcados

Manual de implementação e simulação de projetos

utilizando Arduino UNO e Proteus/ISIS

Utilização de DISPLAYS LCD com o controlador HD44780

Vitória – ES

NOV/2015

DANIEL MADEIRA BUENO

1 Manual de implementação e simulação de projetos utilizando Arduino UNO e Proteus/ISIS

LISTA DE FIGURAS

Figura 1 - Hardware utilizado no item 1 ...............................................................................................................................6

Figura 2 - Diagrama esquemático utilizado no item 1 .....................................................................................................6

Figura 3 - Hardware utilizado no item 2 ...............................................................................................................................9

Figura 4 - Diagrama esquemático utilizado no item 2 .....................................................................................................9

Figura 5 - Hardware utilizado no item 3 ............................................................................................................................ 13

Figura 6 - Diagrama esquemático utilizado no item 3 .................................................................................................. 13


Figura 8 - Diagrama esquemático utilizado no item 4 ................................................................................................. 18


Figura 10 - Diagrama esquemático utilizado no item 5................................................................................................ 24

Figura 11 – Matriz existente nos displays utilizados ..................................................................................................... 26

Figura 12 - Hardware utilizado no item 6 ......................................................................................................................... 33


Figura 14 - Hardware utilizado no item 7 ........................................................................................................................ 42


2 Utilização de DISPLAYS LCD com o controlador HD44780

SUMÁRIO

INTRODUÇÃO......................................................................................................................................................................3

POR QUE UTILIZAR O PROTEUS/ISIS? ....................................................................................3

QUAL O OBJETIVO DESTE DOCUMENTO? ............................................................................3

O QUE ESTE DOCUMENTO ABRANGE? .................................................................................3

SOBRE O AUTOR .....................................................................................................................4

UTILIZAÇÃO DE DISPLAYS LCD COM O CONTROLADOR HD44780....................................5

1 IMPRESSÃO DE CARACTERES NO DISPLAY ................................................................. 6

2 DESLOCAMENTO LATERAL DE CARACTERES ............................................................ 9

3 IMPLEMENTAÇÃO DE UM DISPLAY INFORMATIVO................................................. 13

4 IMPLEMENTAÇÃO DE UM SEMÁFORO INFORMATIVO ........................................... 18

5 DADO DE 6 FACES NO DISPLAY LCD ............................................................................ 24

6 BARRA DE PROGRESSO NO DISPLAY LCD .................................................................. 33

7 DESENVOLVIMENTO DE UM MENU COMPLETO UTILIZANDO DISPLAY LCD ..... 42

APÊNDICE A – Códigos.................................................................................................................................................. 65


INTRODUÇÃO

O Proteus é um software criado pela empresa Labcenter Eletronics, este proporciona ao usuário a

possibilidade de montar circuitos eletrônicos, realizar simulações e ainda criar placas de circuito impresso.

Um dos componentes do Proteus é o ambiente de desenvolvimento ISIS que tem como função principal

auxiliar o desenvolvedor de sistemas embarcados na verificação da parte eletrônica referente aos circuitos

dos mesmos, além de possibilitar a realização de simulações (como dito anteriormente) antes de elaborar o

hardware de um determinado projeto, podendo proporcionar portanto uma redução no tempo de

desenvolvimento e até mesmo do custo envolvido.

POR QUE UTILIZAR O PROTEUS/ISIS?

Além dos motivos citados anteriormente, para muitas pessoas não é possível desenvolver todas as ideias que

surgem na cabeça por vários motivos, um deles pode ser a falta de acesso aos materiais e equipamentos

para o criação de protótipos e realização de testes. Por outro lado, existem ferramentas criadas para

justamente suprir esta carência, entre elas está o Proteus/ISIS, este conta com diversas ferramentas que

estão presentes em laboratórios de eletrônica como osciloscópio, gerador de sinais, voltímetro, amperímetro,

além de uma infinidade de componentes como resistores, capacitores, transistores, motores,

microcontroladores e outros (muitos outros).

QUAL O OBJETIVO DESTE DOCUMENTO?

Este documento visa ao proporcionar o aprendizado básico para a manipulação deste software bem como

uma maneira bastante didática e simples de como realizar pequenos projetos envolvendo a utilização do

Arduino UNO para aqueles que desejam aprender um pouco sobre o assunto e no momento não possuem

conhecimento algum sobre o mesmo. Obviamente existem limitações no que diz respeito à implementação

de projetos utilizando o Proteus/ISIS (no decorrer dos projetos apresentados serão discutidas algumas

limitações caso estas sejam importantes no momento), no entanto, ainda é possível realizar bastante coisa.

O QUE ESTE DOCUMENTO ABRANGE?

Num primeiro momento apresenta-se um pouco da interface do Proteus/ISIS e como fazer para selecionar

componentes, instalar bibliotecas de componentes, definir propriedades de componentes entre outros.


Posteriormente será mostrado como fazer para importar o código desenvolvido para dentro do Proteus/ISIS

e simula-lo em um Arduino UNO virtual.

Serão desenvolvidos também vários projetos básicos organizados para que exista uma certa progressão no

conhecimento adquirido para criação dos mesmos, facilitando portanto, o aprendizado de maneira bastante

simples. Neste documento encontram-se projetos envolvendo displays LCD que utilizam o HD44780 como

controlador. Estes projetos citados são basicamente as aplicações realizadas no material anterior

(Manipulação de leds) porém desta vez, estas possuirão também displays LCD para as mais diversas

finalidades.

SOBRE O AUTOR

Meu nome é Daniel Madeira Bueno, sou engenheiro eletricista graduado pela Universidade Federal do

Espírito Santo. Gosto bastante de questões que envolvem sistemas embarcados porém não sou profissional

no assunto, portanto organizei este conteúdo da forma que geralmente eu consigo aprender melhor e resolvi

compartilhar. Se possível peço que caso existam sugestões, pontos para corrigir ou qualquer outra coisa,

entre em contato comigo, ficarei extremamente agradecido em poder aprimorar meu conhecimento e ajudar

os outros da mesma forma.

Meu e-mail é [email protected]


UTILIZAÇÃO DE DISPLAYS LCD COM O CONTROLADOR HD44780

Neste parte serão apresentados alguns projetos básicos utilizando displays LCD funcionando através do

controlador HD44780 de várias maneiras, proporcionando a possibilidade de aprendizado sobre como

escrever no display, realizar algumas animações, menus e até mesmo a criação de caracteres especiais. Este

material é uma sequência do publicado anteriormente relacionado ao uso de leds, portanto é aconselhável

utilizar os dois materiais juntos para consolidar de maneira mais eficiente o conhecimento adquirido.


1 IMPRESSÃO DE CARACTERES NO DISPLAY

1.1 Objetivo

Este é o primeiro item da segunda parte deste manual, portanto deve-se começar o estudo de como

manipular os displays LCD a partir do requisito mais básico necessário para tal, que por sua vez consiste

em imprimir caracteres no display através da função print(). Além deste tópico serão abordados assuntos

como a inclusão da biblioteca necessária para a interação do Arduino UNO com o display e outros comandos

que devem ser utilizados para garantir o funcionamento correto do mesmo.

1.2 Hardware utilizado na simulação

Figura 1 - Hardware utilizado no item 1

1.3 Diagrama esquemático das ligações

Figura 2 - Diagrama esquemático utilizado no item 1


1.4 Desenvolvimento do código

No decorrer deste tópico serão explicados todos os passos utilizados para o desenvolvimento do projeto,

isto é, o código será comentado de modo que todo conhecimento aplicado seja facilmente compreendido.

As trechos demarcados em vermelho contém elementos que não foram citados anteriormente ou são partes

de bastante relevância para o funcionamento do programa. O código inteiro está disponibilizado no

apêndice A, localizado no final deste documento.

Primeiramente deve-se incluir a biblioteca necessária para utilizar o display através do comando #include

seguido do nome da biblioteca (pode ser representada de duas maneiras: <biblioteca.h>, “biblioteca.h”).

Esta é composta por alguns códigos que visam auxiliar, tornando mais simples a interação do Arduino UNO

com o controlador do display utilizado (HD44780).

#include <LiquidCrystal.h>

O Segundo passo que deve ser realizado antes da manipulação do display é a criação de uma variável do

tipo LiquidCrystal cujo nome é lcd. Observe que são passados alguns valores como parâmetros da função,

estes são utilizados para relacionar os pinos do Arduino UNO com os pinos do controlador. Existem várias

maneiras de criar a variável do tipo LiquidCrystal (no que diz respeito à quantidade de parâmetros a serem

utilizados), neste caso foi utilizada uma declaração com cinco parâmetros e estes podem ser identificados

como:

LiquidCrystal (rs, enable, d4, d5, d6, d7)

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

Em seguida, deve-se realizar apenas mais um procedimento para então começar a manipular o display.

Dentro da função setup() foi utilizada a função begin() responsável por iniciar a interface de comunicação

entre o Arduino UNO e o display (os argumentos desta função são as dimensões do display, número de

colunas e número de linhas, nesta ordem). Neste momento torna-se possível a utilização do display no

desenvolvimento do projeto.

Para imprimir alguma informação no display basta utilizar a função print() e passar a mensagem desejada

como argumento da mesma (entre aspas). Um ponto muito importante deve ser destacado: Sempre que


forem utilizadas funções pertinentes ao funcionamento do display deve-se preceder as mesmas da

variável (do tipo LiquidCrystal) criada, por exemplo lcd.print(“EXEMPLO 1.1”).

void setup() {

lcd.begin(16, 1);

lcd.print("EXEMPLO 1.1");

}

Neste item não houve a necessidade de utilizar a função loop().

void loop() {

}


2 DESLOCAMENTO LATERAL DE CARACTERES

2.1 Objetivo

O objetivo deste item consiste em realizar uma simples animação envolvendo o mesmo display utilizado

no item anterior. O efeito em questão será o deslocamento de uma frase dinâmica (mostrando em “tempo

real” o estado de um led externo ligado a um dos pinos do Arduino UNO) da esquerda para a direita

utilizando a função scrollDisplayRight(). Além disso será apresentada também a função setCursor().












Primeiramente deve-se incluir a biblioteca LiquidCrystal.h para que seja possível fazer a interação do

Arduino UNO com o display utilizado de maneira mais simples.


Em seguida utiliza-se a diretiva #define para associarmos o led (LED) ao pino 10 (pino onde o este se

encontra conectado).

#define LED 10

Neste momento são declaradas as variáveis pertinentes ao projeto em questão. A variável do tipo

LiquidCrystal lcd é responsável por representar o display utilizado. Em seguida são declaradas duas

variáveis do tipo bool, estadoLED e estadoLEDant, ambas servem para registrar as informações relativas

aos estados atual e anterior do led, enquanto a variável tempo atua na progressão da frase através do display.


bool estadoLED = 0;

bool estadoLEDant = 1;

int tempo;

Na função setup() existem duas funções pertinentes ao funcionamento do display, begin() para iniciar a

interface entre o Arduino UNO e o display e a função print() para imprimir a sequência “LED:”. A outra

função existente determina o comportamento do pino 10 como saída.

void setup() {

lcd.begin(16, 1);


lcd.print("LED:");

pinMode(LED,OUTPUT);

}

Num primeiro momento é verificado se as variáveis estadoLED e estadoLEDant possuem valores

diferentes. Caso a condição citada anteriormente seja confirmada, é tomada uma de duas ações dependendo

do valor da variável estadoLED.

Se estadoLED for igual a 1, deve ser escrito “LIG” no display.

Se estadoLED for igual a 0, deve ser escrito “DES” no display.

Antes de continuarmos com a explicação deste código, deve-se informar ao leitor que o cursor (isto é, a

posição onde será escrito o próximo caractere) sempre está situado no canto superior esquerdo (para

displays com mais de uma linha) num primeiro momento e conforme mais caracteres vão sendo escritos,

este cursor é deslocado para a direita (posição do caractere posterior).

Neste item observe que a sentença “LED:” (escrita dentro da função setup()) ocupa quatro posições: L E

D : . Logo, quando o próximo elemento for escrito, assumirá a quinta posição no display, no entanto a

intenção é escrever seguidamente à esta expressão, os termos “LIG” ou “DES”, para isto é utilizada a função

setCursor() cuja função é determinar a posição do cursor e consequentemente do próximo caractere. O

primeiro argumento desta função se refere à coordenada da coluna, enquanto o segundo é relativo à linha

do local onde se deseja posicionar o cursor (ambos os parâmetros começam a ser contados a partir do zero).

Após a decisão à respeito do que deve ser escrito ser tomada, a variável tempo passa a ter um valor

proporcionado pela função millis() e as variáveis estadoLED e estadoLEDant passam a possuir o mesmo

valor (para que assim o programa não passe por esta primeira estrutura condicional atribuindo o valor

disponibilizado pela função millis() toda hora).

Em seguida existe uma outra estrutura condicional que verifica se a diferença entre os valores da variável

tempo e o proporcionado pela função millis() é maior do que um tempo pré-estabelecido (1 segundo), caso

a sentença seja verdadeira, o estado do led é invertido.

Por último foi utilizada a função scrollDisplayRight() responsável por deslocar todo conteúdo uma posição

para a direita. Repare que mesmo realizando este deslocamento, as posições iniciais são mantidas, ou seja,

independentemente do local onde o conteúdo estiver, a posição 4 sempre será a posição depois do “:”. Além


disso, para assegurar que o tempo para terminar esta movimentação foi suficiente utilizou-se a função

delay().

void loop() {

if(estadoLED != estadoLEDant){

if(estadoLED == 1){

lcd.setCursor(4,0);

lcd.print("LIG");

}

else {

lcd.setCursor(4,0);

lcd.print("DES");

}

tempo = millis();

estadoLEDant = estadoLED;

}

if(millis() - tempo > 1000){

estadoLED = !estadoLED;

digitalWrite(LED, estadoLED);

}

lcd.scrollDisplayRight();

delay(250);

}


3 IMPLEMENTAÇÃO DE UM DISPLAY INFORMATIVO

3.1 Objetivo

Este item visa complementar o item 1.3/PARTE I, onde foi realizado o acionamento de um led externo por

meio de um botão, de modo que quando este for pressionado, o led deve permanecer aceso por um tempo

pré-estabelecido. A diferença é que neste momento todas as informações do sistema serão disponibilizadas

em um display LCD para o usuário.















Em seguida utiliza-se a diretiva #define para associarmos os elementos aos seus respectivos pinos, ou seja,

relaciona-se o led (LED) ao pino 9 o botão (BOT) ao pino 10.

#define LED 9

#define BOT 10

Após a organização das diretivas #define, são criadas as variáveis que estarão presentes no programa. Assim

como no item anterior, temos uma variável do tipo LiquidCrystal e duas outras booleanas utilizadas para

registrar as informações relativas aos estados atual e anterior do botão. Além destas, foi criada também uma

variável tempo, porém neste item, esta é do tipo float.


bool estadoBOT;

bool estadoBOTant;

float tempo = 0.0;

Na função setup(), os pinos onde estão conectados o led e o botão, são configurados como saída e entrada

respectivamente através da função pinMode() e a interface entre o Arduino UNO e o display é inicializada

utilizando a função begin().


Após as devidas inicializações é feita uma pequena animação escrevendo no display a palavra “Iniciando...”

e mantendo esta por dois segundos. Em seguida é confeccionada a “tela principal” do projeto (ver o

diagrama esquemático de ligações deste item).

void setup() {


pinMode(BOT,INPUT);

lcd.begin(16, 2);

lcd.print("Iniciando...");

delay(2000);

lcd.setCursor(0,0);

lcd.print("BOT acionado? N");

lcd.setCursor(0,1);

lcd.print("LED:D Tempo:0.0");

}

O primeiro passo realizado dentro da função loop() é a leitura da condição do botão, realizada através da

função digitalRead(). Caso este tenha sido pressionado, ocorre uma mudança no display, sinalizando que o

botão foi pressionado e que o led está aceso. Além disso existe também uma estrutura de repetição for()

que por sua vez faz a contagem do tempo e atualiza o display com esta progressão do tempo.

Após dois segundos, o led é desligado e o display é atualizado com esta informação. Por uma eventual

exigência de que o led não possa ser acionado novamente sem que um intervalo de cinco segundos tenha

se passado desde o momento em que este foi apagado pela última vez, é exibida uma mensagem no display

pedindo que o usuário aguarde juntamente com uma contagem regressiva (através de outra estrutura de

repetição for()) para um novo acionamento.

Posteriormente é verificado se o botão continua apertado, pois o programa só permite que seja feito um

novo acionamento (através da estrutura condicional while()) caso o botão não esteja mais pressionado. Se

o usuário não soltar o botão, é exibido um aviso para que ele proceda com esta ação. O programa termina

com o display apresentando as mesmas características definidas na função setup().

void loop() {


estadoBOT = digitalRead(BOT);

if (estadoBOT == 1) {

lcd.setCursor(14,0);

lcd.print("S");

digitalWrite (LED, HIGH);

lcd.setCursor(4,1);

lcd.print("L");

for( int contador = 0; contador < 5; contador++){


lcd.print(tempo);

tempo = tempo + 0.5;

delay(500);

}

digitalWrite (LED,LOW);

lcd.setCursor(4,1);

lcd.print("D");

lcd.setCursor(0,0);

lcd.print(" AGUARDE ");

lcd.setCursor(6,1);

lcd.print(" segundos ");

tempo = 5.0;

for(int contador = 0; contador < 10; contador++){

lcd.setCursor(0,1);

lcd.print(" ");

lcd.print(tempo);

tempo = tempo - 0.5;

delay(500);

}


lcd.clear();

while(digitalRead(BOT) == 1){

lcd.setCursor(0,0);

lcd.print(" Solte o botao");

}

lcd.setCursor(0,0);


lcd.setCursor(0,1);


}

}


4 IMPLEMENTAÇÃO DE UM SEMÁFORO INFORMATIVO

4.1 Objetivo

O projeto proposto neste item consiste em seguir a mesma linha do item anterior, apresentando ao usuário

o estado de todos os componentes do sistema constituído pelo semáforo apresentado na PARTE I deste

material no display LCD, além disso será apresentada a função clear().















Em seguida utiliza-se a diretiva #define para associarmos os elementos aos seus respectivos pinos. Neste

item os nomes VMC, AMC e VDC representam as luzes vermelha, amarela e verde no semáforo utilizado

para o controle do tráfego dos carros. Da mesma forma VMP e VDP satisfazem as mesmas funções, no

entanto, são para pedestres, e BOT diz respeito ao botão de acionamento utilizado.

#define BOT 13

#define VMC 10

#define AMC 9

#define VDC 8

#define VMP 7

#define VDP 6

Neste momento são criadas as variáveis lcd que representa o display no código, a variável estadoBOT

responsável por armazenar a informação relativa ao estado do botão e a variável tempo para realização da

contagem.


bool estadoBOT;

float tempo = 0.5;


Dentro da função setup() serão definidos os modos de operação dos pinos utilizados. Os pino estão

conectados os 5 leds são definidos como saídas e o pino em que se encontra o botão é definido como entrada.

Neste momento também são acionados dois leds: o verde para os carros e o vermelho para os pedestres.

Em seguida a interface entre o display e o Arduino UNO é inicializada através da função begin(), juntamente

com uma animação de inicialização do programa, de modo que após dois segundos seja exibida a “tela

principal” do programa (ver diagrama esquemático) informando o estado de cada led e do botão. Repare

que é possível sobrescrever os elementos apresentados no display, no entanto muitas vezes o novo elemento

que será inserido posteriormente não “cobre” o anterior, logo, para solucionar este impasse utiliza-se a

função clear() para limpar o display.

void setup() {

pinMode(VMC, OUTPUT);

pinMode(AMC, OUTPUT);

pinMode(VDC, OUTPUT);

pinMode(VMP, OUTPUT);

pinMode(VDP, OUTPUT);

pinMode(BOT, INPUT);

digitalWrite(VMP, HIGH);

digitalWrite(VDC, HIGH);

lcd.begin(16, 4);

lcd.setCursor(4,1);

lcd.print("CARREGAR");

lcd.setCursor(4,2);

lcd.print("SEMAFORO");

delay(2000);

lcd.clear();

lcd.print("CARROS PESSOAS");

lcd.setCursor(0,1);

lcd.print("VDC:LIG VDP:DES");

lcd.setCursor(0,2);

lcd.print("AMC:DES VMP:LIG");

lcd.setCursor(0,3);

lcd.print("VMC:DES TMP:-.-");


}

Num primeiro momento é observar o estado do botão e caso este seja acionado, o led verde para veículos é

apagado e o amarelo é acionado, bem como a atualização do display com estas informações. Depois de 2

segundos, o amarelo para veículos por sua vez é apagado e o vermelho é acionado e o display é mais uma

vez atualizado. Novamente após 1 segundo (temporização de segurança), o led vermelho para pedestres é

apagado e o verde é acionado, seguido da atualização do display. Este estado é mantido por 5 segundos.

Após os acontecimentos descritos anteriormente pode-se ver a presença da estrutura de repetição for() que

faz com que o led verde para pedestres ficará alternando entre ligado e desligado. Neste momento a

sinalização de acionamento deste led no display também estará piscando.

Posteriormente a esta sequência de acionamentos e desligamentos, o led verde para pedestres (VDP)

permanece desligado enquanto led vermelho para pedestres (VMP) é acionado e um segundo depois

(questão de segurança) o led verde para os veículos (VDC) é acionado. Observe que existe um delay() de

cinco segundos após esta última operação, utilizado para garantir um tempo mínimo de tráfego. Todos estes

eventos são atualizados no display.

void loop() {



digitalWrite(VDC, LOW);

digitalWrite(AMC, HIGH);

lcd.setCursor(4,1);

lcd.print("DES");

lcd.setCursor(4,2);

lcd.print("LIG");

delay(2000);

digitalWrite(AMC, LOW);

digitalWrite(VMC, HIGH);


lcd.setCursor(4,2);

lcd.print("DES");

lcd.setCursor(4,3);

lcd.print("LIG");

delay(1000);

digitalWrite(VMP, LOW);

digitalWrite(VDP, HIGH);


lcd.print("LIG");


lcd.print("DES");

delay(5000);

for (int x=0; x<10; x++) {

digitalWrite(VDP, HIGH);


lcd.print("LIG");

delay(250);

digitalWrite(VDP, LOW);


lcd.print(" ");

delay(250);


lcd.print(tempo);


}

tempo = 0.5;


lcd.print("-.-");


lcd.print("DES");



lcd.print("LIG");


lcd.setCursor(4,3);

lcd.print("LIG");

delay(1000);


lcd.setCursor(4,1);

lcd.print("LIG");

digitalWrite(VMC, LOW);

lcd.setCursor(4,3);

lcd.print("DES");

delay(5000);

}

}


5 DADO DE 6 FACES NO DISPLAY LCD

5.1 Objetivo

Este projeto visa o desenvolvimento de um dado de 6 faces, onde os números contidos nestas serão

apresentados no display LCD. O dado é lançado assim que o botão for pressionado e posteriormente seu

resultado é escrito no display de duas formas: gráfica e numérica. Neste item será apresentado como se dá

a criação de caracteres especiais para serem utilizados no display.















Em seguida utiliza-se a diretiva #define para associarmos o botão ao seu respectivo pino. Neste item o

botão é denominado BOT e está ligado ao pino 9.

#define BOT 9

Na parte reservada para a criação das variáveis do programa temos a variável lcd que é a responsável por

representar o display no código, a variável estadoBOT que atua registrando o estado do botão, além da

variável aleatório cujo conteúdo é um número pseudoaleatório gerado pela função random() e um contador

utilizado em estruturas de repetição.

Neste item serão desenvolvidos caracteres especiais para serem utilizados no display, estes consistem em

caracteres que não os utilizados usualmente, como por exemplo um desenho ou símbolo. Primeiramente

deve-se entender que os caracteres são formados em pequenos blocos agrupados em forma de uma matriz

com cinco colunas e 8 linhas, no entanto apenas 7 destas são geralmente utilizadas. Sendo assim, para

formar um caractere basta que os “elementos” corretos da matriz citada seja acionado. Por exemplo, para

formar o número 1:


Figura 11 – Matriz existente nos displays utilizados

O primeiro passo para a criação de caracteres especiais é definir uma variável do tipo byte e escrever seus

cinco bits menos significativos conforme a imagem que queira criar. Neste item, a variável em questão é

chamada numero.


bool estadoBOT;

long aleatorio;

int contador;

byte numero[8] = {

B11111,

B11111,

B11111,

B11111,

B11111,

B11111,

B11111,

B11111

};

Dentro da função setup() é definido o modo de operação do pino no qual está conectado o botão como

entrada. Além disso, através da função randomSeed(), o pino de entrada analógica passa a ser uma fonte

de influência na criação de sequências pseudoaleatórias. Em seguida, a interface entre o Arduino UNO e o

display é inicializada e o caractere especial é criado por meio da função createChar(), onde o primeiro

argumento desta está relacionado à posição do caractere em uma determinada “lista” e o segundo é o nome

da variável que será utilizada na formação do mesmo.


void setup() {

pinMode (BOT, INPUT);

randomSeed(analogRead(0));

lcd.begin(20, 4);

lcd.createChar(0, numero);

}

Primeiramente dentro da função loop() utiliza-se a função digitalRead() para armazenar a informação

relativa ao estado do botão (pressionado ou não) para que através da estrutura condicional if() esta sentença

possa ser verificada. Caso o botão tenha sido apertado, a variável aleatorio recebe um valor pseudoaleatório

podendo variar de 1 a 6 proveniente da função random().

Após a definição do valor contido em aleatorio, são realizadas uma série de análises utilizando a estrutura

switch/case para saber qual é este valor e assim representar os grupos de caracteres correspondentes ao

número sorteado e aguardar 5 segundos até o dado possa ser lançado novamente.

A estrutura switch/case funciona da seguinte maneira:

Primeiramente deve-se iniciar com a função switch (variável), cujo argumento é a variável que se

deseja analisar.

Posteriormente são criados os cases, por exemplo, caso seja necessário analisar se a variável em

questão possui o valor 1 em seu conteúdo, basta escrever “case 1:” seguido dos procedimentos que

devem ser realizados caso esta sentença seja verdadeira. Importante lembrar que no final de cada

case deve existir um break para que o programa possa sair do switch assim que um dos cases for

verdadeiro.

void loop() {



aleatorio = random(1,7);


switch(aleatorio){

case 1:

lcd.clear();

escreveG2();

divisao();


lcd.print("VALOR");


lcd.print(aleatorio);

delay (5000);

break;

case 2:

lcd.clear();

escreveG1();

divisao();


lcd.print("VALOR");



delay (5000);

break;

case 3:

lcd.clear();

escreveG2();

escreveG4();

divisao();


lcd.print("VALOR");




delay (5000);

break;

case 4:

lcd.clear();

escreveG1();

escreveG4();

divisao();


lcd.print("VALOR");



delay (5000);

break;

case 5:

lcd.clear();

escreveG1();

escreveG2();

escreveG4();

divisao();


lcd.print("VALOR");



delay (5000);

break;

case 6:

lcd.clear();

escreveG1();

escreveG3();

escreveG4();


divisao();


lcd.print("VALOR");



delay (5000);

break;

}

lcd.clear();

}

lcd.setCursor(2,1);

lcd.println("PRESSIONE O BOTAO");

lcd.setCursor(2,2);

lcd.println("PARA ROLAR O DADO");

}

Após o fechamento da função loop(), estão localizadas as outras funções necessárias para o funcionamento

do programa. As funções escreveG1/G2/G3/G4() são responsáveis pela escrita do caractere especial que

foi criado anteriormente em diferentes grupos (assim como foi feito com o dado de leds) e a função divisão()

é responsável por desenhar a linha vertical de separação utilizada no display.

Para escrever um caractere especial no display deve-se utilizar a função write(), cujo argumento é a posição

que este caractere ocupa na “lista” citada no começo deste item. É importante ressaltar que caso o caractere

desejado esteja na posição zero, deve-se escrever o argumento da seguinte forma ((byte)0). Para outros

valores pode-se escrever o número normalmente.

void escreveG1(){

lcd.setCursor(4,1);

lcd.write((byte)0);

lcd.setCursor(8,3);


lcd.write((byte)0);

}

void escreveG2(){

lcd.setCursor(6,2);

lcd.write((byte)0);

}

void escreveG3(){

lcd.setCursor(4,2);

lcd.write((byte)0);

lcd.setCursor(8,2);

lcd.write((byte)0);

}

void escreveG4(){

lcd.setCursor(8,1);

lcd.write((byte)0);

lcd.setCursor(4,3);

lcd.write((byte)0);

}

void divisao(){

for( contador = 0; contador < 4; contador++){

lcd.setCursor(13,contador);


lcd.write((byte)0);

}

}


6 BARRA DE PROGRESSO NO DISPLAY LCD

6.1 Objetivo

O objetivo deste item consiste em acionar progressivamente seis leds externos ligados ao Arduino UNO de

acordo com a posição de um potenciômetro e representar este acionamento através de uma barra de

progresso no display.
















item os nomes que vão do LED1 até o LED6 representam os leds existentes na barra de leds, enquanto o

potenciômetro está definido a partir do nome POT.

#define LED1 0

#define LED2 1

#define LED3 6

#define LED4 7

#define LED5 8

#define LED6 9

#define POT 0

Neste momento são criadas as variáveis lcd que representa o elemento ao qual devemos nos referir para

acessar o display a partir do código, medidaPOT e medidaPOTant responsáveis por registrar as medidas

fornecidas pelo potenciômetro através da função analogRead() e variável contador que será utilizada em

estruturas de repetição. Além destes elementos citados, são criadas também variáveis utilizadas para o

desenvolvimento de caracteres especiais.


int medidaPOT = 0;

int medidaPOTant = 0;


int contador;

byte numero1[8] = {

B00000,

B00000,

B00000,

B00000,

B00000,

B00000,

B11111,

B11111

};

byte numero2[8] = {

B00000,

B00000,

B00000,

B00000,

B00000,

B11111,

B11111,

B11111

};

byte numero3[8] = {

B00000,

B00000,

B00000,

B00000,

B11111,

B11111,

B11111,

B11111

};

byte numero4[8] = {

B00000,

B00000,

B00000,

B11111,

B11111,

B11111,


B11111,

B11111

};

byte numero5[8] = {

B00000,

B00000,

B11111,

B11111,

B11111,

B11111,

B11111,

B11111

};

byte numero6[8] = {

B00000,

B11111,

B11111,

B11111,

B11111,

B11111,

B11111,

B11111

};

byte numero7[8] = {

B11111,

B11111,

B11111,

B11111,

B11111,

B11111,

B11111,

B11111

};

Dentro da função setup() serão definidos os modos de operação dos pinos utilizados. Como foram utilizados

apenas leds, todos os pinos nos quais estes se encontram conectados foram definidos como saídas através

da função pinMode(). Além disso a interface entre o display e o Arduino UNO é inicializada utilizando a

função begin() e por último também são criados os caracteres especiais através da função createChar().


Após os procedimentos citados anteriormente é confeccionada a tela inicial do programa.

void setup() {

pinMode(LED1,OUTPUT);







lcd.begin(20,2);

lcd.createChar(0, numero1);







lcd.setCursor(0,0);

lcd.print("MEDIDA:");

lcd.print(medidaPOT);

lcd.setCursor(0,1);

lcd.print("GRAFICO:");

}

A primeira linha de código na função loop() é responsável por realizar a leitura da porta analógica A0

através da função analogRead(), retornar um número que pode variar de 0 a 1023 conforme o nível de

tensão (0 a 5 volts) que é estabelecido no pino em questão e registrar este valor na variável medidaPOT.

Posteriormente o valor armazenado em medidaPOT é comparado com o valor contido em medidaPOTant

(lembre-se que esta variável foi iniciada contendo o valor 0) e caso estes valores sejam diferente torna-se

necessário que código inteiro seja analisado (estruturas if() subsequentes), intervalo por intervalo (definido

em porções de mesmo tamanho, iguais a aproximadamente 1023/8) para que seja determinada qual deve

ser a sequência a ser utilizada.


As sequências são:

medidaPOT ≤ 128 → Todos os leds apagados

146 < medidaPOT ≤ 256 → LED1

256 < medidaPOT ≤ 384 → LED1, LED2

384 < medidaPOT ≤ 512 → LED1, LED2, LED3

512 < medidaPOT ≤ 640 → LED1, LED2, LED3, LED4

640 < medidaPOT ≤ 768 → LED1, LED2, LED3, LED4, LED5

768 < medidaPOT ≤ 895 → LED1, LED2, LED3, LED4, LED5, LED6

medidaPOT > 895 → LED1, LED2, LED3, LED4, LED5, LED6, LED7

Após ocorrer alguma mudança no regime de funcionamento da barra de leds, esta é impressa no display e

a variável medidaPOTant é atualizada com o valor contido em medidaPOT.

Void loop() {

medidaPOT = analogRead(POT);

if(medidaPOTant != medidaPOT){

lcd.clear();

lcd.setCursor(0,0);



lcd.setCursor(0,1);


if(medidaPOT <= 128){

digitalWrite(LED1,LOW);







}

if((medidaPOT > 128) && (medidaPOT <= 256)){

digitalWrite(LED1,HIGH);








lcd.write((byte)0);

}









lcd.write((byte)0);

lcd.write(1);

}









lcd.write((byte)0);

lcd.write(1);

lcd.write(2);

}










lcd.write((byte)0);

lcd.write(1);

lcd.write(2);

lcd.write(3);

}









lcd.write((byte)0);

lcd.write(1);

lcd.write(2);

lcd.write(3);

lcd.write(4);

}










lcd.write((byte)0);

lcd.write(1);

lcd.write(2);

lcd.write(3);

lcd.write(4);

lcd.write(5);

}

if(medidaPOT > 895){








lcd.write((byte)0);

lcd.write(1);

lcd.write(2);

lcd.write(3);

lcd.write(4);

lcd.write(5);

lcd.write(6);

}

medidaPOTant = medidaPOT;

}

}


7 DESENVOLVIMENTO DE UM MENU COMPLETO UTILIZANDO DISPLAY LCD

7.1 Objetivo

Este item consiste em criar uma aplicação utilizando todo o conhecimento adquirido tanto nesta PARTE II

como na PARTE I deste material. Aqui será desenvolvido um sistema composto por um display LCD, três

leds que serão acionados utilizando PWM, um led com comportamento on/off, quatro botões para a

manipulação do menu e dos leds e um potenciômetro para realizar o ajuste fino do PWM.





momento os leds vermelho (R), verde (G) e azul (B) e amarelo (LED_AM) estão relacionados com os pinos

1,10,11 e 13. Os botões BOT1/2/3/4 estão ligados aos pinos 0,1,7 e 8 respectivamente e o potenciômetro

está conectado ao pino de entrada analógica A0.

#define R 9

#define G 10

#define B 11

#define LED_AM 13

#define BOT1 0

#define BOT2 1

#define BOT3 7

#define BOT4 8

#define POT 0

Em seguida é declarada uma grande quantidade de variáveis, sendo assim, estas foram separadas em blocos

para facilitar o entendimento sobre a área de atuação das mesmas. A primeira variável é a lcd já discutida

neste material. Posteriormente tem-se o primeiro bloco de variáveis, estas são responsáveis pelo

funcionamento dos quatro botões existentes no hardware da simulação. Observe que os botões 1 e 2

possuem tratamento em seu acionamento, enquanto os botões 3 e 4 não necessitam deste artifício (Se o

leitor tive alguma dúvida sobre a implementação do tratamento em botões, favor consultar o item 2.1 da

primeira parte).

O segundo bloco possui as variáveis linhaATUAL, linhaANTERIOR e linhaANTERIORaux,

responsáveis pelo controle das linhas do menu criado. Já o terceiro bloco é representado pelas variáveis que

armazenarão os valores para serem utilizados no acionamento dos leds R,G e B através do PWM e pela

variável para realizar o acionamento ON/OFF do led amarelo.

O último bloco é responsável pela interação do potenciômetro com os leds R,G e B. Este possui como

função realizar um ajuste fino no valor que será utilizado no PWM para acionar os leds citados.

Além dos blocos comentados anteriormente existe ainda a variável contador utilizada em estruturas de

repetição e os caracteres especiais que farão parte do menu representado no display.



BLOCO 1

bool estadoatualBOT1 = 0;

bool estadoantBOT1 = 0;

bool leituraBOT1 = 0;

long ultDebounceBOT1 = 0;





long tempoDeb = 50;

bool leituraBOT3;

bool leituraBOT4;

BLOCO 2

int linhaATUAL = 1;

int linhaANTERIOR = 1;

int linhaANTERIORaux = 1;

BLOCO 3

int estadoR;

int estadoRant;

int estadoG;

int estadoGant;

int estadoB;

int estadoBant;

bool estadoAM;

bool estadoAMant;

BLOCO 4


int medidaPOT;

int ajustefinoR;

int ajustefinoRant = 0;

int ajustefinoG;

int ajustefinoGant = 0;

int ajustefinoB;

int ajustefinoBant = 0;

int contador;

CARACTERES ESPECIAIS

byte numero0[8] = {

B00000,

B00000,

B00000,

B11111,

B00000,

B00000,

B00000,

B00000

};

byte numero1[8] = {

B11000,

B11100,

B11110,

B11111,

B11110,

B11100,

B11000,

B11111

};


byte numero2[8] = {

B00000,

B00000,

B00000,

B00000,

B00000,

B00000,

B00000,

B00000

};

byte numero3[8] = {

B00100,

B00100,

B00100,

B00100,

B11111,

B01110,

B00100,

B00000

};

byte numero4[8] = {

B00100,

B01110,

B11111,

B00100,

B00100,

B00100,

B00100,

B00000

};

Dentro da função setup() serão definidos os modos de operação dos pinos utilizados, onde os pinos em que

estão conectados os 5 leds são definidos como saídas e os pinos em que se encontram os botões são

definidos como entradas. Neste momento também são criados os caracteres especiais através da função

createChar(), inicializada a interface entre Arduino UNO e display, além da utilização da função cabeçalho,

responsável por escrever a parte de cima (duas linhas superiores) do display.


void setup() {

pinMode(R,OUTPUT);

pinMode(G,OUTPUT);

pinMode(B,OUTPUT);

pinMode(LED_AM,OUTPUT);

pinMode(BOT1,INPUT);




lcd.begin(20,4);






cabecalho();

}

Na função loop() são chamadas quatro funções que proporcionam o funcionamento propriamente dito do

programa. As funções verificarBOT1/BOT2/BOT3() são responsáveis por analisar os três botões e tomar

as providencias necessárias enquanto a função verificarLINHA() realiza o ajuste do cursor de seleção de

acordo com as linha selecionada e organiza as linhas da forma correta para serem representadas no display.

void loop() {

verificarBOT1();

verificarBOT2();

verificarBOT3();

verificarLINHA();

}


Como as funções mostradas à seguir são grandes e complexas, será explicado neste momento apenas as

partes importantes e necessárias para o entendimento do funcionamento do programa.

No começo do programa, a primeira função que deve ser analisada é a função verificarBOT1().

Primeiramente nesta função verifica-se o estado do botão 1, caso este tenha sido pressionado a variável

linhaANTERIOR recebe o valor da variável linhaATUAL e esta última é incrementada. O mesmo acontece

com a função verificarBOT2(), porém a variável linhaATUAL é decrementada neste caso.

Supondo que por enquanto não ocorra um acionamento do botão 3, o programa passará para a função

verificarLINHA(). Nesta função, o programa escreve as duas linhas que aparecerão por vez no display,

juntamente com o cursor de seleção destas (por isso é importante levar em conta as duas variáveis,

linhaANTERIOR e linhaATUAL para o posicionamento correto do cursor). Repare que dentro das funções

verificarBOT1/2() existem condições que limitam o valor destas variáveis no intervalo de 1 a 4.

As linhas fornecem as possibilidades de atuar sobre os seguintes elementos:

Linha 1 → R

Linha 2 → G

Linha 3 → B

Linha 4 → LED_AM

Supondo agora que o botão 1 foi apertado uma vez (linhaATUAL = 2 e linhaANTERIOR = 1). Quando o

botão 3 for pressionado, serão verificadas várias estruturas condicionais if() e uma delas detectará que a

linha atual é a número 2, sendo assim, o sistema entrará em um outro patamar onde é possível realizar o

acionamento do led G utilizando PWM.

Neste momento o display passa a sinalizar que a componente verde do led RGB foi escolhida para ser

alterada. Para isto existe a esturura do/while(), que realizará primeiramente uma sentença e enquanto uma

determinada condição não é atingida, esta sentença é repetida indefinidamente. A sentença em questão

consiste em verificar o potenciômetro e adicionar até 25 unidades na variável estadoG (responsável por

conter o valor que será utilizado para acionar o led). Observe que dentro desta mesma sentença, as funções

verificarBOT1/BOT2() são chamadas novamente.

Fazendo uma nova observação na função verificarBOT1() pode-se ver que existe uma estrutura condicional

if() que verifica a hipótese de que o botão 3 tenha sido apertado, e posteriormente encontra-se uma estrutura

switch/case onde é determinada em qual linha o programa estava quando o botão 3 foi pressionado. Como

a variável linhaATUAL possui o valor 2, logo, ao ser pressionar o botão 1, a variável estadoG será


decrementada em 25 unidades. O mesmo acontece com o botão 2, porém a diferença é que a variável

estadoG será incrementada do mesmo valor. Este ciclo vai se repetindo até que o botão 4 seja pressionado

(condição de parada da estrutura do/while()), onde o display volta a apresentar a tela onde estava o sistema

no momento em que o botão 3 foi pressionado.

A única exceção acontece quando linhaATUAL = 4, pois neste caso temos o acionamento on/off do led

amarelo.

void linha1(){

lcd.print("R");

}

void linha2(){

lcd.print("G");

}

void linha3(){

lcd.print("B");

}

void linha4(){

lcd.print("LED_AM");

}

void verificarBOT1(){

leituraBOT1 = digitalRead(BOT1);


if (leituraBOT1 != estadoantBOT1) {

ultDebounceBOT1 = millis();

}

if ((millis() - ultDebounceBOT1) > tempoDeb) {

if (leituraBOT1 != estadoatualBOT1) {

estadoatualBOT1 = leituraBOT1;

if (estadoatualBOT1 == 1) {

linhaANTERIORaux = linhaANTERIOR;

linhaANTERIOR = linhaATUAL;

linhaATUAL = linhaATUAL + 1;

if(linhaATUAL > 4){

linhaATUAL = 4;

}

if(leituraBOT3 == 1){

switch(linhaANTERIOR){

case 1:

estadoR = estadoR - 25;

linhaATUAL = linhaANTERIOR;

linhaANTERIOR = linhaANTERIORaux;

break;

case 2:

estadoG = estadoG - 25;




break;

case 3:

estadoB = estadoB - 25;



break;

case 4:

estadoAM = 1;

digitalWrite(LED_AM,HIGH);



break;

}

}

}

}

}

estadoantBOT1 = leituraBOT1;

}





}








linhaATUAL = linhaATUAL - 1;

if(linhaATUAL < 1){

linhaATUAL = 1;

}


switch (linhaANTERIOR){

case 1:

estadoR = estadoR + 25;



break;

case 2:

estadoG = estadoG + 25;



break;

case 3:

estadoB = estadoB + 25;




break;

case 4:

estadoAM = 0;

digitalWrite(LED_AM,LOW);



break;

}

}

}

}

}


}



if (leituraBOT3 == 1) {

if(linhaATUAL == 1){

lcd.setCursor(0,2);

lcd.print("COMP VERMELHA");

lcd.setCursor(0,3);

lcd.print("PWM:");

lcd.print(estadoR);

do{

verificarPOT();

ajustefinoR = medidaPOT;


if(ajustefinoR != ajustefinoRant){

estadoR = estadoR - ajustefinoRant + ajustefinoR;

if(estadoR >= 255){

estadoR = 255;

}

if(estadoR <= 0){

estadoR = 0;

}

analogWrite(R,(estadoR - ajustefinoRant + ajustefinoR));

ajustefinoRant = ajustefinoR;

}

if(estadoR != estadoRant){

for( contador = 4; contador <7; contador++){

lcd.setCursor(contador,3);

lcd.write(2);

}

if(estadoR >= 255){

estadoR = 255;

}

if(estadoR <= 0){

estadoR = 0;

}

lcd.setCursor(4,3);

lcd.print(estadoR);


analogWrite(R,estadoR);

estadoRant = estadoR;

}

verificarBOT1();

verificarBOT2();

verificarBOT4();

} while(leituraBOT4 == 0);

lcd.clear();

cabecalho();

}


lcd.setCursor(0,2);

lcd.print("COMP VERDE");

lcd.setCursor(0,3);

lcd.print("PWM:");

lcd.print(estadoG);

do{

verificarPOT();

ajustefinoG = medidaPOT;

if(ajustefinoG != ajustefinoGant){

estadoG = estadoG - ajustefinoGant + ajustefinoG;

if(estadoG >= 255){

estadoG = 255;

}

if(estadoG <= 0){


estadoG = 0;

}

analogWrite(G,(estadoG - ajustefinoGant + ajustefinoG));

ajustefinoGant = ajustefinoG;

}

if(estadoG != estadoGant){



lcd.write(2);

}

if(estadoG >= 255){

estadoG = 255;

}

if(estadoG <= 0){

estadoG = 0;

}

lcd.setCursor(4,3);

lcd.print(estadoG);

analogWrite(G,estadoG);

estadoGant = estadoG;

}

verificarBOT1();

verificarBOT2();

verificarBOT4();



lcd.clear();

cabecalho();

}


lcd.setCursor(0,2);

lcd.print("COMP AZUL");

lcd.setCursor(0,3);

lcd.print("PWM:");

for(contador = 4; contador < 7; contador++){


lcd.write(2);

}

lcd.setCursor(4,3);

lcd.print(estadoB);

do{

verificarPOT();

ajustefinoB = medidaPOT;

if(ajustefinoB != ajustefinoBant){

estadoB = estadoB - ajustefinoBant + ajustefinoB;

if(estadoB >= 255){

estadoB = 255;

}

if(estadoB <= 0){

estadoB = 0;

}


analogWrite(B,(estadoB - ajustefinoBant + ajustefinoB));

ajustefinoBant = ajustefinoB;

}

if(estadoB != estadoBant){



lcd.write(2);

}

if(estadoB >= 255){

estadoB = 255;

}

if(estadoB <= 0){

estadoB = 0;

}

lcd.setCursor(4,3);

lcd.print(estadoB);

analogWrite(B,estadoB);

estadoBant = estadoB;

}

verificarBOT1();

verificarBOT2();

verificarBOT4();


lcd.clear();

cabecalho();


}


lcd.setCursor(0,2);

lcd.print("LED AMARELO");

lcd.setCursor(0,3);

if(estadoAM == 0){

lcd.print("DESLIGADO");

}

else{

lcd.print("LIGADO ");

}

do{

if(estadoAM != estadoAMant){

lcd.setCursor(0,3);

if(estadoAM == 0){


}

else{


}

estadoAMant = estadoAM;

}

verificarBOT1();

verificarBOT2();

verificarBOT4();



lcd.clear();

cabecalho();

}

}

}



}

void verificarLINHA(){


lcd.setCursor(0,2);

lcd.write(1);

lcd.setCursor(0,3);

lcd.write(2);

lcd.setCursor(1,2);

linha1();

lcd.setCursor(1,3);

linha2();


lcd.write(2);


lcd.write(3);

}



if(linhaANTERIOR == 1){

lcd.setCursor(0,3);

lcd.write(1);

lcd.setCursor(0,2);

lcd.write(2);

lcd.setCursor(1,2);

linha1();

lcd.setCursor(1,3);

linha2();


lcd.write(4);


lcd.write(3);

}


lcd.setCursor(0,2);

lcd.write(1);

lcd.setCursor(0,3);

lcd.write(2);

lcd.setCursor(1,2);

linha2();

lcd.setCursor(1,3);

linha3();

for (contador = 0; contador <5; contador++){

lcd.write(2);

}


lcd.write(4);


lcd.write(3);


}

}



lcd.setCursor(0,3);

lcd.write(1);

lcd.setCursor(0,2);

lcd.write(2);

lcd.setCursor(1,2);

linha2();

lcd.setCursor(1,3);

linha3();


lcd.write(4);


lcd.write(3);

}


lcd.setCursor(0,2);

lcd.write(1);

lcd.setCursor(0,3);

lcd.write(2);

lcd.setCursor(1,2);

linha3();

lcd.setCursor(1,3);

linha4();


lcd.write(4);


lcd.write(3);

}


}


lcd.setCursor(0,3);

lcd.write(1);

lcd.setCursor(0,2);

lcd.write(2);

lcd.setCursor(1,2);

linha3();

lcd.setCursor(1,3);

linha4();


lcd.write(4);


lcd.write(2);

}

}

void cabecalho(){

lcd.setCursor(6,0);

lcd.print("ITEM 1.7");

lcd.setCursor(0,1);


lcd.write((byte)0);

}

}


APÊNDICE A – Códigos

Este apêndice contém todos os códigos de desenvolvidos nos itens referentes à este documento, no entanto

aqui estes não se encontram de forma segmentada (maneira que foram utilizados nos itens já citados).

OBS: Para conferir se os códigos estavam corretos resolvi por várias vezes copia-los diretamente

deste documento e colar os mesmos na IDE do Arduino para compilar e assim testar, no entanto,

existe a possibilidade de esta acusar alguns erros na compilação devido ao fato de alguns caracteres

serem passados de maneira errada, como é o caso do “-“ (sinal de menos), portanto caso isso aconteça,

basta ir ao local onde está escrito este caractere e troca-lo pelo mesmo porém escrito diretamente na

IDE.

CÓDIGO DO ITEM 1



void setup() {

lcd.begin(16, 1);

lcd.print("EXEMPLO 1.1");

}

void loop() {

}


CÓDIGO DO ITEM 2


#define LED 10


bool estadoLED = 0;

bool estadoLEDant = 1;

int tempo;

void setup() {

lcd.begin(16, 1);

lcd.print("LED:");


}

void loop() {

if(estadoLED != estadoLEDant){

if(estadoLED == 1){

lcd.setCursor(4,0);

lcd.print("LIG");

}

else {

lcd.setCursor(4,0);

lcd.print("DES");

}


CÓDIGO DO ITEM 3


#define LED 9

#define BOT 10


bool estadoBOT;

bool estadoBOTant;

float tempo = 0.0;

void setup() {


pinMode(BOT,INPUT);

lcd.begin(16, 2);

lcd.print("Iniciando...");

delay(2000);

tempo = millis();

estadoLEDant = estadoLED;

}

if(millis() - tempo > 1000){

estadoLED = !estadoLED;

digitalWrite(LED, estadoLED);

}

lcd.scrollDisplayRight();

delay(250);

}


lcd.setCursor(0,0);


lcd.setCursor(0,1);


}

void loop() {




lcd.print("S");

digitalWrite (LED, HIGH);

lcd.setCursor(4,1);

lcd.print("L");

for( int contador = 0; contador < 5; contador++){


lcd.print(tempo);


delay(500);

}

digitalWrite (LED,LOW);

lcd.setCursor(4,1);

lcd.print("D");

lcd.setCursor(0,0);

lcd.print(" AGUARDE ");

lcd.setCursor(6,1);

lcd.print(" segundos ");

tempo = 5.0;

for(int contador = 0; contador < 10; contador++){


lcd.setCursor(0,1);

lcd.print(" ");

lcd.print(tempo);

tempo = tempo - 0.5;

delay(500);

}

lcd.clear();

while(digitalRead(BOT) == 1){

lcd.setCursor(0,0);

lcd.print(" Solte o botao");

}

lcd.setCursor(0,0);


lcd.setCursor(0,1);


}

}

CÓDIGO DO ITEM 4


#define BOT 13

#define VMC 10

#define AMC 9

#define VDC 8

#define VMP 7

#define VDP 6


bool estadoBOT;


float tempo = 0.5;

void setup() {

pinMode(VMC, OUTPUT);

pinMode(AMC, OUTPUT);

pinMode(VDC, OUTPUT);

pinMode(VMP, OUTPUT);

pinMode(VDP, OUTPUT);

pinMode(BOT, INPUT);



lcd.begin(16, 4);

lcd.setCursor(4,1);

lcd.print("CARREGAR");

lcd.setCursor(4,2);

lcd.print("SEMAFORO");

delay(2000);

lcd.clear();

lcd.print("CARROS PESSOAS");

lcd.setCursor(0,1);

lcd.print("VDC:LIG VDP:DES");

lcd.setCursor(0,2);

lcd.print("AMC:DES VMP:LIG");

lcd.setCursor(0,3);

lcd.print("VMC:DES TMP:-.-");

}

CÓDIGO DO ITEM 5


#define BOT 9



bool estadoBOT;

long aleatorio;

int contador;

byte numero[8] = {

B11111,

B11111,

B11111,

B11111,

B11111,

B11111,

B11111,

B11111

};

void setup() {

pinMode (BOT, INPUT);

randomSeed(analogRead(0));

lcd.begin(20, 4);

lcd.createChar(0, numero);

}

switch(aleatorio){

case 1:

lcd.clear();

escreveG2();

divisao();


lcd.print("VALOR");



delay (5000);

break;


case 2:

lcd.clear();

escreveG1();

divisao();


lcd.print("VALOR");



delay (5000);

break;

case 3:

lcd.clear();

escreveG2();

escreveG4();

divisao();


lcd.print("VALOR");



delay (5000);

break;

case 4:

lcd.clear();

escreveG1();

escreveG4();

divisao();


lcd.print("VALOR");




delay (5000);

break;

case 5:

lcd.clear();

escreveG1();

escreveG2();

escreveG4();

divisao();


lcd.print("VALOR");



delay (5000);

break;

case 6:

lcd.clear();

escreveG1();

escreveG3();

escreveG4();

divisao();


lcd.print("VALOR");



delay (5000);

break;

}

lcd.clear();


}

lcd.setCursor(2,1);

lcd.println("PRESSIONE O BOTAO");

lcd.setCursor(2,2);

lcd.println("PARA ROLAR O DADO");

}

void escreveG1(){

lcd.setCursor(4,1);

lcd.write((byte)0);

lcd.setCursor(8,3);

lcd.write((byte)0);

}

void escreveG2(){

lcd.setCursor(6,2);

lcd.write((byte)0);

}

void escreveG3(){

lcd.setCursor(4,2);

lcd.write((byte)0);

lcd.setCursor(8,2);

lcd.write((byte)0);

}

void escreveG4(){

lcd.setCursor(8,1);

lcd.write((byte)0);

lcd.setCursor(4,3);

lcd.write((byte)0);


}

void divisao(){


lcd.setCursor(13,contador);

lcd.write((byte)0);

}

}

CÓDIGO DO ITEM 6


#define LED1 0

#define LED2 1

#define LED3 6

#define LED4 7

#define LED5 8

#define LED6 9

#define POT 0


int medidaPOT = 0;

int medidaPOTant = 0;

int contador;

byte numero1[8] = {

B00000,

B00000,

B00000,

B00000,

B00000,

B00000,


B11111,

B11111

};

byte numero2[8] = {

B00000,

B00000,

B00000,

B00000,

B00000,

B11111,

B11111,

B11111

};

byte numero3[8] = {

B00000,

B00000,

B00000,

B00000,

B11111,

B11111,

B11111,

B11111

};

byte numero4[8] = {

B00000,

B00000,

B00000,

B11111,

B11111,

B11111,

B11111,

B11111

};

byte numero5[8] = {

B00000,

B00000,

B11111,

B11111,

B11111,

B11111,


B11111,

B11111

};

byte numero6[8] = {

B00000,

B11111,

B11111,

B11111,

B11111,

B11111,

B11111,

B11111

};

byte numero7[8] = {

B11111,

B11111,

B11111,

B11111,

B11111,

B11111,

B11111,

B11111

};

void setup() {








lcd.begin(20,2);









lcd.setCursor(0,0);



lcd.setCursor(0,1);


}

Void loop() {

medidaPOT = analogRead(POT);

if(medidaPOTant != medidaPOT){

lcd.clear();

lcd.setCursor(0,0);



lcd.setCursor(0,1);


if(medidaPOT <= 128){








}










lcd.write((byte)0);

}









lcd.write((byte)0);

lcd.write(1);

}









lcd.write((byte)0);

lcd.write(1);

lcd.write(2);

}










lcd.write((byte)0);

lcd.write(1);

lcd.write(2);

lcd.write(3);

}









lcd.write((byte)0);

lcd.write(1);

lcd.write(2);

lcd.write(3);

lcd.write(4);

}










lcd.write((byte)0);

lcd.write(1);

lcd.write(2);

lcd.write(3);

lcd.write(4);

lcd.write(5);

}

if(medidaPOT > 895){








lcd.write((byte)0);

lcd.write(1);

lcd.write(2);

lcd.write(3);

lcd.write(4);

lcd.write(5);

lcd.write(6);

}

medidaPOTant = medidaPOT;

}

}


CÓDIGO DO ITEM 7


#define R 9

#define G 10

#define B 11

#define LED_AM 13

#define BOT1 0

#define BOT2 1

#define BOT3 7

#define BOT4 8

#define POT 0










long tempoDeb = 50;

bool leituraBOT3;

bool leituraBOT4;

int linhaATUAL = 1;

int linhaANTERIOR = 1;

int linhaANTERIORaux = 1;

int estadoR;

int estadoRant;


int estadoG;

int estadoGant;

int estadoB;

int estadoBant;

bool estadoAM;

bool estadoAMant;

int medidaPOT;

int ajustefinoR;

int ajustefinoRant = 0;

int ajustefinoG;

int ajustefinoGant = 0;

int ajustefinoB;

int ajustefinoBant = 0;

int contador;

byte numero0[8] = {

B00000,

B00000,

B00000,

B11111,

B00000,

B00000,

B00000,

B00000

};

byte numero1[8] = {

B11000,

B11100,

B11110,

B11111,

B11110,

B11100,

B11000,

B11111

};


byte numero2[8] = {

B00000,

B00000,

B00000,

B00000,

B00000,

B00000,

B00000,

B00000

};

byte numero3[8] = {

B00100,

B00100,

B00100,

B00100,

B11111,

B01110,

B00100,

B00000

};

byte numero4[8] = {

B00100,

B01110,

B11111,

B00100,

B00100,

B00100,

B00100,

B00000

};

void setup() {

pinMode(R,OUTPUT);

pinMode(G,OUTPUT);

pinMode(B,OUTPUT);

pinMode(LED_AM,OUTPUT);






lcd.begin(20,4);






cabecalho();

}

void loop() {

verificarBOT1();

verificarBOT2();

verificarBOT3();

verificarLINHA();

}

void linha1(){

lcd.print("R");

}

void linha2(){

lcd.print("G");

}

void linha3(){

lcd.print("B");

}

void linha4(){


lcd.print("LED_AM");

}





}







linhaATUAL = linhaATUAL + 1;

if(linhaATUAL > 4){

linhaATUAL = 4;

}


switch(linhaANTERIOR){

case 1:

estadoR = estadoR - 25;




break;

case 2:

estadoG = estadoG - 25;



break;

case 3:

estadoB = estadoB - 25;



break;

case 4:

estadoAM = 1;

digitalWrite(LED_AM,HIGH);



break;

}

}

}

}

}


}






}







linhaATUAL = linhaATUAL - 1;

if(linhaATUAL < 1){

linhaATUAL = 1;

}


switch (linhaANTERIOR){

case 1:

estadoR = estadoR + 25;



break;

case 2:

estadoG = estadoG + 25;



break;


case 3:

estadoB = estadoB + 25;



break;

case 4:

estadoAM = 0;

digitalWrite(LED_AM,LOW);



break;

}

}

}

}

}


}



if (leituraBOT3 == 1) {


lcd.setCursor(0,2);

lcd.print("COMP VERMELHA");

lcd.setCursor(0,3);

lcd.print("PWM:");

lcd.print(estadoR);

do{


verificarPOT();

ajustefinoR = medidaPOT;

if(ajustefinoR != ajustefinoRant){

estadoR = estadoR - ajustefinoRant + ajustefinoR;

if(estadoR >= 255){

estadoR = 255;

}

if(estadoR <= 0){

estadoR = 0;

}

analogWrite(R,(estadoR - ajustefinoRant + ajustefinoR));

ajustefinoRant = ajustefinoR;

}

if(estadoR != estadoRant){



lcd.write(2);

}

if(estadoR >= 255){

estadoR = 255;

}

if(estadoR <= 0){

estadoR = 0;

}


lcd.setCursor(4,3);

lcd.print(estadoR);

analogWrite(R,estadoR);

estadoRant = estadoR;

}

verificarBOT1();

verificarBOT2();

verificarBOT4();


lcd.clear();

cabecalho();

}


lcd.setCursor(0,2);

lcd.print("COMP VERDE");

lcd.setCursor(0,3);

lcd.print("PWM:");

lcd.print(estadoG);

do{

verificarPOT();

ajustefinoG = medidaPOT;

if(ajustefinoG != ajustefinoGant){

estadoG = estadoG - ajustefinoGant + ajustefinoG;

if(estadoG >= 255){

estadoG = 255;


}

if(estadoG <= 0){

estadoG = 0;

}

analogWrite(G,(estadoG - ajustefinoGant + ajustefinoG));

ajustefinoGant = ajustefinoG;

}

if(estadoG != estadoGant){



lcd.write(2);

}

if(estadoG >= 255){

estadoG = 255;

}

if(estadoG <= 0){

estadoG = 0;

}

lcd.setCursor(4,3);

lcd.print(estadoG);

analogWrite(G,estadoG);

estadoGant = estadoG;

}

verificarBOT1();


verificarBOT2();

verificarBOT4();


lcd.clear();

cabecalho();

}


lcd.setCursor(0,2);

lcd.print("COMP AZUL");

lcd.setCursor(0,3);

lcd.print("PWM:");

for(contador = 4; contador < 7; contador++){


lcd.write(2);

}

lcd.setCursor(4,3);

lcd.print(estadoB);

do{

verificarPOT();

ajustefinoB = medidaPOT;

if(ajustefinoB != ajustefinoBant){

estadoB = estadoB - ajustefinoBant + ajustefinoB;

if(estadoB >= 255){

estadoB = 255;

}

if(estadoB <= 0){


estadoB = 0;

}

analogWrite(B,(estadoB - ajustefinoBant + ajustefinoB));

ajustefinoBant = ajustefinoB;

}

if(estadoB != estadoBant){



lcd.write(2);

}

if(estadoB >= 255){

estadoB = 255;

}

if(estadoB <= 0){

estadoB = 0;

}

lcd.setCursor(4,3);

lcd.print(estadoB);

analogWrite(B,estadoB);

estadoBant = estadoB;

}

verificarBOT1();

verificarBOT2();

verificarBOT4();



lcd.clear();

cabecalho();

}


lcd.setCursor(0,2);

lcd.print("LED AMARELO");

lcd.setCursor(0,3);

if(estadoAM == 0){


}

else{


}

do{

if(estadoAM != estadoAMant){

lcd.setCursor(0,3);

if(estadoAM == 0){


}

else{


}

estadoAMant = estadoAM;

}


verificarBOT1();

verificarBOT2();

verificarBOT4();


lcd.clear();

cabecalho();

}

}

}



}

void verificarLINHA(){


lcd.setCursor(0,2);

lcd.write(1);

lcd.setCursor(0,3);

lcd.write(2);

lcd.setCursor(1,2);

linha1();

lcd.setCursor(1,3);

linha2();


lcd.write(2);


lcd.write(3);

}




lcd.setCursor(0,3);

lcd.write(1);

lcd.setCursor(0,2);

lcd.write(2);

lcd.setCursor(1,2);

linha1();

lcd.setCursor(1,3);

linha2();


lcd.write(4);


lcd.write(3);

}


lcd.setCursor(0,2);

lcd.write(1);

lcd.setCursor(0,3);

lcd.write(2);

lcd.setCursor(1,2);

linha2();

lcd.setCursor(1,3);

linha3();

for (contador = 0; contador <5; contador++){

lcd.write(2);

}


lcd.write(4);


lcd.write(3);


}

}



lcd.setCursor(0,3);

lcd.write(1);

lcd.setCursor(0,2);

lcd.write(2);

lcd.setCursor(1,2);

linha2();

lcd.setCursor(1,3);

linha3();


lcd.write(4);


lcd.write(3);

}


lcd.setCursor(0,2);

lcd.write(1);

lcd.setCursor(0,3);

lcd.write(2);

lcd.setCursor(1,2);

linha3();

lcd.setCursor(1,3);

linha4();


lcd.write(4);


lcd.write(3);

}

}



lcd.setCursor(0,3);

lcd.write(1);

lcd.setCursor(0,2);

lcd.write(2);

lcd.setCursor(1,2);

linha3();

lcd.setCursor(1,3);

linha4();


lcd.write(4);


lcd.write(2);

}

}

void cabecalho(){

lcd.setCursor(6,0);

lcd.print("ITEM 1.7");

lcd.setCursor(0,1);


lcd.write((byte)0);

}

}

DANIEL MADEIRA BUENO - Embarcados

Documents

Transcript of DANIEL MADEIRA BUENO - Embarcados