PLC Mitsubishi

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



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



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

i

DEDICATÓRIA

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

ii

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.

iii

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

iv

LISTA DE TABELA

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

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

v

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

vi

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

vii

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

viii

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.

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


Para entrada de 4 a 20mA, deve-se colocar o jumper JP2 na posição 2-3 e o


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 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

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

Denominação Denominação

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.

Inicialização

Ladder Carregado

Leitura das entradas;Execução do Programa LadderAtualização das saídas

Carregamento do Programa Ladder

Início

Aguardando

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);


if ((bit_test(selecao,0)==1))

teste2 = 0;

}

break;

}


}

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();


return ent;

}

// Saída

saida(int valor)

{


set_tris_d(0x00);

output_d(valor);


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



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];


}

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

void AND_NOT(int endf)

{

device_ent = read_eeprom(0x1C + endf);

temp[pf-1] = temp[pf-1] & (~device_ent);


}

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

53

void OR()

{

--pf;

temp[pf-1] = temp[pf-1] | temp[pf];


}

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

void OUT(int endf)

{

write_eeprom(0x1C + endf,temp[pf-1]);


--pf;

}

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

void OUT_NOT(int endf)

{

write_eeprom(0x1C + endf,~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(0x2A)==0xff) saida_porta.y6 = 1;


if (read_eeprom(0x2B)==0xff) saida_porta.y7 = 1;


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_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);








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);


if ((bit_test(selecao,0)==1))

teste2 = 0;

}

break;

}


}

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.

Documents

PLC Mitsubishi