ELETRICIDADE E ELETRÔNICA NA PRÁTICA

(1)

ELETRICIDADE E ELETRÔNICA NA PRÁTICA

Prof. César M. Vargas Benítez Prof. Ronnier F.Rohrich (colaborador)

Universidade Tecnológica Federal Do Paraná (UTFPR) 28 de novembro de 2019

Sumário

1 Arduino – Parte 2 2

1.1 Termômetro com NTC . . . 2 1.2 Interface com display de sete segmentos . . . 4

(2)

1 Arduino – Parte 2

1.1 Termômetro com NTC

A Figura 1 apresenta um circuito medidor de temperatura1, composto por um resistor NTC e um Arduino.

Figura 1: Exemplo de medidor de temperatura.

Neste circuito, a tensão do resistor fixo é lida pelo pino A0 do Arduino que, por sua vez, esta conectado a um conversor Analógico/Digital (A/D) de 10bits do µC Atmega328p do Arduino. • A resistência do NTC varia com a variação da temperatura. Portanto, a tensão no resistor

fixo também varia com a temperatura;

• O conversor A/D converte o valor da tensão do resistor fixo para um valor inteiro (de 0 a 1023, por ser de 10bits). Então, o valor fornecido pelo conversor representa a tensão, mas na faixa entre 0 e 1023. Com alimentação de 5V, 0 e 1023 representam 0V e 5V,

respectivamente.

• O valor inteiro fornecido pelo conversor A/D está relacionado ao valor da tensão e, indire-tamente, ao valor da temperatura, mas na faixa de 0 a 1023 (e adimensional). Portanto, é necessário usar um método para conversão do valor inteiro (que representa o valor da tensão/temperatura);

• Como a resposta do NTC à variação de temperatura não é linear, utilizamos uma equação baseada no método de SteinhartHart, geralmente fornecida pelo fabricante de termistores, para relacionar o valor da resistência do NTC com o valor da temperatura. A Equação 1 é comumente utilizada para desenvolver o software para o microcontrolador apresentar o valor da temperatura a partir do valor inteiro fornecido pelo conversor A/D (seja do próprio µC ou externo).

T = βln(R/Rx) (1)

Rx= R0e−β/T0 (2)

Onde,

T e R são a temperatura e a resistência do termistor, respectivamente;

1

(3)

β é um parâmetro fornecido pelo fabricante. Cada termistor tem um β;

R0 é a resistência do termistor para uma temperatura T0; Obs.: a unidade da temperatura

é Kelvin [K]. Então, para converter para °C, devemos subtrair 273.

• Para determinar a resistência do termistor NTC a partir do valor fornecido pelo conversor A/D, devemos considerar os parâmetros:

– Tensão de alimentação (VCC): 5V

– Resistência nominal do resistor fixo (R): 20kΩ

– Número de amostras (número de medições realizadas): N = 5 – Resolução do convesor A/D: 10 bits (de 0 a 1023)

– Rx, calculado utilizando a Equação 2.

• Para calcular a Temperatura em °C, utilize as seguintes equações:

– Cálculo da tensão do resistor fixo medida (VR) a partir da média das amostras do

conversor A/D (soma_amostras/N ). É importante ressaltar que há 1024 valores possíveis entre 0V e VCC.

VR= (VCC ∗ soma_amostras)/(N ∗ 1024.0) (3) – Cálculo da resistência do termistor (Rt).

Rt= (VCC∗ R)/VR− R (4) – Cálculo da Temperatura a partir dos cálculos anteriores e da Equação 1.

T = β/log(Rt/Rx)− 273 (5)

Um exemplo de código fonte para a implementação da interface Arduino-NTC é apresentado abaixo. Neste exemplo, a temperatura é apresentada na janela Serial Monitor do Arduino IDE. // Leitura de temperatura usando um termistor

//Obs.: este código está disponível no link:

//https://www.filipeflop.com/blog/termistor-ntc-arduino/

// Conexão do termistor const int pinTermistor = A0; // Parâmetros do termistor const double beta = 3600.0; const double r0 = 10000.0; const double t0 = 273.0 + 25.0;

const double rx = r0 * exp(-beta/t0); // Parâmetros do circuito

const double vcc = 5.0; const double R = 20000.0;

(4)

// Numero de amostras na leitura const int nAmostras = 5;

// Iniciação void setup() { Serial.begin(9600); } // Laço perpétuo void loop() {

// Le o sensor algumas vezes int soma = 0;

for (int i = 0; i < nAmostras; i++) { soma += analogRead(pinTermistor); delay (10);

}

// Determina a resistência do termistor double v = (vcc*soma)/(nAmostras*1024.0); double rt = (vcc*R)/v - R;

// Calcula a temperatura double t = beta / log(rt/rx); Serial.println (t-273.0); // Dá um tempo entre leituras delay (10000);

}

1.2 Interface com display de sete segmentos

A Figura 22 apresenta um exemplo de interface entre o Arduino e um display de sete segmentos ânodo comum. Realize as modificações no circuito para um display tipo cátodo comum.

O código fonte para programar o Arduino está disponível no site do professor e abaixo. É importante ressaltar que este código também foi implementado para um display tipo ânodo comum.

• Realize as modificações necessárias no código para funcionar com display cátodo comum; • Faça modificações no código fonte para apresentar outros caracteres e/ou animações no

display. Use a sua criatividade!

2

Adaptado de https://blogmasterwalkershop.com.br/arduino/arduino-utilizando-o-display-de-7-segmentos-um-digito/

(5)

Figura 2: Exemplo de interface com display de sete segmentos.

// Exemplo disponível no site: https://blogmasterwalkershop.com.br/ //Importante: este exemplo utiliza um

//display de sete segmentos anodo comum. //Faça as modificações para um catodo comum!

(6)

// Prof. César Benítez (UTFPR-Curitiba) byte seven_seg_digits[16][7] = { { 0,0,0,0,0,0,1 }, //DIGITO 0 { 1,0,0,1,1,1,1 }, //DIGITO 1 { 0,0,1,0,0,1,0 }, //DIGITO 2 { 0,0,0,0,1,1,0 }, //DIGITO 3 { 1,0,0,1,1,0,0 }, //DIGITO 4 { 0,1,0,0,1,0,0 }, //DIGITO 5 { 0,1,0,0,0,0,0 }, //DIGITO 6 { 0,0,0,1,1,1,1 }, //DIGITO 7 { 0,0,0,0,0,0,0 }, //DIGITO 8 { 0,0,0,1,1,0,0 }, //DIGITO 9 { 0,0,0,1,0,0,0 }, //DIGITO A { 1,1,0,0,0,0,0 }, //DIGITO B { 0,1,1,0,0,0,1 }, //DIGITO C { 1,0,0,0,0,1,0 }, //DIGITO D { 0,1,1,0,0,0,0 }, //DIGITO E { 0,1,1,1,0,0,0 } //DIGITO F }; void setup(){

pinMode(2, OUTPUT); //PINO 2 -> SEGMENTO A pinMode(3, OUTPUT); //PINO 3 -> SEGMENTO B pinMode(4, OUTPUT); //PINO 4 -> SEGMENTO C pinMode(5, OUTPUT); //PINO 5 -> SEGMENTO D pinMode(6, OUTPUT); //PINO 6 -> SEGMENTO E pinMode(7, OUTPUT); //PINO 7 -> SEGMENTO F pinMode(8, OUTPUT); //PINO 8 -> SEGMENTO G pinMode(9, OUTPUT); //PINO 9 -> SEGMENTO PONTO ligaPonto(0);

}

void ligaPonto(byte dot){ //FUNÇÃO QUE ACIONA O PONTO DO DISPLAY digitalWrite(9, dot);

}

void ligaSegmentosDisplay(byte digit){ //FUNÇÃO QUE ACIONA O DISPLAY byte pino = 2;

for (byte contadorSegmentos = 0; contadorSegmentos < 7; ++contadorSegmentos){ //PARA "contadorSegmentos"

//IGUAL A 0, ENQUANTO "contadorSegmentos" MENOR QUE 7, //INCREMENTA "contadorSegmentos"

digitalWrite(pino, seven_seg_digits[digit][contadorSegmentos]); //PERCORRE O ARRAY E LIGA OS

//SEGMENTOS CORRESPONDENTES AO DIGITO ++pino; //INCREMENTA "pino"

}

ligaPonto(1); //LIGA O PONTO DO DISPLAY delay(100); //INTERVALO DE 100 MILISSEGUNDOS ligaPonto(0); //DESLIGA O PONTO DO DISPLAY }

(7)

//(NA CONTAGEM HEXADECIMAL "A"=10

// "B"=11 / "C"=12 / "D"=13 / "E"=14 / "F"=15) void loop() {

for (byte contador = 0; contador < 16; contador++){ //PARA "contador" //IGUAL A 0, ENQUANTO "contador" MENOR QUE 16, INCREMENTA "contador"

delay(500); //INTERVALO DE 500 MILISSEGUNDOS ligaSegmentosDisplay(contador); //FAZ A CONTAGEM }

delay(2000); //INTERVALO DE 2 SEGUNDOS }

(8)