PlcLib Arduino User Guide Version 1.4 (1)-1-104_1-52.en.pt

Traduzido do Inglês para o Português - www.onlinedoctranslator.
com
Guia do usuário do PlcLib (Arduino)
Autor:W. Vala
Ultima atualização:28ºsetembro de 2017
Versão do software:1.4
https://github.com/wditch/plcLib
1 Conteúdo
1 Conteúdo................................................. ................................................ ......................................... 2
2 Introdução ................................................. ................................................ ......................................... 5
2.1 Métodos de Desenvolvimento de Software.......................................... ................................................ .. 5
2.2 Hardware Suportado.............................................. ................................................ ................... 6

3 Instalando o Software ....................................... ................................................ ......................... 8
3.1 Primeira instalação............................................... ................................................ ................... 8
3.1.1 Carregando e executando seu primeiro aplicativo ....................................... ................................ 8
3.2 Atualizando para uma Nova Versão ....................................... ................................................ ............. 9
4 Configurando o Hardware............................................. ................................................ ................ 10

5 Introdução à Lógica Ladder ....................................... ................................................ ....... 11
5.1 Entrada e Saída de Bit Simples.......................................... ................................................ ........... 12
5.2 Executando Operações Booleanas ....................................... ................................................ 13

6 Saídas de Bloqueio.............................................. ................................................ ............................. 18
6.1 Trava com Componentes Discretos ....................................... ................................................ 18

6.2 Usando o Comando Latch ....................................... ................................................ ........... 19
6.3 Usando os Comandos Set e Reset ....................................... ................................................ 20
7 Pulsos acionados por borda ....................................... ................................................ ...................... 22
7.1 Criando um Biestável Acionado por Borda ....................................... ......................................... 23
8 Inserção a partir de um teclado ....................................... ................................................ ......................... 25
8.1 Conexões de Hardware ....................................... ................................................ ............. 25

8.2 Software............................................. ................................................ ......................................... 26
9 Usando atrasos de tempo ....................................... ................................................ ............................. 29
9.1 Produzindo um Atraso de Ligação............................... ................................................ ............. 29

9.2 Comutação Debouncing ....................................... ................................................ ................... 30
9.3 Criando um Atraso de Desligamento ....................................... ................................................ ............. 31
9.4 Criando um pulso de duração fixa.......................................... ................................................ .... 32
10 Produzindo Formas de Onda Repetidas ....................................... ................................................ .. 33
10.1 Criação Manual de Pulsos.............................................. ................................................ ............. 33
10.2 Usando o comando timerCycle() ....................................... ................................................ .34

11 Contagem e contadores ....................................... ................................................ ................ 36
11.1 Contador ascendente.............................................. ................................................ ................................ 36
11.2 Contador Decrescente .............................................. ................................................ ......................... 37

11.3 Contador para cima/para baixo.............................. ................................................ ...................... 38
11.4 Depurando Aplicativos Baseados em Contadores............................... ......................................... 39
12 Deslocamento e Rotação de Dados Binários............................................. ................................................ .... 41
12.1 Criando e usando registradores de deslocamento ....................................... ................................................ 41
12.2 Rotação de Dados ....................................... ................................................ ............................. 44

13 Trabalhando com Sinais Analógicos ....................................... ................................................ ...... 47
13.1 Controlando o brilho do LED usando PWM ....................................... ......................................... 47
13.2 Controlando a velocidade e a direção de um motor ....................................... ............................. 47
14 Controle de posição usando servos ....................................... ................................................ ......... 50
15 Comparando Valores Analógicos .............................................. ................................................ .......... 51
15.1 Comparação baseada em software de valores analógicos.............................. ............................. 51
15.2 Um aplicativo comparador simples.............................. ................................................ 52

16 Programação da Lista de Instruções.............................................. ................................................ ......... 54
17 Diagramas de Blocos Funcionais.............................................. ................................................ ................ 55
17.1 Construindo Sistemas de Trabalho ....................................... ................................................ ... 55
17.2 Aplicação 1: Um Alarme Simples ...................................... ................................................ ....... 56

17.3 Aplicação 2: Alarme com LED 'Armado' Piscando ...................................... ................................ 57
17.4 Criando Blocos de Função Definidos pelo Usuário........................................... ......................................... 58
18 Gráficos Sequenciais de Funções ....................................... ................................................ ............ 60
18.1 Criando Sequências........................................... ................................................ ................... 60

18.2 Ramificação e Convergência ....................................... ................................................ .......... 63
19 Desenvolvendo Aplicativos Baseados em SFC Temporizados.......................................... ......................................... 65
19.1 Transições de base de tempo ....................................... ................................................ ................ 65
19.2 Aplicação 1: Aplicação do Controlador de Semáforos.............................. ......................... 67

19.3 Aplicação 2: Exibição de Luz de Corrida.............................. ................................................ 69
20 Texto Estruturado ....................................... ................................................ ............................. 74
20.1 Usando Estruturas de Programa ....................................... ................................................ .......... 74
21 Conceitos Avançados.................................................. ................................................ ...................... 76
21.1 Como o Software Funciona ....................................... ................................................ ............. 76

21.2 Usando Variáveis em Programas ....................................... ................................................ ........ 77
21.2.1 Usando a variável scanValue............................... ................................................ .77

21.3 Trabalhando com variáveis personalizadas ........................................ ................................................ .. 78
21.4 Usando Variáveis com Circuitos Lógicos Complexos ....................................... ......................................... 79

22 Armazenamento e lógica baseados em pilha............................... ................................................ .......... 81
22.1 Operações Lógicas de Bloco........................................... ................................................ ................ 82
23 Definindo alocações de E/S personalizadas ....................................... ................................................ ...... 85
23.1 Alocações de E/S pré-configuradas............................... ................................................ ....... 85

23.2 Estudo de caso: Criando uma alocação de IO personalizada ........................... ......................................... 85
24 Pontos Fortes e Limitações do Software ....................................... ......................................... 88

25 Referência de comando ....................................... ................................................ ................... 89
25.1 Configuração Geral.............................................. ................................................ ................ 89
25.2 Entrada/Saída Digital de Bit Simples ...................................... ................................................ ..... 89
25.3 Lógica Combinacional........................................... ................................................ ................... 90

25.4 Entrada/Saída de Sinal Analógico ....................................... ................................................ .... 90
25.5 Comparando Sinais Analógicos........................................... ................................................ ....... 91
25.6 Fechos .............................................. ................................................ ......................................... 91

25.7 Temporizadores.................................................. ................................................ ......................................... 92
25.8 Pulsos Acionados por Borda .............................................. ................................................ ................ 93
25.9 Contadores.............................................. ................................................ ......................................... 94
25.10 Registros de Deslocamento ....................................... ................................................ ...................... 95
25.11 Lógica de pilha e bloco ....................................... ................................................ ............. 97

26 Perguntas frequentes ............................................... ................................................ .......... 98
27 Histórico de Revisão ................................................ ................................................ ......................... 100
28 Apêndice A – Monitor Serial (Recurso Experimental)........................................... ......................... 101
28.1 Introdução .......................................... ................................................ ......................... 101

28.2 Usando o Monitor Serial ....................................... ................................................ ............ 101
28.3 Operação Técnica.............................................. ................................................ ................ 104
2 Introdução
OplcLibA biblioteca permite que você desenvolva aplicativos de software orientados a controle 'estilo PLC' para
o Arduino e compatíveis.
Figura 1.Convertendo um circuito elétrico simples em um diagrama de escada e depois em um programa simples.
Uma ampla variedade de esboços de exemplo também estará disponível depois que você instalar a biblioteca.
O programa acima - que é provavelmente o mais simples que faz algo útil - estará disponível no menu
suspenso do Arduino IDE selecionandoArquivo > Exemplos > plcLib > InputOutput > BareMinimum.
2.1 Métodos de Desenvolvimento de Software
No método de projeto mais conhecido, um circuito elétrico contendo elementos como interruptores e lâmpadas é primeiro
representado em forma gráfica como um diagrama de escada – que deve então ser transformado em um programa Arduino
baseado em texto (ouesboço), antes de ser compilado e baixado normalmente. Você também pode descrever um sistema como um
diagrama de blocos (diagrama de blocos de função) ou um sistema baseado em sequência (gráfico de função sequencial), todos os
quais podem ser combinados com código C/C++ nativo (texto estruturado), portanto, você pode usar livremente a abordagem de
projeto que melhor se adapta ao problema.
O software é fornecido como uma biblioteca Arduino instalável, que éincluídonormalmente no início do seu
programa. Uma gama de comandos de estilo PLC baseados em texto torna-se disponível para uso em seus
programas.
Observação:Ao contrário de um PLC comercial moderno, o software atualmente não oferece suporte a entrada de programa
gráfico, simulação ou monitoramento de tempo de execução. Os programas devem ser inseridos usando o Arduino IDE padrão.
Os diagramas fornecidos no Guia do Usuário destinam-se a ilustrar o processo de design e estão vinculados a esboços de
exemplo fornecidos com a biblioteca.
Os recursos de software suportados pela versão atual do plcLib incluem entradas (digitais/analógicas), saídas (digitais/
PWM/servo), operadores lógicos booleanos, travas, temporizadores e formas de onda repetidas. Avançar
detalhes estão disponíveis nas seguintes seções doGuia de usuario, incluindo instruções de download e
instalação.
2.2 Hardware suportado

A biblioteca plcLib pode ser usada com uma variedade de hardware, incluindoprotótipos de placas,escudos de E/Se até mesmo
CLPs compatíveis com Arduino.
Figura 2.Usando uma placa protótipo para conectar um receptor de controle remoto a um Arduino Uno.
Oescudo do motor arduinoé suportado como padrão, permitindo o controle de velocidade e direção de até dois motores CC.
Figura 3.Controlando até dois motores com um Arduino Motor Shield.
Sistemas modulares de construção e experimentação, comoArvoredopermitem que uma ampla gama de dispositivos
de entrada e saída sejam conectados, sem a necessidade de fiação ou solda de placa de protótipo.
Figura 4.Um shield base Grove e um módulo Bluetooth serial conectado a um Arduino Uno.
A versão 1.2 ou posterior do software é fornecida com uma ampla variedade de configurações de amostra para hardware
comumente disponível, incluindoControllino eescudos industriais CLPs compatíveis com Arduino. Os detalhes do hardware
suportado são fornecidos noDefinindo alocações de ES personalizadas seção.
Figura 5. Um Controlador Lógico Programável (CLP) típico. Imagem © istockphoto.com/Igor Mazej.
Personalizadoconfigurações de E/Stambém pode ser desenvolvido para outro hardware, não suportado como padrão. Este
processo é ilustrado mais tarde, usando oEscudo Velleman I/O para Arduino como estudo de caso.
Figura 6. O Velleman Input/Output Shield oferece uma gama útil de entradas e saídas pré-configuradas.
3 Instalando o Software
Siga as instruções apropriadas abaixo, dependendo se você está instalando o software pela
primeira vez ou atualizando uma versão existente.
3.1 Primeira Instalação

O software plcLib é fornecido como um arquivo ZIP que pode ser baixado e adicionado ao seu Arduino IDE da
maneira normal. Com o software instalado, você poderá navegar pelos programas de exemplo e criar seus
próprios esboços no estilo PLC.
Os detalhes exatos do processo de instalação dependem da versão do Arduino IDE instalado. Para Arduino 1.6.4 ou
posterior, selecione oEsboço > Incluir biblioteca > Adicionar biblioteca .Zipopção e navegue até o arquivo Zip
baixado anteriormente.
Se você estiver usando a versão 1.0.5 do Arduino IDE, selecioneEsboço > Importar biblioteca... > Adicionar
biblioteca...no menu suspenso, navegue para encontrar o arquivo Zip baixado anteriormente.
O processo de instalação é explicado completamente nesteguia arduino .
3.1.1 Carregando e executando seu primeiro aplicativo
Com o software instalado, navegue até a seção de exemplos e carregue oMínimoesboço.
# inclui <plcLib.h>
/* Biblioteca de Controladores Lógicos Programáveis para Arduino e Compatíveis
Mínimo - Entrada e saída digital de bit único
Conexões:
Entrada - interruptor conectado à entrada X0 (pino A0 do Arduino) Saída
- LED conectado à saída Y0 (pino 3 do Arduino)
Software e documentação: https://

github.com/wditch/plcLib
*/
void setup() {
configuraçãoPLC(); //Configura entradas e saídas
}
loop void() {
em(X0); // Lê a entrada 0
fora(Y0); // Envia para Output 0
}
Listagem 1.Bare Minimum (Fonte: Arquivo > Exemplos > plcLib > InputOutput > BareMinimum)
Observação:Todos os exemplos mostrados estão disponíveis noArquivo > Exemplosseção do Arduino IDE.
O esboço acima lê um switch conectado à entrada X0 (pino A0 no Arduino) e envia o estado do switch para a saída
Y0 (pino 3 no Arduino). Para vê-lo funcionando, você pode conectar um protótipo de circuito de placa ou usar
qualquer um dos hardwares suportados, conforme explicado noConfigurando o
hardware seção.
Figura 7.Testando o programa Bare Minimum usando um sistema de experimentação modular.
3.2 Atualizando para uma Nova Versão
Novas versões do software plcLib são lançadas periodicamente. O procedimento de atualização recomendado é
primeiro remover a versão existente da biblioteca e depois instalar a nova, conforme descrito abaixo.
1. Identifique a localização dos arquivos da biblioteca em seu computador, que estarão em umbibliotecaspasta abaixo doCaderno
de esboços Arduinolocalização. Os detalhes exatos podem variar, mas normalmente será algo
como[Meus Documentos]/Arduino/libraries, com umplcLibpasta existente abaixo dela se o software tiver sido
instalado anteriormente. Você pode verificar o caminho para a pasta Sketchbook selecionandoArquivo >
Preferênciasda IDE do Arduino.
2. Feche o Arduino IDE e exclua a pasta plcLib identificada acima. (É uma boa ideia fazer uma cópia de backup
de todos os arquivos existentes antes de excluí-los – caso você cometa algum erro.)
3. Reinstale a biblioteca conforme explicado anteriormente.
A próxima seção apresenta o arranjo de hardware usado pelo software.

4 Configurando o hardware
Um conjunto básico de entradas e saídas é ativado por padrão. Esta configuração padrão é selecionada primeiro
'incluindo' o arquivo de biblioteca plc (#include <plcLib.h>) e, em segundo lugar, chamando osetupPLC()funcionar de
dentro doconfigurar()seção do seu sketch, como foi visto no sketch de exemplo da Listagem 1.
No mínimo, o software define quatro entradasX0,X1,X2eX3(entradas analógicasA0–A3) e quatro

saídasA0,A1,Y2eY3(pinos 3, 5, 6 e 9).
Figura 8.Alocações padrão de entrada/saída para placas Arduino comuns
Pinos adicionais são alocados para placas Arduino maiores (mega,mega 2560ouDevido), conforme mostrado à
direita, dando 8 entradas e 8 saídas no total.
As principais características deste layout de hardware são explicadas abaixo:
• As entradas são capazes de ler valores digitais ou analógicos.
• As saídas podem produzir valores digitais, PWM ou servo.
• Os pinos do Arduino com funções duplicadas foram evitados sempre que possível, para minimizar conflitos de
hardware.
• As direções de dados de entradas e saídas são configuradas automaticamente e as saídas são inicialmente desativadas (com
base na suposição de que 0 = 'desligado' e 1 = 'ligado')
Observação:A maioria dos arquivos de exemplo fornecidos faz uso da configuração de E/S padrão.
Se esse arranjo padrão for inadequado, várias configurações de hardware personalizadas alternativas estão disponíveis – ou
você pode preferir criar a sua própria. por favor veja oDefinindo alocações de ES personalizadas seção para mais detalhes.
A próxima seção apresenta o uso de umdiagrama de escadadescrever o arranjo e a operação de um sistema

simples e sua conversão emlógica escadaprograma baseado. Os conceitos de lógica ladder são desenvolvidos
em seções subseqüentes do Guia do Usuário plcLib.
5 Introdução à Lógica Ladder
O método de projeto do CLP geralmente começa com um circuito elétrico, ou diagrama de blocos, que é então
redesenhado como umdiagrama de escada, e depois convertido em um esboço do Arduino antes de ser compilado e
baixado da maneira normal. A figura abaixo ilustra o processo.
Figura 9.Converter um circuito elétrico em um diagrama ladder e depois em um programa de lógica ladder.
O nome 'diagrama de escada' vem da semelhança superficial com uma escada física, com trilhos de energia verticais em
cada lado e ramificações de circuito horizontais chamadasdegrausconectados entre os trilhos. Diagramas de escada mais
complexos têm uma série de degraus, cada um representando um circuito separado.
Os diagramas de escada são uma adaptação de uma tecnologia anterior chamadalógica do relé, em que chaves e relés são
usados para controlar circuitos industriais. Um circuito lógico de relé simples é mostrado abaixo.
Figura 10.Um circuito lógico de relé simples.
Observe o trilho de alimentação positivo à esquerda e o negativo à direita. Os interruptores SW1 e SW2 são do tipo push-tomake e
push-to-break, fazendo com que suas lâmpadas associadas sejam acesas quando os interruptores são pressionados ou liberados,
respectivamente. A chave SW3 é conectada à bobina do relé RL1 e os contatos do relé de comutação são
então ligado às lâmpadas BL3 e BL4. Os contatos do relé são dispostos de forma que apenas uma lâmpada esteja acesa a qualquer momento.
Qualquer programa que faça uso da biblioteca de software plcLib deve ser inserido como um padrão baseado em texto do
Arduino.esboço, que os programadores PLC podem se referir comolista de instruçõesprogramação. Com a prática, o
processo de conversão de um diagrama Ladder em um esboço do Arduino torna-se relativamente simples. Várias
alternativas para a abordagem de projeto de lógica ladder estão disponíveis, incluindobloco de funções programação,
gráficos de funções sequenciais etexto estruturado , cada um dos quais é discutido separadamente.
Observação:Esses cinco métodos de programação (diagrama Ladder, lista de instruções, bloco de função, gráfico de função
sequencial e texto estruturado) são definidos pela Parte 3 do padrão IEC 61131 (IEC 61131-3, também conhecido no Reino
Unido como BS EN 61131-3). , que trata de linguagens de programação para controladores programáveis.
5.1 Entrada e Saída de Bit Único

O software plcLib permite que entradas e saídas de bit único sejam controladas emnormalmente desligadoounormalmente
ligadoformulários. Uma entrada normalmente ligada é equivalente a umpush-to-makeswitch, e é representado por um par
de linhas verticais no diagrama Ladder. Aempurrar para quebrarinterruptor fornece uma conexão normalmente fechada e
isso é mostrado adicionando uma linha diagonal entre os contatos verticais. Um arranjo semelhante é usado para saídas
que são mostradas como um par de linhas curvas (ou mesmo um círculo completo), com uma linha diagonal adicionada
para uma saída invertida. O diagrama ladder abaixo mostra a entrada e a saída de valores nas formas normal e invertida.
Figura 11.Um diagrama ladder mostrando métodos de leitura de entradas e saídas de controle.
O diagrama de escada pode ser facilmente convertido em um esboço baseado em texto, conforme mostrado abaixo.
# inclui <plcLib.h>
Entrada/saída digital - E/S de bit único nas formas normal e invertida
Conexões:
Entrada - chave conectada à entrada X0 (pino A0 do Arduino) Entrada -
chave conectada à entrada X1 (pino A1 do Arduino)
Entrada - switch conectado à entrada X2 (pino A2 do Arduino) Entrada -
switch conectado à entrada X3 (pino A3 do Arduino) Saída - LED
conectado à saída Y0 (pino 3 do Arduino) Saída - LED conectado à saída
Y1 (pino 5 do Arduino) Saída - LED conectado à saída Y2 (pino 6 do
Arduino) Saída - LED conectado à saída Y3 (pino 9 do Arduino)

*/
void setup() {
}
loop void() {
fora(Y0); // Envia para Output 0
inNot(X1); // Lê a Entrada 1 (invertida) // Envia

fora(Y1); para a Saída 1
outNot(Y2); // Envia para a Saída 2 (invertida)
inNot(X3); // Lê a Entrada 3 (invertida) e envia para a Saída 3 (invertida) // (O duplo

outNot(Y3); negativo cancela)
}
Listagem 2.Entrada/Saída Digital (Fonte: Arquivo > Exemplos > plcLib > entradaSaída >
DigitalInputOutput)
O software PLC calcula repetidamente cada degrau do diagrama ladder em sequência – da esquerda para a direita e de cima
para baixo – 'varrendo' as entradas, realizando cálculos e exibindo os resultados; um processo conhecido comociclo de
varredura. Cada degrau do diagrama ladder é efetivamente uma tarefa separada, e o computador compartilha seu poder de
processamento entre essas tarefas em uma sequência repetida. A alta velocidade de processamento faz com que pareça
que o PLC está realizando várias atividades ao mesmo tempo.
As entradas podem ser conectadas em série ou paralelo para criar funções simples de lógica booleana (lógica
combinatória), conforme discutido na próxima seção.
5.2 Realizando Operações Booleanas

As funções lógicas booleanas, como AND e OR, podem ser obtidas usando arranjos em série/paralelo de contatos de comutação.
Por exemplo, duas chaves em série darão uma função AND, pois ambas as chaves devem estar fechadas para completar o circuito.
Da mesma forma, uma função OU pode ser alcançada por dois interruptores conectados em paralelo, pois o fechamento de um ou
mais interruptores permitirá que a energia flua para o próximo estágio.
Figura 12.As chaves em série e em paralelo executam as funções lógicas AND e OR.
As funções lógicas booleanas básicas AND, OR, XOR e NOT podem ser representadas em forma de diagrama ladder usando
combinações série/paralelo de chaves de entrada e contatos de saída, conforme mostrado abaixo.
Figura 13.Funções lógicas em escada lógica booleana e suas funções lógicas equivalentes.
Este arranjo de diagrama de escada pode ser facilmente codificado, conforme mostrado no esboço a seguir.
# inclui <plcLib.h>
AND, OR, XOR e Not - Funções básicas de lógica booleana
Conexões:
Output - ANDed Output - LED conectado à saída Y0 (Arduino pino 3) Output - ORed Output -
LED conectado à saída Y1 (Arduino pino 5) Output - XORed Output - LED conectado à saída Y2
(Arduino pino 6) Output - Inverted Output - LED conectado à saída Y3 (pino 9 do Arduino)

*/
void setup() {
}
loop void() {
eBit(X1); // AND com Input 1 // Envia
fora(Y0); resultado para Output 0
ouBit(X1); // OU com Entrada 1
fora(Y1); // Envia o resultado para Output 1
xorBit(X1); // XOR com Input 1 // Envia
outNot(Y3); // Envia o resultado invertido para a Saída 3
}
Listagem 3.Funções AND, OR, XOR e Not (Fonte: Arquivo > Exemplos > plcLib > Lógica > AndOrXorNot
Se forem necessárias saídas baixas ativas, as funções equivalentes NAND, NOR e XNOR podem ser criadas na
lógica ladder.
Figura 14.Circuitos lógicos ladder NAND, NOR e XNOR e suas funções lógicas equivalentes.
A codificação dessas funções é obtida substituindo ofora()instruções do exemplo anterior com a lógica
negativaoutNot()equivalente, como mostrado abaixo.
# inclui <plcLib.h>
NAND, NOR e XNOR - Funções lógicas booleanas com saídas invertidas
Conexões:
Saída - Saída NAND - LED conectado à saída Y0 (pino 3 do Arduino) Saída - Saída NOR -
LED conectado à saída Y1 (pino 5 do Arduino) Saída - Saída XNOR - LED conectado à saída
Y2 (pino 6 do Arduino)

*/
void setup() {
}
loop void() {
// NAND
eBit(X1); // E com Entrada 1
outNot(Y0); // Envia o resultado para Output 0 (invertido)
// NEM
ouBit(X1); // OU com Entrada 1
// XNOR
xorBit(X1); // XOR com entrada 1
}
Listagem 4.Funções NAND, NOR e XNOR. (Fonte: Arquivo > Exemplos > plcLib > Lógica >
NandNorXnor)
As operações lógicas também podem ser realizadas com uma ou mais das entradas invertidas, conforme visto aqui.
Figura 15.Executando operações booleanas envolvendo sinais de entrada invertidos.
Um esboço equivalente é mostrado abaixo.
# inclui <plcLib.h>
Lógica de entrada invertida - operações lógicas booleanas usando entradas invertidas

(equivalente a chaves de entrada normalmente fechadas)
Conexões:
Saída - saída AND - LED conectado à saída Y0 (pino 3 do Arduino) Saída - saída ORed - LED
conectado à saída Y1 (pino 5 do Arduino)

*/
void setup() {
}
loop void() {
eNotBit(X1); // AND com Input 1 (invertido) // Envia
ouNotBit(X1); // OU com Input 1 (invertido) // Envia
}
Listagem 5.Lógica de entrada invertida (Fonte: Arquivo > Exemplos > plcLib > Lógica > InvertedInputLogic)
Também é possível realizar operações lógicas envolvendo o estado dos contatos de saída, que na verdade
aplica realimentação das saídas às entradas. Claro que isso é a baselógica sequencial, sendo o mais simples
oTrava Set-Reset–a ser considerado a seguir.
6 saídas de travamento
Você poderobustouma entrada momentânea, fazendo com que ela permaneça ativa (oudefinir) até que precise ser
cancelado (oureiniciar). Três abordagens diferentes estão disponíveis, conforme descrito nas seções a seguir.
6.1 Trava com componentes discretos

A trava Set-Reset é um dos pilares da eletrônica e é a mais simples de todas.lógica sequencialcircuitos
– geralmente visto como um par de portas NAND ou NOR conectadas cruzadas. Também é bastante fácil criar um circuito de travamento
automático usando apenas umretransmissão(um interruptor operado eletromagneticamente) e alguns outros componentes, como visto no
seguinte circuito lógico de relé.
Figura 16.Componentes discretos foram usados aqui para criar um circuito de travamento automático.
Examinando o circuito à esquerda, observe primeiro que os dois interruptores estão conectados em paralelo, o que é obviamente
um arranjo OR lógico. No entanto, para começar, a corrente não flui por nenhum dos caminhos! A ramificação superior está
desligada, pois o botão push-to-make não está pressionado. A chave inferior é do tipo push-to-break, mas este caminho também
está desligado, sendo bloqueado pelos contatos do relé que estão na posição off (para baixo).
Uma pressão momentânea doDefinirO interruptor de entrada permite que a energia alcance a bobina do relé que é ativada,
movendo os contatos do relé para a posição On (para cima). A corrente agora flui através do ramal inferior, então o relé permanece
habilitado, mesmo quando a entrada Set é liberada. O relé permanece ativo até que oReiniciarinterruptor de entrada é
pressionado, desconectando a bobina do relé e retornando os contatos do relé para sua posição desligada.
Observação:As travas Set Reset geralmente têm saídas normais e invertidas. Esta função pode ser facilmente adicionada, se necessário,
ligando uma segunda lâmpada através do conjunto não utilizado de contatos do interruptor, mas com polaridade oposta à saída principal.
Um esboço Arduino equivalente é mostrado abaixo.
# inclui <plcLib.h>
Trava usando componentes discretos - Circuito de travamento automático com saídas Q e Not Q
Conexões:
Entrada - Set - chave conectada na entrada X0 (pino A0 do Arduino) Entrada - Reset
- chave conectada na entrada X1 (pino A1 do Arduino) Saída - Q - LED conectado à
saída Y0 (pino 3 do Arduino) Saída - NotQ - LED conectado à saída Y1 (pino 5 do
Arduino)
*/
void setup() {
}
loop void() {
em(X0); // Interruptor de leitura conectado à entrada 0 (definir) //
ouBit(Y0); travamento automático usando a saída 0 (Q)
eNotBit(X1); // Redefina a trava usando a Entrada 1
fora(Y0); (Redefinir) // Saída para a Saída 0 (Q)
em(Y0); // Lê a saída Q
outNot(Y1); // Produz saída invertida na Saída 1 (Não Q)
}
Listagem 6.Trava usando componentes discretos (Fonte: Arquivo > Exemplos > plcLib > Trava >
LatchDiscreteComponents)
O circuito de travamento automático acima funciona bem, mas é bastante detalhado. Uma versão simplificada é mostrada na próxima seção.
6.2 Usando o Comando Latch

Orobusto()O comando é funcionalmente idêntico ao arranjo de travamento automático visto acima, mas requer um
mínimo de duas linhas de código. Um equivalentediagrama de blocos de função representação é mostrada abaixo, a
primeira variante tendo saídas normais e invertidas, e a segunda com apenas uma única saída normal.
Figura 17.Defina os símbolos de trava de reinicialização, mostrados com e sem uma saída invertida.
O esboço a seguir mostra uma trava com saídas normais e invertidas, embora as duas últimas linhas usadas
para gerar a saída invertida sejam opcionais.
# inclui <plcLib.h>
Comando Latch - Defina a trava Reset com as saídas Q e NotQ, com base no comando 'latch'
Conexões:
Arduino)

*/
void setup() {
}
loop void() {
em(X0); // Interruptor de leitura conectado à entrada 0 (definir
trava(Y0, X1); entrada) // trava, Q = saída 0, reinicialização = entrada 1
em(Y0); // Lê a saída Q e gera NotQ na Saída 1 // (Estas duas linhas são

outNot(Y1); opcionais)
}
Listagem 7.Comando Latch (Fonte: Arquivo > Exemplos > plcLib > Trava > LatchCommand)
Observe que oDefinira entrada para o latch é retirada do valor anterior do mesmo 'degrau' do diagrama
ladder (lendo a entradaX0nesse caso). O comando recebe dois argumentos que são osQsaída e o
Reiniciarentrada respectivamente.
6.3 Usando os Comandos Set e Reset

Um método alternativo de criar uma saída travada é usardefinir()ereiniciar()comandos, como
mostrado no esboço a seguir.
# inclui <plcLib.h>
Usando os comandos Set e Reset para criar uma Trava Set-Reset
Conexões:
Arduino)

*/
void setup() {
}
loop void() {
em(X0); // Interruptor de leitura conectado à entrada 0 (Definir entrada) // Definir
definir(Y0); Y0 para 1 se X0 = 1, deixar Y0 inalterado caso contrário
em(X1); // Lê switch conectado a X1

reset(Y0); // Limpa Y0 para 0 se X1 = 1, deixa Y0 inalterado caso contrário
}
Listagem 8.Comandos Set e Reset (Fonte: Arquivo > Exemplos > plcLib > Trava > SetResetCommands)
Os comandos set() e reset() estão disponíveis na versão 0.7 ou posterior da biblioteca plcLib.
Uma letra é adicionada ao símbolo de saída padrão indicando se a saída é do tipo 'set' ou 'reset', conforme mostrado
no diagrama ladder equivalente.
Figura 18.Uma trava implementada usando as saídas Set e Reset.
Este método permite uma lógica separada para controlar a ativação e desativação de uma saída travada, o que geralmente
é conveniente. Agráfico de função sequencial é uma aplicação típica, na qual esses comandos podem ser usados para
controlar as transições entre as etapas de uma sequência.
7 Pulsos Acionados por Borda
A versão 1.1 do software plcLib apresenta a capacidade de gerar pulsos acionados por borda, cuja saída está ativa
apenas para um único ciclo de varredura.
Isso pode ser útil em uma variedade de cenários, como acionar uma saída apenas uma vez, garantir que uma saída dure
por menos tempo do que uma entrada ou impedir que um sistema baseado em trava seja travado em uma posição
devido a um interruptor externo defeituoso.
Um sistema acionado por borda simples é mostrado abaixo.
Figura 19.Pulsos de saída breves podem ser gerados a partir das bordas ascendentes ou descendentes de uma forma de onda de entrada.
Isso pode ser representado como mostrado no diagrama ladder a seguir, com bordas ascendentes ou descendentes na
entradaX0sendo usado para definir saídas momentaneamenteA0eA1, respectivamente.
Figura 20.Os pulsos de saída em Y0 e Y1 são gerados pelas bordas ascendentes ou descendentes da forma de onda de entrada X0.
# inclui <plcLib.h>
Gere pulsos de borda ascendente e descendente usando uma entrada digital
Conexões:
Entrada de clock - switch conectado à entrada X0 (pino A0 do Arduino) Saída de borda
ascendente - LED conectado à saída Y0 (pino 3 do Arduino) Saída de borda descendente

*/
Pulso pulso1; // Cria um objeto de pulso chamado 'pulse1'

void setup() {
}
loop void() {
em(X0); // Lê o switch conectado à Entrada 0 e // conecta-o à
pulso1.inClock(); entrada do relógio
pulso1.ascendente(); // Lê a borda de subida

fora(Y0); // Saída da borda de subida apenas para 1 ciclo de varredura
pulso1.caindo(); // Lê a borda descendente

fora(Y1); // Saída de borda descendente apenas para 1 ciclo de varredura
atraso(50); // Desacelere o ciclo de varredura para permitir a visualização dos

pulsos // (remova esse atraso no código final)
}
Listagem 9.Gerando pulsos de borda ascendente e descendente (Fonte: Arquivo > Exemplos > plcLib > Pulso >
PulseInput)
Examinando a listagem acima, um objeto de pulso chamado 'pulse1' é primeiro criado. Entrada externaX0é então conectado à
entrada de clock do pulso criado anteriormente. Finalmente, os sinais de borda ascendente e descendente são usados para
conduzir as saídasA0eA1respectivamente.
Os pulsos de saída duram apenas um único ciclo de varredura, portanto, um atraso de 50 milissegundos foi adicionado ao esboço
acima para 'esticar' os pulsos de saída por tempo suficiente para serem visíveis quando conectados aos LEDs. Esse atraso deve ser
removido após o teste para evitar a lentidão do ciclo de verificação.
7.1 Criando um biestável acionado por borda

Uma trava de reinicialização simples pode ser criada usando vários métodos diferentes, conforme demonstrado em
oSaídas de travamento seção. Dado o potencial para interruptores de entrada defeituosos mencionados anteriormente, é
útil considerar o que aconteceria a um circuito baseado em trava se ambos osDefinireReiniciarentradas foram ativadas
simultaneamente, ou se um dos interruptores de entrada externos ficou preso na posição 'On'?
Esses possíveis problemas podem, em grande parte, ser superados usando sinais acionados por borda para acionar as entradas
de trava, conforme mostrado no diagrama de escada a seguir.
Figura 21.Usando entradas acionadas por borda para definir ou redefinir uma saída.
# inclui <plcLib.h>
Definir ou redefinir uma saída usando entradas acionadas por borda
Conexões:
Definir entrada - switch conectado à entrada X0 (pino A0 do Arduino) Entrada de
reset - switch conectado à entrada X1 (pino A1 do Arduino) Saída travada - LED

*/
Pulse setPulse; // Cria um objeto de pulso para definir a trava // Cria um

Pulse resetPulse; objeto de pulso para redefinir a trava
void setup() {
}
loop void() {
em(X0); // Lê o interruptor conectado à Entrada 0 e // conecta-o à
setPulse.inClock(); entrada do pulso de ajuste do relógio
em(X1); // Lê o interruptor conectado à Entrada 1 e // conecta-

resetPulse.inClock(); o para redefinir a entrada do relógio de pulso
setPulse.ascendente(); // Lê a borda de subida de X0

definir(Y0); // Defina Y0 como 1 usando a borda de subida de X0
resetPulse.ascendente(); // Lê a borda de subida de X1

reset(Y0); // Redefina Y0 para 0 usando a borda de subida de X1
}
Listagem 10.Defina ou redefina uma saída usando entradas acionadas por borda (Fonte: Arquivo > Exemplos > plcLib >
Pulso > SetResetEdge)
8 Entrada de um teclado
Um teclado matricial pode ser usado como um dispositivo de entrada, permitindo que as saídas do PLC sejam ligadas ou desligadas
quando teclas específicas são pressionadas. Para ilustrar o conceito, um teclado de membrana padrão será usado, juntamente com
um download gratuitobiblioteca de teclado, para conduzir uma série de saídas de LED travadas.
Figura 22.Um circuito de teste e esboço, com entradas de teclado e saídas de LED travadas.
Observação:Antes de experimentar os exemplos, você precisará baixar e instalar oBiblioteca de teclado do Arduino . Os
arquivos de exemplo de teclado estão disponíveis com a versão 0.6 ou posterior dosoftware plcLib.
8.1 Conexões de Hardware

Estaremos usando uma placa principal do Arduino Uno para os exemplos, que o software plcLib define como tendo
quatro entradas (X0–X3) e quatro saídas (Y0–Y3). O teclado escolhido é um teclado de membrana Adafruit com 12
teclas, dispostas como uma matriz com quatro linhas e três colunas, exigindo, portanto, mais sete pinos IO no total.
A imagem a seguir mostra o selecionadoalocação de entrada/saídaem forma de diagrama.
Figura 23.Alocação de IO para o Arduino Uno e teclado de membrana.
Um possível arranjo de fiação da placa de protótipo é mostrado abaixo (desenhado usandoFritzing ).

Figura 25.Conexões do teclado e do LED (à esquerda), detalhe da fiação da placa do protótipo (à direita).
8.2 Software
A listagem a seguir usa um programa de entrada de teclado razoavelmente padrão e usa umlatchKey() função para ativar
ou desativar um bit de saída com base em pressionamentos momentâneos das teclas Set e Reset alocadas.
Teclado Matrix com controle liga/desliga das saídas de LED travadas
Conexões de pinos Arduino Uno: Entrada X0 -

não utilizada (pino Arduino A0) Entrada X1 -
não utilizada (pino Arduino A3)
Saída - LED conectado à saída Y0 (pino 3 do Arduino) Saída - LED
conectado à saída Y1 (pino 5 do Arduino) Saída - LED conectado à
saída Y2 (pino 6 do Arduino) Saída - LED conectado à saída Y3 (pino 9
do Arduino)
Conexões do teclado de matriz 4X3:

ROW1 - pino 8 do Arduino
ROW2 - pino Arduino 7
ROW3 - pino Arduino 4
ROW4 - pino Arduino 2 COL1
- pino Arduino 12 COL2 -
pino Arduino 11 COL3 - pino
Arduino 10

*/
# inclui <Keypad.h> // Inclui a biblioteca Keypad // Inclui a

# inclui <plcLib.h> biblioteca plcLib
char keyPress = 0; // Mantém o valor da tecla atualmente pressionada (se houver)

byte const ROWS = 4; // O teclado tem quatro linhas const byte
COLS = 3; // O teclado tem três colunas
// Defina o mapa de teclas char

keys[ROWS][COLS] = {
{'1','2','3'},
{'4','5','6'},
{'7','8','9'},
{'*','0','#'}
};
// Conecte o teclado ROW0, ROW1, ROW2 e ROW3 a esses pinos do Arduino. byte
rowPins[ROWS] = { 8, 7, 4, 2 };
// Conecte o teclado COL0, COL1 e COL2 a esses pinos do Arduino. byte
colPins[COLS] = { 12, 11, 10 };
// Cria o teclado
Teclado kpd = Teclado( makeKeymap(teclas), rowPins, colPins, ROWS, COLS );
void setup() {
configuraçãoPLC(); //Define os pinos de entrada/saída
}
laço vazio()
{
keyPress = kpd.getKey(); // Lê a tecla pressionada (se houver)
latchKey('1', '2', Y0); // Trava do teclado, Set = '1', Reset = '2', // saída = Y0 (pino
3)
5)
6)
9)
}
// Latch Set-Reset baseado em teclado, enviando para um pino. unsigned

int latchKey(char en, char dis, int outPin) {
if(teclaPress) {
if (keyPress == en) {
digitalWrite(outPin, HIGH);
}
if (teclaPress == dis) {
digitalWrite(outPin, LOW);
}
}
}
Listagem 11.Teclado Matrix com controle liga/desliga das saídas de LED travadas (Fonte: Arquivo > Exemplos >
plcLib > Teclado > LedOnOff)
O efeito geral dos quatro comandos latchKey() no esboço acima é ativar os LEDs conectados às saídasA0,A1,
Y2ouY3ao pressionar as teclas '1', '3', '5' ou '7', com as teclas '2', '4', '6' e '8' desligando novamente as saídas
correspondentes.
Uma pequena alteração nas alocações de switch permite que uma única tecla de entrada atue como uma reinicialização principal, conforme
mostrado no extrato a seguir.
laço vazio()
{
keyPress = kpd.getKey(); // Lê a tecla pressionada (se houver)
latchKey('1', '*', Y0); // Trava do teclado, Set = '1', Reset = '*', // saída = Y0 (pino
3)
5)
6)
9)
}
Listagem 12.Modificação da chave de redefinição mestre (Fonte: Arquivo > Exemplos > plcLib > Teclado > LedStop)
Também é possível armazenar o bit de saída do latch em uma variável definida pelo usuário, em vez de enviá-lo diretamente
para um pino de saída. Um exemplo baseado nesta abordagem é dado noLedVariableesboço de exemplo, enquanto a
abordagem subjacente é discutida noUsando Variáveis em Programas seção.
9 Usando atrasos de tempo
O software plcLib possui comandos para produzir atrasos de tempo com base na ativação ou desativação de um sinal de
entrada (otimerOn()etemporizador off()comandos), e também pode produzir um pulso de saída de duração fixa (o
timerPulse()comando). Todos os comandos aceitam dois parâmetros que são, em primeiro lugar, o nome da variável do
temporizador decorrido e, em segundo lugar, o atraso de tempo necessário em milissegundos.
Evite usar o próprio Arduinoatraso()sempre que possível, pois isso interrompe o ciclo de varredura do PLC
durante o atraso e suporta apenas um único atraso ativo a qualquer momento. Veja oAvançado
Conceitos seção para mais detalhes.
9.1 Produzindo um atraso de ativação

OtimerOn()O comando atrasa a ativação de uma saída até que a entrada esteja continuamente ativa pelo período
de tempo especificado em milissegundos.
Figura 26.Um temporizador de atraso fornece ativação atrasada de uma saída.
Um sistema baseado em temporizador pode ser convenientemente representado usando umdiagrama de blocooubloco de funções
diagrama , conforme mostrado no exemplo a seguir.
Figura 27.Um par de temporizadores de atraso produz atrasos separados, controlados por duas entradas diferentes.
Os dois temporizadores de atraso fornecem atrasos de tempo de ativação independentes de 2 segundos e 4 segundos nas
Saídas 0 e 1, respectivamente. A Saída 0 torna-se ativa após um sinal conectado à Entrada 0 ter estado ativo por 2
segundos, enquanto a Saída 1 requer que a Entrada 1 tenha estado ativa por um período de 4 segundos. O esboço
equivalente é mostrado abaixo.
# inclui <plcLib.h>
Atraso de ativação - Atrasa a ativação de uma saída após a aplicação de uma entrada
Conexões:
Saída com atraso de 2 s - LED conectado à saída Y0 (pino 3 do Arduino) Saída com atraso
de 4 s - LED conectado à saída Y1 (pino 5 do Arduino)

*/
longo sem sinal TIMER0 = 0; longo // Variável para reter o tempo decorrido para Timer 0 //
sem sinal TIMER1 = 0; Variável para reter o tempo decorrido para Timer 1
void setup() {
}
loop void() {
timerOn(TIMER0, 2000); // 2 segundos de atraso //
fora(Y0); Saída para Saída 0
timerOn(TIMER1, 4000); // Atraso de 4 segundos //
}
Listagem 13.Atraso na ativação (Fonte: Arquivo > Exemplos > plcLib > TimeDelays > DelayOn)
Observe que cada timer faz uso interno de uma variável de timer decorrido do tipo 'unsigned long', que
deve ser declarada no início do programa.
9.2 Comutação Debouncing

Um problema comum com sistemas baseados em switch ou teclado ésalto de contatoem que um único pressionamento de tecla faz com
que os contatos saltem fisicamente várias vezes – durante um período de vários milissegundos – antes de se estabelecerem. Este efeito
mecânico pode ser eliminado usando um temporizador de retardo de ativação com um retardo de tempo adequado, conforme mostrado no
exemplo a seguir.
# inclui <plcLib.h>
Switch Debounce - Atrasa uma entrada de switch em 10 ms para remover o bounce do contato
Conexões:
Entrada - switch conectado à entrada X0 (pino A0 do Arduino)
Saída - saída debounced - LED conectado à saída Y0 (Arduino pino 3)

*/
longo sem sinal TIMER0 = 0; // Define a variável usada para manter o tempo decorrido do timer 0
void setup() {
}
loop void() {
timerOn(TIMER0, 10); // 10 ms de atraso
fora(Y0); // Saída para Saída 0
}
Listagem 14.Switch Debounce (Fonte: Arquivo > Exemplos > plcLib > TimeDelays > SwitchDebounce)
9.3 Criando um atraso de desligamento
Um temporizador de atraso de desligamento torna-se ativo imediatamente e atrasa o desligamento por um determinado período após a
remoção da entrada de controle.
Figura 28.Um atraso no desligamento faz com que uma saída permaneça ativa por um período fixo após a remoção da entrada.
Uma aplicação do retardo de desligamento é o 'alongamento de pulso', no qual um breve sinal de entrada é expandido para ter uma largura de pulso
mínima. O diagrama de blocos de função a seguir mostra um temporizador de atraso de desligamento com um atraso de desligamento de 2 segundos.
Figura 29.Um temporizador de atraso de desligamento com um atraso de 2 segundos.
O esboço equivalente é dado abaixo.
# inclui <plcLib.h>
Turn-off Delay - Atrasa o desligamento de uma saída depois que uma entrada é removida
Conexões:

*/
longo sem sinal TIMER0 = 0; // Variável para manter o tempo decorrido para Timer 0
void setup() {
}
loop void() {
timerOff(TIMER0, 2000); // 2 segundos de atraso no
fora(Y0); desligamento // Saída para Saída 0
}
Listagem 15.Turn-off Delay (Fonte: Arquivo > Exemplos > plcLib > TimeDelays > DelayOff)
9.4 Criando um pulso de duração fixa
OtimerPulse()O comando (disponível na versão 1.0 ou posterior) cria um pulso de saída de largura fixa quando acionado
por um breve pulso de entrada. Isso é equivalente a um eletrônicomonoestávelo circuito.
Figura 30.Um pulso de largura fixa é criado pelo comando timerPulse().
Um esboço de exemplo é mostrado abaixo.
# inclui <plcLib.h>
Pulso Fixo - Ativa uma saída por um período fixo após a aplicação de uma entrada momentânea
d
Conexões:
Entrada - switch conectado à entrada X0 (pino A0 do Arduino)
Saída com pulso de 2 s - LED conectado à saída Y0 (pino 3 do Arduino)

*/
longo sem sinal TIMER0 = 0; // Variável para manter o tempo decorrido para Timer 0
void setup() {
}
loop void() {
timerPulse(TIMER0, 2000); // Pulso de 2 segundos //
}
Listagem 16.Pulso de largura fixa (localização da fonte: Arquivo > Exemplos > plcLib > TimeDelays > FixedPulse)
Observação:Na versão 1.1 ou posterior, a operação do comando timerPulse foi modificada para ser acionada por
borda em vez de acionada por nível. Portanto, o temporizador é reativado pela primeira transição baixa para alta da
entrada do acionador após o término do pulso anterior. (Isso agora está de acordo com o comportamento padrão na
norma IEC 61131-3.)
A próxima seção estende os conceitos de atraso de tempo introduzidos aqui para criar formas de onda de repetição
contínua.
10 Produção de formas de onda repetitivas
Um pulso de repetição pode ser definido usando a duração dobaixoealtocomponentes da forma de onda.
Figura 31.Um pulso de repetição pode ser definido em termos das durações das seções baixa e alta.
O tempo necessário para um ciclo completo é chamado detempo periódico(ouperíodo), que é obtido somando
as durações dos componentes baixo e alto (uma duração de 1 segundo no exemplo acima).
Os pulsos repetidos podem ser criados manualmente, a partir de componentes mais simples, ou usando um comando
dedicado.
10.1 Criação manual de pulso

Um par de temporizadores de atraso de ligação cruzados pode ser usado para criar um pulso de repetição, conforme mostrado no
exemplo a seguir.
# inclui <plcLib.h>
Pulso repetitivo usando um par de temporizadores de atraso ligados
Conexões:

*/
longo sem sinal TIMER0 = 0; longo // Variável para reter o tempo decorrido para Timer 0 //
sem sinal TIMER1 = 0; Variável para reter o tempo decorrido para Timer 1
void setup() {
}
loop void() {
em(X0); // Lê a entrada 0 (habilita) // E com
eNotBit(Y0); saída invertida // 900 ms (0,9 s) de
timerOn(TIMER0, 900); atraso // Define a saída 0 em time-
definir(Y0); out
em(X0); // Lê a entrada 0 (habilita) // E

eBit(Y0); com a saída
timerOn(TIMER1, 100); // 100 ms (0,1 s) de atraso // Redefinir
reset(Y0); saída 0 no tempo limite
}
Listagem 17.Repetição de pulso usando um par de temporizadores de atraso vinculados (Fonte: Arquivo > Exemplos > plcLib
> Formas de onda > PulsedOutputManual)
Com o programa em execução, você verá que pressionando continuamente o botãohabilitarentrada (X0) causa a saída (
A0) para ligar por 0,1 s, depois desligar por 0,9 s em uma sequência repetida.
O programa faz uso de um par de temporizadores de atraso, além de uma trava de reinicialização baseada na saídaA0. O primeiro
temporizador é inicialmente habilitado, assumindo que a saídaA0é zero e a entrada de habilitação também está ligada. A saída do
primeiro temporizador fica alta após 900 ms, o que, por sua vez, define a saídaA0para 1. Nesse ponto, o segundo temporizador de
retardo de ativação é ativado e começa a contar. Depois de mais 100 ms, a segunda saída do temporizador é definida, o que faz
com que a saídaA0para ser limpo, e todo o ciclo começa novamente.
Este é um exemplo de uma Finite State Machine (FSM) muito simples, que é a base defunção sequencial
gráficos .
Não se preocupe se o exemplo acima parecer bastante complexo, pois essa mesma funcionalidade é fornecida pelo
timerCycle()comando, discutido a seguir.
10.2 Usando o comando timerCycle()

OtimerCycle()O comando pode ser usado para produzir uma forma de onda de pulso repetitiva, que pode, por exemplo, ser
usada para piscar repetidamente um LED. (Como o nome do comando sugere, isso às vezes é chamado detemporizador de ciclo.)
Um símbolo de diagrama de bloco de função equivalente é mostrado abaixo.
Figura 32.Um temporizador de ciclo produz uma forma de onda de pulso repetitiva, quando ativado.
O comando requer que quatro parâmetros sejam especificados para cada forma de onda. Os parâmetros 1 e 3
devem ser especificados como variáveis (do tipolongo não assinado) e são usados internamente pelo software
plcLib para medir o tempo decorrido para as seções baixa e alta da forma de onda, respectivamente. Larguras de
pulso baixas e altas associadas são definidas no 2nde 4ºparâmetros. O exemplo a seguir ilustra o processo.
# inclui <plcLib.h>
Saída Pulsada - Criando um pulso repetitivo usando o comando timerCycle
Conexões:
Entrada - Habilita a entrada conectada à entrada X0 (pino A0 do Arduino) Saída - Forma de
onda de pulso no LED conectado à saída Y0 (pino 3 do Arduino)

*/
// Variáveis:
longo sem sinal AUX0 = 0; // Variável de timer de pulso baixo //
longo sem sinal AUX1 = 0; Variável de timer de pulso alto
void setup() {
configuraçãoPLC(); // Definir entradas e saídas
}
loop void() {
em (X0); // Read Enable input (1 = enable)
timerCycle(AUX0, 900, AUX1, 100); // Pulso repetitivo, baixo = 0,9 s, alto = 0,1 s // (portanto,
período = 1 segundo)
fora(Y0); // Envia forma de onda de pulso para a Saída 0
}
Listagem 18.Saída Pulsada - Criando um pulso repetitivo usando o comando timerCycle (Fonte: Arquivo
> Exemplos > plcLib > Formas de onda > PulsedOutput)
Observação:Uma aplicação típica é a criação de um pulso intermitente repetitivo de 'alarme armado', conforme
demonstrado noArquivo > Exemplos > plcLib > Aplicativos > AlarmWithArmedStatusesboço de exemplo.
11 Contagem e Contadores
A versão 0.8 do software apresentacontadores, que pode ativar uma saída uma vez que um número predeterminado de
eventos tenha ocorrido. Um 'objeto' contador pode ser configurado para contaracima,abaixo, ou uma combinação de
ambos.
Figura 33.Um objeto contador pode ser configurado para contagem crescente, regressiva ou ambas.
Cada contador tem quatro entradas e quatro saídas, mostradas à esquerda e à direita do diagrama acima,
respectivamente. Na prática, apenas um subconjunto destes pode ser necessário, dependendo do tipo de contador
requerido.
11.1 Contador ascendente
Na sua forma mais simples, um contador crescente conta os pulsos recebidos em seucontagem crescenteentrada, ativando
o 'concluído' ouQ superiorsaída quando o número necessário de pulsos de entrada for detectado. Para ilustrar o processo, o
exemplo a seguir cria um contador crescente que conta de 0 a 10, acionado por pressionamentos de chave aplicados à
entradaX0.
# inclui <plcLib.h>
Up Counter - Conta 10 pulsos na entrada 0 com switch debounce
Conexões:
Entrada de contagem - chave conectada à entrada X0 (pino A0 do Arduino)
Entrada limpa - chave conectada à entrada X1 (pino A1 do Arduino) Entrada
predefinida - chave conectada à entrada X2 (pino A2 do Arduino) Saída Q inferior -
LED conectado à saída Y0 (Arduino pino 3) Saída Q superior - LED conectado à
saída Y1 (pino 5 do Arduino)

*/
Contador ctr(10); // Contagem final = 10, começando em zero

void setup() {
}
loop void() {
timerOn(TIMER0, 10); // 10 ms de retardo do debounce do switch //
ctr.contagem crescente(); Contagem crescente
em(X1); // Lê a entrada X1
ctr.claro(); // Limpa contador (contador no limite inferior)
ctr.predefinido(); // Preset counter (contador no limite superior)
ctr.Q inferior(); // Exibe a saída de contagem regressiva em Y0

fora(Y0);
ctr.Q superior(); // Exibe a saída de contagem crescente em Y1

fora(Y1);
}
Listagem 19.Up Counter (Fonte: Arquivo > Exemplos > plcLib > Contadores > CountUp)
Examinando a listagem acima, o primeiro passo é usar oContadorcomando para criar um objeto contadorctr, ao
mesmo tempo definindo o valor final para 10, que é equivalente aovalor predefinidopropriedade do contador. O
contador padrão é umacimacontador, então o internocontarvalor é inicialmente zero, fazendo com queQ inferior
saída a ser ativada. Pulsos aplicados aoX0entrada estão ligados aocontagem crescenteentrada, fazendo com que o
internocontarvalor a ser incrementado a cada transição de 0 para 1. Após 10 pulsos,
ocontartorna-se igual ao limite superior ouvalor predefinido, causando oQ superiorsaída a ser habilitada.
Um problema comumente encontrado com circuitos contadores éinterruptor de salto, onde os contatos do comutador 'pulam' várias vezes
(durante um período de alguns milissegundos) antes de se estabelecerem. Isso, por sua vez, pode fazer com que um único
pressionamento do botão atualize o contador várias vezes em rápida sucessão. Para evitar esse efeito, observe que um temporizador de
atraso de ativação de 10 milissegundos foi vinculado em série com oX0interruptor conectado aocontagem crescenteentrada.
Também pode ser necessário forçar manualmente o contador a voltar ao início, o que é obtido no exemplo acima
conectando a entrada do interruptorX1para oclaroentrada do contador. Opredefinidoentrada (ligada à entrada do
comutadorX2) executa uma função semelhante, mas desta vez definindo a contagem interna para o valor final ou
predefinido. Portanto, pressionando os interruptores conectados às entradasX1ouX2vai causar oQ inferiorouQ superior
saídas a serem acionadas imediatamente, respectivamente.
11.2 Contador Decrescente
A criação de umcontador para baixoé bastante semelhante, conforme mostrado na listagem a seguir.
# inclui <plcLib.h>
Contador descendente - conta 5 pulsos na entrada 0 com debounce do interruptor
Conexões:
Entrada de contagem - chave conectada à entrada X0 (pino A0 do Arduino)
Entrada limpa - chave conectada à entrada X1 (pino A1 do Arduino) Entrada
predefinida - chave conectada à entrada X2 (pino A2 do Arduino) Saída Q inferior -
LED conectado à saída Y0 (Arduino pino 3) Saída Q superior - LED conectado à

*/
Contador ctr(5, 1); // Contagem regressiva, começando em 5

void setup() {
}
loop void() {
ctr.contagem regressiva(); Contagem regressiva

fora(Y0);

fora(Y1);
}
Listagem 20.Contador Regressivo (Fonte: Arquivo > Exemplos > plcLib > Contadores > CountDown)
A primeira diferença está na criação do objeto Contadorctr, usando oContador ctr(5, 1);comando. Além de definir o valor
predefinido para 5, o segundo parâmetro opcional tem o valor 1, fazendo com que o valor inicial da contagem seja definido
igual ao limite superior, o que é adequado para um contador decrescente. (Omitir o segundo parâmetro ou defini-lo como
zero inicializa a contagem para zero). EntradaX0é então conectado aocontagem regressivaentrada, enquanto saídaA0é
dirigido porQ inferior. Por issoA0ficará alto após 5 pulsos terem sido recebidos na entradaX0.
11.3 Contador Up/Down

É fácil combinar essas duas abordagens para criar um dispositivo capaz de fazer contagem crescente ou regressiva,
conforme mostrado no exemplo abaixo.
# inclui <plcLib.h>
Contador ascendente ou descendente - Contagens crescentes ou decrescentes no intervalo de 0 a 10
Conexões:
Entrada de contagem crescente - chave conectada à entrada X0 (pino A0 do Arduino)
Entrada de contagem regressiva - chave conectada à entrada X1 (pino A1 do Arduino)
Entrada limpa - chave conectada à entrada X2 (pino A2 do Arduino) Entrada predefinida
- chave conectada à entrada X3 ( Pino A3 do Arduino) Saída Q inferior - LED conectado à
saída Y0 (pino 3 do Arduino) Saída Q superior - LED conectado à saída Y1 (pino 5 do
Arduino)

*/
Contador ctr(10); // Conta para cima ou para baixo no intervalo de 0-10, começando em
longo sem sinal TIMER0 = 0; longo zero // Define a variável usada para manter o tempo decorrido do timer 0 //
sem sinal TIMER1 = 0; Define a variável usada para manter o tempo decorrido do timer 1
void setup() {
}
loop void() {
timerOn(TIMER1, 10); // 10 ms de retardo do debounce do switch
ctr.contagem regressiva(); // Contagem regressiva

fora(Y0);

fora(Y1);
}
Listagem 21.Contador de cima para baixo. (Fonte: Arquivo > Exemplos > plcLib > Contadores > CountUpDown)
O contador acima tem entradas separadas de contagem progressiva e regressiva vinculadas aos interruptores de entradaX0e
X1respectivamente, e cada entrada do contador tem sua própria entrada de chave debounced.
11.4 Depuração de aplicativos baseados em contador
A saída de um contador é ativada uma vez que o número definido de pulsos foi detectado, mas o valor da contagem
interna normalmente não é visível para o usuário. Com efeito, o contador está 'concluído' ou 'não concluído'. Às
vezes, pode ser útil exibir a contagem interna para fins de depuração, conforme mostrado no exemplo a seguir.
# inclui <plcLib.h>
Up-down Counter - Conta para cima ou para baixo no intervalo 0-10

(Envia a contagem atual para o monitor serial)
Conexões:
Entrada de contagem crescente - chave conectada à entrada X0 (pino A0 do Arduino)
Entrada de contagem regressiva - chave conectada à entrada X1 (pino A1 do Arduino)
Entrada limpa - chave conectada à entrada X2 (pino A2 do Arduino) Entrada predefinida
- chave conectada à entrada X3 ( Pino A3 do Arduino) Saída Q inferior - LED conectado à
saída Y0 (pino 3 do Arduino) Saída Q superior - LED conectado à saída Y1 (pino 5 do
Arduino)

*/
Contador ctr(10); // Conta para cima ou para baixo no intervalo de 0-10, começando em
longo sem sinal TIMER0 = 0; longo zero // Define a variável usada para manter o tempo decorrido do timer 0 //
sem sinal TIMER1 = 0; Define a variável usada para manter o tempo decorrido do timer 1
void setup() {
configuraçãoPLC(); // Configura entradas e saídas // Abre conexão
Serial.begin(9600); serial via USB
}
loop void() {
ctr.contagem regressiva(); Contagem regressiva

fora(Y0);

fora(Y1);
Serial.println(ctr.count()); // Envia contagem para a porta serial delay(100);
}
Listagem 22.Contador up-down com depuração. (Fonte: Arquivo > Exemplos > plcLib > Contadores >
CountUpDownDebug)
Para depurar o aplicativo, basta abrir oMonitor Serialenquanto o esboço está sendo executado. Isso exibirá repetidamente o
valor da contagem interna, com o intervalo de repetição controlado pelo comando de atraso no final da listagem. (No
entanto, não se esqueça de remover o código de depuração, uma vez que seu aplicativo esteja funcionando conforme o
esperado.)
12 Deslocamento e rotação de dados binários
A versão 0.9 do software apresentaregistradores de deslocamentoque pode ser usado para deslocar dados binários para a esquerda ou
direita, por uma posição de bit por vez.
Figura 34.Um registrador de deslocamento simples move os dados uma casa para a direita em cada borda ascendente do Clock.
O exemplo acima mostra um registrador de deslocamento simples de 8 bits, que desloca os dados uma posição para a direita
em cada borda de subida da entrada Clock. Novos dados são deslocados no lado esquerdo, enquanto os dados são descartados
quando saem do lado direito. O conteúdo de bits individuais pode ser lido das conexões de saída na parte superior.
Considerando o conteúdo numérico do registrador de deslocamento, deslocar os dados para a direita equivale a uma
divisão por dois, pois o bit mais significativo está à esquerda. Por outro lado, deslocar para a esquerda seria equivalente a
multiplicar por dois.
12.1 Criando e usando registradores de deslocamento
O primeiro passo é usar oMudançacomando para criar um registrador de deslocamentoobjeto, que tem uma largura de
dados fixa de 16 bits. O conteúdo inicial do registro pode opcionalmente ser definido na criação. Por exemplo, o comando
Shift shift1(0x8888);cria um objeto registrador de deslocamento chamadoturno1com um conteúdo hexadecimal inicial de
0x8888, que é equivalente a 1000 1000 1000 1000 em binário.
Várias outras tarefas de configuração também são necessárias, incluindo a definição doentrada de dados seriais,entrada do
relógio(deslocando dados para a direita neste caso),redefinir entradae qualquersaída paralelaconexões, conforme ilustrado
pelo símbolo do bloco de função a seguir.
Figura 35.Uma representação do bloco de funções do registrador de deslocamento.
A codificação real do registrador de deslocamento é dada pelo esboço a seguir.
# inclui <plcLib.h>
Registrador de deslocamento: Desloca os dados para a direita
Conexões:
Entrada serial - switch conectado à entrada X0 (pino A0 do Arduino) Entrada de
relógio - switch conectado à entrada X1 (pino A1 do Arduino)
Redefinir Entrada - switch conectado à entrada X2 (pino A2 do Arduino) Saída -
LED conectado à saída Y0 (pino 3 do Arduino)

*/
Shift shift1(0x8888); // Cria um registrador de deslocamento de 16 bits com valor inicial 0x8888
// Pedaço 1111 11
// Posições 5432 1098 7654 3210
// |||| |||| |||| ||||
// X0 -> -> -> -> 1 0 0 0 -> 1 0 0 0 -> 1 0 0 0 -> 1 0 0 0 ->
// ||||
// X1 -> Relógio ||||
// ||||
// X2 -> Reiniciar ||||
//
// AAAA
// Saídas 3210
longo sem sinal TIMER0 = 0; // Define a variável usada para debounce do switch
void setup() {
}
loop void() {
em(X0); // Lê a entrada para o registrador de deslocamento de X0

turno1.bit de entrada();
em(X1); // Desloca para a direita na borda de subida da entrada

timerOn(TIMER0, 10); X1 // 10 ms liga o atraso do debounce em X1
turno1.shiftDireita();
em(X2); // Redefine o valor do registrador de deslocamento para zero se X2 = 1

shift1.reset();
turno1.bitValue(15); // Envia o valor do bit 15 para a saída Y3

fora(Y3);

fora(Y2);

fora(Y1);

fora(Y0);
}
Listagem 23.Registrador de deslocamento – deslocando os dados para a direita (Fonte: Arquivo > Exemplos > plcLib > ShiftRotate >
ShiftDireita)
Os dados são deslocados para a direita pela borda de subida da entrada do relógio obtida de um switch conectado à entradaX1, com
novos dados deslocados à esquerda retirados do interruptor de entradaX0. (Observe que o problema potencial desalto de contatona
entrada do relógio é evitada pelo uso de um atraso de debounce do switch de 10 ms.) Entrada
swicthX2fornece uma entrada de reinicialização, limpando o registrador de deslocamento para zero quando pressionado. As saídas paralelas
são obtidas dos bits 15–12, permitindo que qualquer dado serial recém-introduzido seja imediatamente visível nas saídas.
É fácil modificar o esboço acima para deslocar os dados para a esquerda, conforme mostrado abaixo.
# inclui <plcLib.h>
Registrador de deslocamento: Desloca os dados para a esquerda
Conexões:
Entrada Serial - switch conectado à entrada X0 (pino A0 do Arduino) Entrada de
Clock - switch conectado à entrada X1 (pino A1 do Arduino) Entrada Reset - switch
conectado à entrada X2 (pino A2 do Arduino) Saída - LED conectado à saída Y0
(pino 3 do Arduino )

*/
Shift shift1(0x1111); // Cria um registrador de deslocamento de 16 bits com valor inicial 0x1111
// Pedaço 1111 11
// Posições 5432 1098 7654 3210
// |||| |||| |||| ||||
// <- 0 0 0 1 <- 0 0 0 1 <- 0 0 0 1 <- 0 0 0 1 <-
X0
// ||||
// X1 -> Relógio ||||
// ||||
// X2 -> Reiniciar ||||
//
// AAAA
// Saídas 3210
void setup() {
}
loop void() {
em(X0); // Lê a entrada para o registrador de deslocamento de X0

em(X1); // Desloca para a esquerda na borda de subida da entrada X1 //

timerOn(TIMER0, 10); 10 ms de retardo do debounce do interruptor em X1
turno1.shiftEsquerda();

shift1.reset();

fora(Y3);

fora(Y2);

fora(Y1);

fora(Y0);
}
Listagem 24.Registrador de deslocamento – deslocando os dados para a esquerda (Fonte: Arquivo > Exemplos > plcLib > ShiftRotate >
ShiftEsquerda)
As principais diferenças são em primeiro lugar a conexão do relógio (interruptorX1) para oshiftEsquerdaentrada e, em segundo
lugar, a conexão de saídas paralelas aos bits 3–0 do registrador de deslocamento. (O último permite que os dados deslocados à
direita sejam imediatamente visíveis nas saídas, à medida que se movem para a esquerda).
12.2 Rotação de Dados

Adicionar uma conexão de feedback ao nosso registrador de deslocamento da saída para a entrada permite que os dados sejam girados em um
loop contínuo, conforme mostrado abaixo.
Figura 36.Adicionar uma conexão de realimentação faz com que os dados sejam girados para a direita ou para a esquerda em um loop contínuo.
De fato, a conexão de realimentação pode ser obtida de qualquer bit de saída conveniente, criando assim um padrão de bit
circulante de qualquer largura desejada. Como exemplo, o esboço a seguir usa o bit 12 do registrador de deslocamento como a
conexão de realimentação para a entrada serial (ou seja, o 4ºbit da esquerda), para girar uma palavra de dados de 4 bits para a
direita.
# inclui <plcLib.h>
Registrador de deslocamento: gira os dados para a direita
Conexões:
Entrada Clock - switch conectado à entrada X0 (pino A0 do Arduino) Entrada
Reset - switch conectado à entrada X1 (pino A1 do Arduino) Saída - LED

*/
Shift shift1(0x8000); // Cria um registrador de deslocamento com valor inicial 0x8000 // (os
4 bits mais à esquerda são girados para a direita)
// Saídas AAAA
// 3210
//
// Pedaço 1111
// Posições 5432
// ||||
// -> 1 0 0 0 ->
// | |
// | |
// X0 -> Relógio - <--<--<--<--
//
// X1 -> Reiniciar
void setup() {
}
loop void() {
turno1.bitValue(12); // Lê a entrada para o registrador de deslocamento do bit 12 em RHS

em(X0); // Gira para a direita na borda de subida da entrada X0 //

timerOn(TIMER0, 10); 10 ms liga o atraso do debounce em X0
turno1.shiftDireita();

shift1.reset();

fora(Y3);

fora(Y2);

fora(Y1);

fora(Y0);
}
Listagem 25.Registrador de deslocamento – gira os dados para a direita (Fonte: Arquivo > Exemplos > plcLib > ShiftRotate >
Vire à direita)
Um esboço equivalente para girar uma palavra de dados de 4 bits para a esquerda usaria o bit 3 (o 4ºbit da direita) como a
conexão de realimentação, conforme mostrado no exemplo a seguir.
# inclui <plcLib.h>
Registrador de deslocamento: Gira os dados para a esquerda
Conexões:
Entrada Clock - switch conectado à entrada X0 (pino A0 do Arduino) Entrada
Reset - switch conectado à entrada X1 (pino A1 do Arduino) Saída - LED

*/
Shift shift1(0x0001); // Cria um registrador de deslocamento com valor inicial 0x0001 // (os
4 bits mais à direita são girados para a esquerda)
// Saídas AAAA
// 3210
// Pedaço
// Posições 3210
// ||||
// <- 0 0 0 1 <-
// | |
// | |
// X0 -> Relógio ->-->-->-->--
//
// X1 -> Reiniciar
void setup() {
}
loop void() {
turno1.bitValue(3); // Entrada 'Feedback' para registrador de deslocamento do bit 3 no LHS

em(X0); // Gira para a esquerda na borda de subida da entrada X0 // 10

timerOn(TIMER0, 10); ms de atraso do debounce do interruptor em X0
turno1.shiftEsquerda();

shift1.reset();

fora(Y3);

fora(Y2);

fora(Y1);

fora(Y0);
}
Listagem 26.Registrador de deslocamento – gira os dados para a esquerda (Fonte: Arquivo > Exemplos > plcLib > ShiftRotate >
Vire à esquerda)
13 Trabalhando com Sinais Analógicos
OinAnalog()comando lê uma entrada analógica. Isso pode então ser usado para controlar um valor de saída
continuamente variável, como o brilho de um LED, a velocidade de um motor ou a posição de um servo. O
escalonamento das entradas e saídas é feito automaticamente pelo software plcLib.
OscanValuevariável global contém o valor inserido, que está no intervalo 0-1023 para uma entrada analógica. Isso é
escalado automaticamente na faixa de 0-255 ou 0-179 quando usado para controlar uma saída PWM ou servo,
respectivamente.
13.1 Controlando o brilho do LED usando PWM

Ligando oinAnalog()comando para ooutPWM()comando, permite que uma saída PWM seja controlada a partir
de uma entrada analógica. Como exemplo, o esboço a seguir lê um potenciômetro conectado à entradaX0e
produz uma forma de onda de pulso repetitiva com um ciclo de trabalho variável na saídaA0.
# inclui <plcLib.h>
PWM (Pulse Width Modulation) - Controle analógico de uma saída PWM
Conexões:
Entrada - potenciômetro conectado à entrada X0 (pino A0 do Arduino) Saída - LED

*/
void setup() {
}
loop void() {
emAnalógico(X0); // Lê a entrada analógica 0
outPWM(Y0); // Envia para a Saída 0 como forma de onda PWM
}
Listagem 27.Controle analógico de uma saída PWM (Fonte: Arquivo > Exemplos > plcLib > EntradaSaída >
PWM)
13.2 Controlando a velocidade e a direção de um motor

OEscudo do Motor do Arduinoé baseado em um IC de driver de ponte H disponível comercialmente, permitindo que a velocidade e
a direção de até dois motores CC sejam controladas. Uma possível conexão de hardware é mostrada abaixo.
Figura 37.Um Arduino Motor Shield permite que até dois motores sejam controlados.
Dois canais de motor estão disponíveis -Canal AeCanal B–e o shield também suporta um pequeno número de conectores de
entrada e saída compatíveis com Tinkerkit (mais duas interfaces TWI/I2C não consideradas aqui). A imagem acima mostra
um potenciômetro linear conectado ao pinoX2(A2), usado para controlar a velocidade do motor via PWM, e um interruptor
de inclinação que controla a direção do motor, ligado ao pinoX3(A3).
O exemplo a seguir controla a velocidade e a direção de um motor conectado ao Canal A.
# inclui <plcLib.h>
Motor Channel A - Controle simples do motor no Arduino Motor Shield Channel A
Conexões:
Entrada - Velocidade - potenciômetro conectado à entrada X2 (pino A2 do Arduino) Entrada -
Direção - chave conectada à entrada X3 (pino A3 do Arduino) Saída - Direção do canal A
(DIRA) - pino 12 do Arduino
Saída - Canal A PWM (PWMA) - Arduino pino 3 Saída - Canal A Freio
(BRAKEA) - Arduino pino 9

*/
// Variáveis
unsigned int RUN = 0; // Desabilita o freio
void setup() {
// Desliga o Freio do Canal A

em(EXECUTAR); // Lê a variável RUN (0 = freio desligado) // Saída
fora(BRAKEA); para BRAKEA
}
loop void() {
// Direção de controle do motor // Interruptor
em(X3); de leitura conectado à entrada 3 // Saída para
fora(DIRA); DIRA (direção do motor)
// Lê a Entrada Analógica 2 e envia para o Canal A PWM

emAnalógico(X2); // Leitura do potenciômetro conectado à Entrada Analógica 2 // Saída para
outPWM(PWMA); PWMA (velocidade do motor)
}
Listagem 28.Controle de Motor Simples no Canal A do Motor Shield do Arduino (Fonte: Arquivo > Exemplos >
plcLib > Motor > MotorChannelA)
Observação:Veja oMotorseção dos arquivos de exemplo para um esboço equivalente para controlar um motor
conectado ao Canal B.
Observe que várias variáveis predefinidas estão disponíveis para simplificar ao máximo a codificação do software
de controle do motor, conforme resumido abaixo:
• BRAKEAeBRAKEBativar ou desativar o freio em cada canal (0 = freio desligado).
• DIRAeDIRBdefinir a direção direta ou reversa de cada motor.
• PWMAePWMBcontrolar a velocidade do motor de seus canais relacionados.

14 Controle de posição usando servos
O controle de um servo é um pouco mais complexo, devido à necessidade de trabalhar com a biblioteca Servo
que é fornecida como parte padrão do ambiente Arduino. OoutServo()substitui ooutPWM()comando usado
anteriormente e é definido localmente, conforme mostrado abaixo.
# inclui <servo.h>
# inclui <plcLib.h>
Servo Único - Controlando a posição de um servo usando um potenciômetro
Conexões:
Entrada - potenciômetro conectado à entrada X0 (pino A0 do Arduino) Saída -
servo conectado à saída Y0 (pino 3 do Arduino)

*/
servoservo1; // Cria um objeto servo para controlar um único servo
externo int scanValue; // Link para scanValue definido no arquivo da biblioteca PLC
void setup() {
configuraçãoPLC(); // Configura entradas e saídas // Conecta o
servo1.attach(Y0); Servo 1 à Saída 0
}
loop void() {
emAnalógico(X0); // Potenciômetro de leitura conectado à entrada 0 // Saída
outServo(servo1); para Servo 1 (conectado à Saída 0)
}
// A função outServo é definida localmente int outServo(

servo&ServoObj) {
ServoObj.write(map(scanValue, 0, 1023, 0, 179));
return(scanValue);
}
Listagem 29.Servo Único (Fonte: Arquivo > Exemplos > plcLib > InputOutput > ServoSingle)
Observação:Veja oEntradaSaídaseção dos arquivos de exemplo para um esboço de controle de servo duplo.
15 Comparando Valores Analógicos
Comandos de comparação analógica fornecem funcionalidade equivalente a umcomparadorcircuito, dando um
verdadeiro/falsoresultado com base em qual dos dois sinais analógicos testados é o maior.
Figura 38.Um comparador 'testa' a magnitude relativa de duas entradas analógicas.
O símbolo do circuito para um comparador eletrônico é triangular, com duas entradas analógicas à esquerda e
uma única saída digital à esquerda. Aaltosaída é produzida se a tensão aplicada à parte superiorV+, o terminal de
entrada é maior do que o conectado ao inferior,V–entrada (chamada deentrada não inversorae aentrada inversora,
respectivamente). Caso contrário, umbaixosaída é produzida.
15.1 Comparação baseada em software de valores analógicos

A comparação de valores analógicos no software é um processo de três etapas:
1. Insira o primeiro valor analógico.
2. Compare isso com um segundo valor.
3. Envie o resultado da comparação para uma saída digital.
As duas variações disponíveis da operação de comparação sãocompareGT()ecompareLT()que testam se uma

entrada é maior ou menor que um valor de referência, respectivamente.
O exemplo a seguir testa se a tensão analógica na entradaX0é maior do que na entradaX1, definindo a
saídaA0se isso é verdade.
# inclui <plcLib.h>
Comparador - Teste maior que entre dois pinos de entrada
Conexões:
Entrada Analógica - potenciômetro conectado à entrada X0 (pino A0 do Arduino) Entrada
Analógica - potenciômetro conectado à entrada X1 (pino A1 do Arduino) Saída Digital - LED

*/
void setup() {
}
loop void() {
emAnalógico(X0); // Ler entrada analógica 0 // X0 >
compareGT(X1); X1 ?
fora(Y0); // Y0 = 1 se X0 > X1, Y0 = 0 caso contrário
}
Listagem 30.Maior que teste entre dois pinos de entrada usando um comparador (Fonte: Arquivo > Exemplos >
plcLib > AnalogCompare > GreaterThan)
Também é possível comparar uma entrada analógica com uma referência fixa, conforme mostrado no exemplo a
seguir.
# inclui <plcLib.h>
Comparador - Teste menor que entre uma entrada e um limite fixo
Conexões:
Entrada Analógica - potenciômetro conectado à entrada X0 (pino A0 do Arduino) Saída Digital -
LED conectado à saída Y0 (pino 3 do Arduino)

*/
limite int não assinado = 500; // Limiar analógico = 500
void setup() {
}
loop void() {
emAnalógico(X0); // Ler entrada analógica 0 // X0 <
compareLT(limiar); 500?
fora(Y0); // Y0 = 1 se X0 < 500, Y0 = 0 caso contrário
}
Listagem 31.Menor que o teste do comparador entre uma entrada e um limite fixo (Fonte: Arquivo >
Exemplos > plcLib > AnalogCompare > LessThanThreshold)
15.2 Um Aplicativo Comparador Simples

Neste exemplo, um par de comparadores é usado para testar se uma entrada analógica está acima de um limite
superior (maior que 3,5 V) ou abaixo de um limite inferior (menos de 1,5 V), conforme mostrado abaixo.
Figura 39.Um comparador de limite duplo indica se a entrada está acima ou abaixo de uma 'janela' permitida.
O comparador superior faz com que seu LED associado acenda se a tensão de entrada,V1é maior que um limite fixo de 3,5
V. Por outro lado, o comparador inferior fornece uma saída se sua tensão de entrada for menor que sua tensão limite de
1,5 V. (Observe cuidadosamente a polaridade de cada conexão de entrada do comparador para entender como 'maior
que' ou testes 'menos que' são alcançados.)

PlcLib Arduino User Guide Version 1.4 (1)-1-104_1-52.en.pt

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

PlcLib Arduino User Guide Version 1.4 (1)-1-104_1-52.en.pt

Enviado por

Direitos autorais:

Formatos disponíveis

Traduzido do Inglês para o Português - www.onlinedoctranslator.

Guia do usuário do PlcLib (Arduino)

Ultima atualização:28ºsetembro de 2017

2.1 Métodos de Desenvolvimento de Software.......................................... ................................................ .. 5

2.2 Hardware Suportado.............................................. ................................................ ................... 6

3.2 Atualizando para uma Nova Versão ....................................... ................................................ ............. 9

4 Configurando o Hardware............................................. ................................................ ................ 10

5.2 Executando Operações Booleanas ....................................... ................................................ 13

6.1 Trava com Componentes Discretos ....................................... ................................................ 18

7.1 Criando um Biestável Acionado por Borda ....................................... ......................................... 23

8 Inserção a partir de um teclado ....................................... ................................................ ......................... 25

8.1 Conexões de Hardware ....................................... ................................................ ............. 25

9.1 Produzindo um Atraso de Ligação............................... ................................................ ............. 29

9.4 Criando um pulso de duração fixa.......................................... ................................................ .... 32

10 Produzindo Formas de Onda Repetidas ....................................... ................................................ .. 33

10.1 Criação Manual de Pulsos.............................................. ................................................ ............. 33

10.2 Usando o comando timerCycle() ....................................... ................................................ .34

11.2 Contador Decrescente .............................................. ................................................ ......................... 37

11.4 Depurando Aplicativos Baseados em Contadores............................... ......................................... 39

12 Deslocamento e Rotação de Dados Binários............................................. ................................................ .... 41

12.1 Criando e usando registradores de deslocamento ....................................... ................................................ 41

12.2 Rotação de Dados ....................................... ................................................ ............................. 44

13.1 Controlando o brilho do LED usando PWM ....................................... ......................................... 47

13.2 Controlando a velocidade e a direção de um motor ....................................... ............................. 47

14 Controle de posição usando servos ....................................... ................................................ ......... 50

15 Comparando Valores Analógicos .............................................. ................................................ .......... 51

15.1 Comparação baseada em software de valores analógicos.............................. ............................. 51

15.2 Um aplicativo comparador simples.............................. ................................................ 52

17 Diagramas de Blocos Funcionais.............................................. ................................................ ................ 55

17.1 Construindo Sistemas de Trabalho ....................................... ................................................ ... 55

17.2 Aplicação 1: Um Alarme Simples ...................................... ................................................ ....... 56

17.4 Criando Blocos de Função Definidos pelo Usuário........................................... ......................................... 58

18 Gráficos Sequenciais de Funções ....................................... ................................................ ............ 60

18.1 Criando Sequências........................................... ................................................ ................... 60

19.1 Transições de base de tempo ....................................... ................................................ ................ 65

19.2 Aplicação 1: Aplicação do Controlador de Semáforos.............................. ......................... 67

21 Conceitos Avançados.................................................. ................................................ ...................... 76

21.1 Como o Software Funciona ....................................... ................................................ ............. 76

21.2.1 Usando a variável scanValue............................... ................................................ .77

21.4 Usando Variáveis com Circuitos Lógicos Complexos ....................................... ......................................... 79

22.1 Operações Lógicas de Bloco........................................... ................................................ ................ 82

23 Definindo alocações de E/S personalizadas ....................................... ................................................ ...... 85

23.1 Alocações de E/S pré-configuradas............................... ................................................ ....... 85

24 Pontos Fortes e Limitações do Software ....................................... ......................................... 88

25.3 Lógica Combinacional........................................... ................................................ ................... 90

25.6 Fechos .............................................. ................................................ ......................................... 91

25.8 Pulsos Acionados por Borda .............................................. ................................................ ................ 93

25.9 Contadores.............................................. ................................................ ......................................... 94

25.10 Registros de Deslocamento ....................................... ................................................ ...................... 95

25.11 Lógica de pilha e bloco ....................................... ................................................ ............. 97

28 Apêndice A – Monitor Serial (Recurso Experimental)........................................... ......................... 101

28.1 Introdução .......................................... ................................................ ......................... 101

2.1 Métodos de Desenvolvimento de Software

2.2 Hardware suportado

Figura 3.Controlando até dois motores com um Arduino Motor Shield.

Figura 5. Um Controlador Lógico Programável (CLP) típico. Imagem © istockphoto.com/Igor Mazej.

3.1 Primeira Instalação

O processo de instalação é explicado completamente nesteguia arduino .

3.1.1 Carregando e executando seu primeiro aplicativo

Com o software instalado, navegue até a seção de exemplos e carregue oMínimoesboço.

/* Biblioteca de Controladores Lógicos Programáveis para Arduino e Compatíveis

Mínimo - Entrada e saída digital de bit único

Software e documentação: https://

3.2 Atualizando para uma Nova Versão