desenvolvimento de um micro clp com softwares supervisao programacao em fdb renan rodrigues ribeiro
TRANSCRIPT
FACULDADE NOVO MILÊNIO
COORDENADORIA DE ENGENHARIA ELÉTRICA PROJETO DE GRADUAÇÃO
DESENVOLVIMENTO DE UM MICRO-CLP COM SOFTWARES DE SUPERVISÃO E
PROGRAMAÇÃO EM FBD
RENAN RODRIGUES RIBEIRO
VILA VELHA – ES DEZ/2010
RENAN RODRIGUES RIBEIRO
DESENVOLVIMENTO DE UM MICRO-CLP COM SOFTWARES DE SUPERVISÃO E
PROGRAMAÇÃO EM FBD Parte manuscrita do Projeto de Graduação do aluno Renan Rodrigues Ribeiro, apresentado a Coordenadoria de Engenharia Elétrica da Faculdade Novo Milênio, para obtenção do grau de Engenheiro Eletricista.
VILA VELHA – ES
DEZ/2010
RENAN RODRIGUES RIBEIRO
DESENVOLVIMENTO DE UM MICRO-CLP E SOFTWARES DE SUPERVISÃO E
PROGRAMAÇÃO EM FBD
COMISSÃO EXAMINADORA: ___________________________________ Prof. MsC. Ralf Luis de Moura Orientador ___________________________________ Prof. Adjuto Martins Vasconcelos Júnior Examinador ___________________________________ Prof. Jan Jensen Examinador
Vila Velha - ES, 13, Dezembro, 2010
i
DEDICATÓRIA
À minha família, à minha namorada e aos meus amigos.
ii
AGRADECIMENTOS
Agradeço a Deus por sempre estar presente em minha vida, a minha família
que foi fundamental para minha formação, aos professores por todos os ensinamentos
e aos amigos da VALE por todo apoio e incentivo durante o desenvolvimento do
projeto.
iii
LISTA DE FIGURAS
Figura 1 – Estrutura Básica de um CLP. ..................................................................... 15
Figura 2 – Estrutura Básica do Sistema de Memória. ................................................. 17
Figura 3 – Possíveis entradas e saídas de um CLP. ..................................................... 17
Figura 4 – Estados de um CLP. ................................................................................... 18
Figura 5 – Fluxograma de funcionamento de um CLP em modo de operação. .......... 19
Figura 6 – Lógica em Diagrama de Blocos de Função. ............................................... 21
Figura 7 – Arquitetura geral de um microcontrolador. ................................................ 24
Figura 8 – Pinagem do PIC16F877A ........................................................................... 26
Figura 9 – Distancia x Taxa de transmissão. ............................................................... 27
Figura 10 – Transmissão do conteúdo binário no barramento RS-485. ...................... 28
Figura 11 – Visão geral do sistema. ............................................................................. 29
Figura 12 – Visão geral da arquitetura do módulo CPU. ............................................ 30
Figura 13 – Comunicação I2C. .................................................................................... 31
Figura 14 – Aplicação típica da rede RS-485. ............................................................. 33
Figura 15 – Circuito elétrico das entradas. .................................................................. 35
Figura 16 – Circuito elétrico das saídas. ...................................................................... 36
Figura 17 – Circuito conversor RS-232/RS-485. ........................................................ 37
Figura 18 – Mapa de conectores e leds dos módulos. ................................................. 37
Figura 19 – Fluxograma da comunicação durante o carregamento do micro-CLP. .... 45
Figura 20 – Fluxo de execução do firmware. .............................................................. 46
Figura 21 – Funcionamento do controle do Scan Time. .............................................. 48
Figura 22 – Layout final do software de programação em FBD. ................................ 53
Figura 23 – Blocos funcionais desenvolvidos. ............................................................ 54
Figura 24 – Representação gráfica das entradas e saídas. ........................................... 55
Figura 25 – Layout final do software de programação em FBD. ................................ 56
Figura 26 – Etapas de compilação e carregamento do programa de aplicação. .......... 57
Figura 27 – Layout final do software de supervisão. .................................................. 59
Figura 28 – Fluxograma do funcionamento básico do software de supervisão. ......... 61
Figura 29 – Programa FBD do controle da coluna lavadora. ...................................... 64
iv
Figura 30 – Telas de supervisão da coluna lavadora. .................................................. 64
Figura 31 – Plataforma de testes. ................................................................................. 65
Figura 32 – Plataforma de testes. ................................................................................. 67
v
LISTA DE TABELAS
Tabela 1 – Classificação das linguagens de programação. .......................................... 20
Tabela 2 – Tabela de estados lógicos de um transceptor RS-485. .............................. 27
Tabela 3 – Formato das instruções internas do micro-CLP. ........................................ 40
Tabela 4 – Lista de instruções. .................................................................................... 41
Tabela 5 – Modos de endereçamento. ......................................................................... 41
Tabela 6 – Valores utilizados no controle de envio de dados. .................................... 44
Tabela 7 – Valores utilizados no controle de recebimento de dados........................... 44
Tabela 8 – Descrição das entradas do micro-CLP. ...................................................... 63
Tabela 9 – Descrição das saídas do micro-CLP. ......................................................... 63
vi
GLOSSÁRIO
FBD - Function Block Diagram
PID - Proporcional-Integral-Derivativo
PIC - Peripheral Interface Controller
GM - General Motors
CPU - Central Processing Unit
EEPROM - Electrically-Erasable Programmable Read-Only Memory
IL - Instruction List
ST - Structured Text
LD - Ladder Diagram
SFC - Sequential Flow Chart
RISC - Reduced Instruction Set Computer
CCP - Capture, Compare e PWM
I2C - Inter Integrated Circuit
RTS - Request To Send
CP - Contador de Programa
OOP - Object Oriented Programming
IDE - Integrated Development Enviroments
RAD - Rapid Application Development
vii
SUMÁRIO
DEDICATÓRIA........................................................................................................... I
AGRADECIMENTOS ...............................................................................................II
LISTA DE FIGURAS ............................................................................................... III
LISTA DE TABELAS ................................................................................................ V
GLOSSÁRIO ............................................................................................................. VI
SUMÁRIO ................................................................................................................ VII
RESUMO ..................................................................................................................... X
1 INTRODUÇÃO .............................................................................................. 11
1.1 Motivação.......................................................................................................... 11
1.2 Objetivo ............................................................................................................. 12
1.3 Metodologia ...................................................................................................... 12
1.4 Organização do Texto ....................................................................................... 13
2 CONTROLADOR LÓGICO PROGRAMÁVEL ....................................... 14
2.1 Historia do CLP ................................................................................................ 14
2.2 Arquitetura do CLP ........................................................................................... 15
2.3 Principio de Funcionamento do CLP ................................................................ 18
2.4 Linguagens de Programação ............................................................................. 20
2.4.1 Linguagem FBD ...................................................................................... 21
3 DESENVOLVIMENTO DO HARDWARE ................................................ 23
3.1 Microcontroladores ........................................................................................... 23
3.1.1 O PIC16F877A ........................................................................................ 25
3.2 O Padrão RS485 ................................................................................................ 26
3.3 Definições do Projeto ........................................................................................ 28
3.4 Módulo CPU ..................................................................................................... 29
3.4.1 Memória e Protocolo I2C ........................................................................ 30
3.4.2 Porta de comunicação .............................................................................. 32
3.5 Módulo de Entradas Digitais ............................................................................ 34
3.6 Módulo de Saídas Digitais ................................................................................ 35
3.7 Conversor RS-232/RS-485 ............................................................................... 36
viii
3.8 Fonte de Alimentação ....................................................................................... 37
3.9 Mapa de Conectores e Leds Indicadores de Status ........................................... 37
4 DESENVOLVIMENTO DO FIRMWARE ................................................. 40
4.1 Instruções .......................................................................................................... 40
4.2 Cabeçalho .......................................................................................................... 42
4.3 Interrupções ....................................................................................................... 43
4.4 Comunicação ..................................................................................................... 43
4.5 Principais Rotinas ............................................................................................. 46
5 DESENVOLVIMENTO DOS SOFTWARES ............................................. 50
5.1 Linguagem C++ ................................................................................................ 50
5.2 Ambientes de Desenvolvimento ....................................................................... 51
5.2.1 O Ambiente de Desenvolvimento C++ Builder ...................................... 51
5.3 Software de Programação em FBD................................................................... 52
5.3.1 Definição do Layout ................................................................................ 52
5.3.2 Funções Projetadas .................................................................................. 54
5.3.3 Canais Disponíveis para a Programação ................................................. 55
5.3.4 Desenhando o FBD ................................................................................. 56
5.3.5 Compilação e Carregamento ................................................................... 56
5.4 Software Supervisório ....................................................................................... 58
5.4.1 Sistema de Supervisão e Aquisição de Dados ......................................... 58
5.4.2 Definições ................................................................................................ 59
5.4.3 Comunicação com o CLP ........................................................................ 60
6 TESTES E RESULTADOS ........................................................................... 62
6.1 Sistema de Despoeiramento .............................................................................. 62
6.2 Programação da Lógica em FBD ...................................................................... 62
6.3 Criação da Tela de Supervisão .......................................................................... 64
6.4 Resultados ......................................................................................................... 65
7 CONCLUSÕES .............................................................................................. 68
APÊNDICE A – CIRCUITO DO MÓDULO CPU ................................................ 69
APÊNDICE B – CIRCUITO DO MÓDULO DE ENTRADAS ............................ 70
ix
APÊNDICE C – CIRCUITO DO MÓDULO DE SAÍDAS ................................... 71
REFERÊNCIAS BIBLIOGRÁFICAS..................................................................... 72
x
RESUMO
Este trabalho consiste no estudo e desenvolvimento de três elementos
fundamentais nos sistemas de automação de baixa complexidade, os quais são: micro-
CLP, software de supervisão e software de programação em linguagem FBD.
Para isso, foi necessário realizar um estudo do funcionamento dos CLPs, bem
como seus principais conceitos e aplicações. Alem disso, são estudadas as principais
características da linguagem FBD apresentando seus principais blocos funcionais.
No desenvolvimento do micro-CLP, são analisadas as principais
características do microcontrolador PIC16F877A, escolhido para desempenhar as
funções de processamento e gerenciamento da comunicação. Alem disso, é descrito o
funcionamento do padrão RS-485 utilizado na implementação da comunicação entre o
micro-CLP e os softwares de programação e supervisão.
De posse dos conhecimentos obtidos através do embasamento teórico,
iniciam-se as definições da arquitetura de hardware e o desenvolvimento dos módulos
do micro-CLP. Também é elaborado o firmware responsável pela execução do
programa de aplicação.
Em seguida, é realizado um estudo sobre o ambiente de desenvolvimento
Borland C++ Builder e a linguagem de programação C++, os quais são utilizados
durante o desenvolvimento dos softwares de programação e supervisão.
11
1 INTRODUÇÃO
Este Projeto de Graduação tem como pressuposto a proposta de integrar o
conhecimento adquirido durante o curso de Engenharia Elétrica com habilitação em
computação, com um projeto interessante e de grande utilidade.
1.1 Motivação
A necessidade de aumentar a qualidade e a produtividade das indústrias
automobilísticas da década de 60 proporcionou o desenvolvimento dos primeiros
Controladores Lógicos Programáveis (CLP). A partir daí, o CLP se tornou um dos
equipamentos mais utilizados na implementação de sistemas automatizados.
A ampla utilização dos CLPs vem impulsionando o desenvolvimento de novas
funcionalidades. Atualmente, os processadores utilizados nos CLPs possuem uma alta
capacidade computacional, capaz de realizar tarefas complexas através de co-
processadores e controlar uma grande quantidade de variáveis analógicas e digitais.
Em contrapartida, toda esta capacidade disponível nos CLPs de grande porte
possui um preço que inviabiliza sua aplicação para sistemas com baixo nível de
complexidade, tais como as plataformas de uso didático.
Por outro lado, no estagio atual da tecnologia, dispositivos de alto desempenho
e baixo custo como os microcontroladores vêm sendo amplamente utilizados na
construção de sistemas mais compactos e versáteis, com um custo relativamente baixo.
Portanto, a fim de criar alternativas com desempenho que atenda os requisitos
de controle dos sistemas de baixa complexidade e custo mais acessível, é apresentado
nesse projeto o desenvolvimento de um micro-CLP de baixo custo com 8 entradas e 8
saídas digitas e uma porta de comunicação para programação e supervisão através do
padrão RS-485.
A Linguagem de Diagrama de Blocos está bastante difundida no controle de
processos industriais devido à facilidade de aprendizado e utilização. Neste sentido, o
projeto aqui apresentado contempla o desenvolvimento de um software de
programação em linguagem FBD contendo os principais blocos funcionais para
aplicações discretas.
12
1.2 Objetivo
O objetivo deste projeto é desenvolver um micro-CLP com softwares de
supervisão e programação em FBD, a fim de proporcionar uma solução de baixo custo
para a implementação de sistemas automatizados com nível de complexidade baixo,
tais como aplicações didáticas para ensino de automação e controle.
1.3 Metodologia
Inicialmente foram analisadas diversas idéias e possibilidades de arquiteturas
do projeto. Arquiteturas simples e complexas foram pesquisadas, assim como a
disponibilidade de material para desenvolvimento do projeto, componentes e exemplos
de códigos. Estes foram os principais pontos para o início do desenvolvimento do
trabalho.
Na primeira etapa de desenvolvimento, fez-se o uso intenso do software
Proteus 7 para a simulação do funcionamento do microcontrolador quanto a execução
das rotinas do micro-CLP e a comunicação serial com os softwares de programação e
supervisão. Apenas quando verificado em simulação todo o funcionamento do micro-
CLP, os módulos foram criados e testados.
A idéia de implementar canais analógicos e funções complexas como ao
controle PID mostraram-se interessantes a princípio, contudo foi descartada durante a
fase de desenvolvimento do firmware, devido a sua alta complexidade. A
implementação de canais digitais e blocos funcionais básicos mostrou-se mais atrativa
e facilitou a finalização da primeira fase do projeto.
A segunda etapa do desenvolvimento voltou-se para uma implementação em
conjunto do firmware e do software. Antes, entretanto, foi necessário decidir qual seria
a plataforma de desenvolvimento utilizada, assim como a linguagem de programação.
Optou-se pela linguagem C e a plataforma de desenvolvimento mikroC PRO,
da empresa Mikroelektronika, devido aos exemplos de códigos pré-existentes para
esta plataforma.
13
Quanto aos softwares de programação e supervisão, optou-se pelo Borland
C++ Builder 6, devido às facilidades gráficas da plataforma e devido à grande
variedade de componentes disponíveis.
Com o hardware simulado, firmware e softwares operando, iniciou-se a etapa
de confecção das placas de circuito impresso dos módulos.
A etapa final do projeto foi focada em uma bateria de testes e comparação
entre os resultados esperados e os resultados obtidos.
1.4 Organização do Texto
O trabalho está organizado em sete capítulos e três apêndices.
O segundo capítulo aborda o estudo dos CLPs, apresentando sua historia,
arquitetura e principio básico de funcionamento. Este capítulo também descreve os
conceitos de linguagem de programação, enfatizando a linguagem FBD.
O terceiro capítulo mostra o estudo e o desenvolvimento do projeto do micro-
CLP. São descritas as principais características do microcontrolador PIC16F877A e do
padrão RS-485. Posteriormente, é mostrado todas as etapas de definição e
implementação do hardware do micro-CLP.
O quarto capítulo apresenta o desenvolvimento do firmware, descrevendo todo
o seu funcionamento.
O quinto capítulo inicialmente descreve os principais conceitos da linguagem
C++ e apresenta as características do ambiente de desenvolvimento C++ Builder. Após
a abordagem teórica, o capitulo descreve todas as etapas de desenvolvimento dos
softwares de supervisão e programação em FBD.
O sexto capítulo apresenta os testes realizados buscando a validação do
funcionamento do sistema.
Por fim, no sétimo capítulo, avaliam-se os resultados obtidos e são
apresentadas sugestões para trabalhos futuros.
14
2 CONTROLADOR LÓGICO PROGRAMÁVEL
Controlador Lógico Programável (CLP) é um dispositivo eletrônico de estado
sólido, baseado em um microprocessador, projetado para controlar sistemas
automatizados, capaz de armazenar e executar instruções definidas num software
aplicativo pelo usuário [1].
Segundo a National Electrical Manufactures Association (NEMA), o CLP é
um aparelho eletrônico digital que utiliza uma memória programável para armazenar
internamente instruções e implementar funções específicas, tais como: lógica,
seqüenciamento, 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 [2].
2.1 Historia do CLP
Os primeiros CLPs surgiram na década de 60, como conseqüência das
necessidades das indústrias automotivas de aumentarem a qualidade e produtividade
de suas linhas de produção. Antes dos CLPs, todas as tarefas de controle de processos
industriais eram feitas através de painéis de controle a relés, que necessitavam ser
reconstruídos a cada vez que se modificava a lógica de controle. Como estas
modificações ocorriam freqüentemente, fazia-se necessário encontrar uma alternativa
para tornar os sistemas de controle mais flexíveis e facilmente reutilizáveis.
Em 1968, a primeira especificação para o projeto do CLP foi elaborada pela
General Motors (GM), com o objetivo de produzir um equipamento com preço
competitivo com os sistemas de relés, dispositivos de entrada e saída facilmente
substituíveis, funcionamento em ambiente industrial, facilidade de programação e
manutenção por técnicos e engenheiros e repetibilidade de operação e uso. Então, em
1969, foi desenvolvido pela Gould Modicon o primeiro controlador a atender as
especificações elaboradas pela GM [1].
Inicialmente, os CLPs eram utilizados apenas em aplicações de controle
discreto, porém, diferentemente dos sistemas a relés, eram facilmente instalados,
economizando espaço e energia, possuíam indicadores de diagnósticos e as alterações
15
na lógica de controle eram realizadas em pouco tempo, apenas com alteração no
programa, sem precisar alterar as ligações elétricas.
Na década de 70, os CLPs passaram por varias etapas de aprimoramento. Em
1972, incorporaram funções de temporização e contagem, em 1973 surgiu o primeiro
sistema de comunicação que permitia que os CLPs trocassem informações com outros
computadores, já em 1975 passou a incorporar maior capacidade de memória,
controles analógicos e controle PID, em 1979 surgiram os módulos de I/O remotos.
Nos anos 80, os CLPs são aperfeiçoados, possibilitando a comunicação em
rede, que hoje é um recurso indispensável na indústria.
As atuais gerações de CLPs possuem funções avançadas de controle, grande
numero de pontos de entradas e saídas, módulos remotos, softwares de programação
em ambiente Windows, maior velocidade de processamento e pequenos e micros CLPs
que oferecem vários recursos encontrados nos grandes CLPs [1].
2.2 Arquitetura do CLP
Os CLPs são constituídos basicamente por quatro blocos, mostrados na Figura
1, os quais são: CPU, módulos de I/O, fonte de alimentação e Base [1].
Figura 1 – Estrutura Básica de um CLP.
• CPU (Central Processing Unit – Unidade Central de Processamento): é o
elemento principal do controlador, compreendendo o processador, que pode
ser um microprocessador, microcontrolador ou processador dedicado. O
16
sistema de memória (ROM e RAM) e os circuitos auxiliares de controle
também estão contidos neste bloco;
• Módulos ou Circuitos de E/S (Entrada/Saída): é o meio físico de conexão
do CLP aos sensores e atuadores do processo. As entradas e saídas podem
ser do tipo discreto, assumindo os níveis lógicos: 0 ou 1, ligado ou
desligado, através de sinais de tensão, contatos normalmente abertos e
contatos normalmente fechados. Outro tipo são as entradas e saídas
continuas que são padronizados para trabalhar numa faixa, normalmente, de
4 a 20 mA ou 0 a 10 Vdc. A diferença básica entre módulos e circuitos de
E/S deve-se ao tipo de CLP. No caso dos CLPs compactos onde a CPU e as
E/S estão contidas em um único invólucro, é usado o termo Circuitos de
E/S. Para CLPs Modulares, onde as E/S estão disponíveis de forma
independente da CPU, usa-se o termo: Módulo de E/S;
• Fonte de Alimentação: é encarregada de fornecer alimentação ao
barramento do CLP, com proteção contra picos de tensão, garantindo a
operação normal da CPU e dos módulos e circuitos de E/S;
• Base: realiza a sustentação mecânica dos elementos que compõe o CLP e
contem o barramento de conexão elétrico responsável pela alimentação e
comunicação entre a CPU e os módulos de E/S.
O sistema de memória da CPU de um CLP divide-se em memória de aplicação
e memória do sistema de operação.
A memória de aplicação armazena o programa com a lógica de controle
desenvolvida pelo usuário, e pode ser do tipo EEPROM, EPROM ou RAM com
bateria de segurança [1].
A memória do sistema de operação, também conhecida como Firmware,
armazena o programa desenvolvido pelo fabricante do CLP, que realiza as atividades
de operação, tais como: execução do programa de aplicação e atualização dos módulos
17
de E/S. Essa é uma memória não volátil, do tipo ROM. Na Figura 2 pode-se ver a
estrutura básica do sistema de memória de um CLP.
Figura 2 – Estrutura Básica do Sistema de Memória.
As CPUs possuem pelo menos uma porta de comunicação serial para
configuração do CLP e troca de dados com dispositivos externos, porem está porta
pode não ser adequada a determinadas aplicações, sendo necessário incluir módulos
especiais de comunicação [1].
A figura 3 apresenta algumas entradas e saídas típicas de um CLP, bem como
a utilização de um microcomputador como dispositivo de programação.
Figura 3 – Possíveis entradas e saídas de um CLP.
18
Os CLPs podem ser classificados de acordo com a quantidade de pontos de
E/S que a CPU pode controlar e a quantidade de memória disponível para o programa
de aplicação [1].
• Micro-CLPs: até 64 pontos de E/S e até 2Kwords de memória.
• Pequenos CLPs: de 64 a 512 pontos de E/S e até 4Kwords de memória.
• CLPs médios: de 256 a 2048 pontos de E/S e dezenas de Kwords de
memória.
• Grandes CLPs: acima de 2048 pontos de E/S e centenas de Kwords de
memória.
2.3 Principio de Funcionamento do CLP
De maneira geral, os CLPs podem assumir três estados de funcionamento:
estado de espera, estado de execução e erro.
Figura 4 – Estados de um CLP.
O CLP assume o estado de espera quando está em modo de programação.
Nesse modo, o CLP não executa o programa de aplicação, aguardando a requisição do
software de programação para o carregamento do programa de aplicação com a lógica
de controle definida pelo usuário.
19
Quando está no estado de execução, também chamado de modo de operação, o
CLP trabalha executando continuamente os ciclos de varredura (Scan), cuja duração
(Scan Time) está diretamente relacionada à quantidade de pontos de entrada, tamanho
do programa de aplicação, tipos de instruções utilizadas e quantidade de pontos de
saídas. O ciclo de varredura compreende as etapas de atualização das entradas,
execução do programa de Aplicação e atualização das saídas. Na figura 5 pode-se ver
o fluxograma de funcionamento de um CLP em modo de operação [1].
Figura 5 – Fluxograma de funcionamento de um CLP em modo de operação.
O CLP realiza a leitura do estado de cada uma das entradas e armazena na
tabela de imagem das entradas, localizada numa região da memória de aplicação
chamada Tabela de Dados.
Durante a execução do programa de aplicação, a CPU consulta a tabela de
imagem das entradas, e atualiza a tabela de imagem das saídas, de acordo com as
instruções da lógica definida pelo usuário.
Após a execução do programa de aplicação, o CLP atualiza o estado de cada
uma das saídas com o conteúdo da tabela de imagem das saídas, gerada a partir da
lógica executada. Inicia-se então, um novo ciclo de varredura [1].
20
2.4 Linguagens de Programação
O fator responsável pela flexibilidade de um CLP é a sua capacidade de ser
facilmente programado através de um microcomputador. Ao longo dos anos, com a
evolução dos CLPs, surgiram diversas linguagens de programação, possibilitando o
desenvolvimento de programas melhor estruturados, de alto nível e com recursos
gráficos cada vez mais avançados.
A Comissão Eletrotécnica Internacional (IEC - International Electrotechnical
Committee) é a responsável pela padronização dessas linguagens de programação. A
norma IEC 61131-3 define cinco linguagens de programação, divididas em duas
classes, conforme é apresentado na Tabela 1 [3].
Classes Linguagens
Textuais IL (Instruction List)
ST (Structured Text)
Gráficas
LD (Ladder Diagram)
SFC (Sequential Flow Chart)
FBD (Function Block Diagram)
Tabela 1 – Classificação das linguagens de programação.
A Linguagem de diagramas de contato, mais conhecida por linguagem Ladder,
foi a primeira linguagem criada para programação dos CLPs. Por ser uma linguagem
baseada na representação gráfica da lógica de relés, o Ladder foi determinante para a
aceitação do CLP por técnicos e engenheiros acostumados com o sistema de controle a
relés [1].
Outra linguagem de programação para CLPs bastante familiar para os técnicos
e engenheiros, é a Linguagem FBD que atualmente é uma das linguagens de
programação mais utilizada nas indústrias de processo por se parecer com o sistema
em termos do fluxo de sinais entre elementos de processamento tornando mais clara a
programação e inspeção do programa.
21
2.4.1 Linguagem FBD
A Linguagem FBD (Function Block Diagram – Diagrama de Blocos de
Função), mais conhecida por Diagrama de Blocos, é uma linguagem gráfica de alto
nível que permite descrever um processo através de um conjunto de blocos
interconectados por linhas de fluxo, caracterizando-se por uma grande semelhança
com os circuitos eletrônicos digitais [3].
As interconexões entre os blocos devem seguir a convenção utilizada para
linguagens gráficas. Nesta convenção, o lado esquerdo é destinado para os sinais de
entradas do bloco, enquanto o lado direito é reservado para os sinais de saída do bloco.
Na Figura 6 é apresentada uma lógica em linguagem FBD que produz o resultado: S1
= E3 AND ( E1 OR E2 ).
Figura 6 – Lógica em Diagrama de Blocos de Função.
Cada bloco tem um número fixo de pontos de conexão de entrada e de saída, e
é representado por um simples retângulo. A saída de um bloco pode ser conectada a
entrada de outro bloco, desta forma, os sinais se propagam das saídas dos blocos para
as entradas de outros blocos e as saídas são atualizadas como um resultado do
processamento dos blocos.
Os blocos Funcionais padrões da linguagem FBD são:
• Blocos Lógicos: OR, AND, XOR, NOT;
• Blocos Biestáveis: RS e SR;
• Blocos Temporizadores: TON e TOF;
22
• Blocos Contadores: CTU, CTD, CTUD;
• Blocos Detectores de Borda: R_TRIG e F_TRIG;
• Blocos Comparadores: EQ, NE, LT, LE, GT e GE.
23
3 DESENVOLVIMENTO DO HARDWARE
Neste capítulo serão descritas todas as etapas do desenvolvimento do hardware
do micro-CLP, desde os aspectos teóricos relacionado ao projeto até a construção dos
circuitos eletrônicos.
3.1 Microcontroladores
Os microcontroladores estão revolucionando o projeto de equipamentos
eletrônicos. Não somente os sistemas convencionais estão se tornando mais
sofisticados e baratos, como novas funcionalidades estão sendo possíveis de serem
implementadas a um custo compatível com o mercado.
Tipicamente, os microcontroladores possuem integrados em uma única
pastilha, a CPU, memória RAM, memória EPROM (ou suas variantes EEPROM,
ROM e PROM), entradas e saídas digitais e analógicas, temporizadores e
controladores de interrupção, enfatizando a auto-suficiência, em contraste com um
microprocessador de propósito geral, que requer circuitos especiais, como chips
externos para prover a comunicação com os periféricos. A arquitetura geral de um
microcontrolador pode ser vista na Figura 7 [6].
24
Figura 7 – Arquitetura geral de um microcontrolador.
Existem diversas empresas fabricantes de microcontroladores, entre elas, a
Microchip Technology Inc. que criou a família de microcontroladores Peripheral
Interface Controller (PIC). Trata-se de microcontroladores com arquitetura Harvard
que prevê várias vias de comunicação entre a CPU e os periféricos, permitindo a
realização de várias operações simultaneamente, o que implica em um aumento
considerável na velocidade de execução e permite ainda que a memória de dados e o
programa tenham tamanhos diferentes [6].
O PIC possui tecnologia Reduced Instruction Set Computer (RISC), isto
significa dizer que estes microcontroladores possuem um número reduzido de
instruções, como é o caso do PIC16F877A que possui apenas 35 instruções [8].
25
3.1.1 O PIC16F877A
O PIC16F877A é um microcontrolador de baixo custo e suficientemente
robusto fabricado pela Microchip Technology, com palavras de dados de 8 bits de
tamanho, e palavras de instrução de 14 bits. Suas principais características são [8]:
• 40 pinos, o que possibilita a montagem de um hardware capaz de interagir
com diversos recursos e funções ao mesmo tempo;
• Conjunto de instruções RISC com 35 instruções;
• 33 portas configuráveis como entrada ou saída;
• Conversor analógico-digital de 10 bits de resolução e 8 canais de entrada;
• Memória de programação EEPROM, permitindo a gravação rápida do
programa diversas vezes no mesmo chip, sem a necessidade de apagá-lo por
meio de luz ultravioleta;
• Memória de programa com 8kwords, com capacidade de escrita e leitura
pelo próprio código interno;
• Memória EEPROM interna com 256 bytes;
• Memória RAM com 368 bytes;
• Comunicações seriais: SPI, I2C e USART;
• Dois módulos CCP (Capture, Compare e PWM).
• Dois temporizadores de 8 bits programável, com pré-divisor;
• Um temporizador de 16 bits;
• Operação em tensões de 2 a 5,5 volts;
• Freqüência de operação (clock) de até 20MHz.
Para manter o número de terminais pequeno e ao mesmo tempo comportar o
grande numero de periféricos, vários pinos do PIC16F877A são multiplexados, ou
seja, estes pinos possuem mais de uma função. A seleção da função depende do modo
de operação do PIC [8].
26
A definição dos terminais do PIC16F877A é apresentada na Figura 9 [6]:
Figura 8 – Pinagem do PIC16F877A
3.2 O Padrão RS485
O padrão RS-485 é administrado pela Telecommunication Industry
Association (TIA) que é responsável pelo setor de comunicação da Electronic
Industries Alliance (EIA). Ele é chamado normalmente de RS485, entretanto seu
nome oficial é EIA-485, que reflete o nome do comitê que no ano 1998 o padronizou.
O padrão RS-485 tem como propósito garantir a imunidade do sinal quanto às
questões de ruído e distância, desta forma é o padrão mais utilizado em ambiente
industrial nos dias de hoje.
O funcionamento físico do padrão RS485 é baseado na transmissão diferencial
de dados, sendo um padrão ideal para transmissão em altas velocidades, longas
distâncias e em ambientes propícios a interferências eletromagnéticas. Este padrão
representa um baixo custo de implantação e pode transmitir dados a uma velocidade de
até 10 Mbps e podendo suportar distâncias de 1200 metros. Porém quanto maior for
esta distância, menor será sua taxa de transmissão, conforme é mostrado no gráfico da
Figura 9 [4].
27
Figura 9 – Distancia x Taxa de transmissão.
Outra grande vantagem do padrão RS-485 é a facilidade de conversão do
padrão RS-232 ao RS-485, simplesmente utilizando um circuito integrado e poucos
componentes, com isso a compatibilidade com dispositivos já existentes no mercado é
mantida, visto que a maioria dos computadores possui portas de comunicação serial
RS-232.
O padrão RS-485 não define e nem recomenda nenhum protocolo de
comunicação [7].
A comunicação RS-485 é realizada através de dois fios, sendo um deles
chamado de A e o outro de B. Na Tabela 2 são descritos os estados lógicos de A e B
de acordo com o dado que o transmissor precisa enviar:
Tabela 2 – Tabela de estados lógicos de um transceptor RS-485.
Nota-se que quando o transmissor (INPUT D) fica em alto, a linha A fica mais
positiva que a B e o inverso ocorre quando o estado inverte. Há também uma linha de
28
controle chamada DE (habilitação da transmissão) e quando a mesma fica em nível
lógico baixo, o barramento fica em alta-impedância.
Para que o receptor identifique um sinal válido, a diferença entre os terminais
A e B deve ser maior que 200 mV.
Na Figura 10 pode-se visualizar o gráfico que mostra a transmissão do
conteúdo binário 01001 a uma taxa de 9600 bps no barramento RS-485.
Figura 10 – Transmissão do conteúdo binário no barramento RS-485.
3.3 Definições do Projeto
O primeiro passo antes da implementação do hardware foi a elaboração de um
esboço de uma aplicação básica utilizando o micro-CLP. Neste esboço são definidos
os elementos envolvidos no processo e os padrões de comunicação a serem utilizados.
Uma idéia genérica pode ser observada na Figura 11.
29
Figura 11 – Visão geral do sistema.
Com a visão geral do sistema em mente, o próximo passo foi definir a
arquitetura básica do hardware do micro-CLP de forma que atendesse os requisitos
para o perfeito funcionamento da aplicação apresentada na Figura 11.
Foram definidas as seguintes características para o hardware do CLP:
• 8 entradas digitais de 24V;
• 8 saídas digitais a relé;
• 1 porta de comunicação RS-485;
• 5 leds de indicação de status de sistema;
• 1 chave de controle de modo de operação.
3.4 Módulo CPU
No desenvolvimento do módulo CPU, utilizou-se um microcontrolador
PIC16F877A, um circuito integrado MAX485, uma memória EEPROM 24C16A,
30
alem dos componentes auxiliares, tais como capacitores, resistores, cristal, conectores
e chaves. Uma visão geral da arquitetura do modulo CPU pode ser vista na Figura 12.
Figura 12 – Visão geral da arquitetura do módulo CPU.
O microcontrolador PIC16F877A é o principal elemento deste módulo,
responsável pela leitura das entradas, processamento do programa de aplicação,
atualização das saídas, além de gerenciar toda a comunicação entre o CLP e o
computador.
O modulo CPU é alimentado por uma fonte externa com tensão continua de
5V, cuja função é alimentar o circuito interno e fornecer a alimentação necessária aos
módulos de entradas e saídas. Um cristal oscilador 8Mhz está ligado ao
microcontrolador determinando a sua freqüência de operação.
3.4.1 Memória e Protocolo I2C
Para que os dados configurados pelo usuário não sejam perdidos quando
ocorre uma queda de energia no sistema, os mesmos devem ser gravados numa
memória não volátil.
31
Na etapa de definição do projeto, uma idéia inicial foi a de utilizar a memória
EEPROM do microcontrolador para armazenar o programa de aplicação. Tal idéia
logo se mostrou insuficiente, pois haveria pouco espaço de memória de aplicação.
Cada instrução do programa de aplicação ocupa 4 bytes e a memória EEPROM do
microcontrolador possui 256 Bytes, desta forma, o usuário poderia escrever
programas, que compilados, gerasse um código com apenas 64 instruções.
A idéia de utilizar uma memória EEPROM 24C16A foi a solução que
possibilitou maior espaço para armazenamento do programa de aplicação
desenvolvido pelo usuário, alem de possibilitar a expansibilidade de memória do
sistema.
A comunicação entre o microcontrolador e a memória EEPROM 24C16A
presente no módulo CPU é feita com o uso do protocolo I2C.
Por ser um meio de comunicação síncrono, é fácil seu entendimento. O
controle é feito apenas sobre duas vias de comunicação, o SDA e SCL. A primeira
representa a via onde os dados serão transportados e a segunda porta o sinal de clock
responsável por controlar a transferência de informações entre os dispositivos.
Toda vez que é preciso realizar uma comunicação através do protocolo I2C, é
necessário que seja enviar um sinal de start sinalizando que esta está pronta para
efetuar a transmissão. Assim como o inicio da transmissão, o seu encerramento deve
ser indicado através de um sinal de stop. A Figura 13 ilustra o formato de transmissão
do protocolo I2C para gravar um byte na memória EEPROM [9].
Figura 13 – Comunicação I2C.
32
Durante a comunicação, por serem sinais freqüentemente utilizados, foram
utilizadas funções pré-definidas no código do firmware para o envio dos sinais de start
e stop no barramento I2C. Outra função utilizada para a configuração da memória,
envia um fluxo de 8 bits através do barramento I2C, permitindo assim o envio de
valores através do barramento, possibilitando a configuração, envio de endereços e de
dados para a memória externa.
Ao final do envio de cada byte a memória exige que o dispositivo atuando
como master no circuito gere um nono pulso de clock para realizar a confirmação de
que os dados foram enviados. Esta confirmação acontece quando a memória abaixa o
nível de tensão do SDA durante o nono ciclo de clock gerado pelo microcontrolador
[9].
3.4.2 Porta de comunicação
A escolha do padrão RS-485 como meio físico de comunicação apresenta
várias vantagens, dentre elas, a construção de barramento simples, confiável e de baixo
custo. O transceptor escolhido, modelo MAX485 da Maxim, pode ser encontrado no
mercado com bastante facilidade.
Neste projeto, a taxa de transmissão adotada foi a de 9600 Kbps de forma que
a limitação da distância não foi um problema para esta aplicação.
As interpretações das especificações e as características do padrão variam de
fabricante para fabricante, porém essas especificações devem ser seguidas pelos
fabricantes dos chips que implementam o padrão RS-485. Uma aplicação típica da
rede é mostrada na Figura 14.
33
Figura 14 – Aplicação típica da rede RS-485.
O meio físico implementado neste projeto é constituído por uma linha RS-485
que conecta o micro-CLP ao computador por meio de um conversor de comunicação
RS-232 / RS-485.
A rede desenvolvida suporta apenas comunicação half-duplex, ou seja, a
comunicação ocorre em uma direção por vez, numa configuração ponto a ponto.
Para ser possível a troca de mensagens via RS-485 entre o micro-CLP e o
computador, foi necessário a introdução do transceptor MAX485 como citado
anteriormente. A ligação física deste chip ao microcontrolador é feita ligando-se os
pinos 1 e 4 do MAX485 respectivamente nos pinos TX e RX do PIC16F877A.
O pino RC2 é configurado como sendo uma saída digital no microcontrolador,
e está conectado aos pinos 2 e 3 do MAX485 realizando o controle do fluxo de dados.
Enquanto o micro-CLP está em modo de execução, o computador é colocado
em modo de recepção por todo o tempo. Quando o micro-CLP é posto em modo de
programação, o microcontrolador envia uma mensagem permitindo que seja feito o
carregamento do programa de aplicação, então o mesmo é colocado em modo de
recepção e o computador passa a ser o transmissor.
A alimentação deste chip é feita de acordo com sua folha de dados [10].
34
3.5 Módulo de Entradas Digitais
Este módulo foi desenvolvido de acordo com a definição feita na seção 3.3.
Ele possui 8 entradas digitais com um nível máximo de tensão de 24V.
Todo o circuito do modulo de entrada está eletricamente isolado dos
dispositivos externos através dos opto acopladores 4N25.
O circuito possui um conector, cujo cabo é conectado ao modulo CPU e pelo
qual recebe uma tensão contínua de 5V para sua alimentação. Por esse cabo, também,
em outras 8 vias, trafegam os dados para a comunicação com o microcontrolador.
As entradas estão configuradas como sinking de forma que os dispositivos de
campo precisam fornecer corrente ao circuito de entradas quando estão ativos.
Tomando como exemplo a entrada E1 da Figura 15, pode-se descrever o
comportamento do circuito quando é aplicada uma tensão de 24V a uma das entradas.
1. O led de indicação de status da entrada E1 acende, demonstrando que a
entrada está recebendo sinal do dispositivo externo.
2. É estabelecida uma corrente no led do opto acoplador proporcionando um
nível de luz suficiente para saturar o foto-transistor
3. O modulo de entrada envia através de um flat cable, nível lógico 1 para o
pino RB0 do microcontrolador localizado no modulo CPU.
35
Figura 15 – Circuito elétrico das entradas.
3.6 Módulo de Saídas Digitais
Este módulo foi implementado seguindo as definições de projeto feitas na
seção 3.3. Foram projetadas 8 saídas digitais a relé com contatos normalmente abertos.
O circuito também é isolado de interferências externas por meio de opto acopladores.
O circuito possui um conector, cujo cabo é conectado ao modulo CPU e pelo
qual recebe uma tensão contínua de 5V para sua alimentação. Por esse cabo, também,
em outras 8 vias, trafegam os dados para a comunicação com o microcontrolador.
Pode-se descrever o comportamento do circuito quando a CPU habilita a saída
S1 da Figura 16.
1. O microcontrolador coloca nível alto de tensão (5V) ao pino RD0 que está
ligado ao canal 1 do módulo de saída.
2. É estabelecida uma corrente no led do opto acoplador proporcionando um
nível de luz no foto-transistor.
3. Ocorre a saturação do foto-transistor e conseqüentemente a saturação do
transistor BC549.
4. Então, são conduzidos 5V para a bobina do relé que imediatamente fecha o
contato da saída S1.
36
Figura 16 – Circuito elétrico das saídas.
3.7 Conversor RS-232/RS-485
Para viabilizar os testes durante o desenvolvimento do projeto, possibilitando
a comunicação entre o micro-CLP e o computador, foi construído um conversor RS-
232/RS-485. Esta conversão exigiu o uso de um transceptor MAX232 para realizar a
conversão RS-232/TTL e outro transceptor MAX485 para converter TTL/RS-485.
Uma vez que a comunicação RS-485 escolhida é half-duplex, faz-se
necessário o uso de um sinal extra para controlar o fluxo entre o dispositivo
transmissor e o receptor, de modo a estabelecer uma sincronia no barramento,
possibilitando a comunicação. Para o computador, o sinal utilizado para controle de
fluxo é o RTS (Request To Send) disponível em um dos pinos da porta serial. Este
sinal é colocado em nível baixo (3 a 15 volts negativos) para receber dados do micro-
CLP. Quando o computador precisa transmitir dados, o RTS e colocado em nivel alto
(3 a 15 volts positivos), e então é possível iniciar o envio de dados para o micro-CLP.
Estes sinais do padrão RS-232 são convertidos para sinais TTL por meio do
circuito integrado MAX232 e ligado nas portas 6 e 7 do transceptor MAX485 que
implementa a comunicação com o micro-CLP através do padrão RS-485.
37
Figura 17 – Circuito conversor RS-232/RS-485.
3.8 Fonte de Alimentação
Este projeto não contempla a construção de uma fonte de alimentação. A
alimentação de 5V necessária para a alimentação dos módulos do micro-CLP é
fornecida por uma fonte de computador.
3.9 Mapa de Conectores e Leds Indicadores de Status
Os módulos possuem pontos de entrada e saída de sinal, jumpers, conectores e
leds indicadores de status. A Figura 15 apresenta os módulos desenvolvidos com
todos os pontos mencionados acima, destacados e numerados. Em seguida, cada item
é apresentado em detalhe mostrando-se o que representam e como são utilizados. Os
elementos semelhantes dos diferentes canais são apresentados apenas uma vez.
Figura 18 – Mapa de conectores e leds dos módulos.
38
1. Entrada do canal: Recebe sinal dos dispositivos externos.
2. Led indicador de canal ativo: Acende quando o canal é ativado por um
dispositivo externo.
3. Led indicador de módulo ligado: Indica que o módulo está sendo
alimentado.
4. Pinos de alimentação e dados: Pinos cujo cabo é conectado aos pinos
marcados com o numero 11 no módulo CPU. Dos 10 pinos, 8 são para
dados e 2 para a alimentação.
5. Jumper de escolha do modo de operação: Seleciona o modo de operação do
micro-CLP. Uma chave pode ser conectada a este jumper de forma que ao
fechar a chave, o micro-CLP entre em modo de execução, e ao abri-la o
micro-CLP entre no modo de programação.
6. Led indicador do modo de operação: Acende quando o micro-CLP está em
modo de execução.
7. Led indicador do modo de operação: Acende quando o micro-CLP está em
modo de programação.
8. Led indicador de status: Acende quando o micro-CLP está sendo
programado.
9. Led indicador de status: Acende durante a inicialização do sistema.
10. Conector de alimentação: É o ponto de entrada da alimentação que é
fornecida a todo o circuito.
11. Pinos de alimentação e dados: Pinos cujo cabo é conectado aos pinos
marcados com o numero 4 no módulo de entradas.
12. Pinos de alimentação e dados: Pinos cujo cabo é conectado aos pinos
marcados com o numero 14 no módulo de saída.
13. Conector de comunicação: Possui dois canais, A e B, sendo os canais de
comunicação RS-485 com o dispositivo externo.
39
14. Pinos de alimentação e dados: Pinos cujo cabo é conectado aos pinos
marcados com o numero 12 no módulo CPU. Dos 10 pinos, 8 são para
dados e 2 para a alimentação.
15. Led indicador de módulo ligado: Indica que o módulo está sendo
alimentado.
16. Led indicador de canal ativo: Acende sempre que o canal está acionado.
17. Saída do canal: Bornes ligados diretamente aos terminais dos relés.
40
4 DESENVOLVIMENTO DO FIRMWARE
O firmware foi desenvolvido em linguagem C para microcontroladores, para
tanto, utilizou-se a ferramenta mikroC PRO, compilador desenvolvido pela empresa
Mikroelektronika.
O firmware está localizado na memória ROM do microcontrolador e tem por
finalidade determinar como o micro-CLP deve operar, incluindo a execução do
programa de aplicação, gerenciamento da comunicação I2C com a memória EEPROM
e atualização dos módulos de E/S. Também têm como função gerenciar a comunicação
RS-485 através da interface de comunicação USART do microcontrolador.
4.1 Instruções
A elaboração das instruções internas do micro-CLP foi baseada na
configuração do hardware e definida de acordo com as funções projetadas na seção
5.3.2. O formato das instruções é apresentado na Tabela 3.
Byte 0 Byte 1 Byte 2 Byte 3
Opcode Operando 1 Operando 2 Operando 3 Tabela 3 – Formato das instruções internas do micro-CLP.
Cada instrução é composta por 4 bytes, o primeiro byte é o código da
operação, denominado Opcode, e contem o código da operação a ser realizada. Os
bytes seguintes são os operandos e podem especificar endereços de E/S, dados literais
ou endereços de memória. Na Tabela 4 são apresentadas todas as instruções projetadas
para o micro-CLP.
41
Operação Instrução
Byte 0 (Opcode) Byte 1 Byte 2 Byte 3
AND 00000001 Op1 Op2 Op3
OR 00000010 Op1 Op2 Op3
XOR 00000011 Op1 Op2 Op3
NOT 00000100 Op1 Op2 --
FF-SR 00000111 Op1 Op2 Op3
MOVE 00001000 Op1 Op2 --
FF-RS 00001001 Op1 Op2 Op3
TON 12 ~ 133 Op1 Op2 --
TOF 134 ~ 254 Op1 Op2 -- Tabela 4 – Lista de instruções.
O modo de endereçamento de cada operando é definido de acordo com seu
valor. A Tabela 5 apresenta a relação dos modos de endereçamento de acordo os
valores do operando.
Valor do operando Modo de endereçamento Descrição
1 ~ 8 Direto E/S do micro-CLP 128 ~ 192 Indireto Endereços de posição no vetor
auxiliar de memória 240 e 241 Constante literal 240 = falso
241 = Verdadeiro Tabela 5 – Modos de endereçamento.
Quando o valor do operando corresponde ao modo de endereçamento direto, o
microcontrolador faz a leitura ou a escrita diretamente nas entradas e saídas do micro-
CLP. Se o valor do operando corresponde ao modo de endereçamento indireto, o
microcontrolador faz a leitura ou escrita em uma das 64 posições de memória
reservada para manipulação da operação MOVE.
Operandos com o conteúdo 240 e 241 representam respectivamente os valores
verdadeiro e falso. Este valor é atribuído diretamente à operação.
42
Sendo que cada instrução é composta por 4 bytes e a capacidade máxima de
armazenamento da memória EEPROM é de 2048 bytes, é possível o carregamento de
um programa de aplicação com até 512 instruções.
As instruções cujo opcode possui valores entre 12 e 133 são interpretadas
pelo microcontrolador como sendo uma instrução do tipo TON com o tempo pré-
selecionado equivalente a expressão (opcode - 12). Da mesma forma, instruções com
opcode contendo valores entre 134 a 254 são interpretados pelo microcontrolador
como sendo uma instrução do tipo TOF com o tempo pré-selecionado equivalente a
expressão (opcode - 134). Isto significa que podemos pré-selecionar valores de tempo
limitados a 120 segundos.
O operando 3 dos temporizadores poderá ser útil para o desenvolvimento
futuro de funções de temporização com pré-seleção de tempos superiores a 120
segundos.
4.2 Cabeçalho
Para a manipulação das funções de temporização, reservou-se uma estrutura
de dados com capacidade de armazenamento de até 10 temporizadores. Para o
armazenamento dos valores dos operandos em modo de endereçamento indireto,
reservou-se 64 bytes na memória de operação. A estas posições reservadas na memória
do microcontrolador deu-se o nome de cabeçalho.
As operações de escrita e leitura do cabeçalho ocorrem ao longo da execução
das instruções. Quando o ciclo de varredura é executado pela primeira vez, todas as
instruções de temporização são identificadas e atribuídas a uma das estruturas
reservadas para os temporizadores, passando o valor de tempo pré-selecionado para
determinados parâmetros da estrutura. A partir de então, todas as operações
necessárias para temporização, tais como o incremento e decremento dos
temporizadores são baseados na escrita e leitura de valores nessas estruturas.
A variável reservada para os operandos endereçados indiretamente é acessada
toda a vez que uma instrução contém um operando correspondente ao modo de
43
endereçamento indireto, podendo ser lida ou escrita a qualquer momento durante a
execução do programa de aplicação.
4.3 Interrupções
Uma interrupção é um evento que força uma chamada a uma seqüência de
dados que normalmente é definida como uma rotina ou serviço de interrupção. Essas
interrupções podem ser geradas por eventos externos ou internos. Fontes típicas de
interrupção pode ser um sinal externo ligado ao pino RB0 previamente configurado,
uma mudança de estado nas entradas RB4 à RB7, recepção de um dado pelo periférico
USART ou o overflow de algum contador na mudança de valor de 0xFF para 0x00. 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 [8].
Quando ocorre uma interrupção no microcontrolador, o programa sempre
desvia para o mesmo endereço. Porem, na implementação do firmware foram
utilizadas duas interrupções, sendo uma pela USART e outra pelo TIMER1. Portanto
fez-se necessário identificar qual fonte gerou a interrupção, para que seja feito o seu
tratamento adequado.
Utilizou-se a interrupção pela USART, para que, quando uma solicitação de
carregamento do programa de aplicação for efetuada pelo software de programação, a
mensagem com a solicitação seja imediatamente armazenada no microcontrolador,
sem correr o risco da mensagem ser perdida total ou parcialmente por estar o
microcontrolador ocupado com outra tarefa. A interrupção pelo TIMER1, ocorre a
cada 5ms, e é utilizada para determinar o tempo do ciclo de varredura.
4.4 Comunicação
Conforme mencionado na seção 4.3, a comunicação entre o computador e o
microcontrolador gera uma interrupção pela USART, que imediatamente armazena o
conteúdo dos dados da mensagem enviada pelo computador em uma variavel.
As mensagens vindas do computador possuem 7 bytes, porém apenas 2 deles
contém efetivamente os dados recebidos, um deles contém o valor a ser gravado na
44
memória EEPROM durante a programação do micro-CLP e o segundo realiza o
controle de recebimento de dados (CR). A Tabela 6 mostra os valores utilizados para o
controle de envio de dados.
Valor de CR Descrição
0xFD Solicitação de Carregamento
0xFF Inicia o carregamento das instruções.
0xFE Fim da gravação das instruções
Tabela 6 – Valores utilizados no controle de envio de dados.
As mensagens enviadas pelo micro-CLP ao computador são formadas por 4
bytes de conteúdo de dados, o primeiro contém o modo de operação atual, o segundo
realiza o controle de envio de dados (CE), o terceiro informa os valores das entradas e
o quarto informa os valores atuais das saídas do micro-CLP. A Tabela 7 mostra os
valores utilizados para o controle de envio de dados.
Valor de CE Descrição
0x40 Permissão de Carregamento
0x01 Indica o envio dos valores de E/S e
modo de operação.
0x3F Confirma o fim da gravação das
instruções
Tabela 7 – Valores utilizados no controle de recebimento de dados.
A comunicação entre o micro-CLP e o computador durante o carregamento do
programa de aplicação é mostrada no fluxograma da Figura 19.
45
Figura 19 – Fluxograma da comunicação durante o carregamento do micro-CLP.
46
4.5 Principais Rotinas
Nesta seção analisaremos algumas das principais rotinas do firmware
executado pelo microcontrolador. A Figura 20 apresenta o fluxo de execução do
firmware do micro-CLP.
Figura 20 – Fluxo de execução do firmware.
Inicialmente são configurados alguns parâmetros de hardware do
microcontrolador e periféricos a serem utilizados, tais como a comunicação I2C,
TIMER1 e o módulo UART responsável pela comunicação serial com o transceptor
MAX485.
47
Na rotina principal são inicializados os conteúdos das variáveis, é feita a
inicialização do micro-CLP desativando todas as saídas, e os leds de indicação são
seqüencialmente acionados, um a cada vez, indicando ao usuário a inicialização do
micro-CLP. Então é realizada a primeira leitura das entradas armazenando-as na
variável de imagem das entradas.
Depois de inicializar e ler todas as entradas segue-se para o trecho em que é
feita a verificação da posição da chave de seleção do modo de operação. Se esta chave
encontra-se em modo de execução, inicia-se o ciclo de varredura executando os
seguintes passos.
1. O Contador de Programa (CP) recebe o endereço da primeira instrução.
2. A instrução contida no endereço apontado por CP é transferido da memória
EEPROM externa para a memória RAM do microcontrolador.
3. O Opcode da instrução é reconhecido direcionando o programa para o
trecho de tratamento da operação.
4. É identificado o modo de endereçamento de cada operando.
5. Os valores apontados pelos operandos são passados como parâmetros da
operação a ser realizada.
6. O resultado da operação é armazenado no bit da variável de imagem das
saídas indicado pelo operando.
7. A saída do micro-CLP é atualizada de acordo com a variável de imagem
das saídas.
8. O microcontrolador envia uma mensagem para o computador, cujo
conteúdo é composto pelos estados das entradas e saídas e o modo de
operação.
9. O CP é automaticamente incrementado apontando para o endereço da
próxima instrução a ser executada.
48
O contador de programa é automaticamente incrementado para cada ciclo de
instrução de forma que as instruções são executadas seqüencialmente até que seja
encontrado o fim do programa identificado por uma seqüência de 4 bytes com valores
zero. Então, o CP retorna a zero fazendo com que a primeira instrução do programa de
aplicação seja novamente executada.
Para o controle do tempo de varredura (scan time) do micro-CLP, utilizou-se a
interrupção pelo TIMER1 do microcontrolador. Configurou-se o TIMER1 para gerar
uma interrupção que executa uma rotina cuja função é incrementar uma variável
chamada CONT a cada 5ms. O programa entra em estado de espera enquanto esta
variável possui valor menor que 40. Quando CONT é igual a 40, o programa
prossegue com a execução das rotinas seguintes, garantindo que cada ciclo de
varredura seja executado exatamente em 200ms.
Se a varredura do programa de aplicação é concluída em um tempo inferior ao
scan time, o microcontrolador fica em espera até que se passe 200ms, para então
realizar a atualização das saídas e o envio das mensagens para o computador. Ao final
de cada ciclo de varredura a variável CONT é zerada para que o ciclo seguinte seja
concluído com o mesmo tempo, 200ms. O fluxograma da Figura 21 ilustra o
funcionamento do controle do Scan Time.
Figura 21 – Funcionamento do controle do Scan Time.
49
Ao final de cada ciclo de varredura, é realizada uma nova verificação da
posição da chave de modo de operação. Se a chave encontra-se em modo de
programação, as etapas seguintes são realizadas.
1. As saídas recebem valor zero e é enviado o modo de operação atual para a
porta de comunicação avisando que o micro-CLP está pronto para ser
programado.
2. O programa de execução entra em estado de espera aguardando pela
solicitação de programação enviada pelo software de programação.
3. O software de programação solicita o carregamento do programa de
execução.
4. O microcontrolador concede a autorização de carregamento e o led de
indicação de carregamento acende sinalizando o inicio da programação,
neste momento, todos os bytes enviados pelo software de programação são
armazenados na memória EEPROM até que o software sinalize o fim do
carregamento.
5. São carregados 4 bytes com valor zero na memória, logo após a ultima
instrução carregada sinalizando que naquele ponto está o fim do programa
de execução.
6. O microcontrolador envia uma mensagem sinalizando a fim do
carregamento e o sucesso da operação, conseqüentemente o software emite
uma mensagem sinalizando que o carregamento foi concluído com êxito.
A partir deste ponto, o programa de aplicação está completamente carregado
na memória EEPROM e o micro-CLP pronto para entrar em modo de execução.
50
5 DESENVOLVIMENTO DOS SOFTWARES
O primeiro passo para o desenvolvimento dos softwares de supervisão e
programação foi a definição da linguagem de programação a ser utilizada.
A escolha da linguagem de programação para realizar a interface com o
usuário foi baseada em uma das principais características do C++, o suporte a
programação orientada a objetos. Desta forma, é possível o desenvolvimento de
softwares que proporcionam uma aparência sofisticada e ao mesmo tempo uma
interface fácil, intuitiva e amigável ao usuário.
5.1 Linguagem C++
O C++ foi desenvolvido por Bjarne Stroustrup durante a década de 1980 com
o objetivo de melhorar a linguagem de programação C, mantendo a compatibilidade
com esta linguagem. A linguagem C serviu de inspiração para o desenvolvimento da
linguagem C++ por possuir uma proposta de uso genérico, ser rápida e portável para
diversas plataformas.
A linguagem C++ pode ser considerada como uma linguagem de nível
intermediário, pois apensar de utilizar um dialeto de nível alto, possibilita ao
programador facilidades para se trabalhar em nível baixo, como manipulação de bits,
bytes e endereços de memória de maneira direta, sem recorrer a abstrações
apresentadas por outras linguagens de alto nível [11].
As principais vantagens do C++ são listadas a seguir:
• Possibilidade de programação de alto e baixo nível.
• Alta flexibilidade, portabilidade e consistência.
• Compatibilidade com C, resultando em vasta base de códigos.
• Ampla disponibilidade e suporte, devido principalmente à grande base de
desenvolvedores.
• Não está sob o domínio de uma empresa, ao contrario de linguagens como
Java (Sun) e Visual Basic (Microsoft).
51
A linguagem C++ é uma das linguagens que suportam vários paradigmas.
Sendo uma evolução da linguagem C, ela suporta inteiramente o paradigma da
programação estruturada. Além disso, ela suporta outros paradigmas como a
programação procedural, a programação genérica, abstração de dados e a programação
orientada a objetos [11].
Dentre estes paradigmas, o mais utilizado atualmente é a Programação
Orientada a Objetos, ou simplesmente OOP (Object Oriented Programming).
A idéia básica da OOP é criar um conjunto de objetos para modelar um
sistema. Estes objetos são independentes entre si, possuindo responsabilidades e
funções distintas no programa como um todo, mas que se comunicam entre si através
do envio e recebimento de mensagens. A OOP é especialmente útil para grandes
programas que se beneficiam com a modularidade oferecida por este paradigma,
dividindo o programa em vários módulos independentes, aumenta-se a flexibilidade e
a facilidade para manutenção do programa como um todo [11].
5.2 Ambientes de Desenvolvimento
Ambientes de Desenvolvimento Integrado (IDE - Integrated Development
Enviroments) são programas que auxiliam os desenvolvedores no processo de criação
de aplicativos. Esses aplicativos podem ser desenvolvidos utilizando apenas um editor
de texto e um compilador de linha de comando, mas, até mesmo para pequenas
aplicações, gerar interfaces gráficas e código repetitivo tornam a tarefa extremamente
cansativa e passível de erros. Os IDEs comumente oferecem, entre outras facilidades,
fácil acesso às bibliotecas de componentes gráficos através de barras de ferramentas
que permitem arrastar e soltar os objetos nos formulários, verificação e colorização de
sintaxe e compilação automatizada [12].
5.2.1 O Ambiente de Desenvolvimento C++ Builder
O C++ Builder é um ambiente de desenvolvimento de aplicações baseado no
conceito denominado RAD (Rapid Application Development – Desenvolvimento
52
Rápido de Aplicação), isto permite ao programador criar todas as telas do aplicativo de
uma forma totalmente visual, apenas adicionando os objetos gráficos ao formulário.
Após a criação da interface do aplicativo, o programador pode desenvolver a
lógica e o processamento das informações do usuário através da inclusão do código de
programação em C++.
Alem das características acima, por ser totalmente orientado a objeto, o C++
Builder possibilita a reutilização de códigos em varias outras aplicações através de
recursos que permitem transformar essas rotinas em componentes.
Os arquivos executáveis gerados pelo C++ Builder são auto-suficientes, ou
seja, não precisam de bibliotecas de ligação dinâmica (DLL – Dynamic link library)
para interpretar o código compilado [12].
5.3 Software de Programação em FBD
Todo o software de programação foi desenvolvido em linguagem C++,
utilizando-se o ambiente de desenvolvimento Borland C++ Builder 6.
Para a implementação dos recursos gráficos oferecidos pela linguagem FBD
utilizou-se a VCL (Visual Component Library - Biblioteca de Componentes Visuais)
disponível no C++ Builder, alem de componentes externos.
O uso de componentes facilitou a programação, visto que todos os objetos já
estão prontos, disponibilizando mais tempo para o desenvolvimento da lógica.
O componente ComPort 3.0 foi utilizado para estabelecer a comunicação
serial entre o PC e o micro-CLP. Ele oferece todo o suporte necessário para realizar a
comunicação serial, com um equipamento externo, inclusive o controle do sinal
Request to Send (RTS), utilizado para o controle de sentido de transmissão de
dados necessário para emprego do padrão RS485.
5.3.1 Definição do Layout
O desenvolvimento de qualquer programa criado a partir de uma linguagem
orientada a objetos torna necessária uma definição inicial do layout do aplicativo.
53
Para a definição do layout, foram analisadas diversas características desejadas
em um software de programação de CLP, obedecendo aos padrões de interface
estabelecidos pela norma IEC 61131-3.
Na Figura 22 é mostrado o layout final do software de programação.
Figura 22 – Layout final do software de programação em FBD.
O software é composto por três formulários. O primeiro formulário
corresponde a janela principal do aplicativo, o segundo possui a área de
desenvolvimento do programa em FBD e o terceiro contêm as propriedades de
comunicação e carregamento do programa de aplicação no micro-CLP.
Uma vez definido o layout, foi necessário encontrar uma solução que
possibilitasse desenhar os blocos funcionais e as ligações entre eles, assim como as
atribuições das variáveis e o preenchimento de parâmetros em determinados blocos.
Após pesquisar e analisar diversos componentes do C++ builder disponíveis
na rede mundial de computadores, optou-se por utilizar a versão 1.7 do componente
54
Diagram Studio da TMS software. Esse componente fornece todas as ferramentas
necessárias para a criação dos diagramas de blocos e linhas de conexão em tempo de
execução do programa [13].
5.3.2 Funções Projetadas
Na seção 2.4.1 foi apresentado o conjunto básico de blocos funcionais da
linguagem FBD. Estes blocos são freqüentemente utilizados na definição de blocos
mais complexos.
Neste projeto, foram desenvolvidos apenas os blocos funcionais básicos,
conforme é mostrado na Figura 23.
Figura 23 – Blocos funcionais desenvolvidos.
Optou-se por utilizar nomenclaturas de funções em inglês devido ao fato de
ser a mais comumente utilizada nos softwares de programação de CLP disponíveis no
mercado.
Também foram definidas as variáveis de representação direta, ou seja,
variáveis de leitura e escrita de dados em posições conhecidas de memória, tais como
entradas, saídas e constantes discretas.
55
Os blocos funcionais e as variáveis de entradas e saídas foram desenvolvidos
com base em um método disponível no objeto atDiagram do componete Diagram
Studio. Este método possibilita a criação de um arquivo com todos os objetos do
diagrama em formato de texto.
Desta forma, para cada bloco funcional, foram criados arquivos com todos os
parâmetros do objeto FBD. Nestes parâmetros é informado o nome do bloco, titulo do
bloco, dimensão, posição, pontos de conexão e nome dos pontos de conexão.
Quando um bloco funcional é adicionado ao diagrama de blocos pelo usuário,
é executada a função ADD_BLOCK(). Esta função executa o método que salva o
desenho atual em um arquivo temporário em formato de texto, em seguida adiciona no
final deste arquivo os parâmetros contidos no arquivo fonte do bloco escolhido, e para
finalizar a inserção do novo bloco, executa outro método do atDiagram que permite a
importação do arquivo temporário e todos os objetos nele declarado, concluindo a
inserção do novo bloco funcional ao formulário de desenho.
5.3.3 Canais Disponíveis para a Programação
Com base na arquitetura definida na seção 3.3, foram criados 8 variáveis de
entrada e 8 variáveis de saídas, além de constantes do tipo booleano.
A Figura 24 mostra a representação gráfica dessas variáveis no software de
programação. Os valores reconhecidos pelas variáveis são descritos a seguir.
• E1 à E8 – Entradas físicas do micro-CLP;
• S1 à S8 – Saídas físicas do micro-CLP;
• B0 e B1 – Constantes do tipo booleano;
Figura 24 – Representação gráfica das entradas e saídas.
56
5.3.4 Desenhando o FBD
Os objetos da linguagem FBD, tais como funções, variáveis e linhas de
conexão podem ser adicionados ao formulário de desenho através do menu mostrado
da Figura 25. Este menu é exibido ao clicar com o botão direito do mouse sobre
qualquer parte do formulário de desenho através do evento OnMouseDown do objeto
atDiagram. Alem disso, este menu disponibiliza as ferramentas básicas de edição, tais
como editar e excluir.
Figura 25 – Layout final do software de programação em FBD.
Os blocos funcionais podem ser interligados através da ferramenta LINHA,
permitindo a composição da lógica de controle desejada.
5.3.5 Compilação e Carregamento
A compilação é a etapa em que o software lê o programa fonte escrito em
linguagem FBD e o traduz para outro programa equivalente, porém escrito em uma
linguagem de seqüência de bytes, chamado programa objeto.
Todo o processo de compilação é baseado na identificação e interpretação das
linhas de conexão.
Quando uma conexão entre objetos é efetuada, é criada uma instância da
classe atDiagramLine, onde os nomes dos dois objetos interligados são guardados em
uma propriedade deste objeto chamada LinkPoint.
57
Ao iniciar a compilação, a função Compilar_Prog() primeiramente utiliza o
método SaveToFile(arquivo) do componente Diagram Studio para criar um arquivo
temporário contendo todos os objetos FBD inseridos pelo usuário, inclusive as
instancias de atDiagramLine que contem todas as informações de interligação entre
objetos. A partir de então, o processo de compilação é dividido em varias partes, como
é mostrado na Figura 26.
Interface de programação em
linguagem FBD
Analise Léxica
Analise Sintática
Analise Semântica
Geração do programa em código
de máquina
Envio do código de máquina pela
porta de comunicação serial
Figura 26 – Etapas de compilação e carregamento do programa de aplicação.
Na análise léxica o analisador léxico recebe como entrada o próprio programa
fonte e identifica os elementos mais básicos do programa, como nomes das variáveis e
funções. O resultado deste processo é um vetor de tokens, onde cada um dos tokens é
um representante de um dos objetos do programa fonte.
Na análise sintática o analisador sintático recebe como entrada o vetor de
tokens gerado pelo analisador léxico. Sua função é identificar as interligações entre os
objetos FBD e agrupar os tokens de acordo com estas interligação, determinando a
estrutura do programa-fonte.
Na análise semântica o analisador semântico recebe como entrada os dados
estruturados pela analise sintática. Nessa etapa são realizadas todas as verificações no
58
programa, como por exemplo, a verificação se um operador recebeu o número correto
de operando.
Por ultimo, na fase de geração do código, os dados já processados pelas fases
anteriores são subdivididos em instruções de 4 bytes, cuja estrutura é apresentada na
seção 4.1.
Com o programa objeto criado, inicia-se a etapa de carregamento no micro-
CLP. Nessa etapa, os bytes do programa objeto são enviados um a um para a memória
EEPROM do micro-CLP através da comunicação serial estabelecida pelo componente
Com Port 3.0.
5.4 Software Supervisório
O software supervisório foi desenvolvido no ambiente de desenvolvimento
Borland C++ Builder 6 utilizando a linguagem C++.
Assim como no desenvolvimento do software de programação, utilizou-se a
VCL do C++ Builder, alem de componentes adicionais provendo todos os recursos
necessários, facilitando o desenvolvimento das funcionalidades básicas de um software
de supervisão.
5.4.1 Sistema de Supervisão e Aquisição de Dados
Os sistemas SCADA (Supervisory Control and Data Acquisition) são sistemas
destinados à supervisão, controle e aquisição de dados de plantas industriais,
fornecendo ao operador a interação com o processo através de suas interfaces gráficas
[3].
O sistema supervisório possui dois modos de funcionamento, o modo de
desenvolvimento e o modo de execução.
No modo de desenvolvimento é disponibilizado um ambiente para criação de
telas gráficas onde as representações do processo poderão ser desenhadas e as
variáveis de processo poderão ser vinculadas a um objeto gráfico.
59
Em modo de execução, todas as telas e funcionalidades programadas no modo
de desenvolvimento são executadas interagindo com o CLP em tempo real, mostrando
o sistema em operação [3].
5.4.2 Definições
A definição das funcionalidades básicas é o ponto principal no
desenvolvimento do supervisório. Embora os atuais softwares de supervisão permitir o
controle das variáveis de processo, dentre muitos outros recursos avançados, optou-se
em implementar apenas os recursos de supervisão devido ao fato do projeto
contemplar apenas variáveis discretas, tornando desnecessários os ajustes de variáveis
em tempo real.
A interface final do software de supervisão é mostrada na Figura 27.
Figura 27 – Layout final do software de supervisão.
Toda a área de edição gráfica está baseada no componente Diagram Studio 1.7
da TMS software. Esse componente fornece todo o suporte necessário para o
desenvolvimento das telas de supervisão.
60
Em modo de desenvolvimento, o componente Diagram Studio é configurado
para permitir a criação e a alteração dos objetos de desenho da interface gráfica. O
usuário pode então inserir, modificar e excluir qualquer objeto.
O principal recurso desenvolvido permite a inserção de variáveis no
supervisório, proporcionando o acompanhamento em tempo real dos valores das
entradas e saídas do micro-CLP. Em modo de execução, essas variáveis são animadas
alterando sua cor de acordo com o estado das E/S referenciadas.
5.4.3 Comunicação com o CLP
O software de supervisão, assim como o software de programação, utiliza o
componente ComPort 3.0 para realizar a comunicação entre o micro-CLP e o
computador.
A cada ciclo de varredura, o micro-CLP envia uma mensagem com
informações dos valores das E/S e o modo de operação a qual ele se encontra. Estas
mensagens são interpretadas e os valores das entradas, saídas e modo de operação do
micro-CLP são identificados e armazenados na variável de imagem no supervisório.
Caso ocorra timeout, ou seja, o supervisório não receba nenhuma mensagem originada
do micro-CLP durante um intervalo de 3 segundos, uma mensagem com uma
exclamação é exibida na tela sinalizando a falha de comunicação.
Para a atualização das telas do supervisório, foi utilizado um Timer que
executa uma rotina de atualização a cada 50ms. Nesta rotina de atualização, os valores
da variável de imagem são utilizados para atualização das cores dos objetos na tela do
supervisório.
O fluxograma da Figura 28 apresenta o funcionamento básico do software de
supervisão.
61
Figura 28 – Fluxograma do funcionamento básico do software de supervisão.
62
6 TESTES E RESULTADOS
Ao longo do desenvolvimento do hardware e dos softwares foram realizados
diversos testes individuas para validar o funcionamento de cada um deles. Neste
capitulo são apresentados os testes realizados com o objetivo de analisar o
funcionamento do sistema como um todo.
Para isso, utilizou-se uma aplicação de controle de um sistema de
despoeiramento simulado em uma maquete contendo os principais tipos de atuadores e
sensores utilizados no sistema de escala real.
As telas de supervisão e lógicas de controle foram desenvolvidas com base no
funcionamento dos sistemas de despoeiramento utilizados nas usinas de pelotização da
VALE.
6.1 Sistema de Despoeiramento
A maquete desenvolvida está baseada em um sistema de despoeiramento
denominado Coluna Lavadora.
A Coluna Lavadora é um equipamento anti-poluente, que tem por tarefa,
succionar material particulado nos pontos geradores, diluir em água e encaminhá-lo
para reaproveitamento em alguma parte do processo, possibilitando a redução da
emissão de particulados e a reciclagem do material capturado.
6.2 Programação da Lógica em FBD
Inicialmente, foram definidas as entradas e saídas a serem utilizadas no
controle do equipamento. A descrição das entradas e saídas são apresentadas na Tabela
8 e Tabela 9.
63
Entrada do micro-CLP Sensor / Chave Componente do equipamento E1 Nível (25%) Tanque coletor E2 Nível (50%) Tanque coletor E3 Nível (75%) Tanque coletor E4 Nível (100%) Tanque coletor E5 Nível (40%) Tanque reservatório E6 Nível (70%) Tanque reservatório E7 Nível (90%) Tanque reservatório E8 Chave de Emergência --
Tabela 8 – Descrição das entradas do micro-CLP.
Saída do micro-CLP Atuador Componente do equipamento S1 Motor 1 Ventilador S2 Motor 2 Misturador de polpa S3 Bomba 1 Bomba de abastecimento de água ao tanque
coletor S4 Bomba 2 Bomba de recalque de polpa S5 Bomba 3 Bomba de abastecimento de água ao tanque
reservatório
Tabela 9 – Descrição das saídas do micro-CLP.
Após a definição da configuração das entradas e saídas, estudou-se a lógica de
funcionamento da coluna lavadora e desenvolveu-se o programa em linguagem FBD,
conforme é apresentado na Figura 29.
64
Figura 29 – Programa FBD do controle da coluna lavadora.
6.3 Criação da Tela de Supervisão
A tela de supervisão foi desenhada com base na estrutura real da coluna
lavadora, podendo ser vista na Figura 30.
Figura 30 – Telas de supervisão da coluna lavadora.
65
6.4 Resultados
Para a validação final do sistema, foi montada uma plataforma de teste
composta por todos os elementos desenvolvidos ao longo do projeto, tais como o
micro-CLP, o conversor RS-232/RS485, o software de supervisão e o software de
programação em FBD. Na Figura 31 pode-se visualizar a plataforma montada para a
realização dos testes.
Figura 31 – Plataforma de testes.
A maquete de simulação do sistema de despoeiramento foi projetada
utilizando bombas de aquário com potência de 3,8W e tensão de 127VAC, coolers de
12Vdc, além de sensores baseados na condutividade ligados a um circuito comparador
que gera 5V quando os sensores estão em contato com a água.
Durante os testes, constatou-se a ocorrência de interferências no canal de
comunicação do micro-CLP quando as cargas indutivas eram acionadas. Este
66
problema logo foi solucionado com a utilização de snubbers, circuitos RC conectados
as saídas usadas para o acionamento das bombas.
O comportamento do sistema foi analisado e os resultados são descritos a
seguir.
• A bomba de abastecimento de água do tanque reservatório é acionada e só
desliga quando o nível atinge 90%, a partir deste ponto, ela só volta a ser
acionada quando o nível do tanque é inferior a 70%, caracterizando uma
histerese;
• Quando o tanque reservatório atinge 40%, o ventilador é ligado e após 10
segundos é acionada a bomba de abastecimento de água do tanque coletor;
• Quando o nível do tanque coletor atinge 25%, o misturador de polpa é
acionado.
• Quando o nível do tanque coletor atinge 75%, a bomba de recalque de
polpa é acionada e só desliga quando o nível do tanque coletor se encontrar
abaixo de 50%.
• Se por algum motivo o nível do tanque coletor alcançar 100%, a bomba de
abastecimento de água do tanque coletor é desligada.
• Quando a chave de emergência é pressionada por 8 segundos, inicia-se o a
seqüência de desligamento do sistema. O ventilador e as bombas são
desligados, porem o misturador de polpa e a bomba de recalque de polpa
continuam ligados até que o nível do tanque coletor se torne menor que
25%, que em seguida são desligados.
Pode-se perceber que os resultados apresentados pelo sistema durante a
realização dos testes são exatamente compatíveis com a lógica de controle
implementada na seção 6.2.
O software de supervisão possibilitou o acompanhamento do sistema em
tempo real e seu comportamento também foi exatamente como o esperado.
67
Em um modo geral, o trabalho atingiu os seus objetivos, os resultados foram
satisfatórios. O correto funcionamento do sistema desenvolvido foi comprovado por
meio dos testes realizados.
O micro-CLP desenvolvido é apresentado na Figura 32.
Figura 32 – Plataforma de testes.
68
7 CONCLUSÕES
Através deste trabalho foi possível constatar que o universo de aplicações dos
controladores lógicos programáveis está em grande expansão, impulsionando o estudo
e desenvolvimento de dispositivos que atendam a diversos tipos e níveis de
complexidade.
Neste projeto foi possível construir um micro-CLP com um custo reduzido e
desempenho capaz de satisfazer os requisitos de controle dos sistemas de baixa
complexidade. A utilização de um microcontrolador como o principal elemento do
sistema, mostrou-se suficientemente robusto e atendeu a todas as expectativas, mesmo
utilizando o mínimo seus recursos disponíveis.
O projeto também contemplou a construção de um software de supervisão e o
desenvolvimento de um software de programação em linguagem FBD.
Embora tenham sido projetadas apenas as funções básicas de um controlador
lógico programável, foi possível desenvolver lógicas de controle com níveis de
complexidade acima do previsto com resultados extremamente satisfatórios.
Este projeto reuniu uma enorme gama de conhecimentos adquirido ao longo
do curso de Engenharia Elétrica com habilitação em computação, dos quais podemos
citar os conhecimentos de eletrônica e sistemas embutidos ao construir o hardware,
estrutura de dados e compiladores, ao elaborar os softwares, automação e
instrumentação, ao realizar as definições e aplicações do projeto, entre outras
disciplinas que indiretamente contribuíram para o desenvolvimento do projeto.
De acordo com os resultados dos testes, pode-se dizer que o objetivo do
projeto foi alcançado. Entretanto, mesmo com os resultados satisfatório, este projeto
demonstra ter um grande potencial de aplicações, possibilitando a inclusão de diversos
novos recursos e ferramentas.
Desta forma sugere-se como projetos futuros a implementação de canais e
funções que manipulam dados analógicos, expansão do numero de entradas e saídas,
comunicação utilizando a tecnologia ethernet e compatibilidade com os protocolos de
redes industriais, como o Modbus.
69
APÊNDICE A – CIRCUITO DO MÓDULO CPU
70
APÊNDICE B – CIRCUITO DO MÓDULO DE ENTRADAS
71
APÊNDICE C – CIRCUITO DO MÓDULO DE SAÍDAS
72
REFERÊNCIAS BIBLIOGRÁFICAS
[1] GEORGINI, Marcelo. Automação Aplicada – Descrição e Implementação de
Sistemas Seqüenciais com PLCs, 4ª Edição, Érica, 2003.
[2] NEMA. Disponível em <http://www.nema.org>. Acessado em 18/11/2010.
[3] Moraes, C.C. & Castrucci, P de L, Engenharia de Automação Industrial, LTC,
2007.
[4] MATIAS, Juliano. Entenda o protocolo elétrico RS-485. Mecatrônica Atual, São
Paulo, n. 4, Jun. 2002.
[5] AXELSON, Jan. Serial port complete - programming and circuits for RS-232 and
RS-485 links e networks. Third Edition, Madison, 2000.
[6] Microchip. Disponível em <http://www.microchip.com>. Acessado em
28/10/2010.
[7] National semiconductor, Application Note 409 - Transceivers and Repeaters
Meeting the EIA RS-485 Interface Standard, Disponível em
<http://www.national.com/an/AN/AN-409.pdf>. Acessado em 12/11/2010
[8] Souza, D.J. & Lavinia, N.C., Conectando o PIC: Recursos Avançados, 3ª Edição,
Érica.
[9] ATMEL, EEPROM 24C16A Datasheet, Disponível em <http://www.atmel.com>.
Acessado em 02/10/2010
[10] MAXIM, MAX485 Datasheet, Disponível em <http://www.maxim-ic.com>.
Acessado em 13/10/2010.
[11] STROUSTRUP, Bjarne, The C++ Programming Language, Third Edition,
Addison – Wesley. 1997.
[12] ALVES, Willian Pereira. C++ Builder 6 - Desenvolva Aplicações para Windows,
2ª Edição, Editora Érica, 2007.
[13] TMS Software, Diagram Studio. <www.tmssoftware.com>. Acessado em
05/01/2010.