terça-feira, 20 de abril de 2021

EX38 - Potenciômetro e LED's com shield multi funções e Arduino Uno


 Este projeto também vai usar os dois leds, mas controlados por um potenciômetro que está ligado na porta analógica

 
A0 do Arduino. Os leds piscam alternadamente e quanto mais você girar o potenciômetro para a direita, mais lentamente eles vão piscar.

//Programa: Shield Arduino Multifuncoes
//Objetivo: Potenciometro com leds
//Autor: Prof. Sinésio Raimundo Gomes
//Definicao dos pinos
#define Pino_Led_Azul 13
#define Pino_Led_Vermelho 12
#define Pino_Pot A0
//Armazena valor lido do potenciometro
int valor_pot;
void setup()
{
//Pinos led e buzzer como saida
pinMode(Pino_Led_Azul , OUTPUT);
pinMode(Pino_Led_Vermelho , OUTPUT);
//Pino potenciometro como entrada
pinMode(Pino_Pot, INPUT);
}
void loop()
{
//Le o valor do potenciometro
valor_pot = analogRead(Pino_Pot);
valor_pot = map(valor_pot, 0, 1024, 100, 500);
//Pisca o led de acordo com o valor lido
digitalWrite(Pino_Led_Azul, HIGH);
digitalWrite(Pino_Led_Vermelho, LOW);
delay(valor_pot);
digitalWrite(Pino_Led_Azul, LOW);
digitalWrite(Pino_Led_Vermelho, HIGH);
delay(valor_pot);
}

Este programa utiliza o comando MAP (linha 26), que “converte” o valor lido da porta analógica A0, entre 0 e 1024, em um valor entre 100 e 500, que é o valor que será usado para determinar o tempo no comando DELAY, que os leds ficarão acesos. Lembrando que esse tempo é em milissegundos (ms).

© Direitos de autor. 2020: Gomes; Sinésio Raimundo. Última atualização: 14/06/2023 

domingo, 18 de abril de 2021

EX37 - Botões, LED's e Buzzer com shield multi funções e Arduino Uno


 O primeiro projeto é bem básico e nele você vai utilizar os botões SW1 e SW2, no lado esquerdo do shield, para acionar os leds azul e vermelho, e ao mesmo tempo fazer com que o buzzer emita um som. Neste programa não é utilizada nenhuma biblioteca, já que apenas efetuamos a escrita e leitura das portas digitais dos botões (portas digitais D2 e D3), dos leds (D12 e D13) e do buzzer (D5).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
// Programa: Shield Arduino Multifuncoes
//Objetivo: Uso de botoes, led e buzzer //Autor: Prof. Sinésio Raimundo Gomes
//Definicao dos pinos #define Pino_SW1 2 #define Pino_SW2 3 #define Pino_Led_Azul 13 #define Pino_Led_Vermelho 12 #define Pino_Buzzer 5
//Armazena valor botoes int valor_SW1, valor_SW2;
void setup() { //Pinos led e buzzer como saida pinMode(Pino_Led_Azul , OUTPUT); pinMode(Pino_Led_Vermelho , OUTPUT); pinMode(Pino_Buzzer, OUTPUT);
//Pinos botoes SW1 e SW2 como entrada pinMode(Pino_SW1, INPUT); pinMode(Pino_SW2, INPUT); }
void loop() { //Verifica se o botao SW1 foi acionado valor_SW1 = digitalRead(Pino_SW1); if (valor_SW1 == 0) { //Acende o led azul digitalWrite(Pino_Led_Azul, HIGH); //Aciona o buzzer tone(Pino_Buzzer, 50,30); } else { //Desliga o led azul e o buzzer digitalWrite(Pino_Led_Azul, LOW); noTone(Pino_Buzzer); } //Verifica se o botao SW2 foi acionado valor_SW2 = digitalRead(Pino_SW2); if (valor_SW2 == 0) { //Acende o led vermelho digitalWrite(Pino_Led_Vermelho, HIGH); //Aciona o buzzer tone(Pino_Buzzer, 900,50); } else { //Desliga o led azul e o buzzer digitalWrite(Pino_Led_Vermelho, LOW); noTone(Pino_Buzzer); } }

Altere o valor da frequência do som emitido pelo buzzer nas linhas 36 e 51 do programa. 
© Direitos de autor. 2020: Gomes; Sinésio Raimundo. Última atualização: 14/06/2023.

quarta-feira, 14 de abril de 2021

Aula 17 - Programação Arduino com "Shield Multifunções com Sensores e I/O"

 A placa Multifunções com Sensores e I/O  foi desenvolvida para iniciantes em Arduino, com diversos componentes disponíveis que fazem você construir mais de 10 projetos facilmente. Você não precisará soldar ou conectar nada, basta conectá-lo a uma placa Arduino e começar a criar vários exemplos simples, em vez de lidar com cabos, sensores e breadboard. Ao lado de cada componente, você pode ver o pino digital no analógico ao qual está conectado. Também há alguns pinos digitais e um pino analógico disponíveis para outros projetos. Este "Shield" pode ser totalmente compatível com o Arduino UNO R3 e nunca entrará em curto-circuito com a interface Arduino UNO USB, por isso é muito seguro.
 O Shield Multifunções com Sensores e I/Os para Arduino é composto por um sensor de umidade e temperaturada DHT11, um sensor de temperatura LM35, um sensor de luminosidade LDR, 2 leds 3mm, 2 botões tipo push buttons, um led RGB, um receptor infravermelho, um buzzer ativo e um  potenciômetro.
Shield Multifunções com Sensores e I/Os para Arduino:
  • Modelo: K596;
  • Porta serial: TTL;
  • Interface I2C: SDA A4, A5 SCL;
  • Canais Digitais: 2 (D7, D8);
  • Canais Analógicos: 1 (A3);
  • Botão de reset;
  • Dimensões: 68x53x12mm.
Na imagem temos a disposição dos sensores e I/O´s no Shield Arduino Multifunções. Os conectores em amarelo permitem acesso à 2 portas digitais (D7 e D8), uma porta analógica (A3), interface serial e interface I2C. Portas utilizadas por componente:
  • Conectores da interface serial  (D0 e D1);
  • 2 botões customizáveis (D2 e D3);
  • Sensor de temperatura e umidade DHT11 (porta D4);
  • Buzzer Passivo (D5);
  • Receptor IR (D6);
  • Conectores (D7 e D8),
  • Led RGB (D9, D10 e D11);
  • 2 leds de uso geral (D12 e D13);
  • Potenciômetro (A0);
  • Sensor de Luz LDR (A1);
  • Sensor de temperatura LM35 (A2);
  • Conectores (A3).
Biblioteca: para programar o display utilize a biblioteca disponível em: <<https://github.com/adafruit/DHT-sensor-library>>

O manual com diagrama elétrico da placa K596 estará disponìvel em:  Shield K596.

© Direitos de autor. 2021: Gomes; Sinésio Raimundo. Última atualização: 01/04/2021 

sábado, 3 de abril de 2021

EX36 - Detector de cores usando Arduino Uno

Figura 01 - Módulo Sensor TCS3200


    
Neste projeto, faremos a interface do sensor de cores TCS3200 com o Arduino UNO. O TCS3200 é um sensor de cores que pode detectar qualquer número de cores com a programação correta. TCS3200 contém matrizes RGB (Red Green Blue). Conforme mostrado na figura em nível microscópico, pode-se ver as caixas quadradas dentro do olho no sensor. Essas caixas quadradas são matrizes RGB.  
    Cada uma dessas caixas contém três sensores, um para detectar a intensidade da luz VERMELHA, um para detectar a intensidade da luz VERDE e o último para detectar a intensidade da luz AZUL.
    Cada uma das matrizes de sensores nessas três matrizes é selecionada separadamente, dependendo do requisito. Por isso é conhecido como  sensor programável. O módulo pode ser caracterizado para detectar a cor específica e deixar as outras. Ele contém filtros para esse propósito de seleção. 

Há um quarto modo que não é um modo de filtro. Sem modo de filtro, o sensor detecta luz branca. 

    
Componentes necessários
: Hardware e Software:  
  • ARDUINO UNO, 
  • Fonte de alimentação (5v), 
  • LED's vermelho, verde e azul, 
  • Display JHD_162A LCD (16 * 2LCD), 
  • Sensor de cores TCS3200.
  • Software: ARDUINO IDE.
    Diagrama de circuito e explicação do trabalho
    No LCD 16x2 existem 16 pinos ao todo, se houver uma luz de fundo, se não houver luz de fundo, haverá 14 pinos. Pode-se ligar ou deixar os pinos da luz de fundo. Agora, nos 14 pinos, há 8 pinos de dados (7-14 ou D0-D7), 2 pinos de fonte de alimentação (1 e 2 ou VSS e VDD ou GND e + 5v), 3º pino para controle de contraste (VEE-controla a espessura dos caracteres mostrado), e 3 pinos de controle (RS & RW & E)
Figura 02 - Detector de cores com Sensor TCS3200
    No circuito, você pode observar que tirei apenas dois pinos de controle. O bit de contraste e READ / WRITE não são usados ​​com frequência, portanto, podem ser colocados em curto com o aterramento. Isso coloca o LCD no mais alto contraste e modo de leitura. Precisamos apenas controlar os pinos ENABLE e RS para enviar caracteres e dados de acordo. As conexões que são feitas para LCD são fornecidas abaixo:
  • PIN1 ou VSS para aterrar;
  • PIN2 ou VDD ou VCC para alimentação de + 5v;
  • PIN3 ou VEE para aterrar (oferece contraste máximo ou mínimo);
  • PIN4 ou RS (Registrar Seleção) para o PIN8 do ARDUINO UNO;
  • PIN5 ou RW (leitura / gravação) para aterrar (coloca o LCD no modo de leitura e facilita a comunicação para o usuário);
  • PIN6 ou EN (Ativar) para PIN9 do ARDUINO UNO;
  • PIN11 ou D4 a PIN4 do ARDUINO UNO;
  • PIN12 ou D5 a PIN5 do ARDUINO UNO;
  • PIN13 ou D6 a PIN6 do ARDUINO UNO;
  • PIN14 ou D7 a PIN7 do ARDUINO UNO
    As conexões que são feitas para o sensor de cores são fornecidas abaixo:
  • VDD para + 5V
  • GND para GROUND
  • OE (habilitação de saída) para GND
  • S0 para PIN0 do ARDUINO UNO;
  • S1 para PIN1 do ARDUINO UNO;
  • S2 para PIN2 do ARDUINO UNO;
  • S3 para PIN3 do ARDUINO UNO;
  • OUT para PIN A1 do ARDUINO UNO;
    As conexões que são feitas para os LED's são fornecidas abaixo:
  • LED Vermelho na saída A3
  • LED Verde da saída A4
  • LED Azul da saída A5
 
Figura 03 - Sensor TCS3200

   
A cor que precisa ser detectada pelo sensor de cores é selecionada por dois pinos S2 e S3. Com esses dois pinos de controle lógico, podemos dizer ao sensor qual cor de intensidade de luz deve ser medida.
    Digamos que precisamos sentir a intensidade da cor VERMELHA de que precisamos definir os dois pinos como BAIXO. Feito isso, o sensor detecta a intensidade e envia o valor para o sistema de controle dentro do módulo.
  • S2 S3 Tipo de Fotodiodo;
  • L L Vermelho;
  • L H Azul;
  • H L Branco (sem filtro);
  • H H Verde;

Figura 04 - Diagrama funcional do
Sensor TCS3200
    O sistema de controle dentro do módulo é mostrado na figura. A intensidade da luz medida pela matriz é enviada à corrente para o conversor de frequência. O que ele faz é, ele emite uma onda quadrada cuja frequência é em relação à corrente enviada por ARRAY.
    Portanto, temos um sistema que envia uma onda quadrada cuja frequência depende da intensidade da luz da cor que é selecionada por S2 e S3.
Figura 05 - Resposta de frequência do
Sensor TCS3200

    
A frequência do sinal enviada pelo módulo pode ser modulada dependendo do uso. Podemos alterar a largura de banda da frequência do sinal de saída.
  • S0 S1 Escala de frequência de saída (f 0 )
  • L L Desligar
  • L H 2%
  • H L 20%
  • H H 100%
    A escala de frequência é feita por dois bits S0 e S1. Por conveniência, vamos limitar a escala de frequência a 20%. Isso é feito configurando S0 para alto e S1 para BAIXO. Este recurso é útil quando estamos usando o módulo em um sistema com clock baixo. A sensibilidade da matriz à cor é mostrada na figura 04.
    Embora cores diferentes tenham sensibilidade diferente, para um uso normal não fará muita diferença.
Figura 06 - Detector de cores com Arduino e
Sensor TCS3200
    
O Arduino UNO aqui envia sinal ao módulo para detectar cores e os dados recebidos pelo módulo são mostrados no LCD 16 * 2 conectado a ele. O Arduino UNO detecta três intensidades de cor separadamente e as mostra no LCD.
    O Arduino UNO pode detectar a duração do pulso do sinal pelo qual podemos obter a frequência da onda quadrada enviada pelo módulo. Com a frequência disponível, podemos combiná-la com a cor do sensor.
  • Frequência interna = pulseIn (A1, LOW);
    Como por condição acima o Arduino UNO  lê duração do impulso no pino A1 e armazena-o em valor inteiro “frequência”.
    Faremos isso para todas as três cores para reconhecimento de cores . Todas as três intensidades de cor são mostradas por frequências no LCD 16x2.

O manual com diagrama elétrico da placa do Color Sensor TCS3200 está disponìvel em:  Color Sensor TCS3200.

O arquivo do código fonte Detector de cores  está disponível em: 21_03_27_Detector_de_cores_SRG (PDF).

O arquivo do diagrama elétrico Detector de cores estará disponível em: 21_03_27_Circuito_Detector_de_cores_SRG (PDF).

© Direitos de autor. 2021: Gomes; Sinésio Raimundo. Última atualização: 01/04/2021