
INTRODUCCION
============

LDmicro genera cdigo nativo para ciertos Microchip PIC16 y Atmel AVR
microcontroladores. Por lo general, el software para estos microcontroladores est escrito
en un lenguaje de programacin como ensamblador, C o BASIC. Un programa en uno
de estos idiomas comprende una lista de declaraciones. Estos idiomas son
potente y bien adaptado a la arquitectura del procesador, que
ejecuta internamente una lista de instrucciones.

Los PLC, por otro lado, a menudo se programan en "lgica de escalera". (A) simple
El programa podra verse as:

   ||                                                                    ||
   ||    Xbutton1           Tdon           Rchatter           Yred       ||
 1 ||-------]/[---------[TON 1.000 s]-+-------]/[--------------( )-------||
   ||                                 |                                  ||
   ||    Xbutton2           Tdof      |                                  ||
   ||-------]/[---------[TOF 2.000 s]-+                                  ||
   ||                                                                    ||
   ||                                                                    ||
   ||                                                                    ||
   ||    Rchatter            Ton             Tnew           Rchatter     ||
 2 ||-------]/[---------[TON 1.000 s]----[TOF 1.000 s]---------( )-------||
   ||                                                                    ||
   ||                                                                    ||
   ||                                                                    ||
   ||------[END]---------------------------------------------------------||
   ||                                                                    ||
   ||                                                                    ||

(TON es un retraso de encendido; TOF es un retraso de apagado. --] [-- declaraciones
son entradas, que se comportan como los contactos en un rel. los
--( )-- las declaraciones son salidas, que se comportan como la bobina de un
rel. Muchas buenas referencias para la lgica de escalera estn disponibles en Internet.
y en otros lugares; Los detalles especficos de esta implementacin se dan a continuacin.)

Un nmero de diferencias son evidentes:

    * El programa se presenta en formato grfico, no como una lista de texto.
 de declaraciones. Muchas personas inicialmente encontrarn esto ms fcil de
 entender.

    * En el nivel ms bsico, los programas parecen diagramas de circuito, con
 Contactos de rel (entradas) y bobinas (salidas). Esto es intuitivo para
 programadores con conocimientos de teora de circuitos elctricos.

    * El compilador de lgica de escalera se encarga de lo que se calcula
 dnde. No tiene que escribir cdigo para determinar cundo las salidas
 tienen que volver a calcular en funcin de un cambio en las entradas o un
 temporizador de eventos, y no tiene que especificar el orden en que
 estos clculos deben llevarse a cabo; Las herramientas PLC lo hacen por usted.

LDmicro compila la lgica de escalera a cdigo PIC16 o AVR. El seguimiento
Los procesadores son compatibles:
    * PIC16F877
    * PIC16F628
    * PIC16F876
    * PIC16F88
    * PIC16F819
    * PIC16F887
    * PIC16F886
    * PIC16F72
    * PIC12F675
    * PIC12F683
    * PIC16F1512
    * PIC16F1516
    * PIC16F1527
    * PIC10F202
    * PIC10F200
    * ATmega128
    * ATmega64
    * ATmega162
    * ATmega32
    * ATmega32U4
    * ATmega16
    * ATmega8
    * ESP8266
    * STM32
    * "Cdigo PASCAL "para PC LPT y COM
* y un montn de...

Sera fcil admitir ms chips AVR o PIC16, pero no tengo
alguna forma de probarlos. Si necesita uno en particular, contcteme y
Ver que puedo hacer.

Con LDmicro, puede dibujar un diagrama de escalera para su programa. Usted puede
simule la lgica en tiempo real en su PC. Entonces cuando ests convencido
que es correcto, puede asignar pines en el microcontrolador al
programa entradas y salidas. Una vez que haya asignado los pines, puede
compila el cdigo PIC o AVR para tu programa. La salida del compilador es un .hex
archivo que puede programar en su microcontrolador usando cualquier PIC / AVR
programador.

LDmicro est diseado para ser algo similar a la mayora de los PLC comerciales
Sistemas de programacin. Hay algunas excepciones y muchas cosas.
de todos modos no son estndar en la industria. Lea atentamente la descripcin
de cada instruccin, incluso si parece familiar. Este documento asume
Conocimientos bsicos de la lgica de escalera y de la estructura del software PLC.
(el ciclo de ejecucin: leer entradas, calcular, escribir salidas).

PLC y seguridad
    https://github.com/LDmicro/LDmicro/wiki/PLC-and-safety

Tiempo 0 de ciclo del PLC
    https://github.com/LDmicro/LDmicro/wiki/PLC-Cycle-Time-0

OBJETIVOS ADICIONALES
=====================

Tambin es posible generar cdigo ANSI C. Podras usar esto con cualquier
procesador para el que tiene un compilador de C, pero usted es responsable de
suministrando el tiempo de ejecucin. Eso significa que LDmicro solo genera fuente
para una funcin PlcCycle (). Usted es responsable de llamar a PlcCycle
cada ciclo, y usted es responsable de implementar todas las E / S
(lectura / escritura de entrada digital, etc.) funciones a las que llama PlcCycle (). Ver
los comentarios en la fuente generada para ms detalles.

Finalmente, LDmicro puede generar bytecode independiente del procesador para un
Mquina virtual diseada para ejecutar cdigo de lgica de escalera. He proporcionado una
implementacin de muestra del intrprete/VM, escrita en bastante porttil
C. Este objetivo funcionar para casi cualquier plataforma, siempre que
puede suministrar su propia VM. Esto puede ser til para aplicaciones donde
desea utilizar la lgica de escalera como un 'lenguaje de script' para personalizar un
programa. Vea los comentarios en el intrprete de muestra para ms detalles.

Se ha agregado un nuevo objetivo "Controllino Maxi / Ext bytecode". Genera
Archivo .xint interpretable por el software LDuino PLC. Hasta ahora solo
Controllino Maxi PLC es compatible. Sin embargo, como el cdigo de bytes es genrico,
Se puede hacer la adaptacin a cualquier otra placa de PLC o CPU. Ver cdigo fuente LDuino
para eso.

OPCIONES DE LINEA DE COMANDO
============================

ldmicro.exe generalmente se ejecuta sin opciones de lnea de comandos. Eso significa
que puede hacer un acceso directo al programa o guardarlo en su
escritorio y haga doble clic en el icono cuando desee ejecutarlo, y luego
puede hacer todo desde la GUI.

Si se pasa LDmicro un solo nombre de archivo en la lnea de comando
(por ejemplo, `ldmicro.exe asd.ld '), LDmicro intentar abrir` asd.ld',
si existiera. Se produce un error si `asd.ld 'no existe. Esta
significa que puede asociar ldmicro.exe con archivos .ld, para que se ejecute
automticamente cuando hace doble clic en un archivo .ld.

Si LDmicro se pasa argumentos de lnea de comando en el formulario
`ldmicro.exe / c src.ld dest.hex ', luego intenta compilar` src.ld',
y guarde la salida como 'dest.hex'. LDmicro sale despus de compilar,
si la compilacin fue exitosa o no. Cualquier mensaje se imprime
a la consola Este modo es til solo cuando se ejecuta LDmicro desde
lnea de comando.


LO ESENCIAL
===========

Si ejecuta LDmicro sin argumentos, entonces comienza con el programa vacio.
Si ejecuta LDmicro con el nombre de un programa de escalera (xxx.ld)
en la lnea de comando, entonces intentar cargar ese programa al inicio.
LDmicro usa su propio formato interno para el programa; no puede importar
lgica de cualquier otra herramienta.

Si no carg un programa existente, se le dar un programa
con un peldao vaco Podras agregarle una instruccin; por ejemplo
puede agregar un conjunto de contactos (Instruccin -> Insertar contactos) llamado
'Xnuevo'. 'X' significa que los contactos estarn vinculados a un pin de entrada en el
microcontrolador Puede asignarle un pin ms tarde, despus de elegir un
microcontrolador y cambio de nombre de los contactos (Se tienen que cambiar los nombres es obligado).
La primera letra de un nombre indica qu tipo de objeto es. Por ejemplo:

    * Xname -- vinculado a un pin de entrada en el microcontrolador
    * Yname -- vinculado a un pin de salida en el microcontrolador
    * Rname -- `rel interno ': un bit en la memoria
    * Tname -- un temporizador retraso de encendido, retraso de apagado o retentivo
    * Cname -- un contador, ya sea cuenta adelante o cuenta atrs
    * Aname -- una lectura entera de un convertidor A / D
    * Pname -- vinculado a un pin de salida PWM en el microcontrolador
    * Mname -- vinculado a una salida de bobina MODBUS
    * Iname -- vinculado  a una entrada discreta MODBUS
    * Hname -- vinculado to a MODBUS Holding register
    * name  -- una variable de propsito general (entero)

   Nombre de la variable que comienza con el smbolo. '#' como
    #PORTA, #PORTB, #PORTC, ... tratado como puerto de hardware de salida.
 Nombre de la variable que comienza con el smbolo. '#' como
    #PINA, #PINB, #PINC, ... tratado como puerto de entrada de hardware.
    Nombre de la variable que comienza con el smbolo.'#' como
    #TRISA, #TRISB, #TRISC, ... tratado como registro de direccin de datos de los puertos correspondientes
    #PORTA, #PORTB, #PORTC, ...
    Nota: la direccin PORTn y PINn son iguales para PIC's

    El nombre de la variable que comienza con un carcter '#' y luego un nmero
 (comnmente un hexadecimal) tratada como la direccin inmediata del registro de hardware.
 Un valor como # 0xXXXX es un direccionamiento inmediato, directo y explcito.
 Por ejemplo:
 # 0x8E tratado como la direccin del registro PCON de hardware
 del microcontrolador Microchip PIC16F628.
 # 0x136 tratado como la direccin del registro UDR3 de hardware
 (Registro de datos de E/S USART3) del microcontrolador Atmel ATmega2560.

    El nombre de la variable que comienza con un carcter '#' y posterior como
 un nombre de variable de propsito general tratado como la direccin indirecta del registro de hardware.
 Un valor como #VarName es la direccin indirecta del registro de hardware (puntero de direccin indirecta).
 Por ejemplo:
      {MOV  portAddr:=}    portAddr es una variable de propsito general que contiene el valor 0x05.
    --{           0x05}--

      {MOV #portAddr:=}    #portAddr tratada como la direccin indirecta del registro # 0x05 PORTA (Microchip PIC16F887).
    --{           0xF0}--  Los pines de salida PORTA se establecen en un valor binario de 11110000.

      {ADD  portAddr:=}    La variable portAddr de propsito general ahora tiene un valor de 0x06.
    --{portAddr  +   1}--

      {MOV #portAddr:=}    #portAddr tratada como la direccin indirecta del registro # 0x06 PORTB (Microchip PIC16F887).
    --{           0x0F}--  Los pines de salida PORTB estn configurados en un valor binario de 00001111.
    * Wiki: LDmicro direccionamiento indirecto
      https://github.com/LDmicro/LDmicro/wiki/LDmicro-indirect-addressing

    Tenga cuidado al escribir en los registros de hardware mediante el acceso inmediato a la direccin.
 Vea cmo acceder a SPI a travs de los registros de hardware.
    * Wiki: SPI: Interfaz Perifrica Serial
      https://github.com/LDmicro/LDmicro/wiki/SPI:-Serial-Peripheral-Interface


Elija el resto del nombre para que describa lo que hace el objeto,
y para que sea nico dentro del programa. El mismo nombre siempre se refiere
al mismo objeto dentro del programa. Por ejemplo, sera un error.
tener un retraso de encendido (TON) llamado 'Tdelay' y un retraso de apagado (TOF)
llamado 'Tdelay' en el mismo programa, ya que cada contador necesita su propio
memoria. Por otro lado, sera correcto tener un temporizador retentivo
(RTO) llamado `Tdelay 'y una instruccin de reinicio (RES) asociada con
'Tdelay', ya que en ese caso desea que ambas instrucciones funcionen
El mismo temporizador.

Los nombres de las variables pueden consistir en letras, nmeros y guiones bajos '_'.
Un nombre de variable no debe comenzar con un nmero. Los nombres de las variables son
distingue maysculas y minsculas.

Las instrucciones variables generales (MOV, ADD, EQU, etc.) pueden funcionar en
variables con cualquier nombre. Esto significa que pueden acceder al temporizador y
Contadores acumuladores. Esto a veces puede ser til; Por ejemplo usted
podra verificar si la cuenta de un temporizador est en un rango particular.

Las variables son siempre enteros de 16 bits. Esto significa que pueden ir
de -32768 a 32767. Las variables siempre se tratan como firmadas.

ACTUALIZADO: Versin 4.3.0
Las variables pueden asignar 1,2,3 o 4 bytes. Puede cambiar el tamao de la variable
haciendo doble clic en el nombre de la variable en la lista en la parte inferior de la pantalla.
Las variables se almacenan y procesan en forma de complemento de dos.
Ver https://en.wikipedia.org/wiki/Two%27s_complement

Bytes    Tipos      Intervalo de                  a
 1   signed int8   -2^7 =       -128=0x80        2^7 -1=       127=0x7f
 2   signed int16  -2^15=     -32768=0x8000      2^15-1=     32767=0x7fff
 3   signed int24  -2^23=   -8388608=0x800000    2^23-1=   8388607=0x7fFFFF
 4   signed int32  -2^31=-2147483648=0x80000000  2^31-1=2147483647=0x7fffFFFF

El valor cero decimal (0) se representa como todos los bits ceros 00 ... 000
El valor decimal (-1) representado como todos 11 ... 111

Las variables int8 firmadas se utilizan para hacer que el archivo hexadecimal sea ms pequeo y ms rpido.
Los tipos firmados int24 e int32 se utilizan para aumentar el rango de variables.
La extensin de signo para variables de diferentes tamaos se proporciona automticamente.
Nota: Las instrucciones MUL, DIV, MOD no pueden procesar variables int32.

El indicador de desbordamiento aritmtico (subflujo) se proporciona como rel interno ROverflowFlagV.
https://en.wikipedia.org/wiki/Overflow_flag
https://www.allaboutcircuits.com/textbook/digital/chpt-2/binary-overflow/
El indicador de desbordamiento indica que el resultado del complemento a dos firmado
No cabe en el nmero de bits utilizados para la operacin, y seala un error.
Por ejemplo, si la variable int8 dest = 127 (0x7f) suma 1, obtenemos -128 (0x80),
y el indicador de desbordamiento ROverflowFlagV se establecer en 1.
En cambio, si la variable int16 dest = 127 (0x007f) agrega 1, obtenemos 128 (0x0080),
y el indicador de desbordamiento ROverflowFlagV no se ve afectado.
LDmicro restablece el ROverflowFlagV a cero durante la inicializacin.
Nota: CTC genera un impulso de sobrellenado (carry) cuando Counter == Max.
 El CTR genera un impulso de sobrellenado (prestado) cuando el Contador == Min.
 Overfill no establece la bandera de desbordamiento.

El indicador de superposicin se proporciona como el estado de salida de las operaciones ADD, SUB.
El indicador de superposicin indica que se ha cambiado el signo del resultado.
Por ejemplo, se produjo una superposicin cuando -1 (0xf..f) agrega 1 (o sub -1), obtenemos 0 (0x0..0),
todos los 1 se cambian a todos ceros 0.
Adems, se produjo una superposicin cuando 0 (0x0..0) sub 1 (o agregar -1), obtenemos -1 (0xf..f),
todos los ceros 0 se cambian a todos unos 1.
Por ejemplo, se produjo una superposicin cuando -10 agrega 15 (o sub -15), obtenemos 5,
fuente negativa se cambia a resultado positivo.
Adems, se produjo una superposicin cuando 10 sub 15 (o agregamos -15), obtenemos -5,
fuente positiva se cambia a resultado negativo.
ACTUALIZACIONES FINALES: Versin 4.3.0

Puede especificar literales como nmeros decimales normales (10, 1234, -56).
Tambin puede especificar valores de caracteres ASCII ('A', 'z') poniendo
El personaje entre comillas simples. Puedes usar un cdigo de caracteres ASCII
en la mayora de los lugares donde podras usar un nmero decimal.
Puede usar nmeros hexadecimales (0xA, 0x04D2, 0xffc8),
nmeros octales (0o12, 0o2322, 0o177710),
nmeros binarios (0b1010, 0b10011010010, 0b1111111111001000)
en la mayora de los lugares donde podras usar un nmero decimal.
LDmicro us los prefijos C:
0x__ o 0X__ para nmeros hexadecimales con dgitos 1234567890ABCDEF
0o__ o 0O__ o 0__ nmeros octales con 01234567 dgitos
0b__ o 0B__ para nmeros binarios con 01 dgitos.
Hexadecimales, la notacin binaria es ms cmoda para opacidades bit a bit.

En la parte inferior de la pantalla, ver una lista de todos los objetos en
el programa. Esta lista se genera automticamente desde el programa;
no es necesario mantenerlo actualizado a mano. La mayora de los objetos no
Necesitan alguna configuracin. Los objetos 'Xname', 'Yname' y 'Aname' deben ser
asignado a un pin en el microcontrolador, sin embargo. Primero elige que
microcontrolador que desee utilizar (Configuracin -> Microcontrolador). Luego asignar
sus pines de E/S haciendo doble clic en ellos en la lista.

Puede modificar el programa insertando o eliminando instrucciones.
el cursor en la pantalla del programa parpadea para indicar el seleccionado actualmente
instruccin y el punto de insercin actual. Si no est parpadeando, entonces
presione <Tab> o haga clic en una instruccin. Ahora puedes eliminar el actual
instruccin, o puede insertar una nueva instruccin a la derecha o izquierda
(en serie con) o arriba o abajo (en paralelo con) el seleccionado
instruccin. Algunas operaciones no estn permitidas. Por ejemplo, no hay instrucciones
despues de una bobina a su derecha.

El programa comienza con un solo peldao. Puede agregar ms peldaos seleccionando
Inserte Peldao Antes / Despus en el men Lgica. Podras obtener el mismo efecto
colocando muchos subcircuitos complicados en paralelo dentro de un peldao,
pero se lee mejor usando mltiples peldaos.

Una vez que haya escrito un programa, puede probarlo en simulacin y luego
puede compilarlo en un archivo .HEX para el microcontrolador de destino.


SIMULACION
==========

Para ingresar al modo de simulacin, elija Simular -> Modo de simulacin o presione
<Ctrl + M>. El programa se muestra de manera diferente en el modo de simulacin. Ahi esta
Ya no es un cursor. Las instrucciones que se activan aparecen brillantes
rojo; las instrucciones que no aparecen en gris. Presione la barra espaciadora para
ejecute el PLC un ciclo. Para realizar un ciclo continuo en tiempo real, elija
Simular -> Iniciar simulacin en tiempo real o presionar <Ctrl + R>. La exhibicin de
El programa se actualizar en tiempo real a medida que cambie el estado del programa.

Puede establecer el estado de las entradas al programa haciendo doble clic,
en la lista en la parte inferior de la pantalla, o haciendo doble clic en una
Instruccin de contactos 'Xname' en el programa. Si cambia el estado de
un pin de entrada, entonces ese cambio no se reflejar en cmo el programa
se muestra hasta que el PLC realiza un ciclo; esto suceder automticamente si
est ejecutando una simulacin en tiempo real o cuando presiona la barra espaciadora.


COMPILAR CON EL CDIGO NATIVO
=============================

En ltima instancia, el punto es generar un archivo .hex que pueda programar
en su microcontrolador. Primero debe seleccionar el nmero de pieza del
microcontrolador, en el men Configuracin -> Microcontrolador. Entonces usted
debe asignar un pin de E/S a cada objeto 'Xname' o 'Yname'. Haz esto
haciendo doble clic en el nombre del objeto en la lista en la parte inferior de la pantalla.
Aparecer un cuadro de dilogo donde podr elegir un pin no asignado de una lista.

Luego debe elegir el tiempo de ciclo con el que correr, y debe
decirle al compilador a qu velocidad de reloj estar funcionando el micro. Esto
se configuran en el men Configuracin -> Parmetros MCU ... En general usted
no debera necesitar cambiar el tiempo del ciclo; 10 ms es un buen valor para la mayora
aplicaciones. Escriba la frecuencia del cristal que usar
con el microcontrolador (o el resonador de cermica, etc.) y haga clic en Aceptar.

Ahora puede generar cdigo desde su programa. Elija Compilar -> Compilar,
o Compilar -> Compilar como ... si anteriormente compil este programa
y desea especificar un nombre de archivo de salida diferente. Si no hay
errores, entonces LDmicro generar un archivo Intel IHEX listo para
programacin en tu chip. Avertencia:si lla fue copilado y lo vuelve a copilar tenga en cuenta que
suscribira el programa antiguo .hex, para que no suceda es guardar como y cambiar el nombre.

Use cualquier software y hardware de programacin que tenga para cargar el hexadecimal
archivar en el microcontrolador. Recuerde configurar los bits de configuracin
(fusibles)! Para los procesadores PIC16, los bits de configuracin se incluyen en
archivo hexadecimal, y la mayora del software de programacin buscar all automticamente.
Para los procesadores AVR, debe establecer los bits de configuracin a mano.


RESISTENCIAS PULL UP
====================
Resistencias Pulll-up  + (Hacia ariba)
https://github.com/LDmicro/LDmicro/wiki/Pull-up-resistors

Todos los pines de entrada intentan establecer registros desplegables por defecto.
Desde la versin 5.3.0.4 se agreg el men Configuracin-> Establecer resistencias de entrada pull-up.

Deshabilitar resistencias pull up (Obsoleto pero posible)
https://github.com/LDmicro/LDmicro/wiki/Disable-Pull-up-resistors

Resistencias Pulll-down - (hacia a bajo)
https://github.com/LDmicro/LDmicro/wiki/Pull-down-resistors


REFERENCIA DE INSTRUCCIONES
===========================

    Terminologa:
 "Nivel sensible" = salida (elemento) controlado por el nivel de la entrada.
 "Edge accionado" = la salida cambia solo en el momento
 cuando la entrada cambia de valor a la otra. Puede ser positivo
 activado por flanco (0 a 1), o activado por flanco negativo (1 a 0).
 La mayora de los elementos de LDmicro son "sensibles al nivel", algunos elementos son
 "disparado por borde positivo".

> CONTACTO, NORMALMENTE ABIERTO    Xname           Rname          Yname
                                ----] [----     ----] [----    ----] [----

    Si la seal que entra en la instruccin es falsa, entonces la salida
 La seal es falsa. Si la seal que entra en la instruccin es verdadera,
 entonces la seal de salida es verdadera si y solo si el pin de entrada dado,
 pin de salida, o el rel interno es verdadero, de lo contrario es falso. Esta
 instruccin puede examinar el estado de un pin de entrada, un pin de salida,
 o un rel interno.


> CONTACTO, NORMALMENTE CERRADO   Xname           Rname          Yname
                               ----]/[----     ----]/[----    ----]/[----

    Si la seal que entra en la instruccin es falsa, entonces la salida
 La seal es falsa. Si la seal que entra en la instruccin es verdadera,
 entonces la seal de salida es verdadera si y solo si el pin de entrada dado,
 pin de salida, o el rel interno es falso, de lo contrario es falso. Esta
 la instruccin puede examinar el estado de un pin de entrada, un pin de salida,
 o un rel interno. Esto es lo contrario de un contacto normalmente abierto.

    CMO: Las operaciones lgicas AND, OR, XOR en las entradas de CONTACT
    Ver https://github.com/LDmicro/LDmicro/wiki/HOW-TO:-The-AND,-OR,-XOR-logic-operations-on-CONTACTs-inputs

> BOBINA NORMAL (Abierta)       Rname           Yname
                             ----( )----     ----( )----

    Si la seal que entra en la instruccin es falsa, entonces el
 rel interno o pin de salida se borra falso. Si la seal va
 en esta instruccin es verdadera, entonces el rel interno o la salida dada
 el pin se establece como verdadero. No tiene sentido asignar una variable de entrada a un
 bobina. Esta instruccin debe ser la instruccin ms a la derecha en su peldao.
 Nivel sensible.


> BOBINA NEGADA (Cerrada)       Rname           Yname
                             ----(/)----     ----(/)----

    Si la seal que entra en la instruccin es verdadera, entonces el
 rel interno o pin de salida se borra falso. Si la seal va
 en esta instruccin es falsa, entonces el rel interno o
 el pin de salida se establece como verdadero No tiene sentido asignar una entrada
 variable a una bobina. Esto es lo contrario de una bobina normal. Esta
 la instruccin debe ser la instruccin ms derecha en su peldao.
 Nivel sensible.


> BOBINA, SIEMPRE ACTIVA         Rname           Yname
                              ----(S)----     ----(S)----

    Si la seal que entra en la instruccin es verdadera, entonces
 El rel interno o el pin de salida se establece como verdadero. De lo contrario, el interno
 el estado del pin de salida o rel no cambia. Esta instruccin solo puede
 cambia el estado de una bobina de falso a verdadero, por lo que normalmente es
 usado en combinacin con una bobina de solo reinicio --(R)--. Esta instruccin debe
 ser la instruccin ms a la derecha en su peldao.
 Simplemente puede presentar como un disparador con la entrada sensible al nivel SET.


> BOBINA, SOLO RESET            Rname           Yname
                             ----(R)----     ----(R)----

    Si la seal que entra en la instruccin es verdadera, entonces el
 rel interno o pin de salida se borra falso. De lo contrario el
 el estado interno del pin de salida o el rel no cambia. Esta instruccin
 solo puede cambiar el estado de una bobina de verdadero a falso,
 por lo tanto, se usa tpicamente en combinacin con una bobina de solo ajuste. Esta
 la instruccin debe ser la instruccin ms a la derecha en su peldao.
 Simplemente puede presentar como un disparador con la entrada sensible al nivel RESET.


> BOBINA, DISPARADOR T          Rname           Yname
                             ----(T)----     ----(T)----

    Un disparador en T de la bobina es un flip-flop activado por el borde (alternar, volcar, voltear).
 Un flip-flop de bobina cada borde ascendente de la condicin de entrada (es decir
 cul es la condicin de entrada de falso a verdadero).
 Si se detecta un borde ascendente, si el estado de la bobina es falso, se establece como verdadero.
 Si se detecta el siguiente flanco ascendente, si el estado de la bobina es verdadero, se establece en falso.
 Esta instruccin debe ser la instruccin ms a la derecha en su peldao.
 Simplemente puede presentar como un disparador T con el positivo
 entrada activada por el borde.

Nota: Las varias bobinas con el mismo 'YName' o 'RName' pueden ser mentalmente
 representado como un microchip con mltiples entradas y una salida.
 La entrada normal e invertida transfiere directamente el estado de entrada (normal o
 invertido) a la salida cada vez en cada ciclo del PLC.
 Las entradas R, S, T bloquean (bloquean) el estado de salida.
 La entrada T es activada por flanco positivo. Las entradas R, S son sensibles al nivel.
 Si antes de R, S inserte el "OSR: ONE-SHOT RISING" = franco alto o
 "OSF: ONE-SHOT FALLING" = Franco bajo obtienes un elemento "borde positivo activado".
 Si usa solo las entradas R y S, obtiene el disparador RS clsico.
 Si agrega la entrada T, obtendr el "RST-trigger" . Puede haber varias entradas R..R,
 o varias entradas S..S. Puede usar cualquier combinacin de entradas para un 'YName'
 o bobina 'RName'.
    https://github.com/LDmicro/LDmicro/wiki/COIL


> RETARDO DE ENCENDIDO (tiempo en espera)      Tdon
                                          -[TON 1.000 s]-

    Cuando la seal que entra en la instruccin pasa de falso a verdadero,
 la seal de salida permanece falsa durante 1.000 s antes de volverse verdadera. Cuando
 la seal que entra en la instruccin va de verdadero a falso, la salida
 la seal se vuelve falsa de inmediato. El temporizador se reinicia cada vez que la entrada
 se vuelve falso; la entrada debe permanecer verdadera durante 1000 milisegundos consecutivos
 antes de que la salida se haga realidad. El retraso es configurable.

    La variable 'Tname' cuenta desde cero en unidades de tiempos de exploracin.
 La instruccin TON da salida a true cuando la variable del contador es mayor
 que o igual al retraso dado. Es posible manipular el
 Contador variable en otro lugar, por ejemplo con una instruccin MOV.


              Nivel
              Logica
                   ^  La duracin del pulso de entrada.
                   |  debe ser ms largo que 1s
           TON     |     _________
           Entrada | ___/         \_______
                   |    |         |
                   |    | 1s      |
                   |    |<-->|    |
                   |         |    |
                   |         v    v
           TON     |          ____
           Salida  | ________/    \_______
                 --+---------------------------> Tiempo en,s
                   |


> RETARDO DE APAGADO (tiempo en encendido)        Tdoff
                                            -[TOF 1.000 s]-

    Cuando la seal que entra en la instruccin pasa de verdadero a falso,
 la seal de salida permanece verdadera por 1,000 s antes de volverse falsa. Cuando
 la seal que entra en la instruccin va de falso a verdadero,
 la seal de salida se cumple de inmediato. El temporizador se reinicia cada
 tiempo en que la entrada se vuelve falsa; la entrada debe permanecer falsa por 1000
 milisegundos consecutivos antes de que la salida se vuelva falsa. El retraso
 Es configurable.

    La variable 'Tname' cuenta desde cero en unidades de tiempos de exploracin. los
 La instruccin TON da salida a true cuando la variable del contador es mayor
 que o igual al retraso dado. Es posible manipular el
 Contador variable en otro lugar, por ejemplo con una instruccin MOV.


              Nivel
              Logico
                   ^  La duracin del pulso de entrada debe ser
                   |     ms largo que el ciclo del PLC
           TOF     |        _
           Entrada | ______/ \_________
                   |       | |
                   |       | | 1s
                   |       | |<-->|
                   |       |      |
                   |       v      v
           TOF     |        ______
           Salida  | ______/      \____
                 --+----------------------> Tiempo en,s
                   |


> TEMPORIZADOR ALTO              Thi
                           -[THI 1.000 s]-

    Cuando la seal que entra en la instruccin pasa de falso a verdadero,
 La seal de salida es verdadera durante 1.000 s. El retraso es configurable.
 La seal de salida se restablece despus de 1.000 s, el contador interno del temporizador
 se restablece despus de 1,000 sy si la entrada es falsa.


               Nivel
              Logico
                   ^  La duracin del pulso de entrada debe ser
                   |      El ms largo que el ciclo del PLC
           THI     |     _           ________
           Entrada | ___/ \_________/        \_______
                   |    |           |
                   |    | 1s        | 1s
                   |    |<-->|      |<-->|
                   |    |    |      |    |
                   |    v    v      v    v
           THI     |     ____        ____
           Salida  | ___/    \______/    \___________
                 --+------------------------------------> Tiempo en,s
                   |


> TEMPORIZADOR BAJO             Tlo
                          -o[TLO 1.000 s]-

    Cuando la seal que entra en la instruccin pasa de verdadero a falso,
 la seal de salida es falsa durante 1.000 s. El retraso es configurable.
 La seal de salida se establece como verdadera despus de 1.000 s, el contador interno del temporizador
 se restablece despus de 1,000 sy si la entrada es verdadera.


              Nivel
              Logico
                   ^  La duracin del pulso de entrada debe ser
                   |     ms largo que el ciclo del PLC
           TLO     | ___   _________          _______
           Entrada |    \_/         \________/
                   |    |           |
                   |    | 1s        | 1s
                   |    |<-->|      |<-->|
                   |    |    |      |    |
                   |    v    v      v    v
           TLO     | ___      ______      ___________
           Salida  |    \____/      \____/
                 --+------------------------------------> Tiempo en,s
                   |

    See https://github.com/LDmicro/LDmicro/wiki/TON,-TOF,-etc.


> TEMPORIZADOR RETENTIVO        Trto
                           -[RTO 1.000 s]-

    Esta instruccin realiza un seguimiento de cunto tiempo su entrada ha sido verdadera (HI=Alto).
 Si su entrada ha sido verdadera durante al menos 1,000 s, entonces la salida es
 cierto. De lo contrario, la salida es falsa. La entrada no necesita haber sido
 verdadero por 1000 milisegundos consecutivos; si la entrada se cumple
 por 0.6 s, luego falso por 2.0 s, y luego verdadero por 0.4 s, luego el
 La salida se har realidad. Despus de que la salida se vuelva verdadera, seguir siendo verdadera
 incluso despus de que la entrada sea falsa, siempre que la entrada haya sido verdadera
 por ms de 1.000 s. Por lo tanto, este temporizador debe restablecerse manualmente,
 usando la instruccin de reinicio.

    La variable 'Tname' cuenta desde cero en unidades de tiempos de exploracin.
 La instruccin TON da salida a true cuando la variable del contador es mayor
 que o igual al retraso dado. Es posible manipular el
 Contador variable en otro lugar, por ejemplo con una instruccin MOV.


              Nivel
              Logico
                   ^  La duracin total de los pulsos de entrada (Alta)es ms de 1 s
                   |  t1+t2+..+tn >= 1s
                   |
           RTO     |     __     _    _________
           Entrada | ___/  \___/ \__/         \________
                   |    |  |   | |  |
                   |    |t1|   | |  |tn                   Trto
                   |    |<>|  >|-|< |<>|                  RESET
                   |           t2      |                  |
                   |                   v                  v
           RTO     |                    __________________
           Salida  | __________________/                  \___
                 --+-------------------------------------------> Tiempo en,s
                   |


> TEMPORIZADOR RETENTIVO BAJO      Trtl
                             -o[RTL 1.000 s]-

    RTL funciona como RTO, pero captura entradas de bajo nivel.
 Esta instruccin realiza un seguimiento de cunto tiempo, su entrada ha sido falsa (BAJA).
 Si su entrada ha sido falsa durante al menos 1,000 s, entonces la salida es
 cierto. De lo contrario, la salida es falsa.
 Despus de que la salida sea verdadera, seguir siendo verdadera incluso despus de la entrada
 se hace realidad Por lo tanto, este temporizador debe restablecerse manualmente,
 usando la instruccin de reinicio.


              Nivel
              Logico
                   ^  La duracin total de la entrada BAJA es ms de 1 s
                   |  t1+t2+..+tn >= 1s
                   |
           RTL     | ___    ___   __           ________
           Entrada |    \__/   \_/  \_________/
                   |    |  |   | |  |
                   |    |t1|   | |  |tn                   Trtl
                   |    |<>|  >|-|< |<>|                  RESET
                   |           t2      |                  |
                   |                   v                  v
           RTL     |                    __________________
           Salida  | __________________/                  \___
                 --+-------------------------------------------> Tiempo en,s
                   |


> CYCLIC TIMER (TEMPORIZADOR CCLICO)    Tmeander
                                      -[TCY 500 ms]-

    Si la seal de entrada es verdadera, esta instruccin produce un meandro con
 perodo (500ms + 500ms) = 1s y frecuencia 1 Hz. Si la seal entra
 la instruccin es falsa, entonces la seal de salida es falsa.

   Si el valor de Tmeander = tiempo de ciclo del PLC, el TCY es igual a OSC.


              Nivel
              Logico
                   ^  La duracin del pulso de entrada es superior a 1 s.
           TCY     |     ______________________
           Entrada | ___/                      \_______
                   |    |                      |
                   |    |  1s    1s    1s      |
                   |    |<--->|<--->|<--->|    |
                        |     |     |     |    v
           TCY     |    v   __|   __|   __|   _
           Salida  | ______/  \__/  \__/  \__/ \_______
                 --+----------------------------------------> Tiempo en,s
                   |


> TON, TOF, THI, TLO, RTO, RTL, TCY timers      Ton
                                           -[TON valor]-

    Actualizado en la versin 4.4.1.0
 Puede usar una variable general como retraso del temporizador.
 Debe calcular el valor correcto (correcto) de la variable de acuerdo con
 El tiempo de ciclo del PLC.
 Retardo del temporizador (ms) = Tplc (ms) * Valor de retardo
   ||                                                       ||
   ||                                             Adc       ||
   ||-----------------------------------------{READ ADC}----||
   ||                                                       ||
   ||                                                       ||
   ||       X1               T1                   Y1        ||
   ||-------] [-----------[TON Adc]---------------( )-------||
   ||                                                       ||


> Conversor de TIEMPO a CONTADOR       Tconst
                                   -[T2CNT 10 ms]-

    La instruccin 'Convertidor de TIEMPO a CONTADOR' obtiene el tiempo
     constante en ms, lo convierte a los temporizadores (TON, TOF, ...) -
     valor especfico y lo guarda en la variable Const para usarlo en contadores ms adelante.
     Ver https://github.com/LDmicro/LDmicro/wiki/TIME-to-COUNTER-converter


> RESET (Reinico)                Trto             Citems
                             ----{RES}----     ----{RES}----

    Esta instruccin restablece un temporizador o un contador. Los temporizadores TON y TOF.
 se restablece automticamente cuando su entrada es falsa o verdadera, por lo que RES
 No es necesario para estos temporizadores, pero es posible. Temporizadores RTO y
 Los contadores CTU / CTD no se reinician automticamente, por lo que deben reiniciarse
 a mano usando una instruccin RES. Cuando la entrada es verdadera, el contador o
 el temporizador se reinicia; cuando la entrada es falsa, no se toman medidas. Esta
 la instruccin debe ser la instruccin ms correcta en su peldao.
 Nota! RES restablece solo el contador numrico dentro de RTO, CTU / CTD,
 no sus salidas!


> RESET (Reinicio)                  PWM
                               ----{RES}----

    Esta instruccin deshabilita la salida PWM y la establece en nivel bajo.
 Tambin puede establecer otra frecuencia base PWM mediante SET PWM DUTY CYCLE
 despus de la activacin, RESET PWM.

 Ver SET PWM DUTY CYCLE a continuacin.


> DELAY (RETRASO)               1 us
                           ---[DELAY]---

    La instruccin DELAY causa un retraso. La instruccin DELAY no
 use cualquier temporizador / contador. Las instrucciones NOP y JMP (Direccin actual + 1)
 se usan para hacer el retraso.
    See https://github.com/LDmicro/LDmicro/wiki/DELAY-us


> Conversor de TIEMPO a RETRASO       Tconst
                                 -[T2DELAY 10 us]-

    La instruccin 'Convertidor de TIEMPO a RETARDO' obtiene el tiempo constante en 'nosotros',
 lo convierte al valor especfico de DELAY y lo guarda en la variable Tconst
 para usar como parmetro de la instruccin DELAY ms tarde.


> ASCENDENTE DE UN SOLO DISPARO (Franco)     _     _
                                        --[_/ OSR_/ \_]--

    Esta instruccin normalmente genera falso. Si la entrada de la instruccin
 es cierto durante este escaneo y fue falso durante el escaneo anterior
 entonces la salida es verdadera. Por lo tanto, genera una exploracin de pulso uno
 de ancho en cada borde ascendente de su seal de entrada, es decir, univibrador. Esta
 la instruccin es til si desea desencadenar eventos fuera del alza
 borde de una seal.


> DESCENDENTE CADA DE UN DISPARO  Franco)   _       _
                                          --[ \_OSF_/ \_]--

    Esta instruccin normalmente genera falso. Si la entrada de la instruccin
 es falso durante este escaneo y fue cierto durante el escaneo anterior
 entonces la salida es verdadera. Por lo tanto, genera una exploracin de pulso uno
 ancho en cada borde descendente de su seal de entrada, es decir, univibrador. Esta
 la instruccin es til si desea activar eventos de la cada
 borde de una seal.


                              Esto es la
 seal de entrada
                              v v
                                _     _
                           --[_/ OSR_/ \_]--
                              _       _
                           --[ \_OSF_/ \_]--
                                _   _   _
                           --[_/ ODR \_/ ]--
                              _     _   _
                           --[ \_ODF \_/ ]--

                                    ^   ^
                                    esto es la
 seal de salida




                     Nivel
                     Logico
                          ^  La duracin del pulso de entrada es de cinco ciclos.
                  OSR, OSF|     _________
                  Entrada | ___/         \_______
                          |
                  OSR     |     _
                  Salida  | ___/ \_______________
                          |
                  OSF     |               _
                  Salida  | _____________/ \_____
                        --+---------------------------> Tiempo
                          |
       Tiempo de ciclo del PLC N+ 0 1 2 3 4 5 6 7 8




                     Nivel
                     Logico
                          ^      Single-cycle input pulse
                  OSR, OSF|     _
                  Entrada | ___/ \_______
                          |
                  OSR     |     _
                  Salida  | ___/ \_______
                          |
                  OSF     |       _
                  Salida  | _____/ \_____
                        --+------------------> Tiempo
                          |
       Tiempo de ciclo del PLC  N+ 0 1 2 3 4 5 6


> ONE DROP if FALLING
> NIVEL BAJO DE UN DISPARO (Franco)      _     _   _
                                      --[ \_ODF \_/ ]--

    Esta instruccin normalmente emite ture. Si la entrada de la instruccin es
 falso durante este escaneo y fue cierto durante el escaneo anterior, entonces el
 La salida es falsa. Por lo tanto, genera un pulso de bajo nivel de un escaneo de ancho
 en cada borde descendente de su seal de entrada, es decir, univibrador. Esta
 la instruccin es til si desea desencadenar eventos fuera del lmite descendente
 de una seal



                      Nivel
                     Logico
                          ^  La duracin del pulso de entrada es de cinco ciclos.
                  ODF     | ___           _______
                  Entrada |    \_________/
                          |
                  ODF     | ___   _______________
                  Salida  |    \_/
                        --+---------------------------> Tiempo
                          |
       Tiempo de ciclo del PLC N+ 0 1 2 3 4 5 6 7 8



                     Nivel
                     Logico
                          ^     Pulso de entrada de ciclo nico
                  ODF     | ___   _______
                  Entrada |    \_/
                          |
                  ODF     | ___   _______
                  Salida  |    \_/
                        --+------------------> Tiempo
                          |
       Tiempo de ciclo del PLC N+ 0 1 2 3 4 5 6



> OSCILADOR                        _   _
                           --[OSC_/ \_/ \_]--

                             F=1/(2*Tcycle)


                     Nivel
                     Logico
                          ^  La duracin del pulso de entrada es de siete ciclos.
                  OSC     |     ____________
                 Entrada  | ___/            \_______
                          |
                  OSC     |     _   _   _
                  Salida  | ___/ \_/ \_/ \_____________
                          |
                        --+---------------------------> Tiempo
                          |
       Tiempo de ciclo del PLC N+ 0 1 2 3 4 5 6 7 8


    Si la seal de entrada es verdadera, esta instruccin produce un meandro con
 perodo (2 * tiempo de ciclo del PLC), es decir, multivibrador. Si la seal entra
 la instruccin es falsa, entonces la seal de salida es falsa.


> CIRCUITO CERRADO, CIRCUITO ABIERTO
                           ----+----+----      ----+     +----

    La condicin de salida de un cortocircuito es siempre igual a su
 Condicin de entrada. La condicin de salida de un circuito abierto es siempre
 falso. En su mayora son tiles para depurar, el corto temporal
 circuito o desconectar un circuito elctrico.

    Ver ms https://github.com/LDmicro/LDmicro/wiki/OPEN-CIRCUIT,-SHORT-CIRCUIT
    Nota: tenga en cuenta.
   || ; La demostracin de efectos secundarios.                          ||
   ||                                                          Y1        ||
   ||----------------------------------------------------------( )-------||
   || ; Y1 es 1.                                                         ||
   ||                                                                    ||
   ||    abierto                                               Y1        ||
   ||----+      +----------------------------------------------( )-------||
   || ; El elemento COIL (BOBINA) siempre establece la salida de acuerdo ||
 || ; con su entrada Y1 es 0 ahora.                                    ||
   ||                                                                    ||
   ||    Cerrado                                               Y1        ||
   ||----+----+------------------------------------------------( )-------||
   || ; Y1 vuelve a ser 1 otra vez                                       ||


> REL DE CONTROL MAESTRO
                           -{MASTER RLY}-

    Por defecto, la condicin de rengln de cada rengln es verdadera. Si un maestro
 la instruccin de rel de control se ejecuta con una condicin de rengln de
 falso, entonces la condicin de rengln para todos los renglones siguientes se convierte en
 falso. Esto continuar hasta el prximo rel de control maestro
 se alcanza la instruccin (independientemente de la condicin de rengln de ese
 instruccin). Por lo tanto, estas instrucciones deben usarse en pares:
 uno para (tal vez condicionalmente) iniciar la seccin posiblemente deshabilitada,
 y uno para terminarlo.
 Ver https://github.com/LDmicro/LDmicro/wiki/MASTER-CONTROL-RELAY


> MOVE MOVER                {MOV destvar:=}      {MOV  Tret :=}
                           -{          123}-    -{      srcvar}-

    Cuando la entrada a esta instruccin es verdadera, establece el valor dado
 variable de destino igual a la variable fuente dada o
 constante. Cuando la entrada a esta instruccin es falsa, nada
 sucede Puede asignar a cualquier variable con la instruccin de movimiento;
 Esto incluye variables de estado de contador y contador, que pueden ser
 distinguido por la principal 'T' o 'C'. Por ejemplo, una instruccin
 mover 0 a 'Tretentive' es equivalente a una instruccin de reinicio (RES)
 para ese temporizador Esta instruccin debe ser la instruccin ms a la derecha.
 en su peldao.


> OPERACIN ARITMTICA       {ADD  kay  :=}       {SUB  Ccnt :=}
                            -{ 'a' + 10   }-     -{ Ccnt - 10  }-

>                            {MUL  dest :=}       {DIV    dv :=}
                            -{ var * -990 }-     -{ dv / -10000}-

    Cuando la entrada a esta instruccin es verdadera, establece el valor dado
 variable de destino igual a la expresin dada. Los operandos
 pueden ser variables (incluidas las variables de temporizador y contador)
 o constantes Estas instrucciones usan matemtica firmada de 16 bits. Recuerda
 que el resultado se evala cada ciclo cuando la condicin de entrada
 cierto. Si est aumentando o disminuyendo una variable (es decir, si
 la variable de destino tambin es uno de los operandos) entonces usted
 probablemente no quiera eso; normalmente usaras un solo disparo para que
 se evala solo en el borde ascendente o descendente de la entrada
 condicin. La divisin se trunca; 7/3 = 2. Esta instruccin debe ser
 la instruccin ms a la derecha en su peldao.


> MODULO                   {MOD     dest:=}
                          -{src     %    2}-

    Resto de la divisin 7% 3 = 1
 Ver https://en.wikipedia.org/wiki/Modulo_operation


> NEGATIVO                 {NEG     dest:=}
                          -{         - src}-

    Negativo - {NEG a: = -a} - es el equivalente optimizado a - {SUB a: = 0 - a} -


> OPERATION bit A bit        {AND  var1 :=}       {OR   Ccnt :=}
                            -{var2 & var3 }-     -{ Ccnt | 0o07}-

>                            {XOR  dest :=}       {NOT  dv :=  }
                            -{ var ^ 0xAA }-     -{ ~0b11001100}-

    Cuando la entrada a esta instruccin es verdadera, establece el valor dado
 variable de destino igual a la expresin dada. Los operandos
 pueden ser variables (incluidas las variables de temporizador y contador)
 o constantes Recuerde que el resultado se evala en cada ciclo.
 cuando la condicin de entrada es verdadera.
 Por favor lee http://en.wikipedia.org/wiki/Bitwise_operation


> INTERCAMBIAR  bit A bit    {      dest:=}
                            -{SWAP     src}-

    Esta operacin intercambia los nibbles y los bytes.
 Ver https://en.wikipedia.org/wiki/Nibble
    Cuando el tamao de las variables es
    1 - luego, a nivel bit, intercambia los nibbles en un BYTE, es decir, 0x73 -> 0x37

                     MSB       bits       LSB
                      7  6  5  4  3  2  1  0
                      \________/  \________/
                             ^      ^
                             |      |
                             +------+
        Cambios de bits:
           7 <-> 3
           6 <-> 2
           5 <-> 1
           4 <-> 0

    2 - luego intercambie los bytes en una PALABRA, es decir 0x7733 -> 0x3377

            MSB                  bits                   LSB
             15 14 13 12 11 10 9 8  7  6  5  4  3  2  1  0
             \___________________/  \____________________/
                             ^           ^
                             |           |
                             +-----------+
        Cambios de bits:
          15 <-> 7
          14 <-> 6
             ...
           9 <-> 1
           8 <-> 0

    3 - luego, a nivel bit, intercambie los nibbles de 1 byte y los bytes 2 y 0 en un INT24, es decir, 0x775A33 -> 0x33A577

       MSB                             bits                          LSB
        23 22 21 20 19 18 17 16 15 14 13 12 11 10  9  8 7 6 5 4 3 2 1 0
        \_____________________/ \_________/ \_________/ \_____________/
                    ^                ^           ^             ^
                    |                |           |             |
                    |                +-----------+             |
                    +------------------------------------------+
        Cambios de bits:
          23 <->  7
             ...
          16 <->  0
          15 <-> 11
             ...
          12 <->  8

    4 - a continuacin, intercambie los bytes 3 y 0 y los bytes 2 y 1 en un DWORD, es decir, 0x7755AA33 -> 0x33AA5577

        MSB                                          bits                                  LSB
        31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
        \_____________________/ \_____________________/ \___________________/ \_____________/
                    ^                            ^           ^                     ^
                    |                            |           |                     |
                    |                            +-----------+                     |
                    +--------------------------------------------------------------+
        Cambios de bits:
          31 <->  7
             ...
          24 <->  0
          23 <-> 15
             ...
          16 <->  8


> bit A bit OPUESTO          {      dest:=}
                            -{OPPOSITE src}-

    Esta operacin invierte la secuencia de bits al contrario.
 El MSB se mueve al LSB, y el LSB se mueve al MSB y etc.

                     MSB      bits       LSB
                      n n-1 n-2 ... 2  1  0
                      ^  ^   ^      ^  ^  ^
                      |  |   |      |  |  |
                      |  |   +------+  |  |
                      |  +-------------+  |
                      +-------------------+


> CAMBIO ARITMTICO: SHL, SHR.   {SHL  var1 :=}     {SHR   cnt :=}
                                -{var2 << 2   }-   -{  cnt >>  1 }-

    Ver https://en.wikipedia.org/wiki/Arithmetic_shift

    SHL - desplazamiento aritmtico a la izquierda
        MSB                    LSB
             MSB-1         1    0
    C <- x <- x <- .... <- x <- x <- 0


    SHR - desplazamiento aritmtico a la derecha
        MSB                    LSB
             MSB-1         1    0
    /--> x -> x -> .... -> x -> x -> C
    \   /
     <--


    Nota: MSB = bit ms significativo, LSB = bit menos significativo


> CAMBIO LGICO A LA DERECHA SR0.  {SR0  dest :=}
                                  -{var  sr0  3 }-

    Ver https://en.wikipedia.org/wiki/Logical_shift

    SR0 - desplazamiento lgico a la derecha
        MSB                    LSB
             MSB-1         1    0
    0 -> x -> x -> .... -> x -> x -> C


    NOTA: El desplazamiento lgico a la izquierda es equivalente al desplazamiento aritmtico SHL a la izquierda.


> CAMBIO CIRCULAR: ROL, ROR.     {ROL  dest :=}     {ROR    dv :=}
                                -{ var rol 4  }-   -{var ror 4   }-

    Ver https://en.wikipedia.org/wiki/Circular_shift

    ROL - desplazamiento circular (rotacin bit a bit) a la izquierda
        MSB                    LSB
             MSB-1         1    0
    C <- x <- x <- .... <- x <- x
         v                      ^
         \_________>____________/


    ROR - desplazamiento circular (rotacin bit a bit) derecha
        MSB                    LSB
             MSB-1         1    0
         x -> x -> .... -> x -> x -> C
         ^                      v
         \_________<____________/

  SHL, SHR, SR0, ROL, ROR:
    Cuando la entrada a esta instruccin es verdadera, establece el valor dado
 variable de destino igual a la expresin dada. Los operandos
 pueden ser variables (incluidas las variables de temporizador y contador)
 o constantes Recuerde que el resultado se evala en cada ciclo.
 cuando la condicin de entrada es verdadera.


> OPERACIONES CON UN BIT    {           var}       {           var}
                           -{SET Bit    bit}-     -{CLR Bit    bit}-

    -{SET Bit var, bit}- En la variable 'var' establece el nmero de bit 'bit'.
    -{CLR Bit var, bit}- En la variable 'var', borre el nmero de bit 'bit'.

    'Bit' significa nmero de bit, no mscara de bit. Por ejemplo,
 configurar el bit nmero 4 en la variable 'var'
                      v
     Bit nmero:  76543210
     'var'      :  xxx1xxxx
                      ^
    debe escribir    ^
         {          var}               {             var}
        -{SET Bit     4}-        not  -{SET Bit     0x10}-

    y es equivalente a
         {OR     var :=}
        -{   var | 0x10}-


    Para borrar el bit nmero 4 en la variable 'var'
 debes escribir
         {          var}               {             var}
        -{CLR Bit     4}-        not  -{CLR Bit     0x10}-

    y es equivalente a
         {AND    var :=}
        -{   var & 0xEF}-

    var debe ser una variable, no un valor literal.
 El tamao de var debe ser de 1 a 4 bytes.
 El bit puede ser un nmero literal o una variable.
 el bit puede tener un valor de 0-7 si tamao de (var) == 1 byte,
 0-15 si tamao (var) == 2 bytes,
 0-23 si tamao (var) == 3 bytes,
 0-31 si tamao (var) == 4 bytes.

    Aprenda a usar SetBit (), ClearBit () para deshabilitar resistencias pull up
    vea https://github.com/LDmicro/LDmicro/wiki/Disable-Pull-up-resistors


> COMPARAR              [var ==]        [var >]        [1 >=]
                       -[ var2 ]-      -[ 1   ]-      -[ Ton]-

>                       [var !=]       [-4 <   ]       [1 <=]
                       -[ var2 ]-     -[ vartwo]-     -[ Cup]-

    Si la entrada a esta instruccin es falsa, la salida es falsa. Si
 la entrada es verdadera, entonces la salida es verdadera si y solo si
 La condicin es verdadera. Esta instruccin se puede usar para comparar (igual,
 es mayor que, es mayor o igual que, no es igual,
 es menor que, es menor o igual que) una variable a una variable,
 o para comparar una variable con una constante con signo de 16 bits.


> ESTADO DE PRUEBA DE UN BIT   [             var]       [             var]
                              -[if Bit SET   bit]-     -[if Bit CLR   bit]-

    Si la entrada a esta instruccin es falsa, la salida es falsa. Si
 la entrada es verdadera, entonces la salida es verdadera si y solo si
 La condicin es verdadera. Esta instruccin se puede usar solo para verificar el estado
 un bit de la variable
 'Bit' significa nmero de bit, no mscara de bit. Vea arriba la operacin del bit SET.

    La operacin - {si Bit SET var, 0} - es una condicin equivalente 'Si var es impar'.
La operacin - {si Bit CLR var, 0} - es una condicin equivalente 'Si var es par'.

    var debe ser una variable, no un valor literal.
 El tamao de var debe ser de 1 a 4 bytes.
 El bit puede ser un nmero literal o una variable.
 el bit puede tener un valor de 0-7 si tamao de (var) == 1 byte,
 0-15 si tamao de(var) == 2 bytes,
 0-23 si tamao de(var) == 3 bytes,
 0-31 si tamao de(var) == 4 bytes.


> CONTADOR                     Cname          Cname
                           --[CTU >= 5]--  --[CTD > -5]--

    Un contador aumenta (CTU, cuenta atrs) o disminuye (CTD, cuenta
 abajo) el recuento asociado en cada borde ascendente de la entrada de rengln
 condicin (es decir, la condicin de entrada del rengln va de falso a
 cierto). La condicin de salida del contador es verdadera si el contador
 variable CTU> = 5 (CTD> -5), y falso en caso contrario. los
 la condicin de salida del rengln puede ser verdadera incluso si la condicin de entrada es
 falso; solo depende de la variable del contador. Puedes tener CTU
 y las instrucciones CTD con el mismo nombre, para incrementar y
 disminuir el mismo contador. La instruccin RES puede restablecer un contador,
 o puede realizar operaciones de variables generales en la variable de conteo.


> CONTADOR CIRCULAR            Cname             Cname
                           --{CTC 0:7}--     --{CTR 7:0}--

    Un contador circular funciona como un contador CTU normal, excepto que
 despus de alcanzar su lmite superior, restablece su variable de contador
 volver a 0. Por ejemplo, el contador que se muestra arriba contara 0, 1,
 2, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, ... Esto es til en
 combinacin con declaraciones condicionales en la variable 'Cname';
 puedes usar esto como un secuenciador. Contadores CTC reloj en aumento
 borde de la condicin de condicin de entrada de rengln.
 Obsoleto: esta instruccin debe ser la instruccin ms correcta en su peldao.

    CTR es contador circular reversible. igual CTC pero con decremento
 contando por dentro. Por ejemplo, el contador que se muestra arriba contara
 7, 6, 5, 4, 3, 2, 1, 0, 7, 6, 5, 4, 3, 2, 1, 0, 7, ...

   Se agreg el valor 'Inicio' en los contadores CTU, CTD, CTC, CTR.
 La CTU, el contador CTC comienzan desde 'Inicio' y cuentan hasta el valor 'Mx.'
 CTC genera impulso de sobrellenado (carry) cuando Counter == Max.
 Para el trabajo adecuado, el valor 'Inicio' debe ser menor que el valor 'Mx.'

    El contador CTD, CTR comienza desde 'Inicio' y cuenta atrs hasta el valor 'Min'.
 El CTR genera un impulso de sobrellenado (prstamo) cuando el Contador == Min.
 Para el trabajo adecuado, el valor 'Inicio' debe ser mayor que el valor 'Mnimo'.

   ||   Rnew      Tnew                                    Rnew      ||
   ||----] [----[TON 1 s]----------------------------------(/)------||
   ||                                                               ||
   ||                                                               ||
   ||   Rnew       Css           Cmm          Chh         Cdays     ||
   ||----] [----[CTC 0:59]---[CTC 0:59]---[CTC 0:23]---[CTC 0:364]--||
   ||                                                               ||

    Actualizado en la versin 4.4.1.0
 Tipo de entradas de elementos de escalera
    https://github.com/LDmicro/LDmicro/wiki/Kind-of-inputs-of-ladder-elements

   ||                               ||
   ||  X1          CTU1:0      Y1   ||
   ||--] [---+---/[CTU>=10]----( )--|| '/' Entrada dinmica activa en 0 a 1
 ||        |                      || transicin para la lgica positiva.
   ||        |     CTU2:0      Y2   ||
   ||        +---\[CTU>=10]----( )--|| '\' Entrada dinmica activa en 1 a 0
   ||        |                      || transicin para la lgica positiva.
   ||        |     CTU3:0      Y3   ||
   ||        +----[CTU>=10]----( )--|| '-' Entrada lgica esttica directa.
   ||        |                      || Activo en el exterior 1.
   ||        |     CTU4:0      Y4   ||
   ||        +---o[CTU>=10]----( )--|| 'o' Entrada lgica esttica inversa.
   ||                               || Negacin lgica en la entrada.
   ||                               || Externo 0 produce interno 1.

    Nota: Los contadores de versiones anteriores tienen la entrada dinmica "/".
 Estos dos peldaos son equivalentes en la nueva versin.
   ||                                                   ||
   ||       X1               C1                         ||
   ||-------] [----------/[CTC  0:9]---                 ||
   ||                                                   ||
   ||                                                   ||
   ||       X1             _     _            C2        ||
   ||-------] [---------[_/ OSR_/ \_]------[CTC  0:9]---||
   ||                                                   ||

    '-/' es una entrada positiva activada por flanco (flanco ascendente).
    '-\' es una entrada de activacin por flanco negativo (flanco descendente).
    '--' es entrada esttica activa de alto nivel.
    '--' es entrada esttica, activa a un nivel alto.
    '-o' es entrada esttica, activa a un nivel bajo.


> REGISTRO DE DESPLAZAMIENTO      {SHIFT REG   }
                                 -{ reg0..3    }-

   Un registro de desplazamiento est asociado con un conjunto de variables. Por ejemplo,
 este registro de desplazamiento est asociado con las variables `reg0 ',` reg1',
 `reg2 'y` reg3'. La entrada al registro de desplazamiento es 'reg0'. En
 cada borde ascendente de la condicin de rengln, el registro de desplazamiento
 Desplazar a la derecha. Eso significa que asigna `reg3: = reg2 ',` reg2: =
 reg1 '. y `reg1: = reg0 '. `reg0 'no se modifica. Un gran turno
 registrarse puede consumir fcilmente mucha memoria. Esta instruccin debe
 ser la instruccin ms correcta en su peldao.

> TABLA DE BSQUEDA         {dest :=     }
                           -{ LUT[i]     }-

    Una tabla de bsqueda es un conjunto ordenado de n valores. Cuando el peldao
 condicin es verdadera, la variable entera 'dest' se establece igual a la
 entrada en la tabla de bsqueda correspondiente a la variable entera
 'i'. El ndice comienza desde cero, por lo que 'i' debe estar entre 0 y
 (n-1) El comportamiento de esta instruccin no se define si el
 El ndice est fuera de este rango. Esta instruccin debe ser la ms a la derecha
 en su peldao.

    Ver https://github.com/LDmicro/LDmicro/wiki/HOW-TO:-Look-Up-Table,-UART-SEND


> TABLA LINEAL POR TRAMOS   {yvar :=     }
                           -{ PWL[xvar]  }-

    Esta es una buena manera de aproximar una funcin complicada o
 curva. Podra, por ejemplo, ser til si est intentando aplicar
 una curva de calibracin para convertir un voltaje de salida sin procesar de un sensor
 en unidades ms convenientes.

    Suponga que est intentando aproximar una funcin que convierte
 una variable de entrada entera, x, a una variable de salida entera, y. T
 Conocer la funcin en varios puntos; por ejemplo, podras saber que

        f(0)   = 2
        f(5)   = 10
        f(10)  = 50
        f(100) = 100

    Esto significa que los puntos

        (x0, y0)   = (  0,   2)
        (x1, y1)   = (  5,  10)
        (x2, y2)   = ( 10,  50)
        (x3, y3)   = (100, 100)

    Acustate en esa curva. Puedes ingresar esos 4 puntos en una tabla
 asociado con la instruccin lineal por partes. El lineal por partes
 la instruccin analizar el valor de xvar y establecer el valor de
 Yvar. Establecer yvar de tal manera que la curva lineal por partes
 pasar por todos los puntos que le des; por ejemplo,
 si configura xvar = 10, entonces la instruccin establecer yvar = 50.

    Si le da a la instruccin un valor de xvar que se encuentra entre dos
 de los valores de x para los que le ha dado puntos, entonces el
 la instruccin establecer yvar para que (xvar, yvar) quede en la recta
 lnea que conecta esos dos puntos en la tabla. Por ejemplo, xvar =
 55 da una salida de yvar = 75. (Los dos puntos en la tabla son
 (10, 50) y (100, 100). 55 est a medio camino entre 10 y 100, y 75
 est a medio camino entre 50 y 100, entonces (55, 75) se encuentra en la lnea que
 conecta esos dos puntos).

    Los puntos deben especificarse en orden ascendente por coordenada x. Eso
 puede no ser posible realizar operaciones matemticas requeridas para
 ciertas tablas de bsqueda que usan matemtica entera de 16 bits; si este es el
 caso, entonces LDmicro te avisar. Por ejemplo, esta tabla de consulta
 producir un error:

        (x0, y0)    = (  0,   0)
        (x1, y1)    = (300, 300)

    Puede corregir estos errores haciendo la distancia entre puntos en
 La mesa ms pequea. Por ejemplo, esta tabla es equivalente a la tabla
 dado anteriormente, y no produce un error:

        (x0, y0)    = (  0,   0)
        (x1, y1)    = (150, 150)
        (x2, y2)    = (300, 300)

    Casi nunca debera ser necesario usar ms de cinco o seis
 puntos. Agregar ms puntos hace que su cdigo sea ms grande y ms lento
 ejecutar. El comportamiento si pasa un valor de 'xvar' mayor que
 la coordenada x ms grande en la tabla o menos que la x ms pequea
 La coordenada en la tabla no est definida. Esta instruccin debe ser la
 instruccin ms correcta en su peldao.


> CONVERTIDOR A/D LEER           Aname
                           --{READ ADC}--

    LDmicro puede generar cdigo para usar los convertidores A / D integrados en
 ciertos microcontroladores. Si la condicin de entrada a esta instruccin
 es cierto, se adquiere una sola muestra del convertidor A / D y
 almacenado en la variable 'Aname'. Esta variable puede ser posteriormente
 manipulado con operaciones variables generales (menor que, mayor que,
 aritmtica, y as sucesivamente). Asigne un pin a la variable 'Axxx' en el
 de la misma manera que asignaras un pin a una entrada o salida digital,
 haciendo doble clic en la lista en la parte inferior de la pantalla. Si
 la condicin de entrada a este rengln es falsa, entonces la variable 'Aname'
 se deja sin cambios.

    Para todos los dispositivos compatibles actualmente, la entrada de 0 voltios corresponde a
 una lectura de ADC de 0 y una entrada igual a Vdd (la tensin de alimentacin)
 corresponde a una lectura de ADC de 1023. Si est utilizando un AVR, entonces
 conecta AREF a Vdd. Puede usar operaciones aritmticas para escalar el
 leer a las unidades ms convenientes despus, pero recuerde que usted
 estn usando matemticas enteras. En general, no todos los pines estarn disponibles
 para usar con el convertidor A/D. El software no te permitir
 asignar pines que no sean A/D a una entrada analgica. Esta instruccin debe ser
 la instruccin ms a la derecha en su peldao.

    Actualizado: Referencia de voltaje ADC.
 El voltaje de referencia para el ADC (Vref) indica la conversin
 gama para el ADC. Los canales de un solo extremo que excedan Vref resultarn
 en cdigos cercanos a 0x3FF (1023). Vref se puede seleccionar como AVCC,
 referencia interna de 2.56V, referencia interna de 1.1V o pin externo Aref.
 El parmetro REFS = 0 es compatible con versiones anteriores de LDmicro.

    Ver https://github.com/LDmicro/LDmicro/wiki/ADC-Voltage-Reference
    https://github.com/LDmicro/LDmicro/wiki/How-to-measure-battery-voltage
    https://github.com/LDmicro/LDmicro/wiki/How-to-measure-voltage-(PIC)


> CONFIGURAR EL CICLO DE TRABAJO PWM     duty_cycle  3.8 kHz
                                       -{PWM            PWM1}-

    LDmicro puede generar cdigo para usar el perifrico PWM integrado en
 ciertos microcontroladores. Si la condicin de entrada a esta instruccin
 es cierto, entonces el ciclo de trabajo del perifrico PWM se establece en
 valor de la variable duty_cycle.
 Actualizado: LDmicro v4.3.5 permite seleccionar una resolucin PWM ms alta:
 0-100% (resolucin mxima de 6,7 bits)
 0-256 (resolucin mxima 8 bits)
 0-512 (resolucin mxima 9 bits)
 0-1024 (resolucin mxima 10 bits)
 El ciclo de trabajo debe ser un nmero entre 0 y 100/256/512/1024;
 0 corresponde a siempre bajo, y 100/256/512/1024 corresponde a
 siempre alto. (Si est familiarizado con el funcionamiento del perifrico PWM,
 luego observe que eso significa que LDmicro escala automticamente
 ciclo de trabajo variable desde porcentaje (o valor binario) hasta perodos de reloj PWM).

    Puede especificar la frecuencia PWM objetivo, en Hz. La frecuencia que
 que especifique podra no ser exactamente posible, dependiendo de cmo
 se divide en la frecuencia de reloj del microcontrolador. LDmicro will
 elija la frecuencia alcanzable ms cercana; si el error es grande entonces
 Te lo advertir. Las velocidades ms rpidas (frecuencia PWM) pueden sacrificar la resolucin.

    Esta instruccin debe ser la instruccin ms a la derecha en su peldao.
 El tiempo de ejecucin de la lgica de escalera consume un temporizador para medir el ciclo
 hora. Eso significa que PWM solo est disponible en microcontroladores
 con al menos dos temporizadores adecuados. PWM usa el pin CCP2 (no CCP1)
 en chips PIC16 y OC1B (no OC1A) en AVR.

    Actualizado: LDmicro v4.x.x permite todo el hardware PWM.
    Ver https://github.com/LDmicro/LDmicro/wiki/LDmicro-PWM

    Puede establecer otra frecuencia base de PWM solo despus de activar RESET PWM.
 Ver RESET PWM arriba.


> HACER PERSISTENTE          saved_var
                           --{PERSIST}--

    Cuando la condicin de entrada de esta instruccin es verdadera, causa la
 La variable entera especificada se guardar automticamente en EEPROM. Ese
 significa que su valor persistir, incluso cuando el micro pierde
 poder. No hay necesidad de guardar explcitamente la variable en EEPROM;
 eso suceder automticamente, siempre que cambie la variable.
 La variable se carga automticamente desde EEPROM despus del reinicio de encendido. Si
 una variable que cambia con frecuencia se hace persistente, luego en
 La EEPROM en su micro puede desgastarse muy rpidamente, porque eso no es
 bueno para un nmero limitado (~ 100 000) de escrituras. Cuando el peldao
 la condicin es falsa, no pasa nada. Esta instruccin debe ser la
 instruccin ms a la derecha en su peldao.

    Ver https://github.com/LDmicro/LDmicro/wiki/MAKE-PERSISTENT-operation


> UART (SERIE) RECIBIR           var
                           --{UART RECV}--

    LDmicro puede generar cdigo para usar el UART integrado en ciertos
 microcontroladores. En AVR con mltiples UART solo UART1 (no
 UART0) es compatible. Configure la velocidad en baudios usando Configuracin -> MCU
 Parmetros Ciertas velocidades de transmisin pueden no ser alcanzables con ciertas
 frecuencias de cristal; LDmicro te avisar si este es el caso.

    Si la condicin de entrada a esta instruccin es falsa, entonces nada
 sucede Si la condicin de entrada es verdadera, esta instruccin intenta
 recibir un solo caracter de la UART. Si no se lee ningn caracter
 entonces la condicin de salida es falsa. Si se lee un personaje, entonces su
 El valor ASCII se almacena en `var ', y la condicin de salida es verdadera
 para un solo ciclo de PLC.


> UART (SERIE) ENVO             var
                           --{UART SEND}--

    LDmicro puede generar cdigo para usar los UART integrados en ciertos
 microcontroladores. En AVRS con mltiples UART solo UART1 (no
 UART0) es compatible. Configure la velocidad en baudios usando Configuracin -> MCU
 Parmetros Ciertas velocidades de transmisin pueden no ser alcanzables con ciertas
 frecuencias de cristal; LDmicro te avisar si este es el caso.

    Si la condicin de entrada a esta instruccin es falsa, entonces nada
 sucede Si la condicin de entrada es verdadera, entonces esta instruccin escribe
 un solo caracter para el UART. El valor ASCII del personaje a
 send debe haberse almacenado previamente en 'var'. La condicin de salida
 del peldao es verdadero si el UART est ocupado (actualmente transmitiendo un
 carcter), y falso de lo contrario.

    Recuerda que los caracteres tardan un poco en transmitirse. Hay varios
 formas de organizar la transmisin:
    1) Use el tiempo de ciclo del PLC, que es conscientemente mayor que el tiempo de transmisin UART.
   ||                                                               ||
   || ; El tiempo de ciclo del PLC es de 10 ms.                     ||
   || ; La velocidad de transmisin UART es de 9600 bps.            ||
   ||                                                               ||
   || ; En este caso, hay una reserva de tiempo diez veces mayor.   ||
   || ; La secuencia de caracteres se transmitir sin prdida.      ||
   ||                                                               ||
   || ; 1 2 3 4 5 6 7 8 9 10 11 12 ...                              ||
   ||                                                               ||
   ||                                              {ADD     char:=} ||
   ||----------------------------------------------{char    +    1}-||
   ||                                                               ||
   ||      char                                                     ||
   ||---{UART SEND}---                                              ||
   ||                                                               ||

    2) Use temporizadores para insertar retrasos entre caracteres. El retraso del temporizador debe ser
 ms largo que el tiempo de transmisin UART.
   ||                                                                    ||
   || ; El tiempo de ciclo del PLC es de 1 ms.                           ||
   || ; La velocidad de transmisin UART es de 9600 bps.                 ||
   ||                                                                    ||
   || ; En este caso, hay una reserva de cinco veces.                    ||
   || ; La secuencia de caracteres se transmitir sin prdida.           ||
   ||                                                                    ||
   || ; char1 char2 char3   char1 char2 char3   char1 char2 char3   ...  ||
   || ; 1     5     10      2     10    20      3     15    30      ...  ||
   ||                                                                    ||
   ||       T0                                               Rstart      ||
   ||---[TCY 15 ms]--------------------------------------------( )-------||
   ||                                                                    ||
   ||                                                                    ||
   ||     Rstart             T1             _     _     {ADD    char1:=} ||
   ||-------] [----------[RTO 5 ms]------[_/ OSR_/ \_]-+{char1    +   1}-||
   ||                                                  |                 ||
   ||                                                  |      char1      ||
   ||                                                  +---{UART SEND}---||
   ||                                                                    ||
   ||                                                                    ||
   ||     Rstart             T2             _     _     {ADD    char2:=} ||
   ||-------] [----------[RTO 10 ms]-----[_/ OSR_/ \_]-+{char2    +   5}-||
   ||                                                  |                 ||
   ||                                                  |      char2      ||
   ||                                                  +---{UART SEND}---||
   ||                                                                    ||
   ||                                                                    ||
   ||     Rstart             T3             _     _     {ADD    char3:=} ||
   ||-------] [----------[RTO 15 ms]-----[_/ OSR_/ \_]-+{char3   +   10}-||
   ||                                                  |                 ||
   ||                                                  |      char3      ||
   ||                                                  +---{UART SEND}---||
   ||                                                  |                 ||
   ||                                                  |       T1        ||
   ||                                                  +------{RES}------||
   ||                                                  |                 ||
   ||                                                  |       T2        ||
   ||                                                  +------{RES}------||
   ||                                                  |                 ||
   ||                                                  |       T3        ||
   ||                                                  +------{RES}------||
   ||                                                                    ||

    3) Verifique la condicin de salida de esta instruccin para asegurarse de que
 el carcter anterior se ha transmitido antes de intentar enviar un siguiente
 Caracter. Solo debe hacer que la condicin de entrada sea verdadera (intente enviar
 un carcter) cuando la condicin de salida es falsa (UART no est ocupado).
   ||                                                            ||
   || ; El tiempo de ciclo del PLC y la velocidad de             ||
   || ; transmisin UART son independientesy puede ser diferente ||
   ||                                                            ||
   || ; 1 2 3 4 5 6 7 8 9 10 11 12 ...                           ||
   ||                                                            ||
   ||      Rbusy                                {ADD     DATA:=} ||
   ||-------]/[------+--[_/ OSR_/ \_]-----------{DATA    +    1}-||
   ||                |                                           ||
   ||                |      DATA                      Rbusy      ||
   ||                +---{UART SEND}-------------------( )-------||
   ||                                                      ||


   ||                                                                       ||
   || ; DATA1 DATA2   DATA1 DATA2   DATA1 DATA2   ...                       ||
   || ; 1     10      2     20      3     30      ...                       ||
   ||                                                                       ||
   ||   Rbusy        DATA1       _       _        DATA2          Rbusy      ||
   ||----]/[--+---{UART SEND}---[ \_OSF_/ \_]--{UART SEND}--------( )-------||
   ||         |                                                             ||
   ||         |     _     _                                {ADD    DATA1:=} ||
   ||         +--[_/ OSR_/ \_]-+---------------------------{DATA1    +   1}-||
   ||                          |                                            ||
   ||                          |                           {ADD    DATA2:=} ||
   ||                          +---------------------------{DATA2   +   10}-||
   ||                                                                       ||

    4) Use el mensaje 'UART SEND: est listo?' instruccin antes de UART ENVIAR a los cheque
 El estado UART.
   ||                                                    ||
   || ; 0 1 2 3 4 5 6 7 8 9 10 11 12 ...                 ||
   ||                                                    ||
   ||    Is ready?          DATA                         ||
   ||---[UART SEND]--+---{UART SEND}---------------------||
   ||                |                                   ||
   ||                |                  {ADD     DATA:=} ||
   ||                +------------------{DATA    +    1}-||
   ||                                                    ||
    Ver: UART communication FAQ
    https://github.com/LDmicro/LDmicro/wiki/UART-communication-FAQ

    Actualizado: las instrucciones UART RECEIVE, UART SEND pueden recibir / enviar ms
 que las variables de longitud de un byte. Parmetro "Nmero de bytes a transmitir:"
 debe ser menor o igual al tamao de la variable utilizada. El valor de 1 byte es
 compatible con la versin anterior de LDmicro.
 El parmetro "Esperar hasta que se transmitan todos los bytes:" controla el algoritmo
 de la transmisin: si 1 - todos los bytes se transmiten en un paquete,
 si 0: un byte por ciclo de PLC. Cuando todos los bytes se han transmitido,
 la condicin de salida es "verdadera" durante un ciclo de PLC. El valor 0 es
 compatible con la versin anterior de LDmicro.
 Consulte: Preguntas frecuentes sobre comunicacin UART, parte 2
    https://github.com/LDmicro/LDmicro/wiki/UART-communication-FAQ-part-2

    Investigue la instruccin de cadena formateada (siguiente) antes de usar esto
 instruccin. La instruccin de cadena formateada es mucho ms fcil de usar,
 y es casi seguro que es capaz de hacer lo que quieras.

    Vea https://github.com/LDmicro/LDmicro/wiki/HOW-TO:-Look-Up-Table,-UART-SEND


> ENVO UART (SERIE)             var
                           --{UART SENDn}--

    Si la condicin de entrada a esta instruccin es falsa, entonces nada
 sucede Si la condicin de entrada es verdadera, entonces esta instruccin escribe
 una variable a la UART en formato binario sin formato. Un byte enva por ciclo
 de PLC, como el elemento 'FORMATO STR OVER UART'. La condicin de salida
 del peldao es verdadero si el UART est ocupado (actualmente transmitiendo un
 variable), y falso de lo contrario.


> ENVO UART: est listo ?     Is ready?
                           --[UART SEND]--

    Si la condicin de entrada a esta instruccin es falsa, entonces nada
 sucede Si la condicin de entrada es verdadera, entonces la salida es verdadera
 cuando el bfer de transmisin est vaco y listo para cargar nuevos datos,
 y falso de lo contrario.


> UART RECV: est disponible?    Is avail?
                              --[UART RECV]--

    Si la condicin de entrada a esta instruccin es falsa, entonces nada
 sucede Si la condicin de entrada es verdadera, la salida es verdadera cuando
 hay datos no ledos en el bfer de recepcin y falsos de lo contrario.


> CADENA FORMATEADA SOBRE UART             var
                                   -{"Pressure: \3\r\n"}-

    LDmicro puede generar cdigo para usar los UART integrados en ciertos
 microcontroladores. En AVRS con mltiples UART solo UART1 (no
 UART0) es compatible. Configure la velocidad en baudios usando Configuracin -> MCU
 Parmetros Ciertas velocidades de transmisin pueden no ser alcanzables con ciertas
 frecuencias de cristal; LDmicro te avisar si este es el caso.

    Cuando la condicin de entrada para esta instruccin pasa de falso a
 Es cierto, comienza a enviar una cadena completa a travs del puerto serie. Si
 la cadena contiene la secuencia especial `\ 3 ', entonces esa secuencia
 ser reemplazado con el valor de 'var', que es automticamente
 convertido en una cadena. La variable se formatear para tomar
 exactamente 3 caracteres; por ejemplo, si 'var' es igual a 35, entonces
 la cadena exacta impresa ser 'Presin: 35 \ r \ n' (tenga en cuenta el extra
 espacio). Si, en cambio, 'var' fuera igual a 1432, entonces el comportamiento sera
 ser indefinido, porque 1432 tiene ms de tres dgitos. En ese caso
 sera necesario usar `\ 4 'en su lugar.

    Si la variable puede ser negativa, use `\ -3d '(o` \ -4d'
 etc.) en su lugar. Eso har que LDmicro imprima un espacio lder para
 nmeros positivos y un signo menos inicial para nmeros negativos.

    Si se activan varias instrucciones de cadena formateadas a la vez
 (o si uno se energiza antes de que otro complete), o si estos
 las instrucciones se entremezclan con las instrucciones UART TX, luego el
 El comportamiento es indefinido.

    Tambin es posible usar esta instruccin para generar una cadena fija,
 sin interpolar el valor de una variable entera en el texto que
 se enva por serie. En ese caso, simplemente no incluya el especial
 secuencia de escape.

    La condicin de salida de esta instruccin es verdadera mientras es
 transmisin de datos, de lo contrario falso. Esta instruccin consume un muy
 gran cantidad de memoria de programa, por lo que debe usarse con moderacin. los
 La implementacin actual no es eficiente, pero una mejor ser
 requieren modificaciones a todos los back-end.

   Use `\\'para una barra invertida literal. Adems de la secuencia de escape
 para interpolar una variable entera, el siguiente control
 los caracteres estn disponibles:

         Escape       Hex         Carcter
         Secuencia    Valor       Representado

         \a          0x07        BEL, alerta (pitido, campana)
         \b          0x08        BS, Retroceso (Escape)
         \e          0x1B        carcter de escape
         \f          0x0C        FF, Formfeed
         \n          0x0A        NL,Nueva lnea (avance de lnea)
         \r          0x0D        CR, Retorno de carro
         \t          0x09        HT, TAB, Pestaa horizontal
         \v          0x0B        VT, Pestaa vertical
         \'          0x27        Comillas simples
         \"          0x22        Comillas dobles
         \?          0x3F        Signo de interrogacin
         \\          0x5C        Barra invertida
         \xhh        any         El byte cuyo valor numrico viene dado por
                                 hh: interpretado como un nmero hexadecimal
                                 del rango 0x00..0xFF (hex), 0..255 (dec)
         por ejemplo
 \xAB es un carcter con valor ASCII 0xAB (hexadecimal)

      Vea https://en.m.wikipedia.org/wiki/Escape_sequences_in_C

    ------------------------------ Cdigos de control ASCII -------------------------------------
    |Dec Hex Ctl  Nombre Significado del control      |Dec Hex Ctl  Nombre  Significado de Control
    |--- --- ---  ---- ---------------------------  |--- --- ---  ---- -------------------------------
    |  0  00  ^@  NUL  nulo (cadena final)          | 16  10  ^P  DLE   escape de lnea de datos
    |  1  01  ^A  SOH  inicio de encabezamiento     | 17  11  ^Q  DC1   dev ctrl 1 (X-ON)
    |  2  02  ^B  STX  inicio de texto              | 18  12  ^R  DC2   Ctrl 2 del dispositivo
    |  3  03  ^C  ETX  fin del texto                | 19  13  ^S  DC3   dev  ctrl 3 (X-OFF)
    |  4  04  ^D  EOT  fin de la transmisin        | 20  14  ^T  DC4   Ctrl 4 del dispositivo
    |  5  05  ^E  ENQ  peticin                     | 21  15  ^U  NAK   reconocimiento negativo
    |  6  06  ^F  ACK  reconocer                    | 22  16  ^V  SYN   inactivo sncrono
    |  7  07  ^G  BEL  campana                \a    | 23  17  ^W  ETB   bloque de transmisin final
    |  8  08  ^H  BS   retroceso              \b    | 24  18  ^X  CAN   cancelar
    |  9  09  ^I  HT   Pestaa horizontal TAB \t    | 25  19  ^Y  EM    fin del medio
    | 10  0a  ^J  LF   linea de alimentacin  \n    | 26  1a  ^Z  SUB   sustituir
    | 11  0b  ^K  VT   pestaa vertical       \v    | 27  1b  ^[  ESC   escape (Salir)
    | 12  0c  ^L  FF   alimentacin de formulario \ | 28  1c  ^\  FS    separador de archivos
    | 13  0d  ^M  CR   retorno de carro   \r        | 29  1d  ^]  GS    separador de grupo
    | 14  0e  ^N  SO   desplazar fuera              | 30  1e  ^^  RS    separador de registros
    | 15  0f  ^O  SI   desplazar dentro             | 31  1f  ^_  US    separador de unidad


> SPI ENVIAR / RECIBIR          {SPI       SPI}
                               -{->recv send->}-

    Las funciones SPI solo estn disponibles en el modo 'C', es decir, mediante la compilacin de C,
 solo para ARM de 32 bits y AVR de tipo AtMega. Solo se puede usar un SPI
 en una misma escalera, llamada SPI, o SPI1, SPI2, SPI3 cuando hay varios
 disponible en el micro. SPI funciona solo en modo maestro, 8 bits de datos, con
 MSB primero, y su frecuencia se establece en el panel de configuracin del micro
 en ldmicro. El pin SS se maneja para AVR pero no para ARM. Uno puede usar externo
 pines para activar / desactivar los esclavos en el bus SPI, y / o pin SS.
 En un SPI, el envo y la recepcin son simultneos, es por eso que ambas operaciones
 se combinan en una sola funcin.


> SPI ESCRIBIR                  {SPI_WR     SPI}
                               -{   "Message"->}-

    La funcin Escribir SPI enva una cadena a travs de SPI, sin importar los datos entrantes.
 La cadena puede contener caracteres especiales introducidos por \\. No abuses de esto
 funcin, porque SPI puede ralentizar el programa y generar tiempos de ciclo
 problemas!

    NTESE BIEN:
    Las funciones SPI utilizan bibliotecas C externas (suministradas) que deben compilarse
 con el programa C principal generado por ldmicro al compilar a travs de mens ldmicro
 <Compilar Atmel AVR-GCC> o <Compilar ARM-GCC>, seguido de un <FlashMCU>
 comando para construir el ejecutable .hex y, si est bien configurado, cargarlo
 ejecutable en el objetivo AVR o ARM.


> I2C LEER                      {I2C_RD    I2C}
                               -{->recv 0x20 0}-

    Las funciones I2C solo estn disponibles en el modo 'C', es decir, mediante la compilacin de C,
 solo para ARM de 32 bits y AVR de tipo AtMega. Solo se puede usar un bus I2C
 en una misma escalera, llamada I2C, o I2C1, I2C2, I2C3 cuando hay varios
 disponible en el micro. I2C funciona solo en modo maestro y puede acceder a cualquier
 registrarse (basado en 0) en cualquier direccin (1-127) en el bus I2C.
 La frecuencia I2C se configura en el panel de configuracin del micro.
 La funcin I2C READ lee un byte en un registro en el esclavo en la direccin dada.


> I2C ESCRIBIR                  {I2C_WR    I2C}
                               -{0x20 0 send->}-

   La funcin I2C WRITE escribe un byte en un registro en el esclavo en la direccin dada.

    NTESE BIEN:
    Las funciones I2C utilizan bibliotecas C externas (suministradas) que deben compilarse
 con el programa C principal generado por ldmicro al compilar a travs de mens ldmicro
 <Compilar Atmel AVR-GCC> o <Compilar ARM-GCC>, seguido de un <FlashMCU>
 comando para construir el ejecutable .hex y, si est bien configurado, cargarlo
 ejecutable en el objetivo AVR o ARM.


> CADENA FORMATEADA                         dest
                                       -{"string", var}-

    Para objetivos como Netzer con implementaciones de printf ya presentes
 Esta instruccin puede ser utilizada.

    Cuando la condicin de entrada para esta instruccin pasa de falso a
 Es cierto, comienza a procesar la cadena con printf y escribe el resultado
 al registro de destino dado.

   Incrusta completamente la cadena dada en la imagen resultante.

    La variable dada puede ser cualquier registro del programa. Es
 utilizado como marcador de posicin para imprimirf. La funcin printf accede
 el registro si se encuentra algn marcador de posicin de estilo printf (es decir,% d).

    Dest es un registro donde se escribe el resultado. Esto debera
 ser la entrada superior de una memoria intermedia o circular.

    La condicin de llamada de esta instruccin es siempre cierta.


> CLRWDT
                           --{CLRWDT}--

    Cuando la condicin de entrada de esta instruccin es verdadera, causa la
 borrar el temporizador WDT. LDmicro ejecuta el comando CLRWDT en cada ciclo del PLC
 automticamente (al comienzo del ciclo), por lo que necesita CLRWDT adicional
 si el perodo de ciclo del PLC es mayor que el perodo WDT si WDT est habilitado
 Esta instruccin debe ser la instruccin ms a la derecha en su peldao.


> LOCK (BLOQUEAR)
                           --{LOCK}--

    Cuando la condicin de entrada de esta instruccin es verdadera, causa la
 Comando LOCK. Es un artificial
 situacin para provocar el reinicio de WDT (si WDT est habilitado). Comando LOCK
 diseado como bucle infinito. Es punto muerto, forma de congelar, bloquear el
 programa.
 El comando LOCK ejecuta goto a la direccin actual, es decir
 labelN: goto labelN (label02: rjmp label02), es decir, bucle infinito.
 El comando LOCK ejecuta el bucle infinito, pero WDT puede restablecer la MCU.
 Solo WDT o reinicio externo pueden descongelar el programa despus del comando LOCK.


> SLEEP (DORMIR)
                           --{SLEEP}--

    Cuando la condicin de entrada de esta instruccin es verdadera,
 se configura el modo SLEEP (apagado). Se utiliza para ahorrar energa.
 en suministro de batera.
 PIC: Despertar desde el sueo debido a una interrupcin externa en el borde ascendente del pin RB0 / INT.
 PIC10xxxx: Despertar desde el modo de suspensin en el cambio de pin GP0, GP1, GP3.
 AVR: Despertar desde el sueo debido a una interrupcin externa en el borde ascendente de los pines PD2 / INT0, PD3 / INT1.
 La operacin SLEEP no afecta los pines MCU IO y otras operaciones LDmicro.
 Nota: SLEEP alarga el tiempo del ciclo del PLC y los temporizadores TON, TOF, RTO, CTY.
 Esto puede frustrar los planes, romper el flujo de trabajo.
 Esta instruccin debe ser la instruccin ms correcta en su peldao.


>LABEL, GOTO, SUBPROG, RETURN, ENDSUB, GOSUB

    LABEL y GOTO instruccines
    https://github.com/LDmicro/LDmicro/wiki/GOTO-instruction

    SUBPROG, RETURN, ENDSUB and GOSUB, LABEL y GOTO instruccines. Part 2
    https://github.com/LDmicro/LDmicro/wiki/SUBPROG,-RETURN,-ENDSUB-and-GOSUB,-LABEL-and-GOTO-instruction.-Part-2

    SUBPROG, RETURN, ENDSUB and GOSUB, LABEL y GOTO instruccines. Part 3
    https://github.com/LDmicro/LDmicro/wiki/SUBPROG,-RETURN,-ENDSUB-and-GOSUB,-LABEL-and-GOTO-instruction.-Part-3


> RAND                        Rand
                          --{ RAND }--

    El generador de nmeros pseudoaleatorios devuelve el nmero en el rango completo
 de la variable 'Rand'.
 Cuando la entrada a esta instruccin es verdadera, establece el valor dado
 variable de destino 'Rand' con el siguiente nmero pseudoaleatorio calculado
 por un generador lineal congruencial (LCG). Cuando la entrada a esto
 la instruccin es falsa no pasa nada.
 Ver https://en.m.wikipedia.org/wiki/Linear_congruential_generator
 El generador est definido por la relacin de recurrencia:
 X [n + 1] = (a * X [n] + c) mod m
 Constantes usadas de MTH $ RANDOM del VMS, versiones antiguas de glibc
 a = 69069 (0x10DCD)
 c = 1
 m = 2 ^ 32
 X = (X * 0x10DCD + 1)% 0x100000000
 RAND devuelve los bytes ms significativos de X.
 X almacenado como $ seed_Rand variable de 32 bits.


> SRAND                     {SRAND     Rand}
                          --{$seed:=newSeed}--

    El generador de nmeros pseudoaleatorios se inicializa utilizando el argumento
 pasado como nueva semilla. $ seed_Rand: = newSeed.
 Cuando la entrada a esta instruccin es verdadera, establece el valor dado
 variable de destino $ seed_Rand igual a la variable de origen dada o
 constante. Cuando la entrada a esta instruccin es falsa, nada
 sucede
 Dos inicializaciones diferentes con la misma semilla generarn la misma
 sucesin de resultados en llamadas posteriores a RAND.
 Si la semilla se establece en 1, el generador 'Rand' se reinicializa a su inicial
 valor y produce los mismos valores que antes de cualquier llamada a RAND o SRAND.
 Las fuentes de entropa pueden ser ADC, temporizadores, RAND anteriores guardados en EEPROM, etc.

 En este ejemplo tenemos dos SEPARAR los generadores de nmeros pseudoaleatorios LCG.
 Pero si newSeed1 es igual a newSeed2, entonces RAnd1 y Rand2 son iguales
 Secuencias de nmeros.
   ||     _    _      {SRAND     Rand1}                       ||
 1 ||--[_/ OSR/ \_]---{$seed:=newSeed1}-                      ||
   ||                                                         ||
   ||      Rand1                                              ||
 0 ||-----{RAND}------                                        ||
   ||                                                         ||
   ||                                                         ||
   ||     _    _      {SRAND     Rand2}                       ||
 0 ||--[_/ OSR/ \_]---{$seed:=newSeed2}-                      ||
   ||                                                         ||
   ||      Rand2                                              ||
 0 ||-----{RAND}------                                        ||
   ||                                                         ||


> 7-CONVERTIDOR DE SEGMENTOS   {7SEG    dest:=}
                             --{C          src}--

    La variable 'dest' obtiene el valor 'abcdefgDP', controla (resalta)
 los segmentos de fuente
 Puede usar la variable de puerto de acceso directo '#PORTx' como la variable 'dest'.
 Se puede conectar a los nodos (ctodos) del mdulo LED de 7 segmentos.
 a travs de las resistencias limitantes de corriente.

 Para encender (resaltar) el segmento LED "a", se requiere un nivel alto
 en el pin "a" y un nivel bajo en el pin comn, cuando un mdulo con
 Se utiliza la conexin LED de ctodo comn.
 Cuando se utiliza un mdulo con la conexin de nodo comn, para encender
 el segmento LED "a", el nivel bajo se requiere en el pin "a" y
 Se requiere un alto nivel en el pin comn. Utilice el parmetro 'A' en su lugar
 de la 'C' para especificar qu tipo de conexin comn se utiliza.

 Fuente de visualizacin de 7 segmentos
         a
        --
     f|    |b
      |  g |
        --
     e|    |c
      |    |
        -- .
         d  DP

    SEGMENTOS    DP g f e d c b a
    'dest'  BIT   7 6 5 4 3 2 1 0
    DP - es un segmento de puntos


    a  --|>|-----+-- Conexin LED de ctodos comn
                 |
    b  --|>|-----+
    ...          |
                 |
    DP --|>|-----+

    a  --|<|-----+-- Conexin LED de nodos comunes
                 |
    b  --|<|-----+
    ...          |
                 |
    DP --|<|-----+


    La variable 'src' (char) debe estar en el rango de 0..128 y generalmente tiene un tamao de 1 byte.
 Se implementan 128 caracteres de cdigos de tabla ASCII.
 Los primeros 32 caracteres ASCII replased a los dgitos hexadecimales.
 El 129 smbolo es un smbolo de un grado 'o' para usar con un valor de temperatura.
DIRECCION=  0               16(0x10)       31(0x1F)
row+colmn  |               |              | de 0 a 15 - dgitos hexadecimales
  0       0123456789ABCDEF0123456789ABCDEF  del 16 al 31 - dgitos hexadecimales con el punto DP
 32(0x20)  !"#$%&'()*+,-./0123456789:;<=>?
 64(0x40) @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_
 96(0x60) `abcdefghijklmnopqrstuvwxyz{|}~
128(0x80) o
          ^
          |_ grado char 0xB0

    ' ' - cpace char 0x20 - en blanco
    DEL char 0x7F - en blanco

   Ver pantalla LED de segmento X, ejemplo de fuente
    https://github.com/LDmicro/LDmicro/wiki/X-segment-LED-display,-font-example


> 9-CONVERTIDOR DE SEGMENTOS   {9SEG    dest:=}
                             --{C          src}--
         a
        ---j
     f|   / |b
      |  /  |
        ---g
     e|  /  |c
      | /   |
       m---
         d   DP

    SEGMENTO  0 0 m j DP g f e d c b a
    BIT           9 8  7 6 5 4 3 2 1 0
    nibbles  ^        ^       ^       ^
    El tamao de la variable 'dest' debe ser de al menos 2 bytes.


> 14-CONVERTIDOR DE SEGMENTOS  {14SEG   dest:=}
                             --{C          src}--
         a
      h --- j
     f|\ |i/|b
      | \|/ |
     g1-- --g2
     e| /|\ |c
      |/ |l\|
      m --- k
         d   DP

    SEGMENTO 0 g2  l  k  i  h  m  j DP g1  f  e  d  c  b  a
    BIT        14 13 12 11 10  9  8  7  6  5  4  3  2  1  0
    nibbles ^          ^           ^           ^           ^
    El tamao de la variable 'dest' debe ser de al menos 2 bytes.


> 16-CONVERTIDOR DE SEGMENTOS  {16SEG   dest:=}
                             --{C          src}--
       a1 a2
      h-- --j
     f|\ |i/|b
      | \|/ |
     g1-- --g2
     e| /|\ |c
      |/ |l\|
      m-- --k
       d1 d2 DP

    SEGMENTO  0  0  0 a2 d2 g2  l  k  i  h  m  j DP g1  f  e d1  c  b a1
    BIT               16 15 14 13 12 11 10  9  8  7  6  5  4  3  2  1  0
    nibbles  ^          ^           ^           ^           ^           ^
    El tamao de la variable 'dest' debe ser de al menos 3 bytes.


> CONVERTIR BINARIO EN BCD    {BIN2BCD dest:=}
                            --{           src}-

    El 'src' es un valor binario con una longitud de 1,2,3,4 bytes.
 El 'dest' es un valor BCD desempaquetado con 3, 5, 8, 10 bytes de longitud.
 Desempaquetado: cada nmero est codificado en un byte, con cuatro bits
 representando el nmero y los bits restantes que no tienen significado.
 El decimal 99 (0x63) se convertir al valor 0x00 09 09.
 El decimal 100 (0x64) se convertir al valor 0x01 00 00.
 Ver https://en.wikipedia.org/wiki/Binary-coded_decimal


> CODIFICADOR DE CUADRATURA   ~~[XqA0 XqB0            YqDir0]-
                              -\[XqZ0   QUAD ENCOD   qCount0]^-

    La instruccin QUADRATURE ENCODER toma dos seales codificadas en cuadratura
 (A y B) de un dispositivo codificador incremental rotativo o lineal.
 Ver https://en.wikipedia.org/wiki/Incremental_encoder

 Nivel
 Logico             move (mover) ->             |            <- move (mover)
         ^
         | ___         _______         ___________          _______         ___
Entrada A|    |_______|       |_______|           |________|       |_______|
         |
         | _______         _______         ___         ________         _______
Entrada B|        |_______|       |_______|   |_______|        |_______|
         |
         |
Contador |  0 |   | 1 |   | 2 |   | 3 |   | 4 |   | 3 |   | 2 |   | 1 |   | 0
         |
 Salida  | ___________________________________   disminuir o CCW o hacia atrs
 Direcion|    aumentar o CW o hacia adelante  |________________________________
         |
 Salida  |
  Pulso  | _______^_______^_______^_______^_______^_______^_______^_______^____
         |
       --+----------------------------------------------------------------> Tiempo
         |
           '^' - es un impulso de tiempo de ciclo del PLC
    Sugerencia: use el pulso de salida para determinar si se cambi el contador,
 No para contar.

    La instruccin QUAD ENCOD puede contener 3 o 2 entradas y 1 o 0 salida.
 Las entradas A y B deben estar ubicadas en el mismo PUERTO MCU.
 Por ejemplo, RBx y RBx, no RAx, RBx.
 La entrada Z es opcional y puede estar vaca.
 La salida Dir es opcional y puede estar vaca.
 La salida Dir puede ser Y (pin) o R (rel interno).

   ||                                                                    ||
   ||       R0        ~~[XqA0 XqB0            YqDir0]-         R1        ||
   ||-------] [--------\[XqZ0   QUAD ENCOD   qCount0]^---------( )-------||
   ||                                                                    ||

    Cuando la condicin R0 de entrada de la instruccin QUAD ENCOD es falsa,
 las entradas A, B, Z se ignoran.
 Cuando la condicin R0 de entrada de la instruccin QUAD ENCOD es verdadera,
 los pulsos en las entradas A, B, Z se decodifican en el valor del contador,
 la seal de salida Dir es alta, cuando el contador aumenta y
 un nivel bajo cuando se disminuye el contador, se produce un pulso de salida R1.
 El valor del contador cambia cuando ambas entradas A y B cambian.
 Esto corresponde al multiplicador de reloj x2. La frecuencia de la salida
 pulsos es el doble de la frecuencia de los pulsos de entrada A (B).
 La frecuencia de los pulsos de entrada A (B) debe ser menor que la frecuencia de
 el ciclo PLC / 4, de lo contrario habr prdidas de pulsos de entrada.
 Un rebote de los pulsos de entrada A (B) debe ser menor que el tiempo de ciclo del PLC / 8.

    La entrada Z puede ser dinmica (activada por flanco) o esttica.
 Si el parmetro 'Count per revol' es 0 y la entrada Z est activa, el contador se establece en 0.
 Si el parmetro 'Count per revol' es mayor que 0 y la entrada Z est activa, entonces
 el contador se redondear a un mltiplo del valor 'Recuento por revolucin'.
 Si el parmetro 'Count per revol' es menor que 0, entonces la entrada Z se ignora.


 Nivel
 Logico           (Mover)   move ->
         ^
         | ___         _______         _______         _______         ________
Entrada A|    |_______|       |_______|       |_______|       |_______|
         |
         | _______         _______         _______         _______         ____
Entrada B|        |_______|       |_______|       |_______|       |_______|
         |
         |
Entrada Z| _______________________________________________________/\___________
         |
         |
         |                                  'Count per revol' es 0 (restablecer el contador)
         |
Contador |  0 |   | 1 |   | 2 |   | 3 |   | 4 |   | 5 |   | 6 |   | 0 |   | 1
         |
         |
         |  (hay prdidas de pulsos A, B) 'Count per revol' es 10 (recupera el contador)
         |
Contador |  0 |   | 1 |   | 2 |   | 3 |   | 4 |   | 5 |   | 6 |   |10 |   | 11
         |
       --+----------------------------------------------------------------> tiempo
         |

    Para simular las entradas A, B, Z: haga doble clic en el nombre de la entrada en la lista
 en la parte inferior de la pantalla.

    Ver para ms detalles https://github.com/LDmicro/LDmicro/wiki/Incremental-QUADRATURE-ENCODER
    Incremental QUADRATURE ENCODER controls the brightness of the LED (PWM out)
    https://github.com/LDmicro/LDmicro/wiki/Incremental-QUADRATURE-ENCODER-controls-the-brightness-of-the-LED-(PWM-out)


UNA NOTA SOBRE EL USO DE LAS MATEMTICAS
========================================

Recuerde que LDmicro realiza solo matemticas de enteros de 16 bits. Eso significa
que el resultado final de cualquier clculo que realice debe ser un
entero entre -32768 y 32767. Tambin significa que el intermedio
los resultados de su clculo deben estar todos dentro de ese rango.

Por ejemplo, digamos que desea calcular y = (1 / x) * 1200,
donde x est entre 1 y 20. Entonces y va entre 1200 y 60, que
cabe en un nmero entero de 16 bits, por lo que al menos en teora es posible
realiza el clculo Hay dos formas de codificar esto:
puede realizar el recproco y luego multiplicar:

   ||         {DIV  temp  :=}          ||
   ||---------{ 1 / x       }----------||
   ||                                  ||
   ||          {MUL  y  :=  }          ||
   ||----------{ temp * 1200}----------||
   ||                                  ||

O simplemente puede hacer la divisin directamente, en un solo paso:

   ||           {DIV  y  :=}           ||
   ||-----------{ 1200 / x }-----------||

Matemticamente, estos dos son equivalentes; pero si los pruebas, entonces
encontrar que el primero da un resultado incorrecto de y = 0. Que
es porque la variable 'temp' se desborda. Por ejemplo, cuando x = 3,
(1 / x) = 0.333, pero eso no es un nmero entero; la operacin de divisin
aproxima esto como temp = 0. Entonces y = temp * 1200 = 0. En el segundo
En caso de que no haya un resultado intermedio para el flujo inferior, todo funciona.

Si est viendo problemas con sus matemticas, marque el intermedio
resultados de subdesbordamiento (o desbordamiento, que `se envuelve '; por ejemplo,
32767 + 1 = -32768). Cuando sea posible, elija unidades que pongan valores en
un rango de -100 a 100.

Cuando necesite escalar una variable por algn factor, hgalo usando una multiplicacin
y una divisin Por ejemplo, para escalar y = 1.8 * x, calcule y = (9/5) * x
(que es lo mismo, ya que 1.8 = 9/5), y codifique esto como y = (9 * x) / 5,
realizando la multiplicacin primero:

   ||         {MUL  temp  :=}          ||
   ||---------{ x * 9       }----------||
   ||                                  ||
   ||           {DIV  y  :=}           ||
   ||-----------{ temp / 5 }-----------||

This works for all x < (32767 / 9), or x < 3640. For larger values of x,
the variable `temp' would overflow. There is a similar lower limit on x.


ESTILO DE CODIFICACIN
======================

Permito mltiples bobinas en paralelo en un solo peldao. Esto significa que
puedes hacer cosas como esta:

   ||       Xa               Ya        ||
 1 ||-------] [--------------( )-------||
   ||                                  ||
   ||       Xb               Yb        ||
   ||-------] [------+-------( )-------||
   ||                |                 ||
   ||                |       Yc        ||
   ||                +-------( )-------||
   ||                                  ||

En lugar de esto:

   ||       Xa               Ya        ||
 1 ||-------] [--------------( )-------||
   ||                                  ||
   ||                                  ||
   ||                                  ||
   ||                                  ||
   ||       Xb               Yb        ||
 2 ||-------] [--------------( )-------||
   ||                                  ||
   ||                                  ||
   ||                                  ||
   ||                                  ||
   ||       Xb               Yc        ||
 3 ||-------] [--------------( )-------||
   ||                                  ||

Esto significa que, en teora, podra escribir cualquier programa como un peldao gigante,
y no hay necesidad de usar varios peldaos en absoluto. En la prctica eso
sera una mala idea, porque a medida que los peldaos se vuelven ms complejos se vuelven
ms difcil de editar sin eliminar y volver a dibujar mucha lgica.

An as, a menudo es una buena idea agrupar la lgica relacionada como una sola
peldao. Esto genera un cdigo casi idntico a si hiciste peldaos separados,
pero muestra que estn relacionados cuando los miras en la escalera
diagrama.

                  *                 *                  *

En general, se considera una forma pobre de escribir cdigo de tal manera que
su salida depende del orden de los peldaos. Por ejemplo, este cdigo
no es muy bueno si tanto Xa como Xb podran ser ciertos:

   ||       Xa         {v  :=       }  ||
 1 ||-------] [--------{ 12      MOV}--||
   ||                                  ||
   ||       Xb         {v  :=       }  ||
   ||-------] [--------{ 23      MOV}--||
   ||                                  ||
   ||                                  ||
   ||                                  ||
   ||                                  ||
   ||      [v >]             Yc        ||
 2 ||------[ 15]-------------( )-------||
   ||                                  ||

Romper esta regla si al hacerlo puedo hacer un cdigo
significativamente ms compacto, sin embargo. Por ejemplo, as es como lo hara
Convierta una cantidad binaria de 4 bits en Xb3: 0 en un entero:

   ||                                   {v  :=       }  ||
 3 ||-----------------------------------{ 0       MOV}--||
   ||                                                   ||
   ||       Xb0                  {ADD  v  :=}           ||
   ||-------] [------------------{ v + 1    }-----------||
   ||                                                   ||
   ||       Xb1                  {ADD  v  :=}           ||
   ||-------] [------------------{ v + 2    }-----------||
   ||                                                   ||
   ||       Xb2                  {ADD  v  :=}           ||
   ||-------] [------------------{ v + 4    }-----------||
   ||                                                   ||
   ||       Xb3                  {ADD  v  :=}           ||
   ||-------] [------------------{ v + 8    }-----------||
   ||                                                   ||

Si la instruccin MOV se movi al final del peldao en lugar de
arriba, entonces el valor de v cuando se lee en otra parte del programa
ser 0. La salida de este cdigo, por lo tanto, depende del orden en que
Se evalan las instrucciones. Considerando lo engorroso que sera
para codificar esto de otra manera, acepto eso.

ABREVIATURAS
============
PLC - controlador lgico programable.
PWM - modulacin de ancho de pulso.
ADC - convertidor analgico a digital.
PCB - placa de circuito impreso

BUGS
====

LDmicro no genera cdigo muy eficiente; es lento de ejecutar y
derrochador de flash y RAM. A pesar de esto, un PIC o AVR de tamao mediano puede
hacer todo lo que puede hacer un PLC pequeo, por lo que esto no me molesta mucho.

La longitud mxima de los nombres de variables es muy limitada. Esto es para que
encajan bien en el diagrama de escalera, as que no veo una buena solucin
a ese.

Si su programa es demasiado grande para la hora, memoria de programa o memoria de datos
restricciones del dispositivo que ha elegido, entonces probablemente no lo har
obtener un error Simplemente se arruinar en alguna parte.

La programacin descuidada en las rutinas de carga / guardado de archivos probablemente lo hace
posible bloquear o ejecutar cdigo arbitrario dado un corrupto o malicioso
archivo .ld.

Informe errores adicionales o solicitudes de caractersticas al autor.

Gracias a:
* Marcelo Solano, por informar de un error de interfaz de usuario en Win98
* Serge V. Polubarjev, por no solo notar que RA3: 0 en el
PIC16F628 no funcion, pero tambin me dijo cmo solucionarlo
* Maxim Ibragimov, para informar y diagnosticar problemas importantes
con los objetivos ATmega16 y ATmega162 hasta entonces no probados
* Bill Kishonti, por informar que el simulador se bloque cuando el
programa de lgica de escalera dividido por cero
* Mohamed Tayae, por informar que las variables persistentes se rompieron
en el PIC16F628
* David Rothwell, por informar de varios errores de interfaz de usuario y un
problema con la funcin "Exportar como texto"

COPIA Y DESCARGO DE RESPONSABILIDAD
===================================

NO USE EL CDIGO GENERADO POR LDMICRO EN APLICACIONES DONDE SOFTWARE
LA FALLA PODRA RESULTAR EN PELIGRO PARA LA VIDA HUMANA O DAAR LA PROPIEDAD. EL
EL AUTOR NO ASUME NINGUNA RESPONSABILIDAD POR NINGN DAO RESULTANTE DE LA OPERACIN
DE LDMICRO O CDIGO GENERADO POR LDMICRO.

Este programa es software libre: puede redistribuirlo y / o modificarlo
bajo los trminos de la Licencia Pblica General GNU publicada por el
Free Software Foundation, ya sea la versin 3 de la Licencia, o (a su
opcin) cualquier versin posterior.

Este programa se distribuye con la esperanza de que sea til, pero
SIN NINGUNA GARANTA; sin siquiera la garanta implcita de COMERCIABILIDAD
o APTITUD PARA UN PROPSITO EN PARTICULAR. Ver la Licencia Pblica General de GNU
para ms detalles.

Debera haber recibido una copia de la Licencia Pblica General de GNU junto con
con este programa Si no, ver <http://www.gnu.org/licenses/>.


Jonathan Westhues

Rijswijk      -- Dec 2004
Waterloo ON   -- Jun, Jul 2005
Cambridge MA  -- Sep, Dec 2005
                 Feb, Mar 2006
                 Feb 2007
Seattle WA    -- Feb 2009

Email: user jwesthues, at host cq.cx

Soporte LDmicro:
    Foro LDmicro:  http://cq.cx/ladder-forum.pl
    ltimo lanzamiento: https://github.com/LDmicro/LDmicro/releases
    Repositorio:     https://github.com/LDmicro/LDmicro
    Email:          LDmicro.GitHub@gmail.com
