Relatório de aplicações de Microcontroladores output

Prévia do material em texto

UNIVERSIDADE FEDERAL DO MARANHÃO – UFMA 
CENTRO DE CIÊNCIAS EXATAS - CCET 
CURSO DE ENGENHARIA ELÉTRICA 
JESSICA SABRINA DE JESUS SOUSA 
JOÃO PAULO CASTRO OLIVEIRA 
 
 
 
 
 
 
I EXPERIMENTO 
LABORATÓRIO DE APLICAÇÃO COM MICROCOMPUTADORES 
 
 
 
 
 
 
 
 
 
 
SÃO LUÍS - MA 
2018 
 
JESSICA SABRINA DE JESUS SOUSA 
JOÃO PAULO CASTRO OLIVEIRA 
 
 
 
 
 
 
 
 
 
I EXPERIMENTO 
LABORATÓRIO DE APLICAÇÃO COM MICROCOMPUTADORES 
 
 
 
 
 
 
 
 
 
 
SÃO LUIS - MA 
2018 
Relatório apresentado com o objetivo de 
avaliar os conhecimentos referente à cadeira 
de Laboratório de Aplicação com 
Microcomputadores, ministrada pelo Prof. 
Denivaldo Lopes. 
LISTA DE FIGURAS 
Figura 1. Cruzamento de duas ruas ................................................................................................. 9 
Figura 2. Diagrama de blocos do experimento 1.............................................................................. 9 
Figura 3. Comando de um tanque de produtos químicos .............................................................. 12 
Figura 4. Diagrama de blocos do experimento 2 ........................................................................... 13 
Figura 5. Diagrama de blocos do experimento 3 ........................................................................... 17 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
LISTA DE TABELAS 
Tabela 1. Tabela Verdade do experimento 1 ................................................................................... 9 
Tabela 2. Tabela Verdade do experimento 2 ................................................................................. 13 
Tabela 3. Tabela Verdade do experimento 3 ................................................................................. 17 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
SUMÁRIO 
 
1. INTRODUÇÃO ..................................................................................................................................... 6 
1.1 Data e Local dos Experimentos ...................................................................................................... 6 
1.2 Contexto Tecnológico.................................................................................................................... 6 
1.3 Material Utilizado ......................................................................................................................... 8 
1.4 Metodologia ................................................................................................................................. 8 
2. DESENVOLVIMENTO ........................................................................................................................... 8 
2.1 Experimento 1: ............................................................................................................................. 8 
2.2 Experimento 2: ........................................................................................................................... 12 
2.3 Experimento 3: ........................................................................................................................... 16 
3. ANÁLISE DOS RESULTADOS ............................................................................................................... 20 
4. CONCLUSÃO ..................................................................................................................................... 21 
5. REFERÊNCIAS BIBLIOGRÁFICAS ......................................................................................................... 21 
 
 
 
 
 
 
 
 
 
 
 
 
 
1. INTRODUÇÃO 
A ferramenta CodeWarrior se configura com um ambiente de desenvolvimento 
integrado (IDE) para edição, compilação e depuração de software desenvolvido pela 
corporação Freescale Semiconductor (manufaturadora de semicondutores), para vários 
microcontroladores, microprocessadores e sinal controlados voltados para os mercados 
de sistemas embarcados e comunicações para seus chips. 
Em se tratando de linguagens de programação necessária para tal 
desenvolvimento, as mais usadas para o uso em microcontroladores são as linguagens 
C e Assembly. É possível a ativação de um LED com a linguagem de programação 
C e assembly, dentre outras infinitas possibilidades de uso. A programação embarcada 
refere-se ao estudo de programação em microcontroladores e microprocessadores para 
controlar seus periféricos e manipular circuitos externos. A diferença entre programação 
em um dispositivo PC ou eletrônico comum e de um embarcado, são as limitações de 
recursos, como falta de memória, falta de um sistema operacional completo, limitações 
nas formas de comunicação com o mundo externo e requisitos limitados de tempo de 
resposta para realizar uma tarefa que deve ser tratado pelo sistema embarcado. Em 
geral, só se conta com poucos serviços básicos providos pelo hardware ou por 
um software básico. Sistemas embarcados são projetados para executar tarefas 
específicas, que comparado a um computador que tem uma finalidade de realização de 
multitarefas. 
Estes conceitos se desenvolverão melhor com o uso de tais ferramentas no 
decorrer da apresentação deste relatório. Apresentaremos as etapas do desenvolvimento 
de projetos voltados para programação embarcada, utilizando resumidamente o Kit de 
desenvolvimento para família HCS12 em adição com o ambiente de desenvolvimento 
integrado (CodeWarrior). Resolveremos, dessa forma, as situações-problema propostas. 
1.1 Data e Local dos Experimentos 
Os experimentos aqui citados, foram realizados no dia 12 de setembro de 2018 
no laboratório de aplicações de microcontroladores. 
1.2 Contexto Tecnológico 
Um microcontrolador pode ser definido como um single-chip computer 
(computador em um único chip), microcomputer, ou ainda como embedded controller. O 
termo MCU (Micro Controller Unit) também é bastante utilizado para se designar esse 
dispositivo. No mesmo chip estão integrados uma CPU, também chamada de core 
(núcleo), e circuitos auxiliares (periféricos) como memória de programa, memória de 
dados, circuito de clock, interface de comunicação serial, temporizadores/contadores, 
portas de I/O, etc. Esses diferentes recursos embutidos em um microcontrolador variam 
em função do modelo e do fabricante. É uma tarefa do desenvolvedor especificar o 
microcontrolador mais adequado para cada aplicação, neste experimento utilizaremos o 
HCS12 por sua característica didática. 
O HCS12 é uma família de microcontroladores da Freescale Semiconductor. Tem 
dois acumuladores de 8 bits A e B (referido como um único acumulador de 16 bits, D, 
quando A e B estão em cascata, de modo a permitir operações envolvendo 16 bits ), 
dois registradores de 16 bits X e Y, um contador de programa de 16 bits, um ponteiro de 
pilha de 16 bits e um Registro de Código de Condição de 8 bits . Ao contrário do 68HC11, 
o processador possui caminhos de dados internos de 16 bits. 
O Kit de Desenvolvimento HCS12 é uma ferramenta econômica para desenvolver 
código e avaliá-lo em MCUs da família HCS12 Dx, A e B. Este kit fácil de encomendar 
combina o Multilink do modo de depuração em segundo plano (BDM, Background Debug 
Mode) e um painel de avaliação (EVB). O EVB simplifica a avaliação do usuário de 
hardware e software protótipo, fornecendo o tempo essencial de MCU e circuitos de E / S, 
bem como uma área de protótipopara permitir a interface personalizada. O BDM Multilink 
faz a interface com o EVB através do conector BDM de 6 pinos para emulação em tempo 
real e programação rápida de flash. 
Em se tratando da placa de avaliação MCS12DP256 utilizada, temos como 
características: 
▪ Assembler, depurador de nível de montagem, vinculador e programador 
▪ 256K Bytes FLASH 
▪ Área de prototipagem 
▪ Conectores de cabeçalho para acesso às linhas de E / S e barramento do MCU 
▪ Comunicações RS232 
▪ Comunicação CAN 
▪ Multilink BDM 
▪ Ferramenta de desenvolvimento universal para todos os BDM 68HC12s e HCS12s 
▪ Emulação e depuração em tempo real no circuito 
▪ Programação rápida no circuito 
▪ Detecta automaticamente a frequência 
▪ Tamanho discreto pequeno (aproximadamente 3 "x 2" x 3/4 ") 
▪ Suporta alvos de 2 V a 5,5 V 
▪ Edição Especial, HC(S) 12 Ambiente de Desenvolvimento Integrado CodeWarrior 
▪ Suporte para programação de debugger, assembler, linker e flash 
▪ Compilador de Avaliação C 
1.3 Material Utilizado 
Lista de materiais: 
• Hardware: 
- Microcomputador (processador core i5-XXXX, RAM 8 GB, HD 1TB, Monitor 17”); 
- Kit de desenvolvimento para HCS12: APS12C128SLK [Ref1]; 
- Kit de desenvolvimento para HCS12 (placa de expansão): SLK0109UG [Ref2]; 
• Software: 
- Sistema operacional: Windows 7 64 bits; 
- Ambiente de desenvolvimento integrado (IDE): CodeWarrior versão 5.1; 
1.4 Metodologia 
O trabalho é desenvolvido para os seguintes problemas em 3 etapas: definir 
soluções por meio da álgebra booleana, aplicar respectivamente ao programa 
CodeWarrior com a linguagem C e teste na placa. 
A primeira etapa, analisando cada problema proposto, é desenvolvida 
naturalmente com tabela verdade, seguidamente dos mapas de Karnaugh e com estes 
definindo-se as equações booleanas para cada uma das n saídas. 
Na segunda etapa com o software indicado, faz-se configuração de entradas e 
saídas de cada variável criada nos respectivos pinos selecionados, seguidamente aplica-
se o código na linguagem C, mesclando as funcionalidades de cada variável. Nos casos 
decorrentes todas as equações booleanas são representadas por ifs e dentro de um loop 
infinito que sempre testará a entrada na placa. Finalizado se faz o teste do programa no 
kit com os leds representando as saídas. 
2. DESENVOLVIMENTO 
2.1 Experimento 1: 
Nesta primeira parte, temos como objetivo elaborar e escrever um programa em C 
para HCS12 no ambiente CodeWarrior, além de testá-lo no kit APS12 da freescale. Nossa 
problemática se norteia na implementação de um sistema de semáforo, para um 
cruzamento de duas ruas, como ilustra a imagem abaixo: 
 
Figura 1. Cruzamento de duas ruas 
Dessa forma, definimos as possibilidades de operação desse sistema, sabemos 
que existem dois sensores localizados na Rua A e na Rua B, respectivamente, que são 
usados para detecção de veículos nas duas ruas. Com isso, podemos dizer que quando 
não há veículos em ambas ruas, os sinais verdes da Rua A e vermelho da Rua B estão 
acionados, em contrapartida os sinais vermelhos da Rua A e verde da Rua B estão 
desligados, caracterizando a Rua A como preferencial. Da mesma forma ocorre quando 
há veículos em ambas as ruas ou somente na Rua A. E, finalmente, quando não existem 
veículos na Rua A e existem na Rua B, os sinais vermelhos da Rua A e verde da Rua B 
estão acionados, além dos sinais verde da Rua A e vermelho da Rua B estarem 
desligados. 
Observe que, analisando com cuidado, o sinal verde da Rua A equivale ao sinal 
vermelho da Rua B, assim como os sinais verde da Rua B e vermelho da Rua A também. 
Assim, reduzimos o número de saídas de quatro para duas, otimizando a solução. Agora, 
para o melhor desenvolvimento do projeto, sintetizamos o problema no diagrama de 
blocos abaixo: 
 
Figura 2. Diagrama de blocos do experimento 1 
Atribuiu-se como entrada o Sensor A (sensor localizado na Rua A) e Sensor B 
(sensor localizado na Rua B). Temos, também, que as saídas foram identificadas, são 
elas: sinal principal verde / secundário vermelho, que chamaremos agora somente de 
LED1, e o sinal principal vermelho / secundário verde, que chamaremos agora somente 
de LED2. 
Nesta etapa, necessitamos de uma lógica do problema, para aplicarmos no 
desenvolvimento do código do programa em linguagem C. Assim, construímos a tabela 
verdade da problemática abaixo, incluindo todas as possibilidades deste. 
SENSOR A (A) SENSOR B (B) LED1 LED2 
0 0 1 0 
0 1 0 1 
1 0 1 0 
1 1 1 0 
Tabela 1. Tabela Verdade do experimento 1 
Dessa tabela, pode-se extrair as expressões que regem as saídas em função das 
entradas por meio de mapas de Karnaugh: 
• Para encontrar Verde A e Vermelho B: 
 A 
B 0 1 
 0 1 1 
 1 0 1 
 
Assim obtemos a seguinte expressão: LED1 = A + (B!) 
• Para encontrar Vermelho A e Verde B: 
 A 
B 0 1 
 0 0 0 
 1 1 0 
 
Assim obtemos a seguinte expressão: LED2 = (A!)B 
 Nesta altura do desenvolvimento do projeto, já é possível rescrever o código 
apropriado, que será apresentado abaixo: 
/** ################################################################### 
** Filename : Project_3.c 
** Project : Project_3 
** Processor : MC9S12C128CFU16 
** Version : Driver 01.14 
** Compiler : CodeWarrior HC12 C Compiler 
** Date/Time : 05/09/2018, 23:11 
** Abstract : 
** Main module. 
** This module contains user's application code. 
** Settings : 
** Contents : 
** No public methods 
** 
** ###################################################################*/ 
/* MODULE Project_3 */ 
 
/* Including needed modules to compile this module/procedure */ 
#include "Cpu.h" 
#include "Events.h" 
#include "P1.h" 
#include "P2.h" 
#include "S1.h" 
#include "S2.h" 
#include "led1.h" 
#include "led2.h" 
/* Include shared modules, which are used for whole project */ 
#include "PE_Types.h" 
#include "PE_Error.h" 
#include "PE_Const.h" 
#include "IO_Map.h" 
 
/* User includes (#include below this line is not maintained by Processor Expert) */ 
 
void main(void) 
{ 
 /* Write your local variable definition here */ 
 
 /*** Processor Expert internal initialization. DON'T REMOVE THIS CODE!!! ***/ 
 PE_low_level_init(); 
 /*** End of Processor Expert internal initialization. ***/ 
 
 /* Write your code here */ 
 for(;;){ 
 
 
 if(SensorA_GetVal()!=0 || SensorB_GetVal()==0) /*LED1 = A + (B!)*/ 
 led1_ClrVal(); 
 else 
 led1_SetVal(); 
 ; 
 
 
 
 if(SensorA_GetVal()==0 && SensorB_GetVal()!=0)/*LED2 = (A!)B 
 led2_ClrVal(); 
 else 
 led2_SetVal(); 
 
 
 } 
 /*** Processor Expert end of main routine. DON'T MODIFY THIS CODE!!! ***/ 
 for(;;){} 
 /*** Processor Expert end of main routine. DON'T WRITE CODE BELOW!!! ***/ 
} /*** End of main routine. DO NOT MODIFY THIS TEXT!!! ***/ 
 
/* END Project_3 */ 
/* 
** ################################################################### 
** 
** This file was created by Processor Expert 3.02 [04.44] 
** for the Freescale HCS12 series of microcontrollers. 
** 
** ################################################################### 
*/ 
2.2 Experimento 2: 
Nesta segunda parte, temos o mesmo objetivo de elaborar e escrever um 
programa em C para HCS12 no ambiente CodeWarrior, testaremos no mesmo Kit. Porém 
nossa problemática agora é de criar um sistemacomputacional que comande o 
funcionamento de uma eletroválvula de entrada, uma eletroválvula de saída e um 
interruptor de liga e desliga. 
 
Figura 3. Comando de um tanque de produtos químicos 
Para melhor implementação do projeto, adicionamos mais dois níveis, assim 
teremos os níveis Alto, Médio e Baixo, que são, na prática, sensores que indicam a 
quantidade de líquido contido no reservatório, além disso, temos um interruptor I, que liga 
ou desliga o sistema. Dessa forma, pode-se determinar as condições de operação do 
tanque. Temos que: 
➢ Quando I for acionado, liga-se o sistema. 
➢ Com I acionado, se o nível A estiver acionado, a eletroválvula de saída é 
ligada e a de entrada ligadas, para evitar o transbordamento. 
➢ Com I acionado e nível A desligado, se o nível M estiver acionado, a 
eletroválvula de saída e de entrada estarão ligadas. 
➢ Com I acionado e nível A e M desligado, se o nível B estiver acionado ou 
não, a eletroválvula de saída é desligada e de entrada estará ligada, para 
evitar que a bomba queime. 
➢ Com I desligado, se nível A ou M ou B estiver acionado, a eletroválvula de 
saída é ligada e a de entrada desligada. 
➢ Com I desligado, se todos os níveis estiverem desligados, a eletroválvula 
de saída e de entrada estarão desligadas. 
Agora, para o melhor desenvolvimento do projeto, sintetizamos o problema no 
diagrama de blocos abaixo: 
 
Figura 3. Diagrama de blocos do experimento 2 
Atribuiu-se como entrada os sensores de níveis, assim temos como entrada o 
Nível Alto (A), Nível Médio (M) e Nível Baixo (B), além da entrada de controle (I). E como 
saída temos as eletroválvulas de entrada e saída. 
Nesta etapa, necessitamos de uma lógica do problema, para aplicarmos no 
desenvolvimento do código do programa em linguagem C. Assim, construímos a tabela 
verdade da problemática abaixo, incluindo todas as possibilidades deste. 
I 
Nível Alto 
(A) 
Nível Médio 
(M) 
Nível 
Baixo (B) 
Eletroválvula de 
Entrada (E) 
Eletroválvula de 
Saída (S) 
0 0 0 0 0 0 
0 0 0 1 0 1 
0 0 1 0 0 1 
0 0 1 1 0 1 
0 1 0 0 0 1 
0 1 0 1 0 1 
0 1 1 0 0 1 
0 1 1 1 0 1 
1 0 0 0 1 0 
1 0 0 1 1 0 
1 0 1 0 1 1 
1 0 1 1 1 1 
1 1 0 0 0 1 
1 1 0 1 0 1 
1 1 1 0 0 1 
1 1 1 1 0 1 
 
Dessa tabela, pode-se extrair as expressções que regem as saídas em função 
das entradas por meio de mapas de Karnaugh: 
Para encontrar Eletroválvula de Entrada (E): 
 IA 
MB 00 01 11 10 
 00 0 0 0 1 
 01 0 0 0 1 
 11 0 0 0 1 
 10 0 0 0 1 
 
Para encontrar Eletroválvula de Saída (S): 
 IA 
MB 00 01 11 10 
 00 0 1 1 0 
 01 1 1 1 0 
 11 1 1 1 1 
 10 1 1 1 1 
Assim obtemos as seguintes expressões: 
E = I(A!) 
S = A+M+B(I!) 
 Nesta altura do desenvolvimento do projeto, já é possível rescrever o código 
apropriado, que será apresentado abaixo: 
/** ################################################################### 
** Filename : Eletrovalvula.c 
** Project : Eletrovalvula 
** Processor : MC9S12C128CFU16 
** Version : Driver 01.14 
** Compiler : CodeWarrior HC12 C Compiler 
** Date/Time : 08/09/2018, 12:35 
** Abstract : 
** Main module. 
** This module contains user's application code. 
** Settings : 
** Contents : 
** No public methods 
** 
** ###################################################################*/ 
/* MODULE Eletrovalvula */ 
 
/* Including needed modules to compile this module/procedure */ 
#include "Cpu.h" 
#include "Events.h" 
#include "I.h" 
#include "A.h" 
#include "M.h" 
#include "B.h" 
#include "Entrada.h" 
#include "Saida.h" 
/* Include shared modules, which are used for whole project */ 
#include "PE_Types.h" 
#include "PE_Error.h" 
#include "PE_Const.h" 
#include "IO_Map.h" 
 
/* User includes (#include below this line is not maintained by Processor Expert) */ 
 
void main(void) 
{ 
 /* Write your local variable definition here */ 
 
 /*** Processor Expert internal initialization. DON'T REMOVE THIS CODE!!! ***/ 
 PE_low_level_init(); 
 /*** End of Processor Expert internal initialization. ***/ 
 
 /* Write your code here */ 
for(;;){ 
 
 if(I_GetVal()!=0 && A_GetVal()==0){ 
 Entrada_ClrVal(); 
 } 
 else{ 
 Entrada_SetVal(); 
 } 
 
 if(A_GetVal()!=0 || M_GetVal()!=0 || (B_GetVal()!=0 || I_GetVal()==0)) { 
 Saida_ClrVal(); 
 
 }else{ 
 Saida_SetVal(); 
 } 
 
} 
 
 /*** Processor Expert end of main routine. DON'T MODIFY THIS CODE!!! ***/ 
 for(;;){} 
 /*** Processor Expert end of main routine. DON'T WRITE CODE BELOW!!! ***/ 
} /*** End of main routine. DO NOT MODIFY THIS TEXT!!! ***/ 
 
/* END Eletrovalvula */ 
/* 
** ################################################################### 
** 
** This file was created by Processor Expert 3.02 [04.44] 
** for the Freescale HCS12 series of microcontrollers. 
** 
** ################################################################### 
* / 
2.3 Experimento 3: 
Neste último experimento, temos o mesmo objetivo de elaborar e escrever um 
programa em C para HCS12 no ambiente CodeWarrior, testaremos no mesmo Kit. Porém 
nossa problemática agora é elaborar um sistema computacional que selecione 
prioritariamente o preenchimento de uma correia transportadora de uma indústria a partir 
de alimentadores de pátios A, B, C e D. 
Dessa forma, definimos as possibilidades de operação desse sistema, sabemos 
que o preenchimento das correias transportadora é dada por meio da prioridade de cada 
pátio, tendo que: 
➢ Pátio A: Prioridade 1 (maior prioridade) 
➢ Pátio B: Prioridade 2 
➢ Pátio C: Prioridade de 3 
➢ Pátio D: Prioridade 4 (menor prioridade) 
Assim, cada pátio detém um sensor que indicará se este se encontra cheio ou 
vazio, assim cada correia trabalhará sozinha, caso o Pátio A esteja cheio, somente a 
correia 1 funcionará, caso Pátio A esteja vazio e o Pátio B cheio, somente a correia 2 
funcionará, caso Pátio A e Pátio B esteja, vazios e o Pátio C cheio, somente a correia 3 
funcionará, caso Pátio A, Pátio B e Pátio C estejam vazios e o Pátio D cheio, somente a 
correia 4 funcionará, caso todos os pátios estejam vazios, a coreia funcionará sozinha. 
Agora, para o melhor desenvolvimento do projeto, sintetizamos o problema no 
diagrama de blocos abaixo: 
 
Figura 3. Diagrama de blocos do experimento 3 
Atribuiu-se como entrada os sensores dos pátios, assim temos como entrada o 
Pátio A, Pátio B, Pátio C e Pátio D. E como saída temos as correias 1, 2, 3 e 4. 
Nesta etapa, necessitamos de uma lógica do problema, para aplicarmos no 
desenvolvimento do código do programa em linguagem C. Assim, construímos a tabela 
verdade da problemática abaixo, incluindo todas as possibilidades deste. 
Pátio A 
(A) 
Pátio B 
(B) 
Pátio C 
(C) 
Pátio D 
(D) 
Correia 
1 (C1) 
Correia 
2 (C2) 
Correia 
3 (C3) 
Correia 4 
(C4) 
0 0 0 0 1 0 0 0 
0 0 0 1 0 0 0 1 
0 0 1 0 0 0 1 0 
0 0 1 1 0 0 1 0 
0 1 0 0 0 1 0 0 
0 1 0 1 0 1 0 0 
0 1 1 0 0 1 0 0 
0 1 1 1 0 1 0 0 
1 0 0 0 1 0 0 0 
1 0 0 1 1 0 0 0 
1 0 1 0 1 0 0 0 
1 0 1 1 1 0 0 0 
1 1 0 0 1 0 0 0 
1 1 0 1 1 0 0 0 
1 1 1 0 1 0 0 0 
1 1 1 1 1 0 0 0 
Dessa tabela, pode – se extrair as expressões que regem as saídas em função das 
entradas por meio de mapas de Karnaugh: 
Para encontrar Correia 1 (C1): 
 AB 
CD 00 01 11 10 
 00 1 0 1 1 
 01 0 0 1 1 
 11 0 0 1 1 
 10 0 0 1 1 
 
Para encontrarCorreia 2 (C2): 
 AB 
CD 00 01 11 10 
 00 0 1 0 0 
 01 0 1 0 0 
 11 0 1 0 0 
 10 0 1 0 0 
 
Para encontrar Correia 3 (C3): 
 AB 
CD 00 01 11 10 
 00 0 0 0 0 
 01 0 0 0 0 
 11 1 0 0 0 
 10 1 0 0 0 
 
Para encontrar Correia 4 (C4): 
 AB 
CD 00 01 11 10 
 00 0 0 0 0 
 01 1 0 0 0 
 11 0 0 0 0 
 10 0 0 0 0 
 
Assim obtemos a seguinte expressão: 
 C1 = A + (C+D+B)! 
 C2 = (A!)B 
C3 = (A+B)!C 
C4 = (A+B+C)!D 
 
 Nesta altura do desenvolvimento do projeto, já é possível rescrever o código 
apropriado, que será apresentado abaixo: 
/* Including needed modules to compile this module/procedure */ 
#include "Cpu.h" 
#include "Events.h" 
#include "A.h" 
#include "B.h" 
#include "C.h" 
#include "D.h" 
#include "LED1.h" 
#include "LED2.h" 
#include "LED3.h" 
#include "LED4.h" 
/* Include shared modules, which are used for whole project */ 
#include "PE_Types.h" 
#include "PE_Error.h" 
#include "PE_Const.h" 
#include "IO_Map.h" 
 
/* User includes (#include below this line is not maintained by Processor Expert) */ 
 
void main(void) 
{ 
 /* Write your local variable definition here */ 
 
 /*** Processor Expert internal initialization. DON'T REMOVE THIS CODE!!! ***/ 
 PE_low_level_init(); 
 /*** End of Processor Expert internal initialization. ***/ 
 
 /* Write your code here */ 
 
for(;;){ 
 
 if(A_GetVal()!=0 || (B_GetVal()==0 && C_GetVal()==0 && D_GetVal()==0)) /*led1*/ 
 LED1_ClrVal(); 
 else 
 LED1_SetVal(); 
 
 if(A_GetVal()==0 && B_GetVal()!=0)/*led2*/ 
 LED2_ClrVal(); 
 else 
 LED2_SetVal(); 
 
 if(A_GetVal()==0 && B_GetVal()==0 && C_GetVal()!=0)/*led3*/ 
 LED3_ClrVal(); 
 else 
 LED3_SetVal(); 
 
 if(A_GetVal()==0 && B_GetVal()==0 && C_GetVal()==0 && D_GetVal()!=0) 
 LED4_ClrVal(); 
 else 
 LED4_SetVal(); 
} 
 
 /*** Processor Expert end of main routine. DON'T MODIFY THIS CODE!!! ***/ 
 for(;;){} 
 /*** Processor Expert end of main routine. DON'T WRITE CODE BELOW!!! ***/ 
} /*** End of main routine. DO NOT MODIFY THIS TEXT!!! ***/ 
 
/* END CorreiaTransportadora */ 
/* 
** ################################################################### 
** 
** This file was created by Processor Expert 3.02 [04.44] 
** for the Freescale HCS12 series of microcontrollers. 
** 
** ################################################################### 
*/ 
3. ANÁLISE DOS RESULTADOS 
O primeiro projeto com o semáforo apresenta led da rua preferencial ligado a 
qualquer instante, com exceção de quando a rua secundária apresenta carro e a 
preferencial não, ligando seu respectivo led. Os sensores no caso são equivalentes a 
informação de SW1 e SW2. 
Com a eletroválvula ocorre de informar o enchimento do tanque por meio dos 
sensores e botão on/off utilizados no DIP Switch(SW3), testando o led da eletroválvula de 
entrada sempre estará desligado quando sistema for desligado e quando ligado, apenas 
em situação em que o tanque não está em nível alto. Para o led da eletroválvula de saída 
somente led apagado quando não há nível do líquido e quando sistema ligado ainda 
apresenta baixo nível, logo após início do processo. 
Por fim com a correia transportadora utilizou-se do DIP Switch (SW3) e todos os 
leds da porta B, representado em qual pátio a correia estará para transportar o minério. 
De tal modo como nas na tabela verdade sabe-se que sistema é de prioridade, assim 
bastou-se um bit mais significativo estar ativado para que o led acendesse para informar 
onde a correia está, além de estar no pátio A(MSB), quando todos os pátios estiverem 
vazios. 
 
4. CONCLUSÃO 
 
Em conformidade às situações foi observado com os casos que todos necessitam 
somente das equações booleanas aplicadas com a linguagem C no software 
CodeWarrior, além das utilizações de set e clear nas saídas estão relacionadas 
intimamente ao uso do kit APS120, não à linguagem em si. Todas as situações 
mostraram suficiente apenas o uso dos leds da porta B e de suas entradas em SW3 ou 
push buttons SW1 e SW2, estes últimos apenas no semáforo. N 
Conclui-se então que cada solução, sem utilizar a expansão do kit, seriam 
implementadas analogamente à um sistema real de sensores e lograriam êxito, assim 
expostas com sucesso nas simplificadas aplicações do microcontrolador HCS12 
requisitadas. 
5. REFERÊNCIAS BIBLIOGRÁFICAS 
 
<https://pt.wikipedia.org/wiki/Programa%C3%A7%C3%A3o_embarcada>. Acessado em 
21/11/2018. 
<http://www.dca.fee.unicamp.br/courses/EA871/2s2014/sites/default/files/pdf/Apostila%20
CW10.pdf>. Acessado em 21/11/2018. 
 
<http://cache.freescale.com/files/student_learning_kits/doc/fact_sheet/APS12C128SLK_F
S.pdf>. Acessado em 21/11/2018. 
 
<http://paginapessoal.utfpr.edu.br/gustavobborba/material/files/mc_nocoesGerais.pdf>. 
Acessado em 21/11/2018. 
 
<https://en.wikipedia.org/wiki/Freescale_68HC12>. Acessado em 21/11/2018. 
 
<https://www.nxp.com/products/processors-and-microcontrollers/additional-processors-
and-mcus/8-16-bit-mcus/16-bit-s12-and-s12x-mcus/hcs12-development-
kit:M68KIT912DP256>. Acessado em 21/11/2018.