Você está na página 1de 62

UNIVERSIDADE FEDERAL DO ESPRITO SANTO CENTRO TECNOLGICO DEPARTAMENTO DE ENGENHARIA ELTRICA PROJETO DE GRADUAO

ROGRIO COSTA PACHECO NETO

DESENVOLVIMENTO DE UM AMBIENTE PARA PROGRAMAO DE UM MICRO-CLP

VITRIA 2007

ROGRIO COSTA PACHECO NETO

DESENVOLVIMENTO DE UM AMBIENTE PARA PROGRAMAAO DE UM MICRO-CLP

Parte manuscrita do Projeto de Graduao do aluno Rogrio Costa Pacheco Neto, apresentado ao Departamento de Engenharia Eltrica do Centro Tecnolgico da Universidade Federal do Esprito Santo, para obteno do grau de Engenheiro Eletricista.

VITRIA 2007

ROGRIO COSTA PACHECO NETO

DESENVOLVIMENTO DE UM AMBIENTE PARA PROGRAMAO DE UM MICRO-CLP

COMISSO EXAMINADORA:

________________________________ Prof. Dr. Paulo Faria Santos Amaral Orientador

___________________________________ Profa. Dra. Raquel Frizera Vassalo Examinadora ___________________________________ Prof. Dr. Alessandro Mattedi Examinador

Vitria - ES, Fevereiro de 2007

3 DEDICATRIA

minha famlia e amigos pelo apoio e confiana.

4 AGRADECIMENTOS

Agradeo ao professor Paulo Amaral pela idia na qual baseei meu projeto, e pelo suporte durante a execuo do mesmo. Agradeo tambm a Paulo Franklin Raskin Ferrua e Srgio Pazzini Matos por todo amparo nas horas de dificuldades e dividirem comigo o laboratrio de Micro no perodo de frias e no desespero com a aproximao dos prazos finais. Agradeo principalmente ao companheiro de curso, e grande amigo, George Salvador Moraes que muito me auxiliou no incio do desenvolvimento do programa devido aos conhecimentos prvios de C#.

5 LISTA DE FIGURAS Figura 1 Esquema bsico micro-CLP .........................................................................9 Figura 2 Organograma Funcionamento do Ambiente de Programao ...................10 Figura 3 - CLPs Tpicos...............................................................................................12 Figura 4 - Terminal de Programao ...........................................................................13 Figura 5 - Ciclo de Operao de um CLP....................................................................15 Figura 6 - Exemplos da diviso em Namespaces ........................................................21 Figura 7 - Modelo de execuo ...................................................................................23 Figura 8 - Exemplo de aplicaes no console .............................................................25 Figura 9 - Paint.NET Exemplo de programa desenvolvido em Windows Forms ....26 Figura 10 - Exemplo de Aplicao Web......................................................................27 Figura 11 - Layout inicial do programa.......................................................................30 Figura 12 - Layout definitivo do programa .................................................................33 Figura 13 - Layout auxiliar para os parmetros do PID ..............................................34 Figura 14 - Layout auxiliar para os parmetros do Comparador.................................34 Figura 15 - Layout auxiliar para os parmetros do Contador......................................34 Figura 16 - Layout auxiliar para os parmetros do Temporizador ..............................34 Figura 17 - Exemplo de ladder ....................................................................................35 Figura 18 - Cdigo intermedirio gerado ....................................................................36 Figura 19 Estrutura do cabealho .............................................................................37 Figura 20 Ladder controle porto eletrnico ............................................................39 Figura 21 Linguagem intermediaria gerada e enviada para o micro-CLP ...............40 Figura 22 O micro-CLP ............................................................................................41

6 SUMRIO

DEDICATRIA...........................................................................................................3 AGRADECIMENTOS ................................................................................................4 LISTA DE FIGURAS..................................................................................................5 SUMRIO ....................................................................................................................6 RESUMO......................................................................................................................8 INTRODUO............................................................................................................9 1 CLPS................................................................................................................12 1.1 HISTRIA DOS CLPS ....................................................................................12 1.2 FUNCIONAMENTO DE UM CLP..................................................................14 1.3 COMPARAO DO CLP COM OUTROS SISTEMAS DE CONTROLE...16 1.4 LINGUAGENS DE PROGRAMAO ..........................................................17 1.4.1 LINGUAGEM LADDER........................................................................18 1.4.1.1 EXEMPLO DE UM PROGRAMA SIMPLES EM LADDER..18 2 .NET FRAMEWORK ....................................................................................20 2.1 ARQUITETURA ..............................................................................................20 2.2 CARACTERSTICAS ......................................................................................23 2.3 DESENVOLVIMENTO DE APLICAES...................................................25 2.4 LINGUAGENS DE PROGRAMAO ..........................................................27 2.5 AMBIENTES DE DESENVOLVIMENTO.....................................................28 2.6 DOCUMENTAO E RECURSOS ...............................................................28 3 O DESENVOLVIMENTO DO PROGRAMA ............................................30

7 3.1 DEFINIO DO LAYOUT.............................................................................30 3.2 FUNES PROJETADAS ..............................................................................31 3.3 PORTAS DISPONVEIS PARA A PROGRAMAO..................................32 3.4 LAYOUT DEFINITIVO ..................................................................................32 3.5 DESENHANDO O LADDER ..........................................................................35 3.6 GERANDO O CDIGO INTERMEDIRIO..................................................35 3.7 A COMUNICAO SERIAL .........................................................................37 4 5 TESTES E RESULTADOS ...........................................................................39 CONCLUSES ..............................................................................................41

APNDICE A CDIGO PROGRAMA PRINCIPAL LADDER.CS ............43 APNDICE B CDIGO CLASSE COMPONENTE COMPONENTE.CS ..53 APNDICE B CDIGO CLASSE COMPONENTE COMPONENTE.CS ..54 APNDICE C CDIGO CLASSE PIDBOX PIDBOX.CS .............................56 APNDICE D CDIGO CLASSE COMPBOX COMPBOX.CS ..................57 APNDICE E CDIGO CLASSE CONTBOX CONTBOX.CS....................58 APNDICE F CDIGO CLASSE TIMERBOX TIMERBOX.CS ................59 REFERNCIAS BIBLIOGRFICAS.....................................................................60

8 RESUMO O projeto consiste no desenvolvimento de um ambiente para programao de um micro-CLP a ser implementado em PIC. O programa conta com uma interface grfica onde o usurio ir criar o programa em Ladder e dever disponibilizar ao usurio algumas das funes presentes num CLP comercial, sendo assim possvel o usurio utilizar este micro-CLP em conjunto com o programa feito em ladder para poder controlar uma planta. A programao do micro-CLP feita atravs da porta serial (COM1) do computador.

9 INTRODUO A idia deste projeto consiste em desenvolver um ambiente para programao de um micro-CLP implementado em PIC. A parte fsica e rotinas de interpretao da programao enviada ao micro-CLP sero feitas pelo tambm graduando Paulo Franklin Raskin Ferrua, Um esquema bsico do sistema o seguinte:

Figura 1 Esquema bsico micro-CLP

Este trabalho ser responsvel pelo ambiente de programao do micro-CLP no computador, e o envio desta programao atravs de comunicao serial ao microCLP. A seguir temos um organograma bsico do funcionamento do ambiente de programao.

10

Figura 2 Organograma Funcionamento do Ambiente de Programao

Para execuo deste projeto foram utilizados conceitos sobre CLPs e linguagem ladder, e tambm sobre C# (C Sharp) uma linguagem desenvolvida pela Microsoft para aplicaes em .NET Framework. O projeto foi subdividido em etapas descritas nos captulos deste relatrio:

11 Uma pesquisa bibliogrfica sobre CLPs e linguagem ladder, apresentada resumidamente no Captulo CLPs Pesquisa bibliogrfica e introduo aos conceitos do .NET Framework, que so apresentados no Captulo .NET Framework. Etapas do desenvolvimento do ambiente, e alguns problemas encontrados durante a execuo do mesmo, bem como as solues adotadas. Descrito no Captulo Desenvolvimento do Programa. Este relatrio tambm apresenta as consideraes finais sobre este projeto: resultados, testes, possibilidades de outros estudos.

12 1 CLPS Controlador Lgico Programvel, CLP, ou Controlador Programvel um dispositivo eletrnico utilizado na automao de processos industriais, como o controle das mquinas de uma linha de montagem de uma fbrica. Ao contrrio de computadores de uso geral, o CLP projetado para suportar grandes variaes de temperaturas, ambientes sujos ou empoeirados, imunidade a rudos eltricos, e resistncia vibrao e impacto. Os programas para o controle das mquinas so tipicamente armazenados em memrias somente de leitura, ou suportadas por baterias. O CLP um exemplo de sistema de controle de tempo real j que o valor das suas sadas produzido em resposta s condies das entradas em um tempo limitado, caso contrrio poderia resultar num erro no controle. A seguir temos imagens de CLPs tpicos.

Figura 3 - CLPs Tpicos

1.1 HISTRIA DOS CLPS O CLP foi inventado em resposta s necessidades da indstria automobilstica americana. Antes dos CLPs todo controle, seqnciamento, e lgicas de intertravamento de segurana da indstria automobilstica eram feitos utilizando-se de rels, temporizadores e controladores de loop fechado dedicados. O processo de

13 atualizar estes sistemas por modelos mais novos consumia muito tempo e dinheiro, j que os rels precisavam ser religados por eletricistas habilidosos. Em 1968 a Hydramatic Division (diviso de transmisso automtica) da General Motors requisitou uma proposta de um substituto eletrnico para os sistemas de rels[16]. Podemos didaticamente dividir os CLPs historicamente de acordo com o sistema de programao por ele utilizado: 1a. Gerao: Os CLPs de primeira gerao se caracterizam pela programao intimamente ligada ao hardware do equipamento. A linguagem utilizada era o Assembly que variava de acordo com o processador utilizado no projeto do CLP, ou seja, para poder programar era necessrio conhecer a eletrnica do projeto do CLP. Assim a tarefa de programao era desenvolvida por uma equipe tcnica altamente qualificada, gravando-se o programa em memria EPROM, sendo realizada normalmente no laboratrio junto com a construo do CLP. 2a. Gerao: Aparecem as primeiras Linguagens de Programao no to dependentes do hardware do equipamento, possveis pela incluso de um Programa Monitor no CLP, o qual converte (no jargo tcnico, compila), as instrues do programa, verifica o estado das entradas, compara com as instrues do programa do usurio e altera o estado das sadas. Os Terminais de Programao (ou maletas, como eram conhecidas), como o da figura abaixo, eram na verdade Programadores de Memria EPROM. As memrias depois de programadas eram colocadas no CLP para que o programa do usurio fosse executado.

Figura 4 - Terminal de Programao

14 3a. Gerao: Os CLPs passam a ter uma Entrada de Programao, onde um Teclado ou Programador Porttil conectado, podendo alterar, apagar, gravar o programa do usurio, alm de realizar testes (Debug) no equipamento e no programa. A estrutura fsica tambm sofre alteraes sendo a tendncia para os Sistemas Modulares com Racks. 4a. Gerao: Com a popularizao e a diminuio dos preos dos microcomputadores (normalmente clones do IBM PC), os CLPs passaram a incluir uma entrada para a comunicao serial. Com o auxlio dos microcomputadores a tarefa de programao passou a ser realizada nestes. As vantagens eram: 1. A utilizao de vrias representaes das linguagens; 2. Possibilidade de simulaes e testes; 3. Treinamento e ajuda por parte do software de programao; 4. Possibilidade de armazenamento de vrios programas no micro, etc. 5a. Gerao: Atualmente existe uma preocupao em padronizar protocolos de comunicao para os CLPs, de modo a proporcionar que o equipamento de um fabricante seja compatvel com o equipamento de outro fabricante, no s CLPs, como Controladores de Processos, Sistemas Supervisrios, Redes Internas de Comunicao e etc., proporcionando uma integrao a fim de facilitar a automao, gerenciamento e desenvolvimento de plantas industriais mais flexveis e normalizadas. Existem Fundaes Mundiais para o estabelecimento de normas e protocolos de comunicao. [16] Com o avano da tecnologia e consolidao da aplicao dos CLPs no controle de sistemas automatizados, freqente o desenvolvimento de novos recursos dos mesmos. 1.2 FUNCIONAMENTO DE UM CLP Um CLP trabalha varrendo continuamente um programa. Ns podemos pensar que este ciclo de varredura consiste basicamente de trs passos importantes, podendo

15 ser vistos na figura abaixo. Existem tipicamente mais de trs passos, mas podemos focar nos mais importantes e no nos preocupar com os outros. Tipicamente os outros passos consistem em checar o sistema e atualizar os valores de contadores e temporizadores internos. [15]

Figura 5 - Ciclo de Operao de um CLP

Primeiro Passo Checar os estados das entradas (check input status) Inicialmente o CLP olha cada entrada e determina se esta est ligada ou desligada (0 ou 1), e grava esses valores na sua memria para serem utilizados no prximo passo. Segundo Passo Executar o programa (execute program) A seguir o CLP executa o programa uma instruo por vez. Talvez o seu programa diga que caso a primeira entrada esteja ligada, ele dever ligar a primeira sada. Como o CLP j tem na sua memria os valores das entradas (passo anterior) ele capaz de decidir se a primeira sada deve ser ligada se baseando no estado da primeira entrada. A seguir ele grava os resultados da execuo deste programa e os utiliza no prximo passo. Terceiro Passo Atualizar os estados das sadas (update output status) Finalmente o CLP atualiza as sadas, baseado em quais entradas estavam ligadas no primeiro passo, e nos resultados do seu programa durante o segundo passo. Se tomarmos como base o exemplo dado no segundo passo, ele ligaria a primeira sada porque a primeira entrada estava ligada, e seu programa disse para ligar a primeira sada quando esta condio fosse verdadeira. Aps o terceiro passo o CLP volta ao primeiro passo e repete este ciclo continuamente. O tempo de scan do CLP definido pelo tempo que ele leva para executar os trs passos listados acima.

16 1.3 COMPARAO DO CLP COM OUTROS SISTEMAS DE CONTROLE CLPs so bem adaptados para uma determinada escala de tarefas de automao. Essas sendo tipicamente processos industriais em fabricao onde o custo de desenvolvimento e manuteno do sistema de automao alto se comparado ao custo total da automao, e onde mudanas no sistema de controle so esperadas durante o tempo de operao. CLPs possuem dispositivos de entrada e sada compatveis com os principais dispositivos e controladores industriais; pouco projeto eltrico necessrio, e o problema de projeto centrado em expressar a seqncia de operaes desejadas na lgica ladder. Aplicaes do CLP so tipicamente sistemas altamente customizados assim o custo de um CLP baixo comparado ao custo de um sistema de controle especfico, feito sobre encomenda. Para casos de produo em larga escala, sistemas customizados so mais econmicos, pois os custos de engenharia no so recorrentes (e assim divididos entre milhares de vendas) e tambm devido a um baixo custo dos componentes, e assim devem ser escolhidos preferencialmente a uma soluo mais genrica como o CLP [15]. Alguns dos modelos de CLPs modernos com todas as funes esto disponveis por algumas centenas de dlares, o que permite que eles sejam economicamente aplicveis em sistemas de controles muito pequenos. Para altos volumes ou simples tarefas de automao, so utilizadas tcnicas diferentes. Por exemplo, uma mquina de lavar pratos seria controlada por um sistema eletromecnico temporizado, custando somente alguns dlares com produes em grandes quantidades. Uma soluo baseada em microcontrolador seria apropriada onde centenas ou milhares de unidades forem produzidas assim os custos de desenvolvimento (projeto da fonte de energia e hardware de entradas/sadas) podem ser divididos sobre muitas vendas, e onde o usurio final no necessitaria de alterar o controle. Aplicaes automotivas so um exemplo, milhes de unidades so produzidas todo ano, muito poucos usurios finais alteram a programao destes controladores. (Porm alguns

17 veculos especiais, como nibus, usam CLPs ao invs de controladores customizados, pois o volume de nibus pequeno e os custos de desenvolvimento no so economicamente viveis.). Para o controle de processos complexos, como os utilizados na indstria qumica, podem ser necessrios algoritmos e desempenho alm das capacidades dos CLPs de maior desempenho. Controle em velocidades muito elevadas tambm pode necessitar de solues customizadas, por exemplo, controle de vo de uma aeronave. CLPs podem incluir alguns loops de controle para variveis analgicas, como um controlador proporcional, integral e derivativo ou controlador PID. Um loop PID pode ser utilizado para o controle de temperatura, vazo, velocidade, presso e muitos outros processos. Historicamente os CLPs possuem somente alguns loops de controle analgicos. Em processos onde so necessrios centenas ou milhares de loops, um sistema de controle distribudo (SCD, ou DCS do ingls Distributed Control System) utilizado. Porm, conforme os CLPs se tornam mais poderosos, os limites entre as aplicaes de SCDs ou CLPs ficam menos definidas. 1.4 LINGUAGENS DE PROGRAMAO Existem cinco tipos bsicos de modos de programao que normalmente so encontradas em controladores programveis e so padronizadas pela norma IEC 61131-3 [14]: Linguagens de rels ou diagrama de contatos; Linguagens por blocos funcionais; SFC - Sequential Function Chart (diagramas de funes seqenciais); Lista de instrues; Texto estruturado. Dos cinco tipos apresentados acima, a mais difundida e encontrada em quase todos os controladores a linguagem de rels. Os blocos funcionais tambm podem ser encontrados com facilidade, sendo eles uma extenso da linguagem de rels adaptada para incluir instrues mais poderosas e tornar mais clara a programao.

18 Devido grande utilizao da linguagem de rels, esta recebeu vrios nomes ao redor do mundo, e um deles diagrama de escada (LADDER). Esta linguagem baseia-se nas regras da linguagem de rels, na qual linhas de instruo so analizadas da esquerda para a direta, sendo que para que um bloco opere, este deve estar energizado, estando ele ligado barra da esquerda ou a um bloco que possibilite este acionamento. 1.4.1 LINGUAGEM LADDER A lgica ladder um mtodo de desenhar esquemas de lgica eltrica. uma linguagem grfica muito popular na programao de CLPs. Foi originalmente inventada para descrever a lgica feita por rels. Um programa em lgica ladder, tambm chamado de diagrama ladder, similar ao esquemtico para um circuito de rels. A maioria das indstrias que fabricam CLPs fornece um sistema de programao em ladder para seus sistemas. Tipicamente, a linguagem ladder de dois fabricantes no ser totalmente compatvel; a lgica ladder deve ser vista como um conjunto de linguagens proximamente relacionadas ao invs de uma nica linguagem. Mesmo diferentes modelos de CLPs dentro da mesma famlia podem ter notaes diferentes no ladder e estes programas no podem ser trocados entre modelos [15]. 1.4.1.1 EXEMPLO DE UM PROGRAMA SIMPLES EM LADDER A Linguagem pode ser vista como um conjunto de conexes entre verificadores lgicos (contato de rels) e atuadores (bobinas). Se for possvel traar um caminho entre o lado esquerdo de um ramo e a sada (bobina do lado direito), atravs de contatos fechados entre esses pontos, a bobina de sada considerada energizada (o que significa uma sada verdadeira ou 1). Se nenhum caminho pode ser traado, a bobina de sada considerada desenergizada (o que significa uma sada falsa ou 0). [17]

19 Por exemplo:
----[ ]---------|--[ ]--|------( )-X | Y | S | | |--[ ]--| Z

A funo acima pode vista como: S = X AND (Y OR Z) Assim caso o contato X fosse falso, no importaria os estados dos contatos Y ou Z a sada S seria falsa. Mas caso o contato X fosse verdadeiro, qualquer um dos contatos Y ou Z poderiam tornar a sada S verdadeira tambm.

20 2 .NET FRAMEWORK O .NET Framework uma plataforma de desenvolvimento da Microsoft que tem por objetivo facilitar a criao de aplicaes, possibilitando aos desenvolvedores gastar mais tempo na programao das funes especficas da aplicao e menos tempo com complicadas funes de interao com sistema operacional [1] e com problemas de reutilizao de cdigo. O .NET Framework basicamente composto por um conjunto de especificaes de infra-estrutura, um ambiente de execuo comum e uma biblioteca de componentes. 2.1 ARQUITETURA O .NET Framework possui um enorme conjunto de componentes (solues pr-programadas) para suprir necessidades de programao em vrias reas, como funes de manipulao de dados (strings, arrays, colees, enumerao), comunicaes em rede, renderizao grfica, criptografia, leitura e escrita de arquivos entre outros, denominado Biblioteca Base de Classes (Base Class Library BCL), que organizada hierarquicamente em Namespaces. Essa organizao pode ser vista na Figura 6.

21

Figura 6 - Exemplos da diviso em Namespaces

A BCL evita que desenvolvedores reescrevam grandes quantidades de cdigo padro para cada aplicao desenvolvida [2], garante um comportamento padro para todas as funes do framework e permite que cdigo e dados sejam compartilhados e modificados de forma modular [4]. Aplicaes escritas para o .NET Framework rodam em um ambiente que gerencia as necessidades de tempo de execuo da aplicao. Este ambiente de tempo de execuo chamado de Tempo de Execuo de Linguagem Comum (Common Language Runtime CLR) [3]. O CLR possui a aparncia de uma mquina virtual, assim os desenvolvedores no precisam preocupar-se com as capacidades especficas do Sistema Operacional e do processador que executaro a aplicao. O CLR tambm prov outros servios importantes como mecanismos de segurana, gerenciamento de memria (coletor de lixo) e manipulao de excees [3]. O .NET Framework possui um conjunto de especificaes que descreve o cdigo executvel e o ambiente de execuo do framework denominado Infra-estrutura

22 de Linguagem Comum (Common Language Infrastructure CLI). A CLI descreve, dentre outros, os seguintes aspectos: A. Sistema de Tipos Comuns (Common Type System CTS), um conjunto

comum de tipos (string, char, int, float, double, bool) e operaes compartilhados entre as linguagens de programao [6]. O CTS define como todos os possveis tipos de dados e construes de programao interagem entre si [3]; B. Especificao de Linguagem Comum (Common Language

Specification CLS), um conjunto de regras bsicas s quais qualquer linguagem direcionada CLI deve conformar-se para interoperar com outras linguagens compatveis com a CLS [5]; C. Linguagem Intermediria Comum (Common Intermediate Language

CIL), uma linguagem comum em bytecode para qual o cdigo fonte de aplicaes .NET compilado ao invs de cdigo de mquina especfico [7]. Por causa desta caracterstica, o .NET Framework suporta vrias linguagens de programao, basta que o compilador traduza o cdigo fonte corretamente para a CIL de acordo com o CTS e a CLS [3]. Posteriormente, o cdigo CIL compilado para cdigo de mquina especfico do sistema operacional alvo, tornando, desta maneira, a aplicao multiplatforma [8]; D. Compilador Just-In-Time (Just-In-Time compiler JIT), compila o

cdigo CIL em cdigo de mquina durante o tempo de execuo, aumentando a eficincia de sistemas de programao baseados em compilao para linguagem intermediria [8]; E. Metadados (Metadata), descreve todas as classes e membros das classes

contidas num assembly, e todas as classes e membros das classes contidas em outra assembly que a presente chamar [9]. O CLR checa os metadados para certificar-se que o mtodo correto est sendo chamado [3]; F. Sistema Virtual de Execuo (Virtual Execution System VES), prov

um ambiente para executar programas compatveis com a CLI. Ele prov suporte direto para um conjunto de tipos de dados, define uma mquina hipottica com modelo e estado associados, um conjunto de construes de fluxo e um modelo de

23 manipulao de excees. De modo abrangente, o VES prov o suporte necessrio para executar o conjunto de instrues CIL [10]. Ele carrega e executa os programas, usando os metadados para combinar, durante o tempo de execuo, pedaos de cdigo gerados separadamente [5].

O modelo de execuo do sistema .NET Framework pode ser visto na figura a seguir.

Figura 7 - Modelo de execuo

2.2 CARACTERSTICAS A. Assemblies O cdigo CIL guardado em .NET Assemblies, que so as

unidades .NET para distribuio, gerenciamento de verses e segurana [3]. Na implementao Microsoft Windows do .NET Framework, uma assembly um arquivo executvel porttil (portable executable PE), classificado em assembly de processo (EXE) e assembly de biblioteca (DLL Dinamic Link Library Biblioteca de Ligao Dinmica) [12].

24 B. Interoperabilidade Como a interao entre novas e velhas

aplicaes freqentemente necessria, o .NET Framework prov meios para acessar funcionalidades implementadas em cdigo que est fora da plataforma .NET [3]. C. Independncia de Linguagem O .NET Framework suporta

desenvolvimento em vrias linguagens de programao (C#, VB.NET, J#, C++.NET). Esta caracterstica possvel devido s definies do CTS, do CLS e da CIL [3]. D. Distribuio Simplificada Problemas de instalao e distribuio de

aplicaes Windows, como entradas no Registro, configuraes das aplicaes, distribuio de arquivos e o inferno das DLLs foram quase completamente eliminadas pelos mecanismos de distribuio do .NET Framework [3]. E. Segurana O .NET Framework possibilita que cdigo seja executado

com diferentes nveis de segurana sem a necessidade do uso de um sandbox separado [3]. Sandbox um mecanismo de segurana utilizado para executar programas de modo seguro. So normalmente utilizados para executar cdigo no confivel, programas de terceiros e fornecedores no verificados e usurios no confiveis [11]. A segurana do .NET Framework possui seu prprio mecanismo de segurana, com duas caractersticas gerais: Segurana de Acesso a Cdigo (Code Access Security CAS) e validao e verificao. A CAS baseada em evidncia associada a uma assembly especfica. Tipicamente, a evidncia a fonte da assembly (instalada na mquina local, baixada de uma intranet ou da Internet). A CAS usa a evidncia para as permisses conferidas ao cdigo. Validao e verificao so dois dos muitos testes executados pelo CLR quando uma assembly carregada. A validao checa se a assembly contm metadados e cdigo CIL vlidos e a verificao checa o cdigo para descobrir se este executa algo no seguro. Cdigo no seguro somente ser executado se a assembly possuir uma permisso de pular verificao, o que geralmente indica que a assembly est instalada na mquina local [3]. F. Independncia de Platafoma Devido s definies da CLI, ao CLR e

BCL, o .NET Framework suporta independncia de plataforma. Isto , uma aplicao desenvolvida no framework dever ser executada sem nenhuma alterao em qualquer computador que possuir o framework instalado. Atualmente, a Microsoft implementou

25 por completo o framework apenas nos sistemas operacionais Windows. A Microsoft e terceiros implementaram partes do framework em sistemas operacionais noWindows, mas tais implementaes no possuem utilizao em massa. Exemplos de tais implementaes so o Mono Project e o DotGNU Portable.Net [13]. 2.3 DESENVOLVIMENTO DE APLICAES Aplicaes de Console So as aplicaes desenvolvidas para serem executadas em modo texto em linha de comando. Conforme pode ser visto na figura a seguir.

Figura 8 - Exemplo de aplicaes no console

Windows Forms Este um nome genrico para vrios tipos de aplicaes que podem ser desenvolvidas para a interface grfica do Windows. Tais aplicaes contemplam, entre outras, aplicaes Windows, servios Windows e bibliotecas de componentes grficos a serem utilizados em outras aplicaes. Um exemplo de

26 aplicao Windows Forms em .NET Framework, o Paint .NET visto na figura abaixo.

Figura 9 - Paint.NET Exemplo de programa desenvolvido em Windows Forms

Aplicaes Web O .NET Framework, em conjunto com a tecnologia ASP.NET, possibilita o desenvolvimento de pginas web dinmicas e interativas, com cdigo de execuo tanto no cliente quanto no servidor. O comportamento dinmico e a interatividade de tais pginas propiciam ao usurio a sensao da utilizao de uma aplicao, abrindo portas para o desenvolvimento de sistemas web cuja distribuio extremamente simplificada e a utilizao no depende tanto das capacidades do computador do usurio. Ao entregar o cdigo HTML e script da pgina ao cliente, o servidor o faz de tal forma que os recursos grficos e interativos sejam escalados de acordo com as capacidades do navegador. O .NET Framework tambm possibilita o desenvolvimento de componentes grficos web para ASP.NET. A tecnologia ASP.NET tambm possibilita o desenvolvimento de servios web (web services), onde

27 o processamento de requisies e dados pode ser distribudo atravs de vrios servidores. Temos um exemplo de aplicao Web a seguir.

Figura 10 - Exemplo de Aplicao Web

Aplicaes para Dispositivos Mveis O .NET Framework possibilita o desenvolvimento de aplicaes web e Windows Forms para plataformas mveis, como handhelds, PDAs, celulares e tablets. 2.4 LINGUAGENS DE PROGRAMAO Atravs das especificaes do CTS e com a ajuda do CLR, possvel criar compiladores de diversas linguagens de programao que sejam compatveis com o .NET. Basta que este compilador gere o cdigo CIL de forma apropriada. Existe atualmente uma srie de linguagens de programao diferentes que podem ser usadas para desenvolvimento no .NET Framework, sendo as mais populares e com maior suporte: C# (C Sharp) e Visual Basic .NET. O Visual Basic.NET uma evoluo da clssica linguagem Visual Basic. J o C# uma linguagem nova e rica em funcionalidades. Outras linguagens como Perl, Pyhton, Scheme, C++ e at COBOL j

28 tm atualmente compiladores disponveis que geram cdigo em CIL e podem ser executados sobre a plataforma .NET. 2.5 AMBIENTES DE DESENVOLVIMENTO Ambientes de Desenvolvimento Integrado (Integrated Development

Enviroments - IDEs) so programas que auxiliam os desenvolvedores no processo de criao de aplicaes. Aplicaes podem ser desenvolvidas utilizando apenas um editor de texto e um compilador de linha de comando, mas, at mesmo para pequenas aplicaes, gerar interfaces grficas (programas grficos e HTML) e cdigo repetitivo tornam a tarefa extremamente cansativa e passvel de erros. Os IDEs comumente oferecem, entre outras facilidades, fcil acesso s bibliotecas de componentes grficos atravs de barras de ferramentas (arrastar e soltar), verificao e colorizao de sintaxe e compilao automatizada. As IDEs oferecem tais recursos de programao visual, sem perder as caractersticas de orientao a objeto das linguagens de programao do .NET Framework. Algumas IDEs utilizadas para desenvolvimento no .NET Framework so o Microsoft Visual Studio, Microsoft ASP.Net WebMatrix, SharpDevelop,

MonoDevelp, C# Builder e Antechinus C# Editor. 2.6 DOCUMENTAO E RECURSOS A Microsoft possui uma diviso responsvel pelo relacionamento com os desenvolvedores, denominada Rede de Desenvolvedores Microsoft (Microsoft Developers Network MSDN). Uma extensiva documentao da plataforma disponibilizada, de forma gratuita, via web ou via biblioteca que pode ser instalada numa mquina local atravs da MSDN, sendo que as especificaes de todos os componentes da BCL podem ser acessadas diretamente pelo Visual Studio. A MSDN tambm possui uma publicao mensal impressa em vrias lnguas com artigos diversificados sobre as diversas tecnologias da Microsoft e suas interaes. Alm disso, a MSND oferece, gratuitamente, contedo para acesso via web na forma de centenas de artigos e tutoriais, alm de uma comunidade para interao entre os

29 desenvolvedores, onde possvel esclarecer dvidas, compartilhar cdigo e buscar solues j implementadas por outros desenvolvedores. Outras fontes de artigos, informaes e comunidades relacionadas ao .NET Framework so o Code Project, o C# Corner, o C# Station, 4 Guys From Rolla e Dev Articles, dentre outros.

30

3 O DESENVOLVIMENTO DO PROGRAMA
Neste captulo sero apresentados os passo que foram necessrios para o desenvolvimento do programa. Toda a programao poder ser vista detalhadamente nos Apndices. O primeiro passo foi a definio da linguagem de programao a ser utilizada para o desenvolvimento do programa. A linguagem escolhida foi o C#, uma linguagem desenvolvida pela Microsoft que utiliza todos os benefcios citados no captulo .NET Framework. 3.1 DEFINIO DO LAYOUT O primeiro passo no desenvolvimento de qualquer programa a ser desenvolvido numa linguagem orientada a objeto deve ser a definio do layout para a aplicao.

Figura 11 - Layout inicial do programa

31

Uma vez definido o layout foi necessrio saber como seria desenhado o ladder. Aps um estudo nos objetos disponveis no C#, foi definido que seria utilizado o DataGridView onde ser desenhado o ladder. O DataGridView basicamente uma grade, onde o usurio ir selecionar qual posio da grade gostaria de incluir o novo componente, depois selecionaria qual a porta que gostaria de utilizar com o novo componente, uma vez escolhida a porta, somente os botes compatveis com as funes daquela porta so habilitados. 3.2 FUNES PROJETADAS Para este projeto ficou definido que o micro-CLP teria as seguintes funes: Digitais: Contatos normalmente abertos e fechados. Sadas normalmente abertas e fechadas. Dois contadores. Dois temporizadores. Que atualizam a sada somente aps o tempo selecionado ter decorrido Analgicas Dois comparadores, que acionam trs sadas cada um, o primeiro comparador aciona as sadas Mx, onde M0 recebe o valor 1 caso a varivel comparada seja menor que o valor escolhido, M1 recebe o valor 1 caso a varivel comparada seja igual ao valor escolhido, M2 recebe o valor 1 caso a varivel comparada seja maior que o valor escolhido. Dois controladores PID, que acionam as sadas PWM respectivas, os valores de Set Point, constantes proporcional, integral e derivativa so escolhidas pelo usurio quando selecionada esta funo.

32 Uma funo display, que disponibiliza o valor da varivel selecionada no LCD do micro-CLP. 3.3 PORTAS DISPONVEIS PARA A PROGRAMAO As portas existentes so: X0 a X7 Entradas fsicas do micro-CLP (digitais); Y0 a Y7 Sadas fsicas do micro-CLP (digitais); I00 a I15 Variveis internas (digitais) que podem ser utilizadas tanto como entradas ou sadas; M0 a M1 Entradas digitais internas, relacionadas ao resultado do Comparador1 do ladder; N0 a N1 Entradas digitais internas, relacionadas ao resultado do Comparador2 do ladder; AN0 a AN2 Entradas analgicas fsicas. 3.4 LAYOUT DEFINITIVO Aps a definio do layout, definio das variveis, e funes que o ladder deveria ter, foi construdo o layout definitivo do programa, que pode ser visto na figura a seguir.

33

Figura 12 - Layout definitivo do programa

O passo seguinte foi criar uma classe especfica para os componentes. Essa classe necessita de algumas entradas, como: qual a porta do componente a ser criado, o tipo do componente e etc. Esse componente salvo nos dados do dataGridView, ele tem uma caracterstica Tag onde fica salvo o componente. Como citado anteriormente, dependendo da seleo da porta, os botes de funes so liberados, por exemplo, caso selecionemos uma porta X, teremos somente os botes [ ], [/] habilitados, que correspondem a contatos NA e NF respectivamente e o boto do contador. Quando selecionado um dos componentes PID, Comparador (<>=), Contador ou temporizador (timer) aberta uma nova janela para adquirir os dados necessrios para criao desses componentes, as janelas para entrarem com estes dados so mostradas a seguir:

34

Figura 13 - Layout auxiliar para os parmetros do PID

Figura 14 - Layout auxiliar para os parmetros do Comparador

Figura 15 - Layout auxiliar para os parmetros do Contador

Figura 16 - Layout auxiliar para os parmetros do Temporizador

35 3.5 DESENHANDO O LADDER Aps definidas as variveis e funes que o ladder deve ter, podemos passar a desenh-lo. Aqui um exemplo bsico de um programa ladder criado:

Figura 17 - Exemplo de ladder

3.6 GERANDO O CDIGO INTERMEDIRIO A rotina para gerar o cdigo intermedirio consiste basicamente de uma varredura por todas as clulas do dataGridView, Ele s confere os elementos das linhas que possuem elementos na ltima coluna, assim evita que seja feita a varredura de laos na lgica, como o mostrado na segunda linha do ladder da Figura 17.

36 Aps desenhar o ladder, podemos criar o cdigo intermedirio e envi-lo pela porta serial do computador. O cdigo intermedirio gerado pode ser visto na figura a seguir:

Figura 18 - Cdigo intermedirio gerado

O cdigo a ser enviado ao micro-PLC uma codificao da lista de instrues vista na Figura 18, sendo no total 14 bits (tamanho da memria de programa do PIC utilizado - 16F877). Este cdigo gerado tem os seis bits mais significativos simbolizando a funo a ser executada, e os oito bits menos significativos a porta a ser utilizada para a funo descrita. Algumas funes no necessitam da especificao de uma porta, como as funes OR e AND_B, outras necessitam de mais informao que somente a porta, como PID, COMP, CONT e TIMER, para estas utiliza-se de um cabealho, onde sempre so enviadas essas informaes no incio da comunicao serial. O cabealho consiste de enviar os valores das constantes para os blocos PID, comparador, contador e temporizador, sendo no total 14 constantes com 2 bytes cada. Os valores destas constantes so sempre enviados no cabealho, mesmo no sendo utilizadas nenhuma dessas funes, portanto o cabealho possui um comprimento de 28 bytes, fixos, e que sempre so salvos nas mesmas posies de memria.

37 A estrutura do cabealho consiste de, 2 bytes para cada uma das variveis a seguir, na seqncia: Set Point PD1 Ganho Integral do PID1 Set Point PID2 Ganho Integral do PID2 Ganho Proporcional do PID1 Ganho Derivativo do PID1 Ganho Proporcional do PID2 Ganho Derivativo do PID2

Valor a ser comparado pelo Comparador1 Valor a ser comparado pelo Comparador2 Tempo a ser contado no Temporizador1 Tempo a ser contado no Temporizador2

Eventos a serem contados pelo Contador1 Eventos a serem contados pelo Contador2
Figura 19 Estrutura do cabealho

Foi vista a necessidade de se gerar esse cabealho, pois incluir estes valores no cdigo iria dificultar a interpretao do mesmo, como foi definido que haveria um numero mximo de PIDs, comparadores, temporizadores e contadores, ficou decidido que o programa deveria enviar estes valores, sempre nessa ordem antes de enviar o programa do ladder. Assim quando o interpretador do ladder chegasse numa funo PID1, ele saberia que a entrada para esse PID a porta que vem codificada aps estes comando, e que o Set Point, Kp, Ki e Kd esto armazenados num local fixo da memria. 3.7 A COMUNICAO SERIAL Utilizar a comunicao serial utilizando o C# extremamente simples. Para isso, necessrio utilizar a biblioteca System.IO, que disponibiliza a classe SerialPort para o projeto. Uma nova instncia da classe SerialPort necessita somente da definio de alguns parmetros, como o nome da porta a ser utilizada (COM1), BaudRate (9600), se sero enviados bits de paridade (None), nmero de bits por byte (8) e stopbits (one). Para enviar, somente necessrio abrir a porta serial (nome da instncia da porta serial.open() ), utilizar o comando para enviar (nome da instncia da porta

38 serial.write(string a ser enviada) ), e fechar a porta quando o envio concludo (nome da instncia da porta serial.close() ). Uma vez pronta a lgica ladder a ser enviada ao micro-CLP, necessrio coloc-lo num modo especfico para receber o programa, aps preparar o micro-CLP para receber o cdigo, somente necessrio clicar no boto Cdigo + Envio Serial que ser gerado o cdigo intermedirio e posteriormente enviado pela porta serial ao micro-CLP. Primeiramente esse envio foi testado ligando dois computadores atravs da porta serial, e no computador receptor, aberto o HyperTerminal. Durante este teste tudo ocorreu perfeitamente, o computador com o HyperTerminal recebeu todos os caracteres que lhe foram enviados, os caracteres correspondiam as funes corretas. Porm ao fazer o mesmo teste, desta vez utilizando o micro-CLP para receber o cdigo, ocorreu um problema: A rotina de ler a porta serial, salvar na memria o cdigo era por de mais lenta, a cada vinte e oito caracteres enviados eram recebidos somente onze, ou seja, informao estava sendo perdida. Para solucionar este problema, aps cada byte enviado foi inserida uma pausa de 4ms, porm depois de olhar no datasheet do microcontrolador vimos que recomendado uma pausa de 10ms entre dados a serem gravados na EEPROM, ajustando essa pausa, foram feitos novos testes onde tudo ocorreu conforme projetado.

39 4 TESTES E RESULTADOS Neste captulo sero apresentados os testes feitos e resultados obtidos. O primeiro passo para o teste foi a definio de uma possvel aplicao para este micro-CLP. A aplicao escolhida foi o controle de um porto eletrnico. Com a aplicao definida podemos fazer o ladder para o controle do porto. Considerando que o porto est ligado da seguinte maneira: Boto de comando para abrir o porto, porta X0. Boto de comando para fechar o porto, porta X1. Sensor de fim de curso porto aberto, na porta X2. Sensor de fim de curso porto fechado, na porta X3. Sada para motor, abrir o porto Y0. Sada para motor, fechar o porto Y1. O Ladder criado para o controle do porto eletrnico pode ser visto a seguir:

Figura 20 Ladder controle porto eletrnico

40 Analisando o ladder temos, apertando o boto para abrir o porto (X0), e o sensor de porto aberto (X2) no estando ativado, vai acionar a sada interna I00, que utilizada como selo para que ela s seja desligada quando ocorrer o fim de curso de porto aberto, ou o boto de fechar (X1) seja acionado. A sada interna I00 passada para a sada fsica Y0 que indica que o motor deve ser ligado para abrir o porto. Caso o boto pressionado seja o de fechar o porto (X1), e sensor de porto fechado (X3) no estando ativado, vai acionar a sada interna I01, que tambm ser utilizada como selo para que s seja desligada quando ocorrer o fim de curso de porto fechado, ou o boto de abrir (X0) seja acionado. A sada interna I01 passada para a sada fsica Y1 que indica que o motor deve ser ligado para fechar o porto. O cdigo intermedirio gerado e enviado ao micro-CLP foi:

Figura 21 Linguagem intermediaria gerada e enviada para o micro-CLP

Foi possvel simular as atuaes dos botes e sensores acionando as entradas atravs de uma fonte 24Vdc, e visualizar as sadas acionadas pelos leds de indicao onde tudo ocorreu conforme programado.

41

5 CONCLUSES
A utilizao de CLPs na indstria nos dias de hoje muito extensa, muito provvel que se voc for a uma indstria, CLPs estaro sendo utilizados para algum tipo de controle, como controle de vlvulas, ou sistemas de segurana. Na programao destes CLPs a linguagem mais utilizada o ladder por ser uma linguagem grfica, baseada em smbolos semelhantes aos encontrados nos esquemas eltricos (contatos e bobinas). Neste projeto foi possvel construir um ambiente para programao em ladder de um micro-CLP implementado em PIC. O micro-CLP pode ser visto na figura a seguir.

Figura 22 O micro-CLP

O objetivo do projeto foi alcanado, pois a programao do micro-CLP pode ser feita conforme planejada, apesar de no ser possvel testar as funes utilizando

42 variveis analgicas, tudo indica que funcionariam corretamente, dependendo somente da implementao das funes no programa residente no micro-CLP. Este projeto reuniu muitos dos conhecimentos adquiridos ao longo do curso de Engenharia Eltrica, dos quais podemos citar conhecimentos de programao que foram essenciais no desenvolvimento do ambiente de programao. Devido a problemas no desenvolvimento do programa residente do PIC no foi possvel testar todas as funes que foram disponibilizadas no ambiente de programao. Porm isto no impediu a concluso do projeto de modo satisfatrio, e este ambiente de programao em conjunto ao micro-CLP ficaro disponveis nos laboratrios do curso de Engenharia Eltrica para que os alunos possam ter contato com um equipamento parecido com os disponveis na indstria atualmente. Fica como sugesto para um projeto futuro, a implementao de uma lgica para aquisio de um programa que foi gravado no micro-CLP e o disponibilizar para alteraes pelo usurio.

43 APNDICE A CDIGO PROGRAMA PRINCIPAL LADDER.CS


using using using using using using using using using System; System.Collections.Generic; System.ComponentModel; System.Data; System.Drawing; System.Text; System.Windows.Forms; System.IO.Ports; System.Threading;

namespace PG.Roger { public partial class Ladder : Form { public Ladder() { InitializeComponent(); lstPortas.SelectedIndex = -1; } private void MudarLinhaInicial() { for (int i = 0; i < dgrComponentes.Rows[0].Cells.Count; i++) { dgrComponentes.CurrentCell = dgrComponentes.Rows[0].Cells[i]; Mudar(new Componente(null, Componente.TiposComponente.connect, 0, 0, 0, 0, 0, 0, 0, 0)); dgrComponentes.CurrentCell = null; } btnNewLine_Click(null, null); dgrComponentes.CurrentCell = dgrComponentes.Rows[0].Cells[0]; } private void MudarEstadoBotoes(bool ativo) { btnContato.Enabled = ativo; btnContatoInv.Enabled = ativo; btnBobina.Enabled = ativo; btnBobinaInv.Enabled = ativo; btnComp.Enabled = ativo; btnCont.Enabled = ativo; btnPid.Enabled = ativo; btnDisplay.Enabled = ativo; } public void Mudar(Componente comp) { dgrComponentes.CurrentCell.Tag = comp; dgrComponentes.CurrentCell.Value = comp.texto; dgrComponentes.CurrentCell.Selected = false; lstPortas.SelectedIndex = -1; } private void btnNewLine_Click(object sender, EventArgs e) {

44
dgrComponentes.Rows.Add(new DataGridViewRow()); } private void btnContato_Click(object sender, EventArgs e) { Mudar(new Componente((string)lstPortas.Items[lstPortas.SelectedIndex], Componente.TiposComponente.contato, 0, 0, 0, 0, 0, 0, 0, lstPortas.SelectedIndex)); } private void btnContatoInv_Click(object sender, EventArgs e) { Mudar(new Componente((string)lstPortas.Items[lstPortas.SelectedIndex], Componente.TiposComponente.contatoNegado, 0, 0, 0, 0, 0, 0, 0, lstPortas.SelectedIndex)); } private void btnBobina_Click(object sender, EventArgs e) { Mudar(new Componente((string)lstPortas.Items[lstPortas.SelectedIndex], Componente.TiposComponente.bobina, 0, 0, 0, 0, 0, 0, 0, lstPortas.SelectedIndex)); } private void btnBobinaInv_Click(object sender, EventArgs e) { Mudar(new Componente((string)lstPortas.Items[lstPortas.SelectedIndex], Componente.TiposComponente.bobinaNegada, 0, 0, 0, 0, 0, 0, 0, lstPortas.SelectedIndex)); } public string porta; public int portaIndex; private void btnPid_Click(object sender, EventArgs e) { porta = (string)lstPortas.Items[lstPortas.SelectedIndex]; portaIndex = (int)lstPortas.SelectedIndex; Program.pidBox = new PidBox(); Program.pidBox.Show(); this.Enabled = false; } private void btnCont_Click(object sender, EventArgs e) { porta = (string)lstPortas.Items[lstPortas.SelectedIndex]; portaIndex = (int)lstPortas.SelectedIndex; Program.contBox = new ContBox(); Program.contBox.Show(); this.Enabled = false; } private void btnComp_Click(object sender, EventArgs e) { porta = (string)lstPortas.Items[lstPortas.SelectedIndex];

45
portaIndex = (int)lstPortas.SelectedIndex; Program.compBox = new CompBox(); Program.compBox.Show(); this.Enabled = false; } private void btnTimer_Click(object sender, EventArgs e) { Program.timerBox = new TimerBox(); Program.timerBox.Show(); this.Enabled = false; } private void btnDisplay_Click(object sender, EventArgs e) { Mudar(new Componente((string)lstPortas.Items[lstPortas.SelectedIndex], Componente.TiposComponente.display, 0, 0, 0, 0, 0, 0, 0, lstPortas.SelectedIndex)); } private void btnConect_Click(object sender, EventArgs e) { Mudar(new Componente(null, Componente.TiposComponente.connect, 0, 0, 0, 0, 0, 0, 0, 0)); } private void btnUpperLeft_Click(object sender, EventArgs e) { Mudar(new Componente(null, Componente.TiposComponente.upperConnectLeft, 0, 0, 0, 0, 0, 0, 0, 0)); } private void btnUpperRight_Click(object sender, EventArgs e) { Mudar(new Componente(null, Componente.TiposComponente.upperConnectRight, 0, 0, 0, 0, 0, 0, 0, 0)); } private void dgrComponentes_CellClick(object sender, DataGridViewCellEventArgs e) { if (dgrComponentes.CurrentCell.Tag != null) { Componente c = (Componente)dgrComponentes.CurrentCell.Tag; lstPortas.SelectedItem = c.porta; } else lstPortas.SelectedIndex = -1; } private void lstPortas_SelectedIndexChanged(object sender, EventArgs e) // Quando ocorre uma mudana na seleo da porta { // logica para acionar somente os botoes compativeis MudarEstadoBotoes(false); // a porta selecionada

46
if (lstPortas.SelectedIndex >= 0 && lstPortas.SelectedIndex < 8) { btnContato.Enabled = true; btnContatoInv.Enabled = true; btnCont.Enabled = true; } else if (lstPortas.SelectedIndex >= lstPortas.SelectedIndex < 16) { btnBobina.Enabled = true; btnBobinaInv.Enabled = true; } else if (lstPortas.SelectedIndex >= lstPortas.SelectedIndex < 32) { btnContato.Enabled = true; btnContatoInv.Enabled = true; btnBobina.Enabled = true; btnBobinaInv.Enabled = true; btnCont.Enabled = true; } else if (lstPortas.SelectedIndex >= lstPortas.SelectedIndex < 38) { btnContato.Enabled = true; btnContatoInv.Enabled = true; btnCont.Enabled = true; } else if (lstPortas.SelectedIndex >= lstPortas.SelectedIndex < 41) { btnPid.Enabled = true; btnComp.Enabled = true; btnDisplay.Enabled = true; } } 8 &&

16 &&

32 &&

38 &&

public string enviar; // String onde sao salvos os Caracteres para serem enviados ao PIC public string codigo; // String onde salvo o cdigo intermediario para visualizao mais facil public string codigoBin; // Strin onde salvo o cdigo em valores inteiros correspondentes ao Char public bool newrang; // indica a necessidade de um LD no proximo contato a ser lido public bool needAnd; // indica a necessidade de um AND_Block aps o proximo OR public int lastRowIndex = -1; // auxiliar para varredura do DataGridView public int lastCollumIndex = -1; // auxiliar para varredura do DataGridView

47
public int pidNumber = 1, compNumber = 1, tempNumber = 1, contNumber = 1; // Contadores do Numero de elementos restritos public int sp1, sp2, kp1, kp2, ki1, ki2, kd1, kd2; // Variaveis que irao no cabealho public int c1, c2; // Variaveis que irao no cabealho public int cmp1, cmp2; // Variaveis que irao no cabealho public int t1, t2; // Variaveis que irao no cabealho

private void analisar() //rotina utilizada para gerar o codigo intermediario { if (dgrComponentes.Rows[i].Cells[j].Tag != null) { Componente c = (Componente)dgrComponentes.Rows[i].Cells[j].Tag; switch (c.tipo) { case Componente.TiposComponente.contato: if (j == 0 || newrang == true) { codigo = codigo + "LD " + c.porta + "\n"; codigoBin = codigoBin + Convert.ToString(Convert.ToInt32("00000000", 2), 10) + " " + c.portaIndex.ToString() + "\n"; enviar = enviar + (Convert.ToString(Convert.ToChar(0))); enviar = enviar + (Convert.ToString(Convert.ToChar(c.portaIndex))); newrang = false; } else { codigo = codigo + "AND " + c.porta + "\n"; codigoBin = codigoBin + Convert.ToString(Convert.ToInt32("00000010", 2), 10) + " " + c.portaIndex.ToString() + "\n"; enviar = enviar + (Convert.ToString(Convert.ToChar(2))); enviar = enviar + (Convert.ToString(Convert.ToChar(c.portaIndex))); } break; case Componente.TiposComponente.contatoNegado: if (j == 0 || newrang == true) { codigo = codigo + "LD_NOT " + c.porta + "\n"; codigoBin = codigoBin + Convert.ToString(Convert.ToInt32("00000001", 2), 10) + " " + c.portaIndex.ToString() + "\n"; enviar = enviar + (Convert.ToString(Convert.ToChar(1))); enviar = enviar + (Convert.ToString(Convert.ToChar(c.portaIndex)));

48
newrang = false; } else { codigo = codigo + "AND_NOT " + c.porta + "\n"; codigoBin = codigoBin + Convert.ToString(Convert.ToInt32("00000011", 2), 10) + " " + c.portaIndex.ToString() + "\n"; enviar = enviar + (Convert.ToString(Convert.ToChar(3))); enviar = enviar + (Convert.ToString(Convert.ToChar(c.portaIndex))); } break; case Componente.TiposComponente.bobina: codigo = codigo + "OUT " + c.porta + "\n"; codigoBin = codigoBin + Convert.ToString(Convert.ToInt32("00000110", 2), 10) + " " + c.portaIndex.ToString() + "\n"; enviar = enviar + (Convert.ToString(Convert.ToChar(6))); enviar = enviar + (Convert.ToString(Convert.ToChar(c.portaIndex))); break; case Componente.TiposComponente.bobinaNegada: codigo = codigo + "OUT_NOT " + c.porta + "\n"; codigoBin = codigoBin + Convert.ToString(Convert.ToInt32("00000111", 2), 10) + " " + c.portaIndex.ToString() + "\n"; enviar = enviar + (Convert.ToString(Convert.ToChar(7))); enviar = enviar + (Convert.ToString(Convert.ToChar(c.portaIndex))); break; case Componente.TiposComponente.pid: codigo = codigo + "PID" + Convert.ToString(pidNumber) + " SP" + Convert.ToString(c.sp) + " PV" + c.porta + " Kp" + Convert.ToString(c.kp) + " Ki" + Convert.ToString(c.ki) + " Kd" + Convert.ToString(c.kd) + "\n"; codigoBin = codigoBin + Convert.ToString(Convert.ToInt32("00010000", 2) + pidNumber - 1, 10) + " " + c.portaIndex.ToString(); enviar = enviar + (Convert.ToString(Convert.ToChar(15 + pidNumber))); enviar = enviar + (Convert.ToString(Convert.ToChar(c.portaIndex))); if (pidNumber == 1) { sp1 = c.sp; kp1 = c.kp; ki1 = c.ki; kd1 = c.kd; } else if (pidNumber == 2) { sp2 = c.sp;

49
kp2 = c.kp; ki2 = c.ki; kd2 = c.kd; } pidNumber++; if (pidNumber > 2) { pidNumber = 1; } break; case Componente.TiposComponente.cont: codigo = codigo + "CONT" + Convert.ToString(contNumber) + " " + c.porta + " " + Convert.ToString(c.cont) + "\n"; codigoBin = codigoBin + Convert.ToString(Convert.ToInt32("00010110", 2) + contNumber - 1, 10) + Convert.ToString(c.cont) + "\n"; enviar = enviar + (Convert.ToString(Convert.ToChar(21 + contNumber))); enviar = enviar + (Convert.ToString(Convert.ToChar(c.portaIndex))); if (contNumber == 1) { c1 = c.cont; } else if (contNumber == 2) { c2 = c.cont; } contNumber++; if (contNumber > 2) { contNumber = 1; } break; case Componente.TiposComponente.comp: codigo = codigo + "COMP" + Convert.ToString(compNumber) + " " + c.porta + " " + Convert.ToString(c.k) + "\n"; codigoBin = codigoBin + Convert.ToString(Convert.ToInt32("00010010", 2) + compNumber - 1, 10) + Convert.ToString(c.k) + "\n"; enviar = enviar + (Convert.ToString(Convert.ToChar(17 + compNumber))); enviar = enviar + (Convert.ToString(Convert.ToChar(c.portaIndex))); if (contNumber == 1) { cmp1 = c.k; } else if (contNumber == 2) { cmp2 = c.k; } compNumber++; if (compNumber > 2) {

50
compNumber = 1; } break; case Componente.TiposComponente.temp: codigo = codigo + "TIMER " + Convert.ToString(c.temp) + "\n"; codigoBin = codigoBin + Convert.ToString(Convert.ToInt32("00010100", 2) + tempNumber - 1, 10) + "\n"; enviar = enviar + (Convert.ToString(Convert.ToChar(19 + tempNumber))); enviar = enviar + (Convert.ToString(Convert.ToChar(0))); if (tempNumber == 1) { t1 = c.temp; } else if (tempNumber == 2) { t2 = c.temp; } tempNumber++; if (tempNumber > 2) { tempNumber = 1; } break; case Componente.TiposComponente.display: codigo = codigo + "DISPLAY " + Convert.ToString(c.porta) + "\n"; codigoBin = codigoBin + Convert.ToString(Convert.ToInt32("00001000", 2), 10) + " " + Convert.ToString(c.portaIndex) + "\n"; enviar = enviar + (Convert.ToString(Convert.ToChar(8))); enviar = enviar + (Convert.ToString(Convert.ToChar(c.portaIndex))); break; case Componente.TiposComponente.connect: if (i + 1 <= dgrComponentes.Rows.Count - 1 && dgrComponentes.Rows[i + 1].Cells[j].Tag != null) { Componente d = (Componente)dgrComponentes.Rows[i + 1].Cells[j].Tag; if (d.tipo == Componente.TiposComponente.upperConnectLeft) { lastRowIndex = i; j = lastCollumIndex; i++; newrang = true; } else if (d.tipo == Componente.TiposComponente.upperConnectRight) {

51
newrang = true; needAnd = true; lastCollumIndex = j; lastRowIndex = i; } } break; case Componente.TiposComponente.upperConnectLeft: codigo = codigo + "OR\n"; codigoBin = codigoBin + Convert.ToString(Convert.ToInt32("00000101", 2), 10) + " " + c.portaIndex.ToString() + "\n"; enviar = enviar + (Convert.ToString(Convert.ToChar(5))); enviar = enviar + (Convert.ToString(Convert.ToChar(c.portaIndex))); if (i + 1 <= dgrComponentes.Rows.Count - 1 && dgrComponentes.Rows[i + 1].Cells[j].Tag != null) { Componente e = (Componente)dgrComponentes.Rows[i + 1].Cells[j].Tag; if (e.tipo == Componente.TiposComponente.upperConnectLeft) { j = lastCollumIndex; i++; newrang = true; } else if (newrang == true) { i = lastRowIndex; newrang = false; if (needAnd == true) { codigo = codigo + "AND_B\n"; codigoBin = codigoBin + Convert.ToString(Convert.ToInt32("00000100", 2), 10) + " " + c.portaIndex.ToString() + "\n"; enviar = enviar + (Convert.ToString(Convert.ToChar(4))); enviar = enviar + (Convert.ToString(Convert.ToChar(c.portaIndex))); needAnd = false; } } else { i = lastRowIndex; lastCollumIndex = -1; if (needAnd == true) { codigo = codigo + "AND_B\n"; codigoBin = codigoBin + Convert.ToString(Convert.ToInt32("00000100", 2), 10) + " " + c.portaIndex.ToString() + "\n"; enviar = enviar + (Convert.ToString(Convert.ToChar(4)));

52
enviar = enviar + (Convert.ToString(Convert.ToChar(c.portaIndex))); needAnd = false; } newrang = false; } } else { i = lastRowIndex; lastCollumIndex = -1; if (needAnd == true) { codigo = codigo + "AND_B\n"; codigoBin = codigoBin + Convert.ToString(Convert.ToInt32("00000100", 2), 10) + " " + c.portaIndex.ToString() + "\n"; enviar = enviar + (Convert.ToString(Convert.ToChar(6))); enviar = enviar + (Convert.ToString(Convert.ToChar(c.portaIndex))); needAnd = false; } } break; case Componente.TiposComponente.upperConnectRight: break; default: break; } } } int i; // Contador de linha para varrer o DataGridView int j; // Contador de coluna para varrer o DataGridView SerialPort sp = new SerialPort("COM1", 9600, Parity.None, 8, StopBits.One); // inicializa a porta serial private void btnCodigoSerial_Click(object sender, EventArgs e) { sp.Open(); for (i = 0; i <= dgrComponentes.Rows.Count - 1; i++) { if (dgrComponentes.Rows[i].Cells[8].Tag != null) { for (j = 0; j <= 8; j++) { analisar(); } } } MessageBox.Show(codigoBin + "\n \n \n" + codigo); analogicas(c2); analogicas(c1);

53
analogicas(t2); analogicas(t1); analogicas(cmp2); analogicas(cmp1); analogicas(kd2); analogicas(kd1); analogicas(ki2); analogicas(ki1); analogicas(kp2); analogicas(kp1); analogicas(sp2); analogicas(sp1); enviar = enviar + Convert.ToString(Convert.ToChar(0xff)); enviar = enviar + Convert.ToString(Convert.ToChar(0xff)); foreach (byte caracter in (string)enviar) { sp.Write(new byte[] {caracter}, 0, 1); Thread.Sleep(10); } codigo = ""; codigoBin = ""; enviar = ""; sp.Close(); } private void analogicas(int variavel) { int auxiliar; auxiliar variavel variavel enviar = enviar = } private void sairToolStripMenuItem2_Click(object sender, EventArgs e) { this.Close(); } private void Ladder_Shown(object sender, EventArgs e) { MudarLinhaInicial(); } } } = Convert.ToByte(variavel >> 8); = variavel << 8; = variavel >> 8; Convert.ToString(Convert.ToChar(variavel)) + enviar; Convert.ToString(Convert.ToChar(auxiliar)) + enviar;

54 APNDICE B CDIGO CLASSE COMPONENTE COMPONENTE.CS


using System; using System.Collections.Generic; using System.Text; namespace PG.Roger { public class Componente { public enum TiposComponente { contato, contatoNegado, bobina, bobinaNegada, pid, cont, comp, temp , connect, upperConnectLeft, upperConnectRight, display } public string porta, texto; public TiposComponente tipo; public int sp, kp, ki, kd, k, cont, temp, portaIndex; public Componente(string porta, TiposComponente tipo, int sp, int kp, int kd, int ki, int k, int cont, int temp, int portaIndex) { switch (tipo) { case TiposComponente.contato: this.texto = porta + "\n----[ ]----"; break; case TiposComponente.contatoNegado: this.texto = porta + "\n----[/]-----"; break; case TiposComponente.bobina: this.texto = porta + "\n----( )----"; break; case TiposComponente.bobinaNegada: this.texto = porta + "\n----(/)-----"; break; case TiposComponente.pid: this.texto = sp + "\n---[PID]----"; break; case TiposComponente.cont: this.texto = cont + "\n---[Cont]---"; break; case TiposComponente.comp: this.texto = k + "\n---[Comp]---"; break; case TiposComponente.temp: this.texto = temp + " ms" + "\n---[timer]---"; break; case TiposComponente.connect: this.texto = "\n-----+------"; break; case TiposComponente.upperConnectLeft: this.texto = " |\n-----+"; break; case TiposComponente.upperConnectRight:

55
this.texto = " |\n +-----"; break; case TiposComponente.display: this.texto = porta + "\n--[display]--"; break; } this.porta = porta; this.tipo = tipo; this.sp = sp; this.kp = kp; this.ki = ki; this.kd = kd; this.k = k; this.cont = cont; this.temp = temp; this.portaIndex = portaIndex; } } }

56 APNDICE C CDIGO CLASSE PIDBOX PIDBOX.CS


using using using using using using using System; System.Collections.Generic; System.ComponentModel; System.Data; System.Drawing; System.Text; System.Windows.Forms;

namespace PG.Roger { public partial class PidBox : Form { public PidBox() { InitializeComponent(); } private void btnOkPid_Click(object sender, EventArgs e) { int sp = Convert.ToInt32(0 + txbSetPoint.Text); int kp = Convert.ToInt32(0 + txbKp.Text); int kd = Convert.ToInt32(0 + txbKd.Text); int ki = Convert.ToInt32(0 + txbKi.Text); Componente pid = new Componente(Program.ladder.porta, Componente.TiposComponente.pid, sp, kp, kd, ki, 0, 0, 0, Program.ladder.portaIndex); Program.ladder.Mudar(pid); Program.ladder.Enabled = true; this.Close(); } } }

57 APNDICE D CDIGO CLASSE COMPBOX COMPBOX.CS


using using using using using using using System; System.Collections.Generic; System.ComponentModel; System.Data; System.Drawing; System.Text; System.Windows.Forms;

namespace PG.Roger { public partial class CompBox : Form { public CompBox() { InitializeComponent(); } private void btnOkComp_Click(object sender, EventArgs e) { int k = Convert.ToInt32(0 + txbComp.Text); Componente comparador = new Componente(Program.ladder.porta, Componente.TiposComponente.comp, 0, 0, 0, 0, k, 0, 0, Program.ladder.portaIndex); Program.ladder.Mudar(comparador); Program.ladder.Enabled = true; this.Close(); } } }

58 APNDICE E CDIGO CLASSE CONTBOX CONTBOX.CS


using using using using using using using System; System.Collections.Generic; System.ComponentModel; System.Data; System.Drawing; System.Text; System.Windows.Forms;

namespace PG.Roger { public partial class ContBox : Form { public ContBox() { InitializeComponent(); } private void btnOkCont_Click(object sender, EventArgs e) { int cont = Convert.ToInt32(0 + txbCont.Text); Componente contador = new Componente(Program.ladder.porta, Componente.TiposComponente.cont, 0, 0, 0, 0, 0, cont, 0, Program.ladder.portaIndex); Program.ladder.Mudar(contador); Program.ladder.Enabled = true; this.Close(); } } }

59 APNDICE F CDIGO CLASSE TIMERBOX TIMERBOX.CS


using using using using using using using System; System.Collections.Generic; System.ComponentModel; System.Data; System.Drawing; System.Text; System.Windows.Forms;

namespace PG.Roger { public partial class TimerBox : Form { public TimerBox() { InitializeComponent(); } private void btnOkTimer_Click(object sender, EventArgs e) { int timer = Convert.ToInt32(0 + txbTimer.Text); Componente temporizador = new Componente(Program.ladder.porta, Componente.TiposComponente.temp, 0, 0, 0, 0, 0, 0, timer, 0); Program.ladder.Mudar(temporizador); Program.ladder.Enabled = true; this.Close(); } } }

60 REFERNCIAS BIBLIOGRFICAS [1] Acessado em 16/11/2006 http://en.wikipedia.org/wiki/Framework [2] Acessado em 16/11/2006 http://en.wikipedia.org/wiki/Application_framework [3] Acessado em 16/11/2006 http://en.wikipedia.org/wiki/.NET_Framework [4] Acessado em 16/11/2006 http://en.wikipedia.org/wiki/Class_library [5] Acessado em 16/11/2006 http://en.wikipedia.org/wiki/Common_Language_Infrastructure [6] Acessado em 16/11/2006 http://en.wikipedia.org/wiki/Common_Type_System [7] Acessado em 16/11/2006 http://en.wikipedia.org/wiki/Common_Intermediate_Language [8] Acessado em 16/11/2006 http://en.wikipedia.org/wiki/Just-intime_compilation [9] Acessado em 16/11/2006 http://en.wikipedia.org/wiki/.NET_metadata [10] Acessado em 16/11/2006 http://en.wikipedia.org/wiki/Virtual_Execution_System [11] Acessado em 16/11/2006 http://en.wikipedia.org/wiki/Sandbox_(computer_security) [12] Acessado em 16/11/2006 http://en.wikipedia.org/wiki/.NET_assemblies [13] - MOHR, Adilson Arthur et al. Estudo dos Frameworks Baseados na Common Language Infrastructure (CLI): Microsoft .NET Framework, Mono E DotGNU Portable.NET. 2004. [14] Acessado em 20/01/2007 - http://www.plcopen.org/

61 [15] Acessado em 13/10/2006 - http://www.plcs.net/ [16] Acessado em 15/10/2006 http://en.wikipedia.org/wiki/Programmable_logic_controller [17] Acessado em 15/10/2006 http://en.wikipedia.org/wiki/Ladder_logic [18] BUTOW, ERIC; RYAN, TOMMY. C# Your visual blueprint for building .NET applications HungryMinds 1ed. [19] Acessado em 12/01/2007 - http://msdn2.microsoft.com/pt-br/default.aspx