ENGENHARIA DE COMPUTAÇÃO

9º PERÍODO

FELIPE MENDES MARQUES

GUSTAVO MAMOTO KAZIOKA

OTÁVIO DOS SANTOS MOTTA

PROJETO DE SISTEMAS DE CONTROLE

Trabalho Final - Desenvolvimento do Projeto

UBERABA

2023
 Felipe Mendes Marques

Gustavo Mamoto Kazioka

Otávio dos Santos Motta

Trabalho Final – Desenvolvimento do Projeto

Trabalho acadêmico apresentado à disciplina

de Projeto de Sistemas de Controle,
ministrada pelo Professor Robson Borges
Rodrigues, como requisito parcial para
aprovação no 9º período do Curso de
Bacharelado em Engenharia de Computação,
do Instituto Federal de Educação, Ciência e
Tecnologia do Triângulo Mineiro.

UBERABA

2023
 SUMÁRIO

1. INTRODUÇÃO..................................................................................................................... 4
2. OBJETIVOS.........................................................................................................................5
3. DESENVOLVIMENTO......................................................................................................... 5
3.1. COMPONENTES ELETRÔNICOS E PRECIFICAÇÃO.............................................. 6
3.2. FUNCIONAMENTO...................................................................................................14
3.3. CÓDIGO PARA O ARDUÍNO....................................................................................18
3.4. IMPLEMENTAÇÃO PARA O CONTROLE PID......................................................... 22
4. SUPERVISÓRIO NO ELIPSE SCADA.............................................................................. 24
4.1. CORREÇÃO DO ERRO DE TELA AZUL..................................................................24
4.2. TELA E ELEMENTOS DE CONFIGURAÇÃO.......................................................... 25
5. APRESENTAÇÃO............................................................................................................. 27
6. CONSIDERAÇÕES FINAIS...............................................................................................34
REFERÊNCIAS BIBLIOGRÁFICAS..................................................................................... 35
 4

1. INTRODUÇÃO

Este relatório irá apresentar o desenvolvimento de um sistema simplificado de

controle de fan com sensor de temperatura utilizando a plataforma Arduino. O objetivo
deste sistema é regular a temperatura em um ambiente comum, minimamente fechado,
acionando um ventilador quando a temperatura estiver acima de um determinado valor.
Para isso, foi utilizada a plataforma de prototipagem eletrônica Arduino, um sensor
de temperatura, um resistor de fio que irá dissipar calor e um fan (ventoinha) que irá
resfriar esse resistor. O sistema foi projetado de forma a ser facilmente replicável e
personalizável, permitindo que seja utilizado em diferentes contextos e situações.
Ao longo deste relatório serão apresentados detalhes sobre o projeto e
implementação com o sistema supervisório que foi utilizado, assim como os resultados
obtidos durante os testes. Serão discutidas as principais dificuldades encontradas
durante o processo de desenvolvimento e as possíveis melhorias que poderiam ser
implementadas no futuro para aprimorar o sistema.
 5

2. OBJETIVOS

Além do objetivo geral de apresentar o desenvolvimento do sistema de controle

de fan com sensor de temperatura utilizando a plataforma Arduino, este projeto tem
também como objetivo capacitar os alunos para integrar um sistema de controle físico
com um sistema supervisório. Isso significa que os alunos serão capazes de monitorar e
controlar o sistema também de forma remota, utilizando um software de supervisão para
acompanhar as variáveis do sistema, como a temperatura do resistor de fio, o setpoint
desejado e os botões de acionamentos do resistor e do ventilador.
Outro objetivo importante deste relatório é a implementação do controle PID
(Proporcional-Integral-Derivativo) relativo à complexidade do sistema. O controle PID é
uma técnica amplamente utilizada em sistemas de controle de processos industriais e é
considerado um método eficiente para a estabilização e controle de variáveis. Através da
implementação do controle PID, deseja-se que os alunos sejam capazes de controlar a
velocidade do ventilador de forma precisa e eficiente, garantindo que a temperatura do
ambiente seja mantida dentro dos limites desejados.
Além disso, este relatório tem como objetivo colocar em prática os métodos
heurísticos de sintonia PID, junto com a estratégia de controle mais adequada ao
sistema. Os métodos heurísticos de sintonia PID são utilizados para ajustar os
parâmetros do controle PID de forma a otimizar o desempenho do sistema. Através da
aplicação desses métodos, os alunos serão capazes de determinar os parâmetros ideais
do controle PID para o sistema em questão, garantindo um controle preciso e eficiente da
temperatura do ambiente.
Portanto, ao final deste relatório, espera-se que os alunos estejam aptos a
integrar sistemas de controle físico com supervisório, implementar o controle PID,
realizar a sintonia dos parâmetros do PID utilizando métodos heurísticos e escolher a
estratégia de controle mais adequada ao sistema, contribuindo para o desenvolvimento
de soluções de automação e controle de processos industriais.

3. DESENVOLVIMENTO

Podemos aplicar um ventilador ou fan para retirar o ar quente de um equipamento

fechado, assim como refrigerar um dissipador de calor. Essa técnica é amplamente
utilizada em computadores, como por exemplo na utilização de coolers em
processadores e fans no gabinete.
Um projeto que envolve potência ou qualquer outro componente que está
superaquecendo, é interessante adicionar um dissipador de calor e um fan para o circuito
 6

suportar seu funcionamento sem perda de desempenho, que é amenizar o princípio do

Efeito Joule. E com isso, prevenir que não ultrapasse a temperatura máxima
recomendada pelos datasheets, para isso será desenvolvido um projeto utilizando um
controle de fan e termômetro para monitorar a temperatura via plataforma Arduino,
desfrutando de recursos nativos da IDE de desenvolvimento.

3.1. COMPONENTES ELETRÔNICOS E PRECIFICAÇÃO

Para montar este projeto, separamos uma lista completa com os componentes
eletrônicos necessários, e também o esquemático mais abaixo na Figura 01.

● Arduino Uno com cabo USB

Valor: R$ 53,53
 7

● 1 Cooler 80X80X25MM 12VDC DFC802512M

mas pode ser um Fan Simples, de outras tensões inclusive

O cooler no caso o grupo já tinha, mas pesquisando encontramos ele na faixa de

R$ 20,00.
 8

● 1 Sensor de Temperatura Max6675 (Termopar Tipo K)

Valor: R$ 37,11
 9

● 1 Fonte de alimentação 12V

Sobre a fonte, o grupo aproveitou a linha de 12V, de uma fonte ATX de

computador que já tínhamos disponível, do próprio conector de alimentação de FAN.
Onde o positivo é o fio amarelo, e o negativo é o fio preto. Mas pesquisando
encontramos fontes AC/DC de 12V na faixa de R$ 15,00. É preciso pontuar que para
ligar uma fonte ATX fora da placa mãe do computador, é necessário dar um curto em
dois pinos do conector de 24 pinos. Que no caso são os pinos preto e verde, ou os
respectivos pinos 3 e 4 com a trava virada para cima. Tentamos fazer essa conexão com
os jumpers, porém ficou com folga, então a fizemos com um clipe mesmo.
 10

● 1 Display LCD 2x16 com Módulo I2C soldado

Valor: R$ 31,00
 11

● 2 Transistores BC548
Valor (10 Unidades): R$ 13,42

● 1 Diodo 1N4007
Valor (100 Unidades): R$ 20,04

● 1 Resistor de de fio 68Ω 5W 5%

Valor (20 Unidades): R$ 23,04
 12

● 1 Resistor de 1K 5% (1/4W)
Valor (50 Unidades): R$ 18,37

● 1 Resistor de 10K 5% (1/2W)

Valor (10 Unidades): R$ 12,66

● 1 Protoboard Médio de 830 pontos

Valor: R$ 21,97
 13

● Fios Jumpers
-40/pcs De 20cm Macho/fêmea: R$ 17,00
-40/pcs De 20cm Macho/macho: R$ 23,52

● 3 PushButton tipo microchave 6x6x5mm 4 Pinos

Valor (10 Unidades): R$ 10,16
 14

É importante comentar que no protoboard conseguimos utilizar tranquilamente os

botões. Porém, na passagem da estrutura de montagem do circuito para a caixa mdf,
descrita no capítulo 5, nós não conseguimos utilizar esse botão pela sua estrutura ser
muito pequena, uma vez que não foi possível jumpear os pinos dos botões do protoboard
para o topo da caixa, de forma que a experiência do usuário ficasse melhor. Então
substituímos por botões de arcade game, semelhantes aos da figura abaixo, que são
bem maiores e que um dos integrantes do grupo já tinha disponível em sua casa,
evitando a existência de um gasto a mais.

O valor total dos componentes foi R$ 316,82. Porém efetivamente o valor foi R$
281,82 por já termos a fonte e o cooler.

3.2. FUNCIONAMENTO

Figura 01. Esquemático do Projeto com Arduino Uno (Tinkercad).

 15

O funcionamento do circuito de controle é baseado em um transistor BC548, que

é um transistor de junção bipolar do tipo NPN. Para ligar o fan (ventilador), é necessário
aplicar um sinal HIGH (ou seja, uma tensão alta) na base do transistor. Quando um sinal
HIGH é aplicado à base do BC548, uma corrente flui do coletor para o emissor,
permitindo que a corrente flua através do ventilador, ligando-o.
Quando um sinal LOW (ou seja, uma tensão baixa) é aplicado à base do
transistor BC548, a corrente na base é interrompida e o transistor entra em modo de
corte. Nesse estado, a corrente não flui do coletor para o emissor, interrompendo a
corrente que alimenta o ventilador. Assim, o ventilador é desligado.
Em resumo, para ligar o ventilador, você precisa aplicar um sinal HIGH na base
do transistor BC548, e para desligá-lo, um sinal LOW é aplicado. O transistor atua como
uma chave controlada pelo sinal aplicado à base, permitindo controlar o fluxo de corrente
para o ventilador e, consequentemente, ligá-lo ou desligá-lo.
O monitoramento de temperatura é realizado com o termopar tipo K MAX6675.
No esquemático da Figura 01 estamos usando um sensor de temperatura comum,
semelhante a um LM35, pois nos componentes do Tinkercad não se encontra o módulo
que usamos no sistema físico. Seguindo a Figura 02 do MAX6675, temos os seguintes
pinos:
VCC: Este é o pino de alimentação, que deve ser conectado à fonte de energia
positiva. Normalmente, isso é cerca de 3.3V ou 5V, dependendo do seu sistema.
GND: Este é o pino de terra, que deve ser conectado à fonte de energia negativa
ou terra do sistema.
SCK ou CLK: Este é o pino do relógio (clock) para a interface SPI (Interface
Periférica Serial). O microcontrolador usará este pino para sincronizar a transferência de
dados com o MAX6675.
CS: Este é o pino de seleção de chip (chip select). O microcontrolador usa este
pino para indicar quando está enviando ou recebendo dados do MAX6675.
SO: Este é o pino de saída de dados (data out). O MAX6675 envia os dados lidos
da temperatura por meio deste pino para o microcontrolador.
 16

Figura 02. Termopar MAX6675 e esquemático com Arduino Uno (Tinkercad).

Outra referência para que pudéssemos realizar o projeto são os esquemas do

módulo de controle de temperatura da placa McLab2 [4], presentes no software
PICSimLab que se apresentam de forma semelhante à vista anteriormente no escopo.

Figura 03. Sistema de temperatura presente na board McLab2.

R36 na Figura 04 representa um resistor de 1K no projeto, e RC1 uma conexão

para uma porta digital do arduino.
 17

Figura 04. Esquema com base na Placa McLab2 para alimentar o fan.

R48 na Figura 05 representa um resistor de 10K no projeto, RC2_JP uma

conexão para uma porta digital do arduino e R2 POWER o resistor de fio de 68Ω que
dissipa até 5W. Se houver a necessidade do resistor dissipar mais calor, pode-se utilizar
um resistor de 1K sem problemas.

Figura 05. Esquema com base na placa McLab2 para alimentar o resistor de fio 5W.
 18

3.3. CÓDIGO PARA O ARDUÍNO

Utilizamos este código abaixo, onde após enviar para o Arduino e observar o
Display LCD, ou o Supervisório, será possível visualizar o resultado das medições.
Iniciamos o SetPoint da temperatura como 25ºC, e se a leitura do termopar ultrapassar
esse valor, desligamos o resistor e a ventoinha entra em funcionamento.
É interessante pontuar que existe a necessidade de importar os arquivos zipados
das bibliotecas Wire, Modbusino e LiquidCrystal_I2C para que o código compile e
funcione corretamente.

#include "max6675.h" //INCLUSÃO DE BIBLIOTECA

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <Modbusino.h>
/************************************************
ARDUINO - COMUNICAÇÃO SERIAL (MODBUS)
https://github.com/stephane/modbusino
**************************************************/

ModbusinoSlave modbusino_slave(1); /* Inicializa o ID do

Dispositivo*/
uint16_t tab_reg[10]; /* Aloca o Número de Registradores*/

int resistor = 7;
int fan = 6;
int botaoAumenta = 5; // BOTAO DE AUMENTAR A SP
int botaoDiminui = 4;
int botaoONOFF = 2;
int lastAumenta = HIGH;
int lastDiminui = HIGH;
int lastONOFF = HIGH;
bool teto = false; // 0 EMBAIXO 1 EM CIMA
bool chao = false;
float histerese = 0.25;
bool ONOFF = false;
int ktcSO = 8; //PINO DIGITAL (SO)
int ktcCS = 9; //PINO DIGITAL (CS)
int ktcCLK = 10; //PINO DIGITAL (CLK / SCK)
float set_point = 25.0;

MAX6675 ktc(ktcCLK, ktcCS, ktcSO); //CRIA UMA INSTÂNCIA

UTILIZANDO OS PINOS (CLK, CS, SO)
LiquidCrystal_I2C lcd(0x27,16,2);
 19

void setup() {
modbusino_slave.setup(9600); /* Definindo a taxa de
transferencia em bauds */

pinMode(fan, OUTPUT);
pinMode(resistor, OUTPUT);
pinMode(botaoAumenta, INPUT_PULLUP);
pinMode(botaoDiminui, INPUT_PULLUP);
pinMode(botaoONOFF, INPUT_PULLUP);
lcd.begin();
lcd.clear();

delay(500); //INTERVALO DE 500 MILISSEGUNDOS

}

void setDisplay() {
lcd.setCursor(0, 0);
lcd.print("SP: ");
lcd.setCursor(3, 0);
lcd.print(set_point);
lcd.setCursor(0, 1);
lcd.print("MV: ");
lcd.setCursor(3, 1);
lcd.print(ktc.readCelsius());
lcd.setCursor(9, 1);
lcd.print("H: ");
lcd.setCursor(11,1);
lcd.print(histerese);
lcd.setCursor(13, 0);

if (ONOFF) {
lcd.print("ON ");
} else {
lcd.print("OFF");
}
}

void readBotaoAumenta() {
int readingAumenta = digitalRead(botaoAumenta);
if (readingAumenta != lastAumenta) {
if (readingAumenta == LOW) {
set_point++;
}
delay(50);
}
 20

if (tab_reg[3] == 1) {
set_point++;
tab_reg[3] = 0;
}

lastAumenta = readingAumenta;
}

void readBotaoDiminui() {
int readingDiminui = digitalRead(botaoDiminui);
if (readingDiminui != lastDiminui) {
if (readingDiminui == HIGH) {
set_point--;
}
delay(50);
}
if (tab_reg[4] == 1) {
set_point--;
tab_reg[4] = 0;
}

lastDiminui = readingDiminui;
}

void readBotaoONOFF() {
int readingONOFF = digitalRead(botaoONOFF);
if (readingONOFF != lastONOFF) {
if (readingONOFF == LOW) {
ONOFF = !ONOFF;
}
delay(50);
}
lastONOFF = readingONOFF;
}

void loop() {
/*Exemplo de como passar valores para os registradores
tab_reg[0] = 600;

Exemplo de como recuperar valores dos registradores

Variavel = tab_reg[1];
*/

setDisplay();
ONOFF = tab_reg[2];
histerese = (float) (tab_reg[7] / 100.0);
 21

readBotaoAumenta();
readBotaoDiminui();
readBotaoONOFF();
if (ONOFF) {
if (ktc.readCelsius() >= (set_point + histerese)) {
digitalWrite(fan, HIGH);
digitalWrite(resistor, LOW);
}
else if (ktc.readCelsius() <= (set_point - histerese)) {
digitalWrite(resistor, HIGH);
}
if (ktc.readCelsius() < (set_point + histerese)) {
digitalWrite(fan, LOW);
}
} else {
digitalWrite(fan, LOW);
digitalWrite(resistor, LOW);
}

tab_reg[0] = set_point;
tab_reg[1] = (int16_t) (ktc.readCelsius() * 100);
tab_reg[2] = ONOFF;
tab_reg[5] = digitalRead(resistor);
tab_reg[6] = digitalRead(fan);
tab_reg[7] = (int16_t) (histerese * 100);

modbusino_slave.loop(tab_reg, 10); //Atualizando o Modbus

delay(200); //INTERVALO DE 200 MILISSEGUNDOS
}

Para melhor visualização disponibilizamos o código em um repositório no github:

<https://github.com/gukazioka/controle-temperatura/blob/main/sketch_jun28b.ino>.
 22

3.4. IMPLEMENTAÇÃO PARA O CONTROLE PID

float y; //VARIÁVEL DE PROCESSO

float sp=30; //SETPOINT - VALOR ENTRE -40°C E 125°C
float k=120; //GANHO DE REFERÊNCIA
float h=0.1; //AMOSTRAGEM (DIGITALIZAÇÃO)
float ti=10; //TEMPO DE INTEGRAÇÃO
float kd=k*(1+h/(2*ti)); //GANHO PROPORCIONAL
float ki=k/ti; //GANHO INTEGRAL
float p=0;
float i=0;

void setup() {
Serial.begin(9600);
}

void loop() {
y=map.(analogRead(A0), 20, 358, -40, 125); //LEITURA DA PV
Serial.print("PV = ");
Serial.println(y);
float e=y-sp; //DEFINE O ERRO DO PROCESSO
Serial.print("Erro = ");
Serial.println(e);
p=kd*e; //DEFINE O ERRO PROPORCIONAL
i=i+(ki*h*e); //DEFINE O CONTROLE INTEGRAL
float u=p+i //DEFINE O SINAL DE CONTROLE (MV)
u=map(u, -4098, 4098, 0, 225);
Serial.print("MV= ");
Serial.println(u);
analogWrite(10, u); //ESCREVE O SINAL DE CONTROLE NO ATUADOR
delay(500);
}

O código acima representa uma possível implementação para o controle PID que
foi proposto no escopo do projeto. Porém o grupo não conseguiu realizar a
implementação, e nós acreditamos que foi pelos motivos a seguir.
Uma das referências de montagem no escopo era a presente na Figura 06.
 23

Figura 06. Esquema para o escopo do projeto.

Para se ter um controle de tensão da ventoinha, pelo arduíno, por exemplo, seria
ideal que a alimentação dela fosse de 5V. Porém nós só tínhamos ventoinhas de 12V,
então ao conectarmos pelo arduíno, o RPM ficou bem baixo pelo fato da placa só
conseguir alimentar devidamente até 0,5A no pino de 5V.
Outro ponto é que o grupo decidiu que o esquema de montagem da placa
McLab2 seria mais interessante e mais simples, decisão essa que também foi
aconselhada pelo professor. Porém, mesmo a montagem do McLab2 possuindo um
transistor BC548 / 547, acreditamos que não foi o suficiente para controlarmos a tensão.
Por isso o controle feito foi ON/OFF com histerese, emitindo HIGH para a base do
transistor quando o resistor atingir o valor de SetPoint, e LOW para quando o valor
normalizar.
Acreditamos que para o controle de tensão seja necessário um transistor de
potência feito o BD679, presente na Figura 06. Ou então um relé para realizar o
chaveamento com tensão. Contudo, mesmo o controle não atingindo esse ponto de
sofisticação, ele ficou preciso e bastante eficiente nos experimentos.
 24

4. SUPERVISÓRIO NO ELIPSE SCADA

No desenvolvimento do supervisório, foi utilizado o software Elipse Scada com ele

criamos todo sistema de monitoramento do nosso sistema de automação. A partir do
supervisório é possível ligar, desligar, aumentar e diminuir a temperatura do setpoint. Além
disso, o supervisório mostra os estados dos elementos finais de controle (cooler e resistor).
É interessante pontuar que o grupo teve problemas com tela azul logo após a instalação do
software, porém esse erro foi corrigido ao pesquisarmos em um fórum e encontrarmos as
seguintes informações:

4.1. CORREÇÃO DO ERRO DE TELA AZUL

A Elipse Software identificou que na versão mais recente hoje do Windows 10

(versão 2004 até 22H2) podem ocorrer falhas de “Tela Azul” quando seus produtos instalam
certas versões de drivers de acesso aos dispositivos de proteção (drivers HASP, fornecidos
pela Sentinel/Gemalto/Thales). O problema pode afetar produtos como Elipse E3, Elipse
Power, Elipse Plant Manager, entre outros.
Para contornar o problema de incompatibilidade é necessário então PRIMEIRO
instalar uma versão dos drivers (através do haspdinst) mais recente, compatível com essa
versão do Windows, e DEPOIS instalar o produto da Elipse. A versão 8.43 do haspdinst
pode ser encontrada no site na seção de downloads de acessórios 219 do Elipse E3 e EPM,
disponível em: <https://www.elipse.com.br/en/downloads/?key=haspdinst&language=ptbr>.
Após realizar o download deve-se abrir o local do arquivo no cmd e executar o seguinte
comando ‘ haspdinst -install ’. É possível encontrar um tutorial que realiza esses passos no
seguinte vídeo:
<https://www.youtube.com/watch?v=3og7TDP7U2o&ab_channel=JulioCVMachado>.
 25

4.2. TELA E ELEMENTOS DE CONFIGURAÇÃO

Figura 07. Tela do Supervisório.

O programa do supervisório possui uma animação para sinalizar quando o resistor

está esquentando ou desligado, e simultaneamente, outra para quando o cooler estiver
rodando ou não, com isso o usuário tem uma maior percepção do funcionamento do
supervisório. Pela interface é possível:
● Visualizar temperatura atual
● Visualizar e definir setpoint da temperatura
● Ajustar valor de histerese
● Ligar e desligar o circuito
● Aumentar e diminuir o set point

Figura 08. Tags utilizadas.

 26

No Elipse Scada, utilizamos Tags PLC como variáveis para nosso programa, Tags
com expressões matemáticas para amostragem adequada como HIST_FLOAT e
MOSTRAR_PV, Tag Demo para fazer um contador para animação do cooler, realizando
assim comunicação bidirecional pelo supervisório, ou seja, para receber e enviar dados
para o Arduino. Criamos Tags para estados dos elementos finais de controle, estado dos
botões, valores de SP e também foi definida uma última para histerese. A histerese nada
mais é do que um “atraso”, essa é uma função disponível nos controladores de temperatura
que tem como objetivo definir a diferença de temperatura na qual o sistema irá ligar
novamente, após desligar pelo setpoint. Assim sendo, possibilitamos definir um valor para
histerese diretamente pelo programa.

Figura 09. Driver Modicon Modbus.

Para transmissão dos dados seriais para nosso Arduino, utilizamos o driver Modicon
Modbus, responsável por implementar comunicação serial entre o sistema supervisório e o
Arduino. Esse driver não vem instalado por padrão no Elipse Scada, mas é possível fazer o
download na seguinte página:
<https://www.elipse.com.br/en/downloads/?key=Modbus.dll&language=ptbr>.
 27

5. APRESENTAÇÃO

Como o protoboard tem as seguintes dimensões: 165mm x 57mm x 10mm. Para

apresentar melhor o projeto compramos uma caixa mdf de 200mm x 70mm x 70mm, de
forma que os fios, o arduíno e o módulo do termopar ficassem dispostos com um espaço
mínimo para não oferecer risco às conexões elétricas. Depois fizemos cortes e furos para
adaptar o display LCD, os botões, o resistor de fio e os jumpers. Utilizamos materiais como
estilete, furadeira e fita isolante.
A seguir está uma sequência de fotografias mostrando a evolução do projeto, desde
a chegada dos componentes, passando pelas primeiras montagens, até a apresentação
final.
28
29
30
31
32
33
 34

6. CONSIDERAÇÕES FINAIS

Ao longo deste projeto, desenvolvemos um sistema simplificado de controle de

fan com sensor de temperatura utilizando a plataforma Arduino. Foi uma experiência
valiosa, pois nos permitiu integrar um sistema físico com um sistema supervisório,
ampliando nosso conhecimento em automação e controle de processos industriais.
A integração entre o sistema físico e o sistema supervisório foi de fundamental
importância, pois possibilitou o monitoramento e controle remoto do sistema. Através do
software Elipse Scada, conseguimos visualizar as variáveis do sistema, como a
temperatura do resistor de fio e o setpoint desejado, e controlar o funcionamento do
ventilador e do resistor. Essa integração nos proporcionou uma visão abrangente e
detalhada do sistema, facilitando a tomada de decisões no código e o ajuste de
parâmetros, como o da histerese, por exemplo.
Um dos objetivos principais deste projeto foi capacitar os alunos para integrar
sistemas de controle físico com sistemas supervisórios. Com essa experiência,
adquirimos habilidades importantes para o desenvolvimento de soluções de automação,
que podem ser aplicadas em diferentes contextos e situações. Por exemplo, houve um
momento que gostaríamos que o resistor de fio dissipasse mais calor, então substituímos
o resistor de 10K da base do transistor por um de 1K. Aprendemos a importância de ter
um sistema supervisório para monitorar e controlar o sistema em tempo real, garantindo
um funcionamento adequado e eficiente.
Outro ponto importante a ser destacado é a escalabilidade da aplicação deste
projeto. O sistema desenvolvido pode ser facilmente replicado e personalizado para ser
utilizado em diferentes ambientes e contextos. Com pequenas adaptações, é possível
aplicar o controle de fan com sensor de temperatura em sistemas de refrigeração de
equipamentos eletrônicos, sistemas de climatização, entre outros.
Em resumo, este projeto nos proporcionou uma experiência enriquecedora no
desenvolvimento e integração de um sistema físico com um sistema supervisório.
Alcançamos os objetivos propostos, adquirimos conhecimentos em automação e
controle, e percebemos a importância da aplicação de técnicas como o controle com
histerese, para que se possa economizar energia. Por fim agradecemos as orientações e
os momentos de disponibilidade para ajudar no que for preciso, por parte do professor.
 35

REFERÊNCIAS BIBLIOGRÁFICAS

[1] CAVALIERI, Renan; MESSINA, Ana Paula. Tecdicas. Um site sobre desenvolvimento,
Linux, eletrônica, informática e tecnologia em geral. Disponível em:
<https://tecdicas.com/controle-de-fan-com-sensor-de-temperatura-e-arduino/>. Acesso
em: 06 mai. 2023.

[2] MESSINA, Ana Paula. CONTROLE DE FAN COM MONITORAMENTO DE

TEMPERATURA - Embarcados #016. 2018. (2m49s). Disponível em:
<https://www.youtube.com/watch?v=zUXRqIbyg0E&ab_channel=Makin%27Bits>. Acesso
em: 07 mai. 2023.

[3] CAMPOS, Eduardo. Arduino - Controlador PID no Arduino. 2020. (6m50s).

Disponível em:
<https://www.youtube.com/watch?v=_VIijMJgVNI&ab_channel=EngEduardoCampos>.
Acesso em: 07 mai. 2023.

[4] GAMBÔA, Luis Claudio. PICSimLab. PICSimLab é um emulador em tempo real de

placas eletrônicas variadas, muito aplicado para o teste do funcionamento de muitos PIC.
Disponível em:
<https://lcgamboa.github.io/picsimlab_docs/0.8.12/TemperatureSystem.html>. Acesso
em: 10 mai. 2023.

[5] GUSTAVO, Luis. Como integrar o Supervisório ELIPSE SCADA com o Arduino? -
Projeto Integrador 4. 2020. (1h4m46s). Disponível em:
<https://www.youtube.com/watch?v=a4Ab418E9sM&t=3373s&ab_channel=LGUSTAVOE
xerc%C3%ADcioseProjetosdoLivro>. Acesso em: 07 jul. 2023.

[6] BECHELENI, Ilgner. Criando uma Animação no ELIPSE SCADA (Simulando no

ARDUINO). 2021. (14m47s). Disponível em:
<https://www.youtube.com/watch?v=FXGIsNQNmaw&t=425s&ab_channel=CodificaDev>
. Acesso em: 07 jul. 2023.

[7] BECHELENI, Ilgner. Tutorial - Supervisório ELIPSE SCADA com ARDUINO - Parte
2. 2021. (8m13s). Disponível em:
<https://www.youtube.com/watch?v=PHk2lKHxBFg&ab_channel=CodificaDev>. Acesso
em: 07 jul. 2023.