O documento descreve o desenvolvimento de um kit didático para simular sistemas de instrumentação industrial e controle de processos. O kit inclui um resistor para simular um sistema termodinâmico, um sensor de temperatura e uma ventoinha controlada por PWM para simulação. Um microcontrolador controla o kit e se comunica com um computador via serial.

1. Instituto Federal Sul-rio-grandense
Curso de Eletrônica
Disciplinas de Instrumentação Industrial, Microcontroladores e Programação III.
Professores Ulisses Lyra dos Santos, Rafael Galli e Norberto de Castro Peil.
Desenvolvimento de um kit didático para trabalhos práticos nas disciplinas de
Instrumentação Industrial e Sistemas de Controle
Gustavo dos Santos Fernandes
Rodrian Garcia Radmann
Tro7ni

2. 1 - Introdução
Tornar o conhecimento teórico e prático um único saber é o objetivo de todos os
cursos técnicos e a maior parte dos cursos superiores. O problema surge quando devido
a deficiências financeiras e estruturais dos cursos não é possível reproduzir para o aluno
a situação real em que se aplica determinado conteúdo. Nestas situações, apela-se para
os kits didáticos, estes embora não apresentem a situação real de aplicação dos
conteúdos vistos nas disciplinas, podem simular algo em que seja necessário aplicar
parte dos conhecimentos adquiridos em sala de aula.
O objetivo deste trabalho foi desenvolver um kit didático para trabalhos práticos
nas disciplinas de Instrumentação Industrial e Sistemas de Controle. O kit oferece
elementos que podem simular um sistema termodinâmico, um sistema de sensoriamento
e um sistema de atuação. A aquisição, registro de dados e lógica de controle deste
sistema deve ser feita pela interface serial RS232 de um microcomputador de uso geral.
Através da programação em ambiente Delphi, pode-se facilmente implementar uma
lógica de controle para o sistema termodinâmico oferecido pelo kit.

3. 2 - Desenvolvimento
2.1 – Descrição geral do projeto
O kit desenvolvido pode ser usado para simular o controle de dois sistemas
termodinâmicos diferentes:
- um forno controlado;
- uma carga que precise ter a sua temperatura máxima limitada.
Ex: processador.
O sistema termodinâmico oferecido pelo kit é composto por um resistor de
68 ohms / 10 W. Utiliza-se o efeito joule da corrente para aquecê-lo e tornar possível o
controle de temperatura tanto por controle de aquecimento quanto por controle de
resfriamento. Este resistor também pode se comportar como um atuador, como no caso
da simulação do forno controlado.
O sistema de sensoriamento é composto por um CI LM35, sensor de temperatura
de precisão que é capaz de variar a sua saída em 10 mV a cada variação de um grau
Celsius. A partir deste, é possível saber qual é a temperatura do resistor.
O sistema de atuação é composto por uma ventoinha que pode ter a sua rotação
controlada a partir de um sinal PWM – Pusle Width Modulation. No caso do forno
controlado, o resistor também pode se comportar como um atuador e também tem o seu
aquecimento controlado por um sinal PWM.
O sistema possui um microcontrolador PIC16F877A para fazer a interface entre
o kit e a porta serial RS232 do microcomputador.
2.2 – Hardware
O hardware do kit é uma placa de interface entre os dispositivos que compõem o
kit e o microcomputador.
Este kit foi desenvolvido para tornar possível a implementação de lógicas de
controle a partir da programação em alto nível por meio de plataformas de
desenvolvimento que rodam em microcomputadores de uso geral. Logo se fez
necessário desenvolver uma placa microcontrolada que fizesse a interface entre a porta
serial RS232 do microcomputador e periféricos do kit. A partir desta placa, tornou-se
possível acionar cargas de potência e fazer leituras analógicas de tensão, o que é de
extrema importância para o bom funcionamento do kit.
2.2.1 – Microcontrolador
O microcontrolador utilizada para a interface foi o PIC16F877A, fabricado pela
Microchip. Este microcontrolador foi escolhido pois possui 2 módulos para controle de
pwm, suporte para comunicação uart e canais de conversão analógico-digital, e
principalmente, por se ter várias peças disponíveis no curso.

4. 2.2.2 – Comunicação serial
Conforme já dito, o microcontrolador PIC16F877A possui uma USART
integrada. Esta USART é responsável pela serialização e temporização da transferência
dos dados que são enviados e paralelização e temporização dos dados que são recebidos.
Através deste periférico integrado ao chip, não é necessário usar o processador para
fazer o trabalho de transmissão ou recepção serial, bastando apenas enviar o dado de
forma paralela e recebê-lo de forma paralela.
O microcontrolador trabalha com o protocolo UART com níveis TTL: 0 V –
“0”, 5 V – “1”. Entretanto a porta serial dos microcomputadores utiliza os níveis
RS232: +3 a +15 V – “0”, -3 a -15 V - “1”. Para fazer o interface entre a comunicação
do microcontrolador com a do microcomputador foi necessário utilizar um conversor de
níveis também conhecido como transceptor TTL-RS232, o CI MAX232.
O MAX232 é um CI que possui dois tranceptores TTL-RS232 integrados.
Através de quatro capacitores externos este consegue gerar as tensões do padrão RS232
sendo alimentado por uma única fonte de 5 V.
Para a comunicação com o computador foram usados apenas 3 fios: TX, RX e
GND. Não foi necessário utilizar os outros sinais disponíveis na porta. Foi montado um
cabo específico para o kit, com um DB9 fêmea em uma das pontas e um conector spox
de 3 vias para ser conectado em uma barra de pinos, na outra.
2.2.3 – Alimentação
A alimentação do kit é feita por uma fonte linear de aproximadamente
44 V - 800 mA. A tensão de 44 V é resultado da retificação e filtragem da tensão de
saída do secundário de um transformador de 30 Vac. Esta tensão está sendo aplicada no
ramo do resistor e na entrada de um regulador de 24 V. A tensão de saída do regulador
de 24 V está sendo aplicada no ramo da ventoinha e na entrada de um regulador de 5 V.
A tensão de saída do regulador de 5 V está alimentando todos os circuitos integrados do
kit.
Caso haja uma revisão do projeto, procurará reduzir-se a tensão entre os
terminais dos reguladores ou montá-los de forma que seja possível a fixação de um
dissipador de calor.
2.2.1 – Acionamento de cargas de potência
As cargas de potência acionadas pelo microcontrolador são duas: uma ventoinha
de 24 V - 300 mA e um resistor de 68 ohms - 10 W. Ambas estão conectadas às saídas
de sinal PWM do microcontrolador.
A ventoinha está sendo acionada por um transistor NPN BC337 que liga o seu
terminal negativo ao GND, quando acionado. Colocou-se um diodo em antiparalelo
com a bobina da ventoinha para evitar o golpe indutivo ao desligar o transistor. Este
golpe indutivo em casos extremos pode danificar o transistor ou até mesmo o
microcontrolador.
O resistor está sendo acionado por um transistor MOSFET N IRF3205. Este
transistor liga o negativo da fonte ao resistor quando acionado. Sabe-se que aplicando

5. 45 V em um resistor de 68 ohms tem-se uma potência dissipada de aproximadamente 30
W. O resistor usado é de 10 W. Porém o kit possui um sistema de proteção que bloqueia
o uso do usuário quando a temperatura do resistor ultrapassar 100 º C, forçando-o a
baixar a temperatura para no mínimo 50 º C antes de desligar o sistema de proteção.
Esta proteção foi implementada no firmware do microcontrolador.
2.2.4 – Indicação
O kit possui dois leds: um vermelho e um laranja.
O led vermelho serve para indicar se a fonte de 5 V está ligada.
O led laranja indica o estado do microcontrolador. Aceso indica funcionamento
normal. Piscando indica proteção de sobre temperatura e apagado indica que o
microcontrolador está inativo.
2.2.5 – Leitura de temperatura
O microcontrolador PIC16F877A possui um conversor AD por aproximação
sucessiva integrado ao chip. Este tipo de conversor é muito vantajoso quando se
necessita de um equivalente binário de uma determinada tensão analógica a partir de
uma tensão de referência. Para realizar a leitura de temperatura foi necessário converter
de um sinal analógico para digital a saída do sensor de temperatura LM35. Para isso,
ligou-se a saída do sensor a uma dos canais de conversão AD do microcontrolador,
utilizando um filtro passa-baixas composto por um resistor de 1k2 e um capacitor de
100 nF para estabilizar o sinal. Mesmo realizando uma filtragem analógica ainda foi
necessário implementar um filtro digital no firmware do microcontrolador.
2.2.6 – Layout da placa de circuito impresso
O layout da placa de circuito impresso foi desenhado no EAGLE v 5.6, da
CadSoft.
2.3 – Firmware
As pessoas confundem bastante o conceito de “software” e “firmware” e
chamam muitas vezes um firmware de software ou um software de firmware.
O firmware pode ser definido como um software embarcado. Um software para
um hardware específico que vem gravado de fábrica na memória de programa de um
sistema microprocessado. Pode-se dizer que o firmware esta “preso” à sua placa de
aplicação.
Quando se desenvolve um programa para rodar em um hardware específico, este
é chamado de firmware. Entretanto ao se desenvolver um programa para funcionar
independente do hardware utilizado, desenvolve-se um software.

6. Exemplos de equipamentos que utilizam firmwares: celulares mais antigos,
controles remotos, cafeteiras, relógios, BIOS, estações meteorológicas, multímetros, etc.
Exemplos de equipamentos que utilizam softwares: microcomputadores da
família PC, MAC, IBM, celulares mais modernos, televisões mais modernas, etc.
Exemplos de softwares que parecem firmwares: programa para kits de didáticos,
programas para kits de desenvolvimento.
2.3.1 – Compilador
O desenvolvimento do firmware gravado no microcontrolador foi feito usandose o CCS C Compiler versão 4.074. Este compilador, apesar de ser muito bom para fins
didático e para desenvolvimento rápido é muito deficiente em relação à otimização de
código assembly gerado e acesso direto aos registradores do microcontrolador. Optou-se
por usar este compilador devido às ferramentas para comunicação serial e a
transparência do código escrito.
2.3.2 – Metodologia de desenvolvimento
A forma de programar um sistema embarcado é diferente de programar um
computador de uso geral. Na programação de um computador têm-se um fim de
execução do programa, em um sistema embarcado não.
Em um sistema embarcado existem basicamente duas etapas em sua
programação: a inicialização e o laço principal.
Na inicialização são feitos todos os tipos de configurações e inicializações de
variáveis e periféricos. Já no laço principal é feita a execução de rotinas que só cessará
quando o dispositivo for desligado, ou seja, um laço é infinito.
Um firmware eficiente é um firmware desenvolvido com um único laço (sem for
ou while): o laço principal. Todos os outros laços devem ser feitos com estruturas de
seleção (if-else switch-case) dentro do laço principal. Deve-se passar pelo início do laço
o mais freqüente possível para que se possa realizar comandos de varredura ou testes
que dependem de respostas rápidas o mais rápido possível sem deixar o
microcontrolador esperando estes resultados. O microcontrolador deve saber qual
instrução executar em uma passagem pelo laço com base na instrução executada na
ultima passagem pelo laço e nas variáveis de controle que podem direcionar para a
execução de uma instrução específica.
Um código eficiente tem o menor número de delays possível. Ao invés de usar
delays, pode-se ter um timer rodando paralelo ao programa que dita quando um led deve
piscar, por exemplo.

7. 2.4 – Software
O software desenvolvido não acompanha o kit didático tendo em vista que o
objetivo do kit é justamente possibilitar o usuário desenvolver um software para o
sistema de controle. Entretanto, criou-se um software exemplo, para mostrar o
funcionamento do kit.
2.4.1 - Interface com a placa
A interface com a placa é feita com a porta serial RS232 do microcomputador. O
programa pode ser desenvolvido em alguma plataforma de desenvolvimento Delphi, C+
+ Builder, Visual Basic, Visual Studio, Eclipse ou em compiladores convencionais.
Cabe ao desenvolvedor de compiladores convencionais desenvolverem o código para
acessar a porta serial do microcomputador.
A placa desenvolvida é uma placa escrava, ou seja, ela só faz o que mandam
fazer e só responde o que perguntam. Ocorre uma exceção quando a temperatura do
resistor ultrapassa 105 º C, nesta situação a placa encarrega-se de rebaixar a temperatura
do resistor e envia um alerta para o microcomputador.
Existem basicamente 13 comandos que a placa pode responder:
‘i’
‘d’
‘I’
‘D’
‘c’
‘C’
‘l’
‘L’
‘t’
‘r’
‘p’
‘P’
‘h’
Incrementar o PWM da ventoinha
Decrementar o PWM da ventoinha
Incrementar o PWM do resistor
Decrementar o PWM do resistor
Zerar o PWM da ventoinha
Põe o PWM da ventoinha no máximo
Zerar o PWM do resistor
Põe o PWM do resistor no máximo
Pede o envio do valor da temperatura
Pede o envio do valor da rotação
//
valor do PWM da ventoinha
//
valor do PWM do resistor
Reconhecimento da placa
Da mesma forma, a placa responde o caracter enviado acompanhado de um
numero inteiro de 5 casas preenchidas com 0.
Ex: recebe ‘t’ envia “t00048”

8. 2.4.2 – Software de demonstração
Imagem do software de interface
O software foi desenvolvido na plataforma Delphi 7 da antiga Borland, hoje
Embarcadero. Abaixo estão as descrições de cada componente da imagem.
O plano cartesiano, representado pelo componente “TChart” no canto inferior
direito mostra a variação de temperatura em função do tempo do sistema.
O groupbox intitulado “Comunicação com a placa” indica o estado da porta
COM do computador e se a placa foi reconhecida pelo sistema.
O radiogroup “Métodos de Controle” possui dois radiobuttons que permitem o
usuário escolher se deseja que o sistema controle a placa ou se deseja fazer o controle
manual dos parâmetros.
O groupbox “Interface” permite iniciar o teste e escrever qual é a temperatura
desejada do sistema.
O radiogroup “Seleção do sistema” permite o usuário escolher se quer simular
um forno controlado ou uma carga que deve ser resfriada. Em uma situação pode-se
variar o pwm do resistor, na outra o do cooler.
O groupbox “PWM Controle” é habilitado apenas no controle manual e serve
para o usuário definir o valor de pwm do resistor e pwm do cooler.
O groupbox “Informações do sistema” indica o estado do pwm do resistor, do
cooler e a temperatura do resistor.
O checkbox “Salvar em arquivo”, se selecionado no início do teste guarda as
informações em um arquivo de texto.
O botão sair serve para sair desligando todos os periféricos da placa antes.

9. 3 - Conclusão
Desenvolver um kit didático representa desenvolver uma ferramenta de
aprendizado. Por este motivo torna-se muito mais trabalhoso pois deve-se prever todas
as ações de uma pessoa que está em treinamento,é diferente de desenvolver um produto
comum.
Ao mesmo tempo em que se deve dar liberdade para o sistema fazer o que a
pessoa quiser, deve-se ter a segurança de monitorar o estado do sistema e entrar em
alerta caso algo dê errado. Sem dúvidas, o desenvolvimento deste projeto trouxe
conhecimentos não só do conteúdo que deveria ser visto em sala de aula, mas da área
didática e da área de desenvolvimento de produto.

10. Apêndice A – Diagrama esquemático da placa

11. Apêndice B – Firmware do mircrocontrolador
//inclusão de bibliotecas
#include <16F877A.h>
//configurações do dispositivo
#device adc = 10
#fuses HS, WDT
#use delay(clock = 4000000)
#use rs232 (baud = 9600, xmit = PIN_C6, rcv=PIN_C7)
//Endereçamento de resgistradores
#byte PORTA = 0x05
#byte PORTB = 0x06
#byte PORTC = 0x07
#byte PORTD = 0x08
#byte PORTE = 0X09
#byte TRISA = 0x85
#byte TRISB = 0x86
#byte TRISC = 0x87
#byte TRISD = 0x88
#byte TRISE = 0x89
#byte OPTION_REG = 0x81
#byte CCPR1L = 0x15
#byte CCPR1H = 0x16
#byte CCP1CON = 0x17
#byte CCPR2L = 0x1b
#byte CCPR2H = 0x1c
#byte CCP2CON = 0x1d
#bit RB0 = PORTB.0
#bit RB4 = PORTB.4
#bit RC1 = PORTC.1
#bit RC2 = PORTC.2
#bit T0CS = OPTION_REG.5
#bit PSA = OPTION_REG.3
#bit PS2 = OPTION_REG.2
#bit PS1 = OPTION_REG.1
#bit PS0 = OPTION_REG.0
#bit TRISC1 = TRISC.1
#bit TRISB4 = TRISC.4
#define pwm_c_reg CCPR1L
#define pwm_r_reg CCPR2L
#define sentido_pino_led TRISB4
//Definições de pinos

12. #define ft
#define led
RB0
RB4
//Definições dos estados de máquina e valores constantes
#define EST_LE_TEMP 0
#define EST_PRC_ERR 1
#define EST_PWMC_INC 'i'
#define EST_PWMC_DEC 'd'
#define EST_PWMR_INC 'I'
#define EST_PWMR_DEC 'D'
#define EST_PWMC_MIN 'c'
#define EST_PWMC_MAX 'C'
#define EST_PWMR_MIN 'l'
#define EST_PWMR_MAX 'L'
#define EST_ENV_TEMP 't'
#define EST_ENV_ROT 'r'
#define EST_ENV_PWMC 'p'
#define EST_ENV_PWMR 'P'
#define EST_HND_SHKN 'h'
#define TEMP_MAX 210
#define TEMP_MIN 100
//para o valor real, dividir por 2
//variáveis globais
short erro = 0;
char buffer[8];
unsigned int sm = 0,sma = 0, pwm_c = 0, pwm_r = 0;
unsigned long int temp = 0, np = 0, rpm = 0;
//protótipos de subrotinas
void inicializa();
void processo();
void config_ad();
void config_pwm();
void comunica();
void config_io();
void reset_wdt();
void config_wdt();
void le_temp();
void config_timer1();
void config_interrupts();
void procura_erro();
void init_signal();
//interrupções
#INT_EXT
void trata_ext0()

13. {
np++;
}
#INT_TIMER1
void trata_timer1()
{
static unsigned int cont = 0;
if(cont<20)
{
cont++;
} else
{
//efetua o cálculo a cada 1 s
cont = 0;
rpm = np * 60;
np = 0;
if(erro)
{
sentido_pino_led = 1; //configura o pino do led como entrada
led = !led;
//coloca no buffer de saída o inverso do estado do buffer
de entrada
sentido_pino_led = 0; //configura o pino como saída
putc(‘a’);
}
}
set_timer1(15536); //time out após 50 ms
}
//main
void main()
{
inicializa();
while(1)
{
comunica();
processo();
reset_wdt();
}
}
void inicializa()
{
config_wdt();
config_io();
init_signal();
config_ad();

14. config_pwm();
config_timer1();
config_interrupts();
init_signal();
}
void comunica()
{
if(kbhit()) //se houver algo no buffer de recepção,executa
{
sma = sm; //armazena o valor do estado de máquina atual
sm = getc(); //pula para o estado indicado pelo caracter recebido
}
}
void processo()
{
switch(sm)
{
//estados de execução normal do programa
case EST_LE_TEMP: le_temp();
sm = EST_PRC_ERR; //pula para o estado "procura erro"
break;
case EST_PRC_ERR: procura_erro();
sm = EST_LE_TEMP; //pula para o estado "lê temperatura"
break;
//estados de tratamento de interrupção
case EST_ENV_TEMP: sprintf(buffer,"t%5lu", temp); //imprime o valor
medido de temperatura em uma string
puts(buffer); //envia a string pelo dispositivo de saída padrão, o
periférico USART
sm = sma; //retorna para o estado anterior antes da "interrupção"
break;
case EST_ENV_ROT: sprintf(buffer,"r%5lu", rpm);
puts(buffer);
sm = sma;
break;
case EST_ENV_PWMC: pwm_c = pwm_c_reg;
sprintf(buffer,"p%5u", pwm_c);
puts(buffer);
sm = sma;
break;

15. case EST_ENV_PWMR: pwm_r = pwm_r_reg;
sprintf(buffer,"P%5u", pwm_r);
puts(buffer);
sm = sma;
break;
case EST_PWMC_INC: if(pwm_c<255)
pwm_c++;
pwm_c_reg = pwm_c;
sm = sma;
break;
case EST_PWMC_DEC: if(pwm_c>0)
pwm_c--;
pwm_c_reg = pwm_c;
sm = sma;
break;
case EST_PWMC_MIN: pwm_c = 0;
pwm_c_reg = pwm_c;
sm = sma;
break;
case EST_PWMC_MAX: pwm_c = 255;
pwm_c_reg = pwm_c;
sm = sma;
break;
case EST_PWMR_INC: if(pwm_r<255)
pwm_r++;
pwm_r_reg = pwm_r;
sm = sma;
break;
case EST_PWMR_DEC: if(pwm_r>0)
pwm_r--;
pwm_r_reg = pwm_r;
sm = sma;
break;
case EST_PWMR_MIN: pwm_r = 0;
pwm_r_reg = pwm_r;
sm = sma;
break;
case EST_PWMR_MAX: pwm_r = 255;
pwm_r_reg = pwm_r;
sm = sma;
break;

16. case EST_HND_SHKN: sprintf(buffer,"HS_OK"); //HANDSHAKING
puts(buffer);
sm = sma;
break;
default: sm = sma;
estado de máquina anterior
//caso receba algum caracter inválido, retorna para o
}
}
void config_ad() //configura o periférico adc
{
setup_ADC_ports(RA0_analog);
setup_adc(ADC_CLOCK_INTERNAL);
set_adc_channel(0);
}
void config_pwm() //configura os dois módulos ccp como geradores de sinal
pwm
{
setup_timer_2(T2_DIV_BY_1,255,1);
setup_ccp1(ccp_pwm);
set_pwm1_duty(0);
setup_ccp2(ccp_pwm);
set_pwm2_duty(0);
}
void config_io() //configura a direção dos pinos(entrada ou saída)
{
TRISA = 0xff;
TRISB = 0b11101111;
TRISC = 0b11111001;
TRISD = 0xff;
TRISE = 0xff;
pwm_c = 0;
pwm_r = 0;
led = 1;
}
void config_wdt() //configura o watch dog timer
{
PSA = 1; //preescaler para o watch dog timer não para o timer 0
PS2 = 1; //preescaler de 1:128
PS1 = 1;

17. PS0 = 1;
}
void reset_wdt() //chama uma instrução assembly para resetar o wdt
{
#asm
CLRWDT
#endasm
}
void le_temp() //realiza a leitura do pino analógico ligado ao sensor de
temperatura
{
//soma as leituras a cada passada. Quando passa pela oitava vez
//obtêm a média dos valores e atualiza o variável global que indica a
//temperatura
static int cont = 0;
static unsigned long int buffer_ad = 0;
if(cont<8) //lê e soma 8 amostras
{
buffer_ad = buffer_ad + read_adc();
cont++;
} else
{
cont = 0;
temp = buffer_ad >> 3; //divide por 8
buffer_ad = 0;
}
}
void config_timer1() //configura o timer 1
{
setup_timer_1(T1_INTERNAL | T1_DIV_BY_1); // clock interno de 1 MHz
set_timer1(15536); //time out após 50 ms
}
void config_interrupts() //configura as fontes de interrupção
{
enable_interrupts(GLOBAL);
enable_interrupts(INT_EXT);
enable_interrupts(INT_TIMER1);
ext_int_edge(0,H_TO_L);
}
void procura_erro() //verifica se a temperatura do resistor está muito alta
{
//e entra em estado de alerta caso esteja
static short flag = 0;
if(temp>TEMP_MAX)

18. {
pwm_r = 0;
pwm_r_reg = pwm_r;
pwm_c = 255;
pwm_c_reg = pwm_c;
erro = 1;
flag = 1;
}
if(temp<TEMP_MIN && flag)
{
erro = 0;
pwm_c = 0;
pwm_c_reg = pwm_c;
led = 1;
flag = 0;
}
}
void init_signal() //piscada inicial do led
{
led = 0;
delay_ms(200);
led = 1;
delay_ms(200);
}