COMPOSIÇÃO DE CORES - ENSINANDO CONCEITOS DE FÍSICA COM ARDUINO

1) Nome do Projeto: COMPOSIÇÃO DE CORES - ENSINANDO CONCEITOS DE FÍSICA COM ARDUINO

 

2) Objetivo: Mostrar que combinando adequadamente as cores azul, vermelho e verde podemos formar uma infinidade de cores.

 

3) Esquema elétrico e lista de materiais:

Quantidade

Componente

1

Placa Arduino Uno

1

Protoboard sem Solda

12

fios jumper pré-cortados

6

Resistores de 330 Ω

3

Botões de Pressão Táctil Momentâneo

1

LED RGB

4) Software:

// Se segurarmos os botões, alteraremos o brilho das diferentes cores do LED (RGB) possibilitando, com isso, a percepção de uma gama de cores.// Acende, separadamente, as diferentes cores do LED (RGB) quando os respectivos botões são pressionados, mantendo-os acesos mesmo depois que deixamos de pressioná-los.

// Combinação de Cores: azul+verde+vermelho=branco; azul+verde=ciano; azul+vermelho=magenta; verde+vermelho=amarelo; alterando o brilho é possível obter várias tonalidade de amarelo por exemplo.

// Inclui recurso simples de anti-repique.

//

const int LED_VERMELHO=9; // pino para o LED (RGB) vermelho

const int LED_VERDE=10; // pino para o LED (RGB) verde

const int LED_AZUL=11; // pino para o LED (RGB) azul

//

const int BUTAO_VERMELHO=2; // pino de entrada para o botão de pressão que controla a cor vermelha

const int BUTAO_VERDE=4; // pino de entrada para o botão de pressão que controla a cor verde

const int BUTAO_AZUL=7; // pino de entrada para o botão de pressão que controla a cor azul

//

int VAL_VERMELHO=0; // armazena o estado do pino de entrada LED_VERMELHO

int VAL_VERDE=0; // armazena o estado do pino de entrada LED_VERDE

int VAL_AZUL=0; // armazena o estado do pino de entrada LED_AZUL

//

int VAL_ANTERIOR_VERMELHO=0; // armazena o valor anterior de "VAL_VERMELHO"

int VAL_ANTERIOR_VERDE=0; // armazena o valor anterior de "VAL_VERDE"

int VAL_ANTERIOR_AZUL=0; // armazena o valor anterior de "VAL_AZUL"

//

int ESTADO_VERMELHO=0; // possíveis estados apara o LED (RGB) vermelho, 0 = LED apagado, enquanto 1 = LED aceso

int ESTADO_VERDE=0; // possíveis estados apara o LED (RGB) verde, 0 = LED apagado, enquanto 1 = LED aceso

int ESTADO_AZUL=0; // possíveis estados apara o LED (RGB) azul, 0 = LED apagado, enquanto 1 = LED aceso

//

int BRILHO_VERMELHO=128; // armazena o valor do brilho do LED (RGB) vermelho quando começamos a pressionar o botão vermelho (pino 2)

int BRILHO_VERDE=128; // armazena o valor do brilho do LED (RGB) verde quando começamos a pressionar o botão verde (pino 4)

int BRILHO_AZUL=128; // armazena o valor do brilho do LED (RGB) azul quando começamos a pressionar o botão azul (pino 7)

//

unsigned long TEMPO_VERMELHO=0; // armazena quando o botao de pressão vermelho (pino 2) foi acionado pela última vez

unsigned long TEMPO_VERDE=0; // armazena quando o botao de pressão verde (pino 4) foi acionado pela última vez

unsigned long TEMPO_AZUL=0; // armazena quando o botao de pressão azul (pino 7) foi acionado pela última vez

//

void setup(){

  pinMode(LED_VERMELHO,OUTPUT); // diz ao Arduino que o pino conectado ao LED (RGB) vermelho é de saída de dados

  pinMode(LED_VERDE,OUTPUT); // diz ao Arduino que o pino conectado ao LED (RGB) verde é de saída de dados

  pinMode(LED_AZUL,OUTPUT); // diz ao Arduino que o pino conectado ao LED (RGB) azul é de saída de dados

//

  pinMode(BUTAO_VERMELHO,INPUT); // diz ao Arduino que o pino conectado ao botão de pressão vermelho (pino 2) é de entrada de dados

  pinMode(BUTAO_VERDE,INPUT); // diz ao Arduino que o pino conectado ao botão de pressão verde (pino 4) é de entrada de dados

  pinMode(BUTAO_AZUL,INPUT); // diz ao Arduino que o pino conectado ao botão de pressão azul (pino 7) é de entrada de dados

}

//

void loop(){

//

// CONTROLE LED (RGB) VERMELHO 

//

  VAL_VERMELHO=digitalRead(BUTAO_VERMELHO); // lê e armazena o valor da entrada

  if((VAL_VERMELHO==HIGH)&&(VAL_ANTERIOR_VERMELHO==LOW)){ // verifica se houve uma transição

    ESTADO_VERMELHO=1-ESTADO_VERMELHO; // altera o estado, de apagado para aceso ou vice-versa

    TEMPO_VERMELHO=millis(); // esta linha recorda quando o botão foi pressionado pela última vez

    delay(10); // recurso de anti-repique

  }

  if((VAL_VERMELHO==HIGH)&&(VAL_ANTERIOR_VERMELHO==HIGH)){ // verifica se estamos segurando o botão pressionado

    if(ESTADO_VERMELHO==1&&(millis()-TEMPO_VERMELHO)>500){ // se o botão for segurado por mais de 500 milisegundos

      BRILHO_VERMELHO++; // aumenta o brilho em 1

      delay(10); // intervalo para evitar que o brilho aumente rápido demais

      if (BRILHO_VERMELHO>255){ // 255 é o brilho máximo

        BRILHO_VERMELHO=0; // se passarmos de 255, devemos retornar a 0

      }

    }

  }

  VAL_ANTERIOR_VERMELHO=VAL_VERMELHO; // VAL agora está ultrapassada, vamos armazená-la

  if(ESTADO_VERMELHO==1){

    analogWrite(LED_VERMELHO,BRILHO_VERMELHO); // acende o LED utilizando o nível atual de brilho

  }else{

    analogWrite(LED_VERMELHO,0); // apaga o LED

  }

//

// CONTROLE DO LED (RGB) VERDE

//

  VAL_VERDE=digitalRead(BUTAO_VERDE); // lê e armazena o valor da entrada

  if((VAL_VERDE==HIGH)&&(VAL_ANTERIOR_VERDE==LOW)){ // verifica se houve uma transição

    ESTADO_VERDE=1-ESTADO_VERDE; // altera o estado, de apagado para aceso ou vice-versa

    TEMPO_VERDE=millis(); // esta linha recorda quando o botão foi pressionado pela última vez

    delay(10); // recurso de anti-repique

  }

  if((VAL_VERDE==HIGH)&&(VAL_ANTERIOR_VERDE==HIGH)){ // verifica se estamos segurando o botão pressionado

    if(ESTADO_VERDE==1&&(millis()-TEMPO_VERDE)>500){ // se o botão for segurado por mais de 500 milisegundos

      BRILHO_VERDE++; // aumenta o brilho em 1

      delay(10); // intervalo para evitar que o brilho aumente rápido demais

      if (BRILHO_VERDE>255){ // 255 é o brilho máximo

        BRILHO_VERDE=0; // se passarmos de 255, devemos retornar a 0

      }

    }

  }

  VAL_ANTERIOR_VERDE=VAL_VERDE; // VAL agora está ultrapassada, vamos armazená-la

  if(ESTADO_VERDE==1){

    analogWrite(LED_VERDE,BRILHO_VERDE); // acende o LED utilizando o nível atual de brilho

  }else{

    analogWrite(LED_VERDE,0); // apaga o LED

  }

//

// CONTROLE DO LED (RGB) AZUL

//

  VAL_AZUL=digitalRead(BUTAO_AZUL); // lê e armazena o valor da entrada

  if((VAL_AZUL==HIGH)&&(VAL_ANTERIOR_AZUL==LOW)){ // verifica se houve uma transição

    ESTADO_AZUL=1-ESTADO_AZUL; // altera o estado, de apagado para aceso ou vice-versa

    TEMPO_AZUL=millis(); // esta linha recorda quando o botão foi pressionado pela última vez

    delay(10); // recurso de anti-repique

  }

  if((VAL_AZUL==HIGH)&&(VAL_ANTERIOR_AZUL==HIGH)){ // verifica se estamos segurando o botão pressionado

    if(ESTADO_AZUL==1&&(millis()-TEMPO_AZUL)>500){ // se o botão for segurado por mais de 500 milisegundos

      BRILHO_AZUL++; // aumenta o brilho em 1

      delay(10); // intervalo para evitar que o brilho aumente rápido demais

      if (BRILHO_AZUL>255){ // 255 é o brilho máximo

        BRILHO_AZUL=0; // se passarmos de 255, devemos retornar a 0

      }

    }

  }

  VAL_ANTERIOR_AZUL=VAL_AZUL; // VAL agora está ultrapassada, vamos armazená-la

  if(ESTADO_AZUL==1){

    analogWrite(LED_AZUL,BRILHO_AZUL); // acende o LED utilizando o nível atual de brilho

  }else{

    analogWrite(LED_AZUL,0); // apaga o LED

  } 

}

 

5) Análise do Sofware: (PARTE  DA ANÁLISE SE ENCONTRA NO PRÓPRIO SKETCH)

const int ... – usado para definir uma variável como constante e inteira. Definindo-a como constante no início significa que ela não sofrerá alteração em seu valor durante a execução do programa, garantindo que os pinos de entrada e saída não serão acidentalmente trocados.

int BRILHO_(VERMELHO/VERDE/AZUL)=128 – as variáveis que definem o brilho dos LEDs foram definidas inicialmente com um valor equivalente a 50% do brilho máximo.

delay(10); // recurso de anti-repique – botões de pressão são dispositivos muito simples: apenas duas peças de metal, separadas por uma mola. Quando o pressionamos, os dois contatos se encontram e a eletricidade pode fluir. Não parece haver problemas nisso, mas, na vida real, essa conexão não é perfeita, especialmente quando o botão não é pressionado até o fim. Nesses casos, o dispositivo pode gerar alguns sinais imprecisos que são os repiques. Quando o botão está nesse estado, o Arduino recebe uma sequência muito rápida de sinais que alternam entre ligado e desligado. Utilizamos essa espera de 10 ms como técnica de anti-repique.

O restante do programa está explicado nos comentários do sketch.

6) Análise do Hardware:

a) Botões de pressão são dispositivos muito simples: apenas duas peças de metal, separadas por uma mola. Quando o pressionamos, os dois contatos se encontram e a eletricidade pode fluir. Ao clicar no botão as duas conexões laterais (setas em destaque nas laterais) serão conectadas.

b) Resistores são dispositivos utilizados para limitar a quantidade de elétrons que circulam por unidade de tempo em um determinado ramo do circuito protegendo os outros dispositivos nesse mesmo ramo. Utilizamos resistores de 330 Ω (marron, preto e laranja).

c) Leds brancos chamados RGB são formados por três "chips", um vermelho (R de red), um verde (G de green) e um azul (B de blue). O diagrama esquemático do LED RGB encontra-se na figura abaixo. Nela podemos perceber q

ue cada perna possui um tamanho diferente, sendo a maior delas o GND. De um dos lados do GND encontramos uma única perna (que acende o led vermelho) e do outro lado duas pernas (a primeira, maior delas, acende o led verde e a outra o led azul).

d) Placa de Arduino:

e) Uma placa de ensaio ou matriz de contato, (ou protoboard, ou breadboard em inglês) é uma placa com furos (ou orifícios) e conexões condutoras para montagem de circuitos elétricos experimentais. A grande vantagem da placa de ensaio na montagem de circuitos eletrônicos é a facilidade de inserção de componentes, uma vez que não necessita soldagem. As placas variam de 800 furos até 6000 furos, tendo conexões verticais e horizontais. Porém, a sua grande desvantagem é o seu "mau-contato", e muitas vezes a pessoas preferem montar os seus circuitos com muitos fios a usar a protoboard. Na superfície de uma matriz de contato há uma base de plástico em que existem centenas de orifícios onde são encaixados os componentes. Em sua parte inferior são instalados contatos metálicos que interligam eletricamente os componentes inseridos na placa. Geralmente suportam correntes entre 1 A e 3 A. Os contatos metálicos estão em diferentes sentidos na matriz. Como você pode observar na figura, a placa de montagem possui a matriz principal em seu meio e duas linhas superiores e duas inferiores em cada matriz (alguns possuem apenas uma linha). Nestes últimos, os contatos estão na horizontal, enquanto na matriz principal eles estão na vertical. Em outras palavras, as linhas isoladas se conectam com os furos de baixo e as linhas agrupadas se conectam com os furos do lado. A placa de ensaio é bastante usada em escolas de ensino técnico, para os alunos terem seus primeiros contatos com a eletrônica visto que não precisa de soldagem de componentes.

 

 

 

 

 

Exibições: 1369

Comentar

Você precisa ser um membro de Laboratorio de Garagem (arduino, eletrônica, robotica, hacking) para adicionar comentários!

Entrar em Laboratorio de Garagem (arduino, eletrônica, robotica, hacking)

Comentário de jackson andrade em 10 fevereiro 2015 às 18:33

show de bola, meus parabéns.

Destaques

Registre-se no
Lab de Garagem
Clicando aqui

Convide um
amigo para fazer
parte

curso gratis de arduino

© 2018   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço