UNIVERSIDADE FEDERAL DO ESPÍRITO SANTO

CENTRO TECNOLÓGICO
DEPARTAMENTO DE ENGENHARIA ELÉTRICA
PROJETO DE GRADUAÇÃO

ESTUDO E DESENVOLVIMENTO DE UM MICRO CLP DE

BAIXO CUSTO EM UM PIC

PAULO FRANKLIM MAIA RASKIM FERRUA

VITÓRIA – ES
02/2007
 PAULO FRANKLIM MAIA RASKIM FERRUA

ESTUDO E DESENVOLVIMENTO DE UM MICRO CLP DE

BAIXO CUSTO EM UM PIC

Parte manuscrita do Projeto de Graduação

do aluno Paulo Franklim Maia Raskim
Ferrua, apresentado ao Departamento de
Engenharia Elétrica do Centro
Tecnológico da Universidade Federal do
Espírito Santo, para obtenção do grau de
Engenheiro Eletricista.

VITÓRIA – ES
02/2007
 PAULO FRANKLIM MAIA RASKIM FERRUA

ESTUDO E DESENVOLVIMENTO DE UM MICRO CLP DE

BAIXO CUSTO EM UM PIC

COMISSÃO EXAMINADORA:

___________________________________
Prof. Dr. Paulo Farias Santos Amaral
Orientador

___________________________________
Prof. Dra. Raquel FrizeraVassallo
Examinadora

___________________________________
Prof. Dr. Alessandro Mattedi
Examinador

Vitória - ES, 23, Fevereiro, 2007

DEDICATÓRIA

À minha família, à minha namorada e aos meus amigos.

i
AGRADECIMENTOS

Agradeço ao professor Paulo Amaral pela sua importante ajuda quando já

estava sem saber o que fazer. Agradeço ao professor José Denti por nos apresentar o
CLP em sua disciplina de Supervisão e Controle de Processos.
Agradeço a meu companheiro Rogério Costa Pacheco Neto, que desenvolveu
um projeto complementar a este, pela ajuda e por facilitar a comunicação entre os
projetos.

ii
LISTA DE FIGURAS

Figura 1 Diagrama esquemático do Micro-CLP............................................................9 

Figura 2 Estrutura básica de funcionamento de um CLP ............................................14 
Figura 3 Diagrama lógico (esquerda) e programa ladder (direita) para o acionamento
de um motor. ................................................................................................................17 
Figura 4 - Circuito elétrico das entradas digitais .........................................................20 
Figura 5 - Circuito elétrico das saídas digitais.............................................................21 
Figura 6 - Circuito elétrico da entrada analógica.........................................................22 
Figura 7 - Circuito elétrico das saídas analógicas .......................................................23 
Figura 8 - Esquema de comunicação serial .................................................................24 
Figura 9 - Alocação da memória de programa ............................................................25 
Figura 10 - Alocação da memória de dados EEPROM ...............................................26 
Figura 11 - Fluxograma do programa residente ..........................................................29 
Figura 12 - Diagrama Ladder do controle do portão eletrônico ..................................39 
Figura 13 - Linguagem intermediária enviada ao Micro-Clp ......................................40 
Figura 14 - Vista frontal do Micro-CLP ......................................................................40 
Figura 15 - Vista superior do Micro-CLP....................................................................41 
Figura 16 - Vista lateral esquerda do Micro-CLP .......................................................41 
Figura 17 - Vista lateral direita do Micro-CLP ...........................................................41 
Figura 18 - Vista traseira do Micro-CLP .....................................................................42 
Figura 19 - Placa de entradas e saídas ........................................................................42 

iii
LISTA DE TABELA

Tabela 1 - Codificação das Instruções .........................................................................27 

Tabela 2 - Mapeamento das Variáveis.........................................................................28 

iv
GLOSSÁRIO
CLP Controlador Lógico Programável
EEPROM Electrically-Erasable Programmable Read-Only Memory
PLC Programmable Logic Controller.
PID Proporcional-Integral-Derivativo
PWM Pulse Width Modulation ou Modulação por Largura de Pulso

v
 SUMÁRIO

DEDICATÓRIA........................................................................................................... I 
AGRADECIMENTOS .............................................................................................. II 
LISTA DE FIGURAS ............................................................................................... III 
LISTA DE TABELA ................................................................................................ IV 
GLOSSÁRIO ............................................................................................................... V 
RESUMO ................................................................................................................ VIII 
1  INTRODUÇÃO ................................................................................................9 
1.1 Ferramentas Utilizadas......................................................................................10 
1.1.1 Compilador C CCS ..................................................................................10 
1.1.2 MPLAB ...................................................................................................11 
1.1.3 Eagle ........................................................................................................11 
2  CONTROLADOR LÓGICO PROGRAMÁVEL .......................................13 
2.1 Funcionamento do CLP ....................................................................................14 
2.2 Programação do CLP ........................................................................................15 
2.2.1 Linguagem LADDER ou Diagrama de Relés .........................................16 
3  DESENVOLVIMENTO DO HARDWARE ................................................18 
3.1 Microcontroladores PIC ....................................................................................18 
3.1.1 Características do PIC 16F877 ................................................................18 
3.2 Definições .........................................................................................................19 
3.3 Entradas Digitais ...............................................................................................19 
3.4 Saídas Digitais ..................................................................................................20 
3.5 Entradas Analógicas..........................................................................................21 
3.6 Saídas Analógicas .............................................................................................22 
3.7 A Fonte de Alimentação ...................................................................................23 
3.8 Display LCD .....................................................................................................23 
3.9 Botões................................................................................................................24 
3.10 Comunicação Serial ........................................................................................24 
4  DESENVOLVIMENTO DO PROGRAMA RESIDENTE ........................25 
4.1 Cabeçalho ..........................................................................................................25 
vi
 4.2 Instruções ..........................................................................................................26 
4.3 Variáveis ...........................................................................................................27 
4.4 Programação do PIC .........................................................................................29 
4.4.1 Entradas e Saídas Digitais .......................................................................29 
4.4.2 Entradas Analógicas ................................................................................30 
4.4.3 Controle do PWM ...................................................................................31 
4.4.4 Interrupções .............................................................................................31 
4.4.5 Cronômetros (Timers) .............................................................................32 
4.5 Rotinas ..............................................................................................................32 
4.5.1 Rotina Principal .......................................................................................33 
4.5.2 Carregamento do Ladder .........................................................................35 
4.5.3 Função AND() .........................................................................................37 
4.6 Monitorando o programa pela porta serial ........................................................37 
5  TESTES E RESULTADOS ...........................................................................38 
6  CONCLUSÕES ..............................................................................................43 
APÊNDICE A – CIRCUITO PRINCIPAL .............................................................44 
APÊNDICE B – CIRCUITO COMPLETO DE ENTRADAS DIGITAIS ...........45 
APÊNDICE C – CIRCUITO COMPLETO DE SAÍDAS DIGITAIS ..................46 
APÊNDICE D – CIRCUITO COMPLETO DE ENTRADAS ANALÓGICAS ..47 
APÊNDICE E – CIRCUITO COMPLETO DE SAÍDAS ANALÓGICAS .........48 
REFERÊNCIAS BIBLIOGRÁFICAS.....................................................................61 

vii
RESUMO
Este trabalho apresenta o estudo e o desenvolvimento de um micro PLC em
um microcontrolador da família PIC da empresa Microchip.
Para tal foi necessário estudar os PLCs do mercado, analisando suas
características e aplicações principais. As funcionalidades dos Micro-PLCs atuais
também foram observadas. A seguir estudou-se profundamente as características do
PIC 16F877, escolhido para desempenhar a função de micro PLC, a fim de adequar as
funções a serem implementadas.
De posse deste conhecimento foi possível projetar a interface de entradas e
saídas do Micro-PLC.
O micro PLC também é composto por um software capaz de executar um
programa específico de controle. Para o desenvolvimento desse software nativo no
PIC, algo como um mini-sistema operacional, estudou-se a linguagem de programação
C.

viii
 9

1 INTRODUÇÃO

A necessidade de automatizar sistemas tem impulsionado o desenvolvimento

de novos equipamentos. Os Controladores Lógicos Programáveis disponíveis no
mercado possuem um grande poder de processamento, capacidade de manipular uma
grande quantidade de variáveis digitais e analógicas. Esta capacidade possui um preço
que inviabiliza sua aplicação para sistemas com menor complexidade. Surgiu então a
alternativa de CLPs mais simples, possuindo assim um preço mais acessível. Este
projeto visa a pesquisa e o desenvolvimento de um CLP com poucas entradas e saídas
em um microcontrolador PIC garantindo assim um baixo custo e boa funcionalidade.
Na Figura 1 observa-se o esquema base do projeto.

Figura 1 Diagrama esquemático do Micro-CLP

 10

Este projeto foi elaborado a partir das seguintes etapas:

1. Estudo dos micro PLCs
2. Definição das especificações do projeto
3. Implementação da placa de interface entradas/saídas
4. Estudo e definição do programa base executado pelo PIC

1.1 Ferramentas Utilizadas

O código a ser desenvolvido deve ser escrito, testado, e armazenado na ROM
do microcontrolador. Normalmente o software é escrito e compilado em um PC e
então carregado na ROM como código de máquina. Se o programa é escrito em
linguagem assembler, o PC tem que ter um compilador para gerar o código de
máquina para o microcontrolador.
Para microcontroladores PIC a programação é realizada mediante o aplicativo
MPLAB. Este software está disponível para download grátis na internet
(www.microchip.com). Programar um PIC utilizando linguagem assembler pode ser
no princípio muito difícil e poderia resultar em um extenso procedimento de
depuração. Felizmente compiladores de linguagem de alto nível estão disponíveis e
nos permitem programar o PIC a um nível mais amigável. Neste projeto é utilizado um
compilador C chamado CCS.

1.1.1 Compilador C CCS

O compilador C CCS inclui uma biblioteca de programas de exemplo para
muitas aplicações comuns. Cada programa de exemplo contém um cabeçalho com
instruções de como rodar o exemplo, e se necessário, as instruções de instalação
elétrica para conectar dispositivos externos [3]. Na programação do PIC este arquivo
compilado aparecerá como um arquivo '.hex'.
O compilador inclui muitas funções em forma de bibliotecas para acessar o
hardware de PIC.
 11

1.1.2 MPLAB
O MPLAB é um programa que tem a função de um gerenciador, para o
desenvolvimento de projetos com a família PIC de microcontroladores. É distribuído
gratuitamente pela Microchip, fabricante dos PICs.
O MPLAB integra num único ambiente o editor de programa fonte, o
compilador, o simulador e quando conectado às ferramentas da Microchip também
integra o gravador do PIC, o emulador etc.
O Programa fonte, ou simplesmente fonte do programa é uma seqüência em
texto, escrita numa linguagem de programação que será convertida em códigos de
máquina para ser gravado no PIC.
O Compilador é o programa que converte o fonte em códigos de máquina.
O Simulador é o programa que simula o funcionamento da CPU (PIC),
conforme o programa fonte que está sendo desenvolvido.
O Projeto no MPLAB é um conjunto de arquivos e informações que diz ao
ambiente integrado qual o PIC que estamos usando, qual freqüência de clock, qual a
linguagem de programação usada, qual o layout das janelas etc. Enfim o projeto é o
nosso trabalho de uma forma global. E para ele guardar todas essas informações basta
salvar e fechar só o projeto, sem se preocupar em fechar todas as janelas abertas no
ambiente integrado [4].
É importante lembrar que o MPLAB se integra ao ambiente Windows,
permitindo cópia de arquivos, de textos de um aplicativo para outro de uma forma bem
simplificada.

1.1.3 Eagle
Este software é utilizado para desenhar circuitos impressos e esquemas
eletrônicos. Eagle é a sigla para Easily Applicable Graphical Layout Editor.
Os componentes são arranjados manualmente na placa, com a ajuda das linhas
coloridas que mostram as conexões eventuais entre os pinos que são requeridos pelo
diagrama esquemático, isto ajuda a encontrar uma colocação que permita a disposição
mais eficiente das trilhas [7].
 12

Este relatório apresenta os conceitos necessários para a elaboração do projeto,

assim como seus resultados. No Capítulo 2 será apresentado o controlador lógico
programável. O Capítulo 3 apresenta o PIC16F877. O Capítulo 4 mostra o
desenvolvimento do hardware. O Capítulo 5 mostra o desenvolvimento do programa
residente. O Capítulo 6 apresenta os resultado obtidos, e Capítulo 7 conclui o trabalho.
 13

2 CONTROLADOR LÓGICO PROGRAMÁVEL

Um Controlador Lógico Programável é um computador especializado, baseado

num microprocessador que desempenha funções de controle de diversos tipos e níveis
de complexidade. Geralmente as famílias de Controladores Lógicos Programáveis são
definidas pela capacidade de processamento de um determinado número de pontos de
Entradas e/ou Saídas (E/S).
Controlador Lógico Programável Segundo a ABNT (Associação Brasileira de
Normas Técnicas), é um equipamento eletrônico digital com hardware e software
compatíveis com aplicações industriais. Segundo a NEMA (National Electrical
Manufactures Association), é um aparelho eletrônico digital que utiliza uma memória
programável para armazenar internamente instruções e para implementar funções
específicas, tais como: lógica, sequenciamento, temporização, contagem e aritmética,
controlando, por meio de módulos de entradas e saídas, vários tipos de máquinas ou
processos [9].
O CLP começou a ser usado no ambiente industrial desde 1960 embora ainda
existam muitas empresas do ramo da indústria de automação que possuem pouca
experiência com eles. A grande vantagem dos controladores programáveis é a
possibilidade de reprogramação, motivo pelo qual substituíram os tradicionais painéis
de controle a relés. Esses painéis necessitavam de modificações na fiação cada vez que
se mudava o projeto, o que muitas vezes era inviável, tornando-se mais barato
simplesmente substituir todo painel por um novo. Os CLPs permitiram transferir as
modificações de hardware em modificações no software [1].
Um CLP é o controlador indicado para lidar com sistemas caracterizados por
eventos de lógica binária, ou seja, com processos em que as variáveis assumem valores
zero ou um (ou variáveis ditas digitais, ou seja, que só assumem valores dentro de um
conjunto finito). Podem ainda lidar com variáveis analógicas definidas por intervalos
de valores de corrente ou tensão elétrica. As entradas e/ou saídas digitais são os
elementos discretos, as entradas e/ou saídas analógicas são os elementos variáveis
entre valores conhecidos de tensão ou corrente [2].
 14

Os CLPs estão muito difundidos nas áreas de controle de processos e de

automação industrial. No primeiro caso a aplicação se dá nas indústrias com processos
do tipo contínuo, produtoras de líquidos, materiais gasosos e outros produtos, no outro
caso a aplicação se dá nas áreas relacionadas com a produção em linhas de montagem,
por exemplo na indústria do automóvel.
Num sistema típico, toda a informação dos sensores é concentrada no
controlador (CLP) que de acordo com o programa em memória define o estado dos
pontos de saída conectados a atuadores.
Os CLPs têm capacidade de comunicação de dados via canais seriais. Com
isto podem ser supervisionados por computadores formando sistemas de controle
integrados. Softwares de supervisão controlam redes de Controladores Lógicos
Programáveis.

2.1 Funcionamento do CLP

O funcionamento de um CLP corresponde a três etapas distintas, as quais são:
entradas, processamento e saídas. Essas etapas são ilustradas na Figura 2. Com essa
finalidade o CLP possui uma arquitetura bastante conhecida baseada em
microcontroladores e microprocessadores.

Figura 2 Estrutura básica de funcionamento de um CLP

O hardware de um CLP é formado por três unidades distintas, as quais são:

fonte de alimentação, CPU (Unidade Central de Processamento), e interfaces de
entrada e saídas ou I/O. Cada unidade que compõe um CLP é responsável pelo seu
funcionamento.
 15

• Fonte de Alimentação: A alimentação de energia do CLP utiliza uma fonte

chaveada e uma única tensão de saída de 24 V. Esse valor já é utilizado com
a finalidade de alimentar os módulos de entrada e saída de dados e a CPU ao
mesmo tempo. Outra característica importante é que normalmente as
máquinas industriais, funcionam com essa tensão por ser bem menos
suscetível a ruídos. Outro ponto destacável, é que essa tensão já é
compatível com o sistema de comunicação RS-232.

• CPU: É responsável pela execução do programa do usuário, atualização da

memória de dados e memória-imagem das entradas e saídas. Inicialmente
com a 2ª geração de CLP (barramento de dados, endereço e controle), a
CPU era constituída por um microcontrolador. A opção por
microcontroladores baseava-se pelo custo-benefício, facilidade de manuseio,
e também pela baixa complexidade dos softwares. Com exceção dos CLPs
de pequeno porte, geralmente, os CLPs apresentam um microprocessador na
forma de um CI (Circuito Integrado) dedicado [6].

• Interfaces de I/O: As entradas e saídas de um CLP podem ser divididas em

duas categorias: as analógicas e digitais.

2.2 Programação do CLP

Atualmente o IEC 61131-3 define cinco modos de programação para os
controladores lógicos programáveis. São eles:
• LADDER ou Diagrama de Relés;
• SFC - Sequential Function Chart ou diagramas de funções seqüenciais;
• IL – Instructions List ou Lista de Instruções;
• Linguagens de blocos funcionais;
• Texto estruturado.
Dentre estes o mais amplamente utilizado é o Ladder, e este foi o escolhido para
a programação do micro-CLP.
 16

O desenvolvimento de um ambiente de programação Ladder não é contemplado

por este projeto, mas é o tema do projeto de graduação do aluno Rogério Costa
Pacheco Neto.

2.2.1 Linguagem LADDER ou Diagrama de Relés

Relés são pequenos dispositivos eletromecânicos que, quando energizados,
fecham (no caso dos relés “normalmente abertos”) ou abrem (no caso dos
“normalmente fechados”) um contato elétrico. A passagem ou não de corrente elétrica
pelo contato pode ser associada aos estados lógicos “verdadeiro” e “falso”
respectivamente.
A chamada linguagem ladder surgiu para possibilitar a programação dos
CLPs, por técnicos e engenheiros eletricistas, de uma forma bem similar à lógica de
relés empregada até então. Num diagrama ladder, elementos de entrada combinam-se
de forma a produzir um resultado lógico booleano, que então é atribuído a uma saída.
A representação destes elementos é feita da seguinte forma:
• Entradas: São na maioria das vezes representadas por contatos
normalmente abertos (NA), representados pelo símbolo –||–, e pelos
contatos normalmente fechados (NF), cujo símbolo é –|/|–. Estes elementos
refletem, logicamente, o comportamento real do contato elétrico de um
relé, no programa aplicativo.
• Saídas: São usualmente representadas pela bobina simples, cujo símbolo é
–( )–. As bobinas modificam o estado lógico do operando na memória do
Controlador Programável, capaz de ativar um dispositivo externo, como
um motor, por exemplo.
Por lidarem com objetos booleanos, todo diagrama ladder pode ser traduzido
para uma diagrama lógico e vice-versa. Contudo, a notação gráfica e mais compacta
dos diagramas lógicos faz com que os mesmos sejam essenciais na documentação de
projetos de automação e controle.
Como exemplo de um programa em ladder, imaginemos um motor que é
controlado por dois botões independentes, um de LIGA e outro de DESLIGA.
 17

Considerando que ambos os botões sejam do tipo pushbutton, a Figura 3 apresenta

uma lógica simples para o acionamento do motor com base nos estados dos botões:

Figura 3 Diagrama lógico (esquerda) e programa ladder (direita) para o acionamento de um motor.
 18

3 DESENVOLVIMENTO DO HARDWARE

Para a determinação do hardware que será montado, primeiramente escolheu-

se o microcontrolador, depois os circuitos de entradas e saídas, a fonte, a comunicação
serial, o display LCD e os botões.

3.1 Microcontroladores PIC

Os PIC (PICmicro) são uma família de microcontroladores fabricados pela
Microchip Technology, que processam dados de 8 bits (recentemente foi lançada uma
família de 16 bits com prefixo 24F) com extensa variedade de modelos e periféricos
internos, com arquitetura Harvard e conjunto de instruções RISC (conjuntos de 35
instruções a 76 instruções), com recursos de programação por Memória Flash,
EEPROM e OTP. Os microcontroladores PIC têm famílias com núcleos de
processamento de 12 bits, 14 bits e 16 bits e trabalham em velocidades de até 48MHz,
usando ciclo de instrução mínimo de 4 períodos de clock, o que permite uma
velocidade de no máximo 10 MIPS. Há o reconhecimento de interrupções tanto
externas como de periféricos internos. Funcionam com tensões de alimentação de 2 a
6V e os modelos possuem encapsulamento de 6 a 100 pinos em diversos formatos
(SOT23, DIP, SOIC, TQFP, etc).

3.1.1 Características do PIC 16F877

O PIC 16F877 é um microcontrolador da família de 8 bits e núcleo de 14 bits
fabricado pela Microchip Technology. Possui memória flash de programa com 8192
palavras de 14 bits, memória RAM com 368 bytes e memória EEPROM com 256
bytes. Sua frequência de operação (clock) vai até 20MHz, resultando em uma
velocidade de processamento de 5 MIPS. Seu conjunto de instruções RISC se compõe
de 35 instruções. Pode funcionar com alimentação de 2V a 5,5V. Sua pinagem DIP
tem 40 pinos.
Como periféricos ele possui:
• 5 conjuntos de portas de entrada e saída (total de 33 portas)
 19

• Conversor analógico-digital de 10 bits de resolução e 8 canais de entrada

• Periférico de comunicação paralela e serial (USART e MSSP)
• 2 Módulos CCP (Comparação, Captura e PWM)
• 3 Timers (1 de 16 bits e 2 de 8 bits)
• Watchdog timer

3.2 Definições
A definição de um hardware básico é o ponto principal do projeto, pois a partir
desse ponto foi possível determinar as funções de cada pino do PIC16F877 e o fluxo
de dados do CLP.
Características:
• 8 entradas digitais
• 8 saídas digitais
• 3 entradas analógicas
• 2 saídas PWM
• 1 display LCD com 2 linhas e 16 colunas
• 4 botões

3.3 Entradas Digitais

Para o barramento de dados definiu-se a porta D do microcontrolador
PIC16F877, possibilitando oito entradas e saídas digitais. O sentido do fluxo de dados
neste barramento é determinado pelos pinos:
• RC0 em nível baixo habilita as entradas;
• RC3 recebendo uma transição positiva habilita as saídas.
As entradas são de 24V.
O circuito de entradas digitais é isolado de interferências externas por meio de
opto acopladores.
O sistema possui um GND interno e um GND EXT externo, isto também é
necessário para o isolamento dos circuitos do micro-CLP.
 20

Tomando como exemplo a entrada IN_0 da Figura 4, com o barramento

habilitado para entrada, pode-se observar O circuito funciona da seguinte forma
quando alimentamos um pino de entrada:
1. O LED1 conduz, demonstrando que a entrada está ativa.
2. Por conseguinte o LED do opto acoplador também é ativado.
3. Ocorre a saturação do transistor do opto acoplador, que drena a corrente.
4. Dessa forma um nível baixo chega à porta A1 do chip 74HC240N.
5. O Sinal é invertido na saída do chip, logo o pino RD0 recebe um nível
alto.

Figura 4 - Circuito elétrico das entradas digitais

3.4 Saídas Digitais

O circuito de saídas digitais a transistor é isolado de interferências externas
por meio de opto acopladores. A separação dos terras também é necessária para manter
o isolamento dos circuitos, logo este circuito possui um GND (interno) e um GND
EXT (externo).
 21

Analisando o circuito de saída do pino OUT_0 da Figura 5, com o barramento

habilitado para saída, quando chega ao pino RD0 um nível alto, ocorre o seguinte:
• O LED do opto acoplador pára de emitir,
• Consequentemente o transistor do opto acoplador é cortado,
• Com isso o LED1conduz, indicando saída ativa,
• Finalmente OUT_0 recebe nível baixo.

Figura 5 - Circuito elétrico das saídas digitais

3.5 Entradas Analógicas

As entradas analógicas são tratadas por conversão AD realizada pelo próprio
microcontrolador PIC. Estas se encontram nos pinos RA0, RA1 e RA3.
Adotou-se três tipos entradas analógicas para cada canal selecionáveis por
meio de jumpers. São estes:
 22

• 0 a 5V
• 0 a 10V
• 4 a 20mA
Para entrada de 0 a 10V, deve-se colocar o jumper JP2 na posição 1-2 e o
jumper JP1 na posição 5-3.
Para entrada de 0 a 5V, deve-se colocar o jumper JP2 na posição 1-2 e o
jumper JP1 na posição 1-3.
Para entrada de 4 a 20mA, deve-se colocar o jumper JP2 na posição 2-3 e o
jumper JP1 na posição 6-4.

Figura 6 - Circuito elétrico da entrada analógica

3.6 Saídas Analógicas

As saídas analógicas são de dois tipos:
• Sinal PWM
• 0 a 5V
O sinal PWM é obtido diretamente do PIC16F877 nos pinos RC1 (CCP2) e
RC2 (CCP1).
As saídas de 0 a 5V são obtidas a partir do sinal PWM.
 23

Figura 7 - Circuito elétrico das saídas analógicas

3.7 A Fonte de Alimentação

Este projeto não contempla a construção de uma fonte de alimentação. O
Micro-CLP necessita de uma alimentação de 5V e 12V fornecidas por uma fonte AT
de computador. Também é necessário uma alimentação de 24V, esta fornecida por
uma fonte do laboratório de Microprocessadores 1.

3.8 Display LCD

A placa está provida de um LCD alfanumérico padrão de 16 colunas por 2
linhas.
São utilizados os pinos RB4, RB5, RB6 e RB7 do microcontrolador para
enviar dados.
A linha Enable (E), ligada no pino RB3, permite a ativação do display e a
utilização das linhas R/W e RS. Quando a linha de habilitar (Enable) está em nível
baixo, o LCD fica inibido e ignora os sinais R/W e RS. Quando (E) está em nível alto,
o LCD verifica os estados das duas linhas de controle e reage de acordo com estes.
A linha Read.Write (R/W), ligada no pino RB2, determina o sentido dos dados
entre o microcontrolador e o LCD. Quando está em nível baixo, os dados serão
escritos no LCD. Quando está em nível alto, os dados serão lidos do LCD.
Com a ajuda da linha de Selecção de registo (RS), o LCD interpreta o tipo de
dados presentes nas linhas de dados. Quando está em nível baixo, será escrita uma
instrução no LCD. Quando está em nível alto, caracter será escrito no LCD.
 24

3.9 Botões
Os botões da parte frontal do Micro-CLP, Figura 14, estão ligados da seguinte
forma:
• Botão B1 ligado ao pino RE2
• Botão B3 ligado ao pino RE1
• Botão B5 ligado ao pino RE0
• Botão B8 ligado ao pino RB0

3.10 Comunicação Serial

A placa possui um driver RS232 para adequar os níveis de tensão do
microcontrolador (TTL) ao padrão RS232C (+12V e – 12V).
A comunicação é feita com 2 vias, a via de TX está ligada ao pino RC6 e a via
de RX está ligada ao pino RC7 do microcontrolador.
A montagem pode ser vista Figura 8.

Figura 8 - Esquema de comunicação serial

 25

4 DESENVOLVIMENTO DO PROGRAMA RESIDENTE

O programa residente é o responsável pela inicialização do micro-CLP, a

leitura das entradas, a execução do programa Ladder, a atualização das saídas, a
recepção, gravação, a interpretação e a execução do programa Ladder.
O programa Ladder é gravado em um espaço reservado da memória de
programa EEPROM a partir do endereço 0x1C00.

Figura 9 - Alocação da memória de programa

4.1 Cabeçalho
Para a manipulação das funções de controlador Proporcional-Integral-
Derivativo (PID), temporizadores, contadores e comparadores é necessário o envio de
algumas constantes específicas para cada função. São elas:
• SP1 e SP2 – Set Point, referência do PID1 e do PID2 respectivamente;
• KP1 e KP2 – Constantes de proporcionalidade;
• KI1 e KI2 – Constantes de integração;
• KD1 e KD2 – Constantes de derivação;
• K1 e K2 – Constantes de comparação;
 26

• KT1 e KT2 – Constantes de temporização;

• KC1 e KC2 – Constantes dos contadores.
Para cada constante reservou-se o tamanho de dois bytes. A este conjunto de
constantes deu-se o nome de cabeçalho. É o primeiro bloco de informações enviado
para o micro-CLP. Nota-se que este bloco possui um tamanho fixo de 28 bytes. O
cabeçalho é armazenado na memória de dados EEPROM, a partir do endereço 0x00
até o endereço 0x1B. Como a memória de dados EEPROM é formada por palavras de
oito bits, cada constante ocupa dois endereços na memória.

Figura 10 - Alocação da memória de dados EEPROM

4.2 Instruções
Para definir a possível quantidade de instruções é necessário determinar o
formato das instruções na palavra de 14 bits da memória de programa EEPROM. O
padrão escolhido é o seguinte:
Instruções Digitais
Bits de 13 a 8 – Código da instrução Bits 7 a 0 – Índice das variáveis

Logo é possível um conjunto de 64 instruções com os seis bits do campo de

instruções. Foram implementadas as seguintes funções de um programa Ladder básico:
• LD()
• LD_NOT()
• AND()
 27

• AND_B()
• AND_NOT()
• OR()
• OUT()
• OUT_NOT()
• DISPLAY()
• END
Na Tabela 1 encontram-se a codificação de cada instrução.

Tabela 1 - Codificação das Instruções

Instrução Codificação Instrução Codificação
LD() 000000 OR() 000101
LD_NOT() 000001 OUT() 000110
AND() 000010 OUT_NOT() 000111
AND_NOT() 000011 DISPLAY() 001000
AND_B() 000100 END 111111

4.3 Variáveis
De posse da quantidade de entradas e saídas passa-se a definir as variáveis
digitais e analógicas possíveis. A Tabela 2 mostra o mapeamento das variáveis que
serão gravadas na memória de dados EEPROM a partir do endereço 0x1C, que é o
endereço imediatamente após o cabeçalho de constantes.
A denominação das variáveis evidencia a separação dos tipos da seguinte
maneira:
• Iniciadas com ‘X’ – variáveis digitais de entrada física.
• Iniciadas com ‘Y’ – variáveis digitais de saída física.
• Iniciadas com ‘I’ – variáveis digitais internas.
• Iniciadas com ‘M’ – variáveis digitais de saída do comparador 1.
• Iniciadas com ‘N’ – variáveis digitais de saída do comparador 2.
 28

• Iniciadas com ‘AN’ – variáveis analógicas de entrada física.

• Iniciadas com ‘SA’ – variáveis analógicas de saída física.
• Iniciadas com ‘IN’ – variáveis analógicas internas.
O campo ‘Índice’ da Tabela 2 é usado para apontar o endereço das variáveis
na memória.

Tabela 2 - Mapeamento das Variáveis

Denominação Índice Denominação Índice
X 0 00000000 M 0 00100000
X 1 00000001 M 1 00100001
X 2 00000010 M 2 00100010
X 3 00000011 N 0 00100011
X 4 00000100 N 1 00100100
X 5 00000101 N 2 00100101
X 6 00000110 A N 0 00100110
X 7 00000111 A N 0
Y 0 00001000 A N 1 00101000
Y 1 00001001 A N 1
Y 2 00001010 A N 2 00101010
Y 3 00001011 A N 2
Y 4 00001100 S A 0 00101100
Y 5 00001101 S A 0
Y 6 00001110 S A 1 00101110
Y 7 00001111 S A 1
I 0 00010000 IN 0 00110000
I 1 00010001 IN 0
I 2 00010010 IN 1 00110010
I 3 00010011 IN 1
I 4 00010100 IN 2 00110100
I 5 00010101 IN 2
I 6 00010110 IN 3 00110110
I 7 00010111 IN 3
I 8 00011000 IN 4 00111000
I 9 00011001 IN 4
I 10 00011010 IN 5 00111010
I 11 00011011 IN 5
I 12 00011100 IN 6 00111100
I 13 00011101 IN 6
I 14 00011110 IN 7 00111110
I 15 00011111 IN 7
 29

4.4 Programação do PIC

De posse das definições de número de entradas, saídas, dos tipos, das
instruções e das configurações de hardware, passa-se à definição do programa
residente, cujo fluxograma é mostrado na Figura 11.

Início

Inicialização

Leitura das
entradas;
Execução do Carregamento do
Programa Ladder Programa Ladder
Atualização das
saídas

Aguardando

Ladder Carregado

Figura 11 - Fluxograma do programa residente

Ao ligar o Micro-CLP, ocorre: a inicialização do PIC, a leitura das entradas, a

execução do programa Ladder e a atualização das saídas, durante este processo ao
apertar-se os botões B1 e B3 entra-se no processo de Carregamento de um novo
programa Ladder, terminando-se o carregamento, volta-se para o processo de execução
do programa principal. Caso o botão B8 seja pressionado segue-se ao processo
“Aguardando” que é um estado parado; pressionando-se o botão B5 volta-se ao estado
de execução do programa principal.

4.4.1 Entradas e Saídas Digitais

Os pinos que têm a notação R podem ser utilizados como entradas ou saídas
digitais. RD[0-7] configuram oito bits de I/O bidirecional (porta D). De forma
 30

semelhante, ocorre para as outras portas. O bit menos significativo se refere ao pino 0
de A, B, C, D ou E. O valor binário 1 indica que o pino é configurado como entrada e
o valor 0 indica que o pino é configurado como saída. A função em CCS para setar a
direção estas portas é set_tris_d() para a porta D. Observa-se a utilização desta função
no trecho de código a seguir.
// Leitura do estado das entradas
int ler_entrada()
{
int ent;
set_tris_d(0xff);
output_low(PIN_C0);
ent=input_d();
output_high(PIN_C0);
return ent;
}
Os valores output de todos os pinos digitais podem ser mudados usando os
comandos seguintes simultaneamente:
output_b(0xFF); // fixa todos os pinos de saída de B em 1

4.4.2 Entradas Analógicas

Os pinos identificados como AN podem ser usados como entradas analógicas.
Neste caso AN[0-4] (pinos 2, 3, 4, 5 & 7). O PIC16F877 tem um ADC interno
(conversor analógico digital) que nos permite introduzir valores analógicos mediante
as portas A e E. É possível fixar todos os canais A ou E como analógicos ou pode-se
definir canais específicos para serem analógicos[5].
Exemplo:
// Todos os pinos são analógicos
setup_adc_ports (ALL_ANALOG);
// Pinos A0, A1 e A3 são analógicos e todos os outros são digitais. +5v é
utilizado como referência de entrada analógica.
setup_adc_ports (RA0_RA1_RA3_ANALOG);
 31

// Pinos A0 e A1 são analógicos. Pino RA3 é usado para a voltagem de

referência e todos os outros pinos são digitais.
setup_adc_ports (A0_RA1_ANALOGRA3_REF);
//lendo um valor analógico
//isto fixará a porta AN2 como analógica
set_adc_channel(2);
//esta demora é um imperativo para o PIC trabalhar
delay_us(10);
// leia o valor digital do sinal analógico
value = read adc();

4.4.3 Controle do PWM

Os pinos relativos à Modulação por Largura de Pulso (PWM) são CCP1 e
CCP2. O PIC pode ter dois drivers com controle de PWM. Também podem ser usados
para ler um pulso de uma entrada. Na maioria dos casos o algoritmo PWM é utilizado
para acionamento de motores. Para ativar o controle de PWM primeiro a porta CCP
deve ser configurada como saída. Na realidade quando o diagrama de pinos é
analisado, os pinos CPP são RC1 e RC2[5].
Como um exemplo, assumir que nós queremos usar CCP1 como um PWM
para acionar um motor. Neste caso é necessário setar pino C1 como uma saída
utilizando o comando set_tris_c () .
Utiliza-se o comando:
setup_ccp1(CCP_PWM) / / configura CCP1 como um PWM

4.4.4 Interrupções
Uma interrupção é um evento que força uma chamada a uma seqüência de
dados que normalmente é definida como rotina ou serviço de interrupção. Fontes
típicas de interrupções no PIC incluem uma transição positiva ou negativa na entrada
de RB.0/INT, uma mudança em quaisquer das entradas RB4 - RB7 ou a saturação
(overflow) de algum contador ou timer na mudança de valor de 0xFF(255) para 0x00
 32

(0). Na interrupção, o processador salva o endereço de retorno na pilha e o controle de

programa é redirecionado à rotina de serviço de interrupção[5].

4.4.5 Cronômetros (Timers)

Cronômetro é uma rotina de interrupção especialmente disponível com PIC. O
PIC tem um número de cronômetros que podem ser usados para executar operações de
cronometragem. As operações de cronômetro típicas são Timer_0, Timer_1, Timer_2
ou RTCC. Os cronômetros consideram valores inteiros na forma set_timer0 ou
set_RTCC (valor). Timer_0 ou RTCC assume um valor inteiro de 8 bits (max 255).
Timer_1 e Timer_2 consideram valores de 16 bits. Todas as contas dos cronômetros
são incrementais e quando um cronômetro alcança o valor de máximo deverá retornar
ao seu valor inicial. Como exemplo considerar set_timer0(0) contará
0,1,....254,255,0,1,2...
Se a velocidade do clock é 4MHz e se fixássemos o RTCC_DIV a 256 (valor
máximo) o contador incrementará a uma taxa (4000000/4)/256 vezes por segundo que
é 3906.25 incrementos por segundo ou 256us por incremento.
Pode-se usar este método para contar um período de tempo pre-especificado, 1
segundo, 2 segundos e assim por diante. Seguindo o anterior exemplo, o número total
de contas requeridos para um segundo de duração é dado por, (1x1000000/256) =
3906.25 contas. Se fixamos o cronômetro para contar de 0, temos um total de 3906.25
/256 = 15.25 interrupções de cronômetro. Ou nós podemos aproximar a 15
interrupções de cronômetro. Se um valor preciso é requerido, o valor de DIV poderia
ser diminuído para reduzir o erro.

4.5 Rotinas
Nesta seção analisaremos algumas rotinas principais.
 33

4.5.1 Rotina Principal

A rotina principal inicializa e lê as entradas, da seguinte forma: carrega o
estado das variáveis de entrada para suas respectivas posições de memória. O trecho de
código abaixo mostra a leitura da entrada X0.
entradas = ler_entrada();
if ( bit_test(entradas,0)) write_EEPROM( 0x1C, 0xff);
else write_EEPROM( 0x1C, 0);

Depois de ler todas as entradas (X0 a X7), segue-se para o trecho em que
escolhe-se: carregar um novo programa Ladder ou ficar parado.

selecao = ~ler_botoes();
while ((bit_test(selecao,2)==1))
{

teste = bit_test(selecao,1);
switch (teste)
{
break;
case 1 : p2 = 0x1c00;
p1 = 0;
pc = 0;
x = 0;
carrega=0;
lcd_gotoxy(1,1);
printf(lcd_putc,"Carregar Ladder ");
printf("Carregar Ladder ");
carregar_ladder();
break;
default : selecao = ~ler_botoes();
teste2 = bit_test(selecao,3);
while (teste2==1)
{
lcd_gotoxy(1,1);
 34

printf("\r Aguardando ");

printf(lcd_putc," Aguardando ");
delay_ms(200);
selecao = ~ler_botoes();
if ((bit_test(selecao,0)==1))
teste2 = 0;
}

break;
}
selecao = ~ler_botoes();
}

A seguir o programa é executado. E sua saída é atualizada ao final de cada

ciclo do programa Ladder, quando é encontrada a função END.

codigo = read_program_eeprom(p2);
indice= codigo & 0b11111111;
num_funcao= codigo >> 8;
p2++;

lcd_gotoxy(1,1);
printf(lcd_putc,"Executando ");
printf("Executando ");

switch (num_funcao)
{
case 0b000000 : LD(indice);
printf(" LD %u", indice);
break;
case 0b000001 : LD_NOT(indice);
printf(" LD_NOT %u", indice);
break;
case 0b000010 : AND(indice);
printf(" AND %u", indice);
 35

break;
case 0b000011 : AND_NOT(indice);
printf(" AND_NOT %u", indice);
break;
case 0b000100 : AND_B();
printf(" AND_B %u", indice);
break;
case 0b000101 : OR();
printf(" OR %u", indice);
break;
case 0b000110 : OUT(indice);
printf(" OUT %u", indice);
break;
case 0b000111 : OUT_NOT(indice);
printf(" OUT_NOT %u", indice);
break;
case 0b001000 : DISPLAY(indice);
break;
case 0b111111 : printf ("END OF FILE!");
p2 = 0x1c00;
atualizar_saida();
break;
default : lcd_gotoxy(1,2);
printf ("funcao nao implementada");
printf (lcd_putc,"funcao nao implementada");
break;
}

delay_ms(100);

4.5.2 Carregamento do Ladder

A rotina abaixo recebe os dados enviados pelo programa através da porta
serial. A função getc() espera um byte chegar. Enquanto o contador pc for menor do
 36

que ou igual 27 significa que os dados que estão chegando pertencem ao cabeçalho,
logo são armazenados na memória de programa EEPROM.
Quando pc atinge 28, a cada dois bytes formam-se uma palavra que é gravada
na memória de programa, estas são as instruções Ladder .

void carregar_ladder()
{
while (carrega==0)
{
dados=getc();
if (pc>27)
{
dadosp[x]=dados;
x++;
if (x==2)
{
x=0;
cod_prog = dadosp[0];
cod_prog = (cod_prog<<8) +dadosp[1];
write_program_EEPROM (0x1c00 + p1,cod_prog);
if (cod_prog == 0xffff)
{
lcd_gotoxy(1,1);
printf(lcd_putc,"Ladder Carregado");
carrega=1;
}
p1++;
}
}
else
{
write_EEPROM( pc, dados );
pc++;
}
}
 37

4.5.3 Função AND()

Cita-se a função AND() como exemplo das funções Ladder implementadas.
A função AND(argumento) tem como argumento o índice que somado ao
endereço 0x1C aponta para a variável desejada. A variável temporária recebe o
resultado da operação AND entre um valor na variável temporária e o conteúdo da
variável apontada pelo endereço.

void AND(int endf)

{
device_ent = read_EEPROM(0x1C + endf);
temp[pf-1] = temp[pf-1] & device_ent;
}

4.6 Monitorando o programa pela porta serial

A conexão serial RS232 também pode ser usada para transferir e apresentar
dados da placa PCB. Dados, como leituras de sensor, podem ser transferidos ao
computador em tempo real e facilmente podem ser usados para serem exibidos
enquanto a aplicação PIC está rodando. Para exibir os dados, um hyperterminal é
utilizado via porta serial COM1. Para habilitar o hyperterminal, ir para o menu start e
selecionar accessories/communications/hyperterminal para estabelecer uma conexão
nova, configurar o PIC como usuário do COM1. Configurações:
1. Bits Per Second para 9600;
2. Data Bits para 8;
3. Stopbits para 1;
4. Flow Control to None.
 38

5 TESTES E RESULTADOS

Os testes feitos no Micro-CLP foram essenciais não apenas para este projeto
mas também para o projeto de desenvolvimento do ambiente de programação Ladder
elaborado pelo aluno Rogério Costa Pacheco Neto. Os testes foram realizados em
conjunto.
A aplicação utilizada foi o exemplo do controle de um portão eletrônico.
Para este exemplo utilizou-se, as seguintes considerações:
• Botão de comando para abrir o portão, porta X0.
• Botão de comando para fechar o portão, porta X1.
• Sensor de fim de curso portão aberto, na porta X2.
• Sensor de fim de curso portão fechado, na porta X3.
• Saída para motor, abrir o portão Y0.
• Saída para motor, fechar o portão Y1.
Gerando o diagrama Ladder visto na Figura 12.
Analisando o ladder temos, apertando o botão para abrir o portão (X0), e o
sensor de portão aberto (X2) não estando ativado, vai acionar a saída interna I00, que é
utilizada como selo para que ela só seja desligada quando ocorrer o fim de curso de
portão aberto, ou o botão de fechar (X1) seja acionado.
A saída interna I00 é passada para a saída física Y0 que indica que o motor
deve ser ligado para abrir o portão.
Caso o botão pressionado seja o de fechar o portão (X1), e sensor de portão
fechado (X3) não estando ativado, vai acionar a saída interna I01, que também será
utilizada como selo para que só seja desligada quando ocorrer o fim de curso de portão
fechado, ou o botão de abrir (X0) seja acionado.
A saída interna I01 é passada para a saída física Y1 que indica que o motor
deve ser ligado para fechar o portão.
 39

Figura 12 - Diagrama Ladder do controle do portão eletrônico

Após preparar o programa devemos ligar o Micro-CLP e prepará-lo para

receber o diagrama Ladder.
Ao ligar o Micro-CLP aparece a mensagem “MicroCLP”.
Ao apertar o botão B3, o Micro-CLP vai para o estado de aguardar o
carregamento do programa e escreve a mensagem “Carregar Ladder”. Neste ponto
envia-se o programa Ladder gerado no ambiente gráfico. A linguagem intermediária
enviada é mostrada na Figura 13. Quando todo o código é enviado, a mensagem que
aparece é “Ladder Carregado”.
 40

Figura 13 - Linguagem intermediária enviada ao Micro-Clp

Ao apertar o botão B1, o programa é executado.

Pode-se ver então o programa em funcionamento no Micro-CLP, através dos
LEDs que são ativados pelas entradas e saídas. Para setar as entradas foi utilizada uma
fonte de 24V disponível no laboratório.
Os resultados de exemplo foram conforme o esperado.
As Figuras 14 a 18 mostram as vista do Micro-CLP.
A Figura 19 mostra a placa de entradas e saídas.

Figura 14 - Vista frontal do Micro-CLP

 41

Figura 15 - Vista superior do Micro-CLP

Figura 16 - Vista lateral esquerda do Micro-CLP

Figura 17 - Vista lateral direita do Micro-CLP

 42

Figura 18 - Vista traseira do Micro-CLP

Figura 19 - Placa de entradas e saídas

 43

6 CONCLUSÕES

O estudo sobre os controladores lógicos programáveis constatou que estes

estão sendo cada vez mais utilizados devido à sua grande flexibilidade de aplicações.
Para aplicações de complexibilidade reduzida, a alternativa de um Micro-CLP torna-se
vantajosa, uma vez que este possui um preço bem menor que um CLP normal. A partir
do estudo também determinaram-se os requisitos necessários para o projeto. Dentre
estes a determinação da linguagem Ladder ou diagrama de relés, como a utilizada para
programar o Micro-CLP. Para realizar este projeto destaca-se a utilização de
conhecimentos de eletrônica digital, microprocessadores e programação em linguagem
C.
Foram desenvolvidos os circuitos elétricos necessários para o micro CLP.
Foi desenvolvido um programa residente no PIC, responsável pelo
gerenciamento de entradas e saídas, gravação de um programa Ladder e a execução do
mesmo.
De acordo com os resultados dos testes, pode-se dizer que o projeto alcançou
seu objetivo satisfatoriamente, pois executou com sucesso um programa Ladder
desenvolvido no ambiente gráfico no computador e enviado pelo mesmo pela porta
serial.
Existiram algumas dificuldades com a familiarização da linguagem C adotada
pelo CCS PICC, pois este possui várias funções já implementadas.
Faltou implementar as funções analógicas.
Este projeto demonstra ter um grande potencial de aplicações, dessa forma
sugere-se como projetos futuros a implementação das funções que manipulam dados
analógicos, ou de uma rede de CLPs.
 44

APÊNDICE A – CIRCUITO PRINCIPAL

 45

APÊNDICE B – CIRCUITO COMPLETO DE ENTRADAS DIGITAIS

 46

APÊNDICE C – CIRCUITO COMPLETO DE SAÍDAS DIGITAIS

 47

APÊNDICE D – CIRCUITO COMPLETO DE ENTRADAS ANALÓGICAS

 48

APÊNDICE E – CIRCUITO COMPLETO DE SAÍDAS ANALÓGICAS

 49

APÊNDICE F – CÓDIGO FONTE

#case
#include "clp.h"
#include "LCD.C"
#use delay(clock=20000000)

#org 0x1C00, 0X1FFF {}

char c,dadosp [2];

int entradas=0, indice, device_sai, device_ent, selecao, carrega=0;
long int codigo, p1 = 0, p2=0x1C00, i, cod_prog;
int num_funcao, pc=0, dados, x=0, teste2=0, i3=0, rodar=0;
short int teste;

int pf,temp [10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0,};

int i2;
long value, min, max;

struct botoes
{
short int b3;
short int b2;
short int b1;
short int b0;
} botao;

struct out_porta
{
short int y0;
short int y1;
short int y2;
short int y3;
short int y4;
 50

short int y5;

short int y6;
short int y7;
} saida_porta;

// Leitura do estado das entradas

int ler_entrada()
{
int ent;
set_tris_d(0xff);
output_low(PIN_C0);
ent=input_d();
output_high(PIN_C0);
return ent;
}

// Saída
saida(int valor)
{
output_high(PIN_C0);
set_tris_d(0x00);
output_d(valor);
output_high(PIN_C3);
delay_us(1);
output_low(PIN_C3);
set_tris_d(0xFF);
}

// Leitura do estado dos botões

int ler_botoes()
{
int entbot=0;
set_tris_e(0xff);
set_tris_b(0x01);
botao.b0 = input(PIN_B0);
botao.b1 = input(PIN_E0);
 51

botao.b2 = input(PIN_E1);
botao.b3 = input(PIN_E2);
entbot = botao;
return (entbot);
}

// Escrita de variáveis do tipo long int na data EEPROM

write_long_eeprom(long int n, long int data) {
int i1;
for (i1 = 0; i1 < 2; i1++)
write_eeprom(i1 + n, *(&data + i1) ) ;
}

// Leitura de variáveis do tipo long int na data EEPROM

long int read_long_eeprom(long int n) {
int i1;
long int data;
for (i1 = 0; i1 < 2; i1++)
*(&data + i1) = read_eeprom(i1 + n);
return(data);
}

//Funcoes basicas ladder

//----------LD()

void LD(int endf)

{
temp[pf] = read_eeprom(0x1C + endf);
printf("\n\rTEMP= %u", temp[pf]);
++pf;
}

//----------LD_NOT()

void LD_NOT(int endf)

 52

{
temp[pf] = ~read_eeprom(0x1C + endf);
printf("\n\rTEMP= %u", temp[pf]);
++pf;
}

//----------AND()

void AND(int endf)

{
device_ent = read_eeprom(0x1C + endf);
temp[pf-1] = temp[pf-1] & device_ent;
printf("\n\rTEMP= %u", temp[pf-1]);

//----------AND_B()

void AND_B()
{
--pf;
temp[pf-1] = temp[pf-1] & temp[pf];
printf("\n\rTEMP= %u", temp[pf-1]);
}

//----------AND_NOT()

void AND_NOT(int endf)

{
device_ent = read_eeprom(0x1C + endf);
temp[pf-1] = temp[pf-1] & (~device_ent);
printf("\n\rTEMP= %u", temp[pf-1]);
}

//----------OR()
 53

void OR()
{
--pf;
temp[pf-1] = temp[pf-1] | temp[pf];
printf("\n\rTEMP= %u", temp[pf-1]);
}

//----------OUT()

void OUT(int endf)

{
write_eeprom(0x1C + endf,temp[pf-1]);
printf("\n\rTEMP= %u", temp[pf-1]);
--pf;
}

//----------OUT_NOT()

void OUT_NOT(int endf)

{
write_eeprom(0x1C + endf,~temp[pf-1]);
printf("\n\rTEMP= %u", temp[pf-1]);
--pf;
}

//----------DISPLAY()

void DISPLAY(int endf)

{
long int valor;
valor = read_long_eeprom(indice);
printf(lcd_putc,"\Lu ", valor);
printf("\Lu ", valor);
}
 54

//----------Carregar Ladder

void carregar_ladder()
{
while (carrega==0)
{
dados=getc();
if (pc>27)
{
dadosp[x]=dados;
x++;
if (x==2)
{
x=0;
cod_prog = dadosp[0];
cod_prog = (cod_prog<<8) +dadosp[1];
write_program_eeprom (0x1c00 + p1,cod_prog);
if (cod_prog == 0xffff)
{
lcd_gotoxy(1,1);
printf(lcd_putc,"Ladder Carregado");
carrega=1;
teste=0;
delay_ms(1000);
}
p1++;
}
}
else
{
write_eeprom( pc, dados );
pc++;
}
}

}
 55

//-----------------zera eeprom
void zera_eeprom()
{
while (i3<=55)
{
write_eeprom( 0x24+i3 , 0x00 );
i3++;
}
}

void atualizar_saida()
{
if (read_eeprom(0x24)==0xff) saida_porta.y0 = 1;
else saida_porta.y0 = 0;
if (read_eeprom(0x25)==0xff) saida_porta.y1 = 1;
else saida_porta.y1 = 0;
if (read_eeprom(0x26)==0xff) saida_porta.y2 = 1;
else saida_porta.y2 = 0;
if (read_eeprom(0x27)==0xff) saida_porta.y3 = 1;
else saida_porta.y3 = 0;
if (read_eeprom(0x28)==0xff) saida_porta.y4 = 1;
else saida_porta.y4 = 0;
if (read_eeprom(0x29)==0xff) saida_porta.y5 = 1;
else saida_porta.y5 = 0;
if (read_eeprom(0x2A)==0xff) saida_porta.y6 = 1;
else saida_porta.y6 = 0;
if (read_eeprom(0x2B)==0xff) saida_porta.y7 = 1;
else saida_porta.y7 = 0;
teste2=saida_porta;
saida (teste2);
printf (" \n\rSaida=%u ", teste2);
}

void main() {
 56

rs232_errors=0;

set_tris_c(0xb0);
set_tris_a(0xFF);
set_tris_d(0xff);
set_tris_e(0xff);

setup_adc_ports( RA0_RA1_RA3_ANALOG );
setup_adc( ADC_CLOCK_INTERNAL );
set_adc_channel( 0 );

setup_adc(ADC_CLOCK_DIV_2);

setup_psp(PSP_DISABLED);
setup_counters(RTCC_INTERNAL,RTCC_DIV_2);
setup_timer_1(T1_DISABLED);

setup_timer_2(T2_DIV_BY_1,249,5);

setup_ccp1(CCP_OFF);
setup_ccp2(CCP_OFF);

lcd_init();
output_high(PIN_C0);
output_low(PIN_C3);

zera_eeprom();

putc(0x0c);
printf(lcd_putc,"\fMicroCLP");
printf("\fMicroCLP\n\r");
 57

while (TRUE)
{

entradas = ler_entrada();
if ( bit_test(entradas,0)) write_eeprom( 0x1C, 0xff);
else write_eeprom( 0x1C, 0);

if ( bit_test(entradas,1)) write_eeprom( 0x1D, 0xff);

else write_eeprom( 0x1D, 0);

if ( bit_test(entradas,2)) write_eeprom( 0x1E, 0xff);

else write_eeprom( 0x1E, 0);

if ( bit_test(entradas,3)) write_eeprom( 0x1F, 0xff);

else write_eeprom( 0x1F, 0);

if ( bit_test(entradas,4)) write_eeprom( 0x20, 0xff);

else write_eeprom( 0x20, 0);

if ( bit_test(entradas,5)) write_eeprom( 0x21, 0xff);

else write_eeprom( 0x21, 0);

if ( bit_test(entradas,6)) write_eeprom( 0x22, 0xff);

else write_eeprom( 0x22, 0);

if ( bit_test(entradas,7)) write_eeprom( 0x23, 0xff);

else write_eeprom( 0x23, 0);

selecao = ~ler_botoes();
while ((bit_test(selecao,2)==1))
{

teste = bit_test(selecao,1);
switch (teste)
{
 58

break;
case 1 : p2 = 0x1c00;
p1 = 0;
pc = 0;
x = 0;
carrega=0;
lcd_gotoxy(1,1);
printf(lcd_putc,"Carregar Ladder ");
printf("Carregar Ladder ");
carregar_ladder();
break;
default : selecao = ~ler_botoes();
teste2 = bit_test(selecao,3);
while (teste2==1)
{
lcd_gotoxy(1,1);
printf("\r Aguardando ");
printf(lcd_putc," Aguardando ");
delay_ms(200);
selecao = ~ler_botoes();
if ((bit_test(selecao,0)==1))
teste2 = 0;
}

break;
}
selecao = ~ler_botoes();
}

codigo = read_program_eeprom(p2);
indice= codigo & 0b11111111;
num_funcao= codigo >> 8;
p2++;

lcd_gotoxy(1,1);
printf(lcd_putc,"Executando ");
 59

printf("Executando ");

switch (num_funcao)
{
case 0b000000 : LD(indice);
printf(" LD %u", indice);
break;
case 0b000001 : LD_NOT(indice);
printf(" LD_NOT %u", indice);
break;
case 0b000010 : AND(indice);
printf(" AND %u", indice);
break;
case 0b000011 : AND_NOT(indice);
printf(" AND_NOT %u", indice);
break;
case 0b000100 : AND_B();
printf(" AND_B %u", indice);
break;
case 0b000101 : OR();
printf(" OR %u", indice);
break;
case 0b000110 : OUT(indice);
printf(" OUT %u", indice);
break;
case 0b000111 : OUT_NOT(indice);
printf(" OUT_NOT %u", indice);
break;
case 0b001000 : DISPLAY(indice);
break;
case 0b111111 : printf ("END OF FILE!");
p2 = 0x1c00;
atualizar_saida();
break;
default : lcd_gotoxy(1,2);
printf ("funcao nao implementada");
 60

printf (lcd_putc,"funcao nao implementada");

break;
}

delay_ms(100);

}
 61

REFERÊNCIAS BIBLIOGRÁFICAS

[1] – Acessado em 4/02/2007 -

http://www.engprod.ufjf.br/epd_automacao/EPD030_PLCs.pdf
[2] – Acessado em 10/09/2006 -
http://www.lee.eng.uerj.br/downloads/cursos/clp/clp_1.pdf
[3] – Acessado em 12/01/2006 - http:// www.ccsinfo.com
[4] – Acessado em 10/09/2006 - http://www.microchip.com
[5] – Acessado em 5/11/2006 -
http://www2.brazcubas.br/professores1/arquivos/20_franklin/T7037A/Projeto_PA
C_-_Modulo_PIC.pdf
[6] – Acessado em 5/11/2006 - http://www.plcopen.org/
[7] – Acessado em 4/02/2007 - http://www.cadsoft.de/
[8] – Acessado em 5/11/2006 - http://www.plcs.net/
[9] – Acessado em 11/09/2006 -
http://en.wikipedia.org/wiki/Programmable_logic_controller
[10] - Acessado em 10/09/2006 –
http://ww1.microchip.com/downloads/en/DeviceDoc/3092c.pdf
[11] Webb, John W.; Reis, Ronald A.. Programmable Logic Controllers: Principles
and Applications. 4. ed. Rio de Janeiro, 1999.