Relatorio embarcados

Prévia do material em texto

UNIVIX – Faculdade Brasileira 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
RELATÓRIO SISTEMAS EMBARCADOS II 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Vitória 
2013
UNIVIX – Faculdade Brasileira 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
RELATÓRIO SISTEMAS EMBARCADOS II 
2º Bimestre 
 
 
 
Relatório referente ao trabalho de 
sistemas embarcados II, executado 
no segundo bimestre, cuja finalidade 
foi interfacear uma entrada analógica, 
e trabalha-la digitalmente. 
 
 
 
 
Professor Orientador: Marcelo Souza Fassarela 
 
 
 
 
 
 
Vitória 
2013
MOTIVAÇÃO: 
Na disciplina de Sistemas Embarcados II, foi-se solicitado escrever e executa-
lo em um microprocessador (STM32VL-Discovery), um software que recebesse uma 
entrada analógica, e a convertesse em informação digital, para que pudesse ser 
tratada. 
Para a execução de tal projeto, Escolhemos trabalhar com um sensor de 
temperatura, cuja entrada seria proveniente da variação da resistência de um 
PT100, cuja resistência é sensível a temperatura. 
Este mesmo foi escolhido, devido a nossa facilidade de acesso ao 
equipamento, além do mesmo ser utilizado em algumas aplicações industriais, o 
projeto do software foi pensado, como uma simulação de implementação industrial, 
onde parâmetros podem ser arbitrariamente ajustados de acordo com a necessidade 
do usuário. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ORGANIZAÇÃO E PLANEJAMENTO 
O projeto tem duas grandes vertentes, o projeto analógico, e o projeto digital. 
O projeto analógico envolve a captura da tensão a ser medida e tratada, 
assim como todos os componentes analógicos, como circuitos amplificadores, 
circuitos de relé, e o de botoeiras. 
O projeto digital, foi baseado de forma que, o usuário tenha a liberdade de 
parametrizar os valores de controle de temperatura, para que o mesmo possa ser 
ajustado para diferentes tipos de necessidades. 
Tendo definido o escopo. Foi organizado e desenvolvido paralelamente a 
parte analógica, e a parte digital, para que o mesmo pudesse ser implementado e 
testado gradativamente. 
 
 
 
DESENVOLVIMENTO 
Parte analógica: 
 
A Parte analógica do projeto, consiste basicamente de um circuito 
comparador e amplificador, para a entrada da tensão analógica no 
microprocessador. 
Do circuito de relé que, abre e fecha o circuito da estufa, para que a 
temperatura se mantenha dentro dos valores parametrizados. 
Circuito conversor binário para BCD 7-segmentos, junto com o circuito dos 
displays. 
Circuito dos botões, que servem como entradas para tomada de decisão para 
o microprocessador. 
Para fins de facilitação da explicação, iremos primeiramente tratar cada 
componente da parte analógica do projeto em separado, e ao final, haverá um 
esquemático de como os mesmos estão interligados. 
 
 
 
 
 
 
 
 
 
 
 
 
Circuito Comparador e Amplificador: 
 
Figura 1 - Circuito Amplificador de diferenças 
 
O circuito funciona em duas etapas, primeiro, temos um circuito amplificador 
de diferença, onde caso as tensões de entrada sejam iguais, o amplificador U1, terá 
0V na sua saída (V01), o que o torna altamente sensível a variação da resistência do 
PT100 (que varia de 100 a 150 Ω), sendo assim a saída (V01) a diferença entre as 
tensões de referência (conectado à porta 3 do Amp-Op U1), com relação a tensão 
resultante da variação de resistência do PT100, (conectado à porta 2 do Amp-Op 
U1). 
Tabela 1 - Tabela de Variação de Resistencia do PT100 em relação a Variação de Temperatura 
Temperatura 
(em ºC) 
Resistência ôhmica 
(em Ω) 
20 108,8 
25 111,3 
30 113,2 
35 115,1 
40 116,7 
45 118,9 
50 120,4 
55 122,5 
60 124,4 
65 126,5 
70 128,7 
75 130,3 
80 132,2 
85 134,7 
90 136,5 
95 138,6 
100 141,5 
 
 
 
Tabela 2 - Variação da Resistencia do PT100 e a tensão de saída do Amp-Op U1 (V01) 
 
 
 Com a tensão de saída do Amp-Op U1 ajustada, Bastou colocarmos um 
amplificador (U2) na saída de U1, e escolhermos os valores de resistências 
adequados, para que com o ganho (G = - R11/R10) do Amp-Op U2, a tensão de 
saída não ultrapasse o valor de tensão máximo de entrada o Microprocessador 
(3,3V), assim tendo em (V02) a tensão a ser lida, e convertida para sinal digital. 
Tabela 3 - Variação da Resistencia do PT100 e as tensões de saídas (V01) e (V02) 
Resistencia PT100 Tensão V01 em mV Tensão V02 
100 2 14,5mV 
110 62,9 882mV 
120 120,9 1,71V 
130 176,2 2,5V 
140 228,9 3,25V 
 
Circuito Display 7-Segmentos: 
 
Figura 2 - Circuito de Acionamento do Display 7-segmentos 
 
Resistencia PT100 Tensão V01 em mV 
100 -2 
110 -62,9 
120 -120,9 
130 -176,2 
140 -228,9 
 
 
 Para mostrar os valores de temperatura, tanto a temperatura atual medida pelo PT100, 
como para as parametrizações de temperatura, fez-se necessário o uso de um display 7-
segmentos. 
 Para facilitar as conexões e usos de componentes, assim como portas de saída do 
microprocessador, Utilizou-se a técnica onde, apenas um display é ligado por vez, em um 
chaveamento rápido e alternado dos transistores Q1 e Q2, que acionam o display, é possível 
passar a sensação aos olhos humanos, que os dois displays estão ligados simultaneamente. 
 Portanto, o Conversor Binario-7-Segmentos (U3), recebe a saída do microprocessador, 
bits 0 ou 1, que serão convertidos para o formato 7-segmentos, e em seguida mostrados em 
decimal no display. 
 Como exemplo, caso queira mostrar o número 53, no display, primeiro convertemos o 
número 5 para binário (0101) e passamos esse número para U3, Simultaneamente, acionamos 
o transistor Q1, para que o display U1 seja ligado. A seguir, desacionamos o transistor Q1 
convertemos o número 3 para binário (0011) e passamos esse número para U3 e 
simultaneamente, acionamos o transistor Q2, e assim sucessivamente. 
 
 
Circuito Botões: 
 
Figura 3 - Circuito Botões 
 
 Circuito de Botões utilizados na parametrização da temperatura. Ele é normalmente 
Fechado, e ligado a 3,3V (tensão máxima aceita pelo Micro Controlador). 
 
 
 
 
 
 
 
 
 
 
 
Circuito Relé: 
 
Figura 4 - Circuito de Acionamento do Controlador de Temperatura 
 
 O Acionamento do relé é feito quando o transistor Q1 é acionado pelo micro 
controlador, acionando assim o circuito responsável por manter a temperatura dentro 
dos parâmetros desejados. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Figura 5 - Diagrama de Ligação dos Componentes 
 
 
 
Parte Digital: 
 
 
 A Parte Digital do Projeto consiste basicamente da parte de software, que irá 
receber as informações dos componentes analógicos, processa-los, e passar para 
as saídas, os valores desejados. 
 Para tanto, foi-se pensado em desenvolver no controlador de temperatura, 
uma faixa de controle (ajustável de acordo com as necessidades do usuário), onde é 
acionado a estufa, caso o valor esteja abaixo do desejado. 
 Antes de explanar sobre o programa, e suas funções, será apresentado 
rapidamente o funcionamento do mesmo, e apresentado em um fluxograma. 
 
Funcionamento do Programa: 
 
 O Programa funciona coletando a tensão do amplificador de diferenças, e 
convertendo a tensão em temperatura, seguindo uma escala pré-definida. 
 A conversão é feita, tendo como base os seguintes parâmetros: 
- A tensão varia de 0 a 3,3V 
- Como a conversão é feita e transportada para um registrador de 12-bits, o 
conversor analógico-digital tem 4096 níveis de tensão diferentes dentro dafaixa de (0~3,3V) 
- A temperatura pode variar de 0 a 100 ºC 
Portanto, é fácil deduzir que a fórmula para conversão de tensão em temperatura é: 
 
 C = (100*T / 4096) 
 
Onde C é a temperatura em ºC 
 T é o nível de tensão lido pelo ADC (variando de 0~4095). 
 
Com essa conversão, o software compara com os valores máximos e 
mínimos parametrizados e toma as devidas ações de acionar ou não o relé de 
controle de temperatura. 
Em qualquer momento, caso o botão USER do micro controlador seja 
apertado, os LED’s do mesmo (verde e azul) são acesos, indicando que o software 
entrou no modo parametrização, e fica aguardando o usuário escolher se deseja 
parametrizar o valor máximo ou mínimo (pressionando um dos botões do circuito 
analógico). 
Ao escolher, um dos LED’s irá se apagar (Verde, caso parametrizar o valor 
máximo, Azul, caso parametrizar o valor mínimo) 
Após, o software aguardará os ajustes de temperatura, através dos botões 
externos, um para unidade, e outro para dezena. 
O software fica aguardando até o usuário aperte novamente o botão USER, 
que após pressionado, os LED’s azul e verde piscarão simultaneamente, indicando 
que o novo valor foi aceito, e em seguida volta a fazer as conversões e tomadas de 
decisão. 
 
 
 
Ajustar
Temperatura?
Qual Temperatura
ajustar?
Temperatura
Máxima
Temperatura
Mínima
Ajustar
Temperatura
Botão User
foi Presionado?
Prescionar
o Botão USER
Pressionar o
Respectivo 
Botão
SIM NÃO
SIMNÃO
Coletar e 
Converter 
Temperatura
Temp Min < Temp 
< Temp Max
SIM NÃO
Desligar Relé Ligar Relé
INICIO
 
Figura 6 - Fluxograma de decisão do Software 
 
 
Analise do Código: 
 
Void Config_portas() 
{ 
 GPIO_InitTypeDef GPIO_InitStructure; 
 
// Portas de saídas Para o Conversor Binário para BCD 7-segmentos 
 
 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); 
 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1+GPIO_Pin_2+GPIO_Pin_3+GPIO_Pin_4; 
 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; //Configurando a Saída como Push-Pull 
 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 
 GPIO_Init(GPIOA, &GPIO_InitStructure); 
 
// Portas de saída para ativação dos transistores dos Display 
 
 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); 
 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5+GPIO_Pin_6; 
 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; //Configurando a Saída como Push-Pull 
 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 
 GPIO_Init(GPIOA, &GPIO_InitStructure); 
 
// Porta de saída para ativação do Relé 
 
 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE); 
 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3; 
 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; //Configurando a Saída como Push-Pull 
 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 
 GPIO_Init(GPIOC, &GPIO_InitStructure); 
 
 
 
 
 
 
// Portas de Entrada Botões 
 
 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE); 
 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1+GPIO_Pin_2; 
 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD; //Ligando o Botão como Pull-Down 
 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 
 GPIO_Init(GPIOC, &GPIO_InitStructure); 
 
// Botão User, do Micro controlador 
 
 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); 
 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0; 
 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD; //Ligando o Botão como Pull-Down 
 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 
 GPIO_Init(GPIOA, &GPIO_InitStructure); 
 
//Porta Conversor ADC 
 
 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE); 
 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0; 
 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN); //Configurando como entrada Analogica 
 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 
 GPIO_Init(GPIOC, &GPIO_InitStructure); 
} 
 
 Função para configurar as portas que serão necessárias no projeto, como as 
saídas para o conversor binário, os botões, conversor ADC e transistor para 
acionamento dos displays e relé 
 
 
Void ADC_Config() 
{ 
 ADC_InitTypeDef ADC_InitStructure; 
 ADC_DeInit(ADC1); 
 RCC_ADCCLKConfig(RCC_PCLK2_Div6); 
 RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_AFIO, ENABLE); 
 
 ADC_InitStructure.ADC_Mode = ADC_Mode_Independent; 
 ADC_InitStructure.ADC_ScanConvMode = DISABLE; 
 ADC_InitStructure.ADC_ContinuousConvMode = ENABLE; 
 ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
 ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right; 
 ADC_InitStructure.ADC_NbrOfChannel = 1; 
 ADC_Init(ADC1, &ADC_InitStructure); 
 ADC_Cmd(ADC1, ENABLE); 
 ADC_ResetCalibration(ADC1); 
 while(ADC_GetResetCalibrationStatus(ADC1)); 
 ADC_StartCalibration(ADC1); 
 while(ADC_GetCalibrationStatus(ADC1)); 
} 
 
Essa Função Faz a Configuração do Conversor ADC, de Como ele fará as 
conversões e como armazenará os bits no registrador: 
 Cada Linha é uma configuração do ADC: 
 
ADC_InitStructure.ADC_Mode = ADC_Mode_Independent; 
Configura o ADC para Fazer uma conversão simples, e apenas uma, e não 
fazer uma conversão dual 
 
 
 
 
 
ADC_InitStructure.ADC_ScanConvMode = DISABLE; 
Desabilita o Scan Mode, o que nos permite fazer uma conversão em um único 
canal, e não vem vários canais. 
 
ADC_InitStructure.ADC_ContinuousConvMode = ENABLE 
Especifica que a conversão é feita de Forma Continua. 
 
ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None; 
Define se a Conversão será acionada por um evento externo, ou se será via 
software. No caso, está configurado para iniciar a conversão via software. 
. 
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right 
Seleciona a forma de que será armazenado no registrador. Se ele será 
preenchido da direita para a esquerda, ou da esquerda para direita. No caso ele é 
preenchido da direita para a esquerda. 
 
Figura 7 - Posicionamento dos Bits, ao Serem Preenchidos pelo ADC no registrador 
 
ADC_InitStructure.ADC_NbrOfChannel = 1; 
Especifica o número de canais que o ADC trabalhará. 
 
ADC_Cmd(ADC1, ENABLE); 
ADC_ResetCalibration(ADC1); 
while(ADC_GetResetCalibrationStatus(ADC1)); 
ADC_StartCalibration(ADC1); 
while(ADC_GetCalibrationStatus(ADC1)); 
 
Reseta o registrador de calibração do ADC e calibra o mesmo 
 
 
Void Config_Led() 
{ 
 GPIO_InitTypeDef GPIO_InitStructure; 
 
 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE); 
 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 + GPIO_Pin_9; 
 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; 
 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 
 GPIO_Init(GPIOC, &GPIO_InitStructure); 
} 
 
 Configura os LED’s do micro controlador, para que o mesmo acenda para 
indicar os estados de parametrização. 
 
 
 
 
 
 
 
Void Config_clock() 
{ 
 RCC_DeInit(); 
 RCC_HSEConfig(RCC_HSE_ON ); 
 RCC_PLLConfig(RCC_PLLSource_PREDIV1, RCC_PLLMul_6 ); 
 RCC_PREDIV1Config(RCC_PREDIV1_Source_HSE, RCC_PREDIV1_Div2 ); 
 RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK ); 
 RCC_PLLCmd(ENABLE); 
} 
 
 Configura o Clock para funcionar com 24MHz. 
 
 
u16 readAnalogica1() 
{ 
 u16 value; 
 ADC_RegularChannelConfig(ADC1,ADC_Channel_10, 1, ADC_SampleTime_71Cycles5); 
 ADC_SoftwareStartConvCmd(ADC1, ENABLE); 
 while(ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET); 
 value = ADC_GetConversionValue(ADC1); 
return (value); 
} 
 
 Função que faz a conversão ADC, como se segue: 
 
u16 value; 
Declara um registrador de 16-bits. 
 
ADC_RegularChannelConfig(ADC1,ADC_Channel_10, 1, ADC_SampleTime_71Cycles5); 
Configura a Porta em que será feita a conversão (Canal 10), informa o 
número de canais, e aquantidade de amostras a serem coletadas. 
 
ADC_SoftwareStartConvCmd(ADC1, ENABLE); 
Habilita o início da conversão por software. 
 
while(ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET); 
value = ADC_GetConversionValue(ADC1); 
Enquanto o status do registrador EOC (End of Conversion) for nulo, a 
conversão continua, jogando valores para o registrador Value. 
 
 
Void mostra (int num ) 
{ 
 switch (num) 
 { 
case(0): 
 GPIO_ResetBits(GPIOA,GPIO_Pin_1); 
 GPIO_ResetBits(GPIOA,GPIO_Pin_2); 
 GPIO_ResetBits(GPIOA,GPIO_Pin_3); 
 GPIO_ResetBits(GPIOA,GPIO_Pin_4); 
 break; 
 case(1): 
 GPIO_SetBits(GPIOA,GPIO_Pin_1); 
 GPIO_ResetBits(GPIOA,GPIO_Pin_2); 
 GPIO_ResetBits(GPIOA,GPIO_Pin_3); 
 GPIO_ResetBits(GPIOA,GPIO_Pin_4); 
 break; 
 
 
 
 
case(2): 
 GPIO_ResetBits(GPIOA,GPIO_Pin_1); 
 GPIO_SetBits(GPIOA,GPIO_Pin_2); 
 GPIO_ResetBits(GPIOA,GPIO_Pin_3); 
 GPIO_ResetBits(GPIOA,GPIO_Pin_4); 
 break; 
 case(3): 
 GPIO_SetBits(GPIOA,GPIO_Pin_1); 
 GPIO_SetBits(GPIOA,GPIO_Pin_2); 
 GPIO_ResetBits(GPIOA,GPIO_Pin_3); 
 GPIO_ResetBits(GPIOA,GPIO_Pin_4); 
 break; 
 case(4): 
 GPIO_ResetBits(GPIOA,GPIO_Pin_1); 
 GPIO_ResetBits(GPIOA,GPIO_Pin_2); 
 GPIO_SetBits(GPIOA,GPIO_Pin_3); 
 GPIO_ResetBits(GPIOA,GPIO_Pin_4); 
 break; 
 case(5): 
 GPIO_SetBits(GPIOA,GPIO_Pin_1); 
 GPIO_ResetBits(GPIOA,GPIO_Pin_2); 
 GPIO_SetBits(GPIOA,GPIO_Pin_3); 
 GPIO_ResetBits(GPIOA,GPIO_Pin_4); 
 break; 
 case(6): 
 GPIO_ResetBits(GPIOA,GPIO_Pin_1); 
 GPIO_SetBits(GPIOA,GPIO_Pin_2); 
 GPIO_SetBits(GPIOA,GPIO_Pin_3); 
 GPIO_ResetBits(GPIOA,GPIO_Pin_4); 
 break; 
 case(7): 
 GPIO_SetBits(GPIOA,GPIO_Pin_1); 
 GPIO_SetBits(GPIOA,GPIO_Pin_2); 
 GPIO_SetBits(GPIOA,GPIO_Pin_3); 
 GPIO_ResetBits(GPIOA,GPIO_Pin_4); 
 break; 
 case(8): 
 GPIO_ResetBits(GPIOA,GPIO_Pin_1); 
 GPIO_ResetBits(GPIOA,GPIO_Pin_2); 
 GPIO_ResetBits(GPIOA,GPIO_Pin_3); 
 GPIO_SetBits(GPIOA,GPIO_Pin_4); 
 break; 
 case(9): 
 GPIO_SetBits(GPIOA,GPIO_Pin_1); 
 GPIO_ResetBits(GPIOA,GPIO_Pin_2); 
 GPIO_ResetBits(GPIOA,GPIO_Pin_3); 
 GPIO_SetBits(GPIOA,GPIO_Pin_4); 
 break; 
 } 
} 
 
 Função que recebe um valor unitário, e de acordo com o valor, Passa para o 
conversor Binario-BCD 7-Segmentos, uma configuração diferente, correspondendo 
em bits, o valor da variável. 
 
 
 
 
 
 
 
 
 
 
 
 
void display_unid (int unid) 
{ 
 int aux = 0; 
 int tempo = 5000; 
 for (aux=0;aux<=tempo;aux++); 
 { 
 GPIO_ResetBits(GPIOA,GPIO_Pin_6); 
 GPIO_SetBits(GPIOA,GPIO_Pin_5); 
 mostra(unid); 
 } 
} 
 
void display_dez (int dez) 
{ 
 int aux = 0; 
 int tempo = 5000; 
 for (aux=0;aux<=tempo;aux++); 
 { 
 GPIO_ResetBits(GPIOA,GPIO_Pin_5); 
 GPIO_SetBits(GPIOA,GPIO_Pin_6); 
 mostra(dez); 
 } 
} 
 
 Funções que, Ligam e desligam os transistores dos displays, e passam os 
respectivos valores das variáveis, (dezena e unidade) para a função mostra (função 
analisada anteriormente) para que os valores sejam mostrados nos displays. 
 
 
void rele (int ctrl, int temp_max, int temp_min) 
{ 
 int aux1; 
 if(ctrl >= temp_max) 
 { 
 aux1 = 1; 
 GPIO_ResetBits(GPIOC,GPIO_Pin_3); 
 } 
 if (ctrl <= temp_min) 
 { 
 aux1 = 2; 
 GPIO_SetBits(GPIOC,GPIO_Pin_3); 
 } 
 if ((ctrl>temp_min)&&(ctrl<temp_max)) 
 { 
 if ((aux1 == 1)) 
 { 
 GPIO_ResetBits(GPIOC,GPIO_Pin_3); 
 } 
 if ((aux1 == 2)) 
 { 
 GPIO_SetBits(GPIOC,GPIO_Pin_3); 
 } 
 } 
} 
 
 Função de tomada de decisão do relé, onde se a temperatura controlada 
(CTRL), for maior que a temperatura máxima parametrizada, o relé é desligado, 
caso CTRL for menor do que a temperatura mínima, aciona o relé. 
 Caso o Relé esteja entre a temperatura mínima e máxima, a variável aux1 
(memória do estado anterior do relé) é o parâmetro para o relé, pois se o mesmo 
 
 
estava com a temperatura decrescendo, o relé não é acionado, porém se a 
temperatura estava em ascendência, o relé é acionado. 
 
 
int parame_dec () 
{ 
 GPIO_SetBits(GPIOC,GPIO_Pin_8); 
 GPIO_SetBits(GPIOC,GPIO_Pin_9); 
 int dec_param = 0; 
 int bounce = 0; 
 while (1) 
 { 
 if(GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_1) == 0) 
 { 
 while (GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_1) == 0) 
 { 
 bounce++; 
 } 
 if (bounce >700) 
 { 
 dec_param = 1; 
 return (dec_param); 
 } 
 } 
 if(GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_2) == 0) 
 { 
 while (GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_2) == 0) 
 { 
 bounce++; 
 } 
 if (bounce >700) 
 { 
 dec_param = 2; 
 return (dec_param); 
 } 
 } 
 bounce = 0; 
 } 
} 
 
 Ao entrar no modo de parametrização (apertar o botão USER), essa função é 
chamada. 
 Enquanto o usuário não apertar um dos botões externos, a função estará em 
LOOP permanente, esperando o usuário decidir, qual temperatura deseja 
parametrizar, a máxima ou a mínima. 
 
 
int ajust_temp_max(int temp_max) 
{ 
 GPIO_SetBits(GPIOC,GPIO_Pin_8); 
 GPIO_ResetBits(GPIOC,GPIO_Pin_9); 
 int aux_unid = 0; 
 int aux_dez = 0; 
 int aux_temp = 0; 
 int bounce = 0; 
 int confir = 0; 
 int tempo = 0; 
 aux_unid = temp_max%10; 
 aux_dez = temp_max/10; 
 while (1) 
 { 
 display_unid (aux_unid); 
 
 
 delay(); 
 display_dez (aux_dez); 
 if(GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_1) == 0) 
 { 
 while (GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_1) == 0) 
 { 
 bounce++; 
 } 
 if(bounce > 700) 
 { 
 aux_unid = aux_unid +1; 
 if (aux_unid == 10) 
 { 
 aux_unid = 0; 
 } 
 bounce =0; 
 } 
 } 
 if(GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_2) == 0) 
 { 
 while (GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_2) == 0) 
 { 
 bounce++; 
 } 
 if (bounce > 700) 
 { 
 aux_dez=aux_dez +1; 
 if(aux_dez == 10) 
 { 
 aux_dez = 0; 
 } 
 bounce = 0; 
 } 
 } 
 if (GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_0) == 1) 
 { 
 while (GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_0) == 1) 
 { 
 bounce++; 
 } 
 if(bounce > 700) 
 { 
 while (confir != 5) 
 { 
 GPIO_SetBits(GPIOC,GPIO_Pin_8); 
 GPIO_SetBits(GPIOC,GPIO_Pin_9); 
 for (tempo=0;tempo<=200000;tempo++); 
 GPIO_ResetBits(GPIOC,GPIO_Pin_8); 
 GPIO_ResetBits(GPIOC,GPIO_Pin_9); 
 for (tempo=0;tempo<=200000;tempo++); 
 confir++; 
 } 
 GPIO_ResetBits(GPIOC,GPIO_Pin_8); 
 GPIO_ResetBits(GPIOC,GPIO_Pin_9); 
 aux_temp = ((aux_dez*10)+aux_unid); 
 return (aux_temp); 
 } 
 } 
 bounce = 0; 
 } 
} 
 
 Função onde é feita a parametrização da temperatura (no caso, máxima), nas 
linhas: 
 
 
 
aux_unid = temp_max%10; 
aux_dez = temp_max/10; 
é feita o div e mod da temperatura máxima , para separar a dezena e unidade para 
variáveis separadas, para que possam ser ajustadas. 
 A função fica em LOOP permanente, enquanto o botão USER não for 
apertado. 
 Cada botão externo, incrementa em 1 unidade (ou na dezena ou na unidade), 
o valor da temperatura, caso o valor chegue a 9, ao pressionar o botão novamente, 
o mesmo volta a 0. 
 Após escolher o valor máximo para a temperatura e pressionar o botão 
USER, o valor temp_max é substituído pelo novo valor de temperatura 
parametrizado, os LED’s do micro controlador piscam em conjunto por um tempo, 
informando para o usuário que o novo valor foi aceito e está salvo na memória. 
 
 
int ajust_temp_min(int temp_min) 
{ 
 GPIO_ResetBits(GPIOC,GPIO_Pin_8); 
 GPIO_SetBits(GPIOC,GPIO_Pin_9); 
 int aux_unid = 0; 
 int aux_dez = 0; 
 int aux_temp = 0; 
 int bounce = 0; 
 int confir = 0; 
 int tempo = 0; 
 aux_unid = temp_min%10; 
 aux_dez = temp_min/10; 
 while (1) 
 { 
 display_unid (aux_unid); 
 delay(); 
 display_dez (aux_dez); 
 if(GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_1) == 0) 
 { 
 while (GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_1)== 0) 
 { 
 bounce++; 
 } 
 if (bounce > 700) 
 { 
 aux_unid = aux_unid +1; 
 if (aux_unid == 10) 
 { 
 aux_unid = 0; 
 } 
 bounce = 0; 
 } 
 } 
 if(GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_2) == 0) 
 { 
 while(GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_2) == 0) 
 { 
 bounce++; 
 } 
 if(bounce>700) 
 { 
 aux_dez = aux_dez +1; 
 if(aux_dez == 10) 
 { 
 aux_dez = 0; 
 } 
 bounce = 0; 
 
 
 } 
 } 
 if (GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_0) == 1) 
 { 
 while (GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_0) == 1) 
 { 
 bounce++; 
 } 
 if(bounce > 700) 
 { 
 while (confir != 5) 
 { 
 GPIO_SetBits(GPIOC,GPIO_Pin_8); 
 GPIO_SetBits(GPIOC,GPIO_Pin_9); 
 for (tempo=0;tempo<=200000;tempo++); 
 GPIO_ResetBits(GPIOC,GPIO_Pin_8); 
 GPIO_ResetBits(GPIOC,GPIO_Pin_9); 
 for (tempo=0;tempo<=200000;tempo++); 
 confir++; 
 } 
 GPIO_ResetBits(GPIOC,GPIO_Pin_8); 
 GPIO_ResetBits(GPIOC,GPIO_Pin_9); 
 aux_temp = ((aux_dez*10)+aux_unid); 
 return (aux_temp); 
 } 
 } 
 bounce = 0; 
 } 
} 
 
 Função de Parametrização para a temperatura mínima. Funciona de forma 
análoga a função de Parametrização de temperatura máxima, anteriormente 
explanado. 
 
 
void delay () 
{ 
 int aux = 0; 
 for(aux=0;aux<=20000;aux++); 
} 
 
 Função Delay, para ajustar as trepidações do clock, ou dar um espaço de 
tempo entre a execução de uma função e outra. 
 
 
int main () 
{ 
 
 int valor = 0; 
 int ctrl = 0; 
 int temp_max = 99; 
 int temp_min = 00; 
 int unid=0; 
 int dez=0; 
 int bounce=0; 
 int parametro = 0; 
 int cont = 200; 
 int aux1=0; 
 Config_portas(); 
 ADC_Config(); 
 Config_Led(); 
 Config_clock(); 
 
 
 while (1) 
 { 
 cont++; 
 if (cont > 200) 
 { 
 valor = readAnalogica1(); 
 ctrl = ((100*valor)/4096); 
 cont = 0; 
 } 
 unid = ctrl%10; 
 dez = ctrl/10; 
 display_unid (unid); 
 delay(); 
 display_dez (dez); 
 delay(); 
 rele(ctrl,temp_max,temp_min); 
 if (GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_0) == 1) 
 { 
 while (GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_0) == 1) 
 { 
 bounce++; 
 } 
 if (bounce > 700) 
 { 
 parametro = parame_dec(); } 
 if (parametro == 1) 
 { 
 temp_max = ajust_temp_max(temp_max); 
 } 
 if (parametro == 2) 
 { 
 temp_min = ajust_temp_min(temp_min); 
 } 
 } 
 bounce = 0; 
 parametro = 0; 
 valor = 0; 
 } 
} 
 
 Função Main, onde há toda a declaração das variáveis globais, e as 
chamadas das funções, já descritas anteriormente. 
 O que vale atentar, que há de diferente no corpo da função main são as 
linhas: 
valor = readAnalogica1(); 
ctrl = ((100*valor)/4096); 
Onde é chamada a função para a conversão ADC. 
A função readAnalogica1 retorna para a função main, um endereço de 
memória de 16-bits, e a variável valor é do tipo inteira (int). 
A ideia foi, já que para os micro controladores, números decimais, são 
guardados em memória como suas respectivas representações binarias, foi que, ao 
transferirmos os bits da conversão ADC para uma variável do tipo int, o próprio 
micro controlador convertesse essa série de bits em número decimal, para ficar mais 
plausível de se trabalhar com os valores coletados da conversão. 
Logo em seguida temos, como já discutido anteriormente na sessão de 
funcionamento do programa, a linha que faz a conversão do nível de tensão em 
temperatura. 
Vale detalhar que, o nível de precisão do sensor projetado, não entra em 
valores decimais, sendo somente inteiro, devido ao fato da variável ctrl ser do tipo 
int. 
 
 
 
CONCLUSÕES 
Ao termino do projeto, pudemos tirar uma série de lições a cerca de eletrônica 
(tanto analógica quanto digital), quanto a organização dos projetos. 
Tivemos que pesquisar, para projetar o circuito analógico, e descobrir a 
melhor configuração de resistências para o circuito de amplificador de resistências. 
Assim como, a solução de usar as mesmas portas de saída para mandar para 
os displays de unidade e dezena, números diferentes, sendo esses mesmos 
displays ligados e desligados em alta velocidade de permutação, para que o efeito 
de memória da retina fosse utilizado junto com a incapacidade dos olhos 
perceberem mudanças acima de uma determinada velocidade, fazendo o usuário ter 
a falsa impressão de que ambos os displays estavam simultaneamente ligados. 
Outro ponto que é importante salientar foi no desenvolvimento do software, 
que foi feito de forma mais estrutural possível, a ponto de simplificar o entendimento 
e fazer melhorias. 
O software passou por várias modificações desde a versão original, para que 
uma versão funcional fosse apresentada. 
Houveram dificuldades na parte da lógica de parametrização das 
temperaturas, assim como a execução do mesmo, devido as trepidações de clock, 
quando um botão era acionado. 
E não menos importante, as dificuldades encontradas para interfacear a parte 
Analógica, com a parte Digital. Colocar junto, aquilo que sempre foi estudado em 
separado e interfacea-las entre si 
Portanto houveram dificuldades durante o projeto, houveram dificuldades que 
foram superadas com pesquisa e debates, para que pudéssemos apresentar um 
modelo funcional.