Manual de uso para PLC con LDmicro

Seguramente ya han visto varios post sobre PLC con PIC y programación en Ladder con LDmicro.
Links de PLC con LDmicro:

http://electgpl.blogspot.com.ar/2012/08/plc-con-pic.html
http://electgpl.blogspot.com.ar/2013/12/plc-usb.html

Ahora voy a traducir y agregar algunas cosas sobre el manual de ayuda en sus funciones principales y sintaxis de programación.

Link al LDmicro: http://cq.cx/ladder.pl

INTRODUCCIÓN

LDmicro genera código nativo para cierta PIC16 de Microchip y Atmel AVR
microcontroladores. Por lo general, el software para estos microcontroladores está escrito en un lenguaje de programación como ensamblador, C o BASIC.
Un programa en una de idiomas comprende una lista de instrucciones. Estos lenguajes son potente y bien adaptado a la arquitectura del procesador, que
internamente ejecuta una lista de instrucciones.

PLC, por el contrario, a menudo se ha programado en lógica de escalera. Un simple
programa podría tener este aspecto:

   ||                                                                    ||
   ||    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 retardo a la desconexión Las -] [- son entradas, que se comportan algo así como los contactos de un relé. los - (+) - son salidas, que se comportan igual que el tipo de bobina de un relé. 

Un número de diferencias son:

     * El programa se presenta en formato gráfico, no como una lista textual
       de los estados. Muchas personas inicialmente encontrarán esto más fácil de
       entender.

     * En el nivel más básico, los programas se ven como diagramas de circuitos, con
       contactos de relé (entradas) y bobinas (salidas). Esto es intuitivo para
       programadores con conocimiento de la teoría de circuitos eléctricos.

     * El compilador con lógica de escalera se ocupa de lo que se calcula
       dónde, usted no tiene que escribir código para determinar cuando las salidas
       tiene que conseguir vuelto a calcular sobre la base de un cambio en las entradas o una
       evento de temporizador, y usted no tiene que especificar el orden en el que
       estos cálculos deben llevarse a cabo; las herramientas PLC hacen eso por usted.

LDmicro compila lógica de escalera para PIC16 o código AVR.
Los procesadores compatibles son:

    * PIC16F877
    * PIC16F628
    * PIC16F876 
    * PIC16F88 
    * PIC16F819 
    * PIC16F887 
    * PIC16F886 
    * ATmega128
    * ATmega64
    * ATmega162
    * ATmega32
    * ATmega16 
    * ATmega8 

Usando LDmicro, puede dibujar un diagrama de contactos para su programa. Usted puede
simular la lógica en tiempo real en su PC. Entonces, cuando usted está convencido
que es correcta puede asignar pines del microcontrolador al programa y salidas. 
Una vez que haya asignado los pines, puede puede compilar PIC o AVR. 
La salida del compilador es archivo un .hex que se puede programar en el microcontrolador utilizando cualquier programador o bootloader para PIC / AVR.

LDmicro está diseñado para ser algo similar a la mayoría de PLC comercial y sistemas de programación. Hay algunas excepciones, y un montón de cosas No son estándar en la industria de todos modos. Lea cuidadosamente la descripción de cada instrucción, incluso si parece familiar. Este documento asume conocimiento básico de la lógica de escalera y de la estructura de software PLC (El ciclo de ejecución: leer entradas, cálculo, escribir salidas).


OBJETIVOS ADICIONALES

También es posible generar un código ANSI C. Usted podría utilizar esto con cualquier
procesador para el que tenga un compilador C, pero usted es responsable de
suministrar el tiempo de ejecución. Esto significa que solo genera el fuente para un PlcCycle función(). Usted es responsable de llamar PlcCycle cada tiempo de ciclo, y usted es responsable de la implementación de todas las E/S (Lectura / escritura de entrada digital, etc.) funciones que el PlcCycle() llama. 

Por último, LDmicro puede generar código de bytes independiente del procesador para una
máquina virtual diseñado para ejecutar código de lógica de escalera. Este objetivo se trabajará para casi cualquier plataforma, siempre y cuando se puede proporcionar su propia máquina virtual. Esto podría ser útil para aplicaciones donde se desee utilizar la lógica de escalera como un lenguaje de script para personalizar una mayor programa. 


OPCIONES DE LÍNEA DE ÓRDENES

ldmicro.exe es normalmente ejecutado sin opciones de línea de comandos. Eso significa
que sólo 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 dentro de la interfaz gráfica de usuario.

Si LDmicro se pasa un solo nombre de archivo en la línea de comandos
(Por ejemplo, `ldmicro.exe asd.ld '), entonces LDmicro intentará abrir` asd.ld',
si es que existe. Un error se produce si no existe `asd.ld '. Esta significa que se puede asociar con los archivos ldmicro.exe .LD, para que se ejecute automáticamente cuando se hace doble clic en un archivo .ld.

Si LDmicro se hace pasar argumentos de línea de comandos en forma `Ldmicro.exe / c src.ld dest.hex ', entonces se trata de compilar` src.ld', y guardar la salida como `dest.hex '. LDmicro sale después de compilar, si la compilación se ha realizado correctamente o no. Cualquier mensaje se imprimen a la consola. Este modo es útil sólo cuando se ejecuta desde el LDmicro línea de comando.


LO ESENCIAL

Si ejecuta LDmicro sin argumentos a continuación, se inicia con un vacío programa. Si ejecuta LDmicro con el nombre de un programa de escalera (xxx.ld) en la línea de comandos a continuación, se intentará cargar ese programa en el inicio.
LDmicro utiliza su propio formato interno para el programa; no puede importar
la lógica de cualquier otra herramienta.

Si no se ha cargado un programa existente a continuación, se le dará un programa con un escalón vacío. Se podría añadir una instrucción para ello; por ejemplo se podría añadir un conjunto de contactos (Instrucción -> Insertar Contactos) llamado `XNew '. `X 'significa que los contactos serán atados a un pin de entrada en el microcontrolador. Se podría asignar un PIN a ella más tarde, después de elegir una microcontrolador y cambiar el nombre de los contactos. La primera letra del nombre indica qué tipo de objeto se trata. Por ejemplo:

     * Xname - ligado a un pin de entrada en el microcontrolador
     * Yname - ligado a un pin de salida en el microcontrolador
     * RNAME - `relé interno ': un poco en la memoria
     * NombreT - un temporizador; a su vez-en el retraso, desvío de retardo, o retentiva
     * Cname - un contador, ya sea hacia arriba o contar-count-down
     * Aname - un número entero leer de un convertidor A / D
     * Nombre - una de propósito general (entero) Variable

Elija el resto del nombre para que describa lo que hace el objeto,
y de manera que es único dentro del programa. El mismo nombre se refiere siempre
al mismo objeto dentro del programa. Por ejemplo, sería un error
tener un retraso de encendido (TON) llamado Tdelay y un retardo de desconexión (TOF)
Tdelay llamado en el mismo programa, ya que cada uno necesita su propio contador
memoria. Por otra parte, sería correcto para tener un temporizador retentivo
(RTO) llamado Tdelay y una instrucción de restablecimiento (RES) asociado con
Tdelay, ya que ese caso se desea que ambas instrucciones para trabajar con
el mismo temporizador.

Los nombres de variables pueden consistir en letras, números y caracteres de subrayado
(_). Un nombre de variable no debe empezar por un número. Los nombres de variables
distingue mayúsculas y minúsculas.

Las instrucciones generales variables (MOV, ADD, EQU, etc.) pueden trabajar en variables con cualquier nombre. Esto significa que pueden acceder temporizador y acumuladores mostrador. Esto a veces puede ser útil; por ejemplo, se podría comprobar si el recuento de un contador de tiempo está en un intervalo particular.

Las variables son siempre enteros de 16 bits. Esto significa que pueden ir de -32768 a 32767. Las variables siempre se tratan como firmado. Usted puede especificar literales como números decimales normales (0, 1234, -56). También puedes especificar los valores de caracteres ASCII ('A', 'z'), poniendo el carácter de comillas simples. Se puede utilizar un código de caracteres ASCII en la mayoría de los lugares que se puede utilizar un número decimal.

En la parte inferior de la pantalla, verá una lista de todos los objetos en el programa. Esta lista se genera automáticamente a partir del programa; no hay necesidad de mantenerlo al día con la mano. La mayoría de los objetos no lo hacen necesita ninguna configuración. 
Xname, Yname, y objetos unNombre deben estar asignado a un pin del microcontrolador, sin embargo. En primer lugar elegir qué microcontrolador que está utilizando (Ajustes -> Microcontroladores). A continuación, asigne su I/O botones por doble clic en ellos en la lista.

Puede modificar el programa mediante la inserción o eliminación de instrucciones. los
cursor en la pantalla del programa parpadea para indicar el seleccionado en ese momento
la instrucción y el punto de inserción actual. Si no parpadea entonces pulse <Tab> o haga clic en una instrucción. Ahora puede eliminar el actual instrucciones, o puede insertar una nueva instrucción a la derecha oa la izquierda (En serie con) o por encima o por debajo (en paralelo con) el seleccionado instrucción. Algunas operaciones no están permitidos. Por ejemplo, hay instrucciones se permite que el derecho de una bobina.

El programa comienza con sólo un peldaño. Se pueden añadir más peldaños eleccionando
Insertar peldaño antes / después en el menú de la lógica. Usted podría conseguir el mismo efecto mediante la colocación de muchos subcircuitos complicadas en paralelo dentro de un peldaño, pero es más clara para utilizar varios peldaños.

Una vez que haya escrito un programa, puede probarlo en la simulación, y luego se puede compilar en un archivo HEX para el microcontrolador de destino.


SIMULACIÓN

Para entrar en el modo de simulación, seleccione Simular -> modo de simulación o pulse
<Ctrl + M>. El programa se muestra diferente en el modo de simulación. Ahi esta ya no es un cursor. Las instrucciones que se energizan aparecen brillantes rojo; las instrucciones que no aparecerá en gris. Presione la barra espaciadora para ejecutar el PLC un ciclo. Para desplazarse continuamente en tiempo real, seleccione Simular -> Iniciar en tiempo real de simulación, o pulse <Ctrl + R>. La pantalla de el programa se actualiza en tiempo real como los cambios de estado del programa.

Puede establecer el estado de las entradas para el programa haciendo doble clic en la lista en la parte inferior de la pantalla, o haciendo doble clic en un Xname instrucción contactos en el programa. Si cambia el estado de un pin de entrada después de que el cambio no se refleja en cómo el programa Se muestra hasta que los ciclos de PLC; esto sucederá automáticamente si se está ejecutando una simulación en tiempo real, o al pulsar la barra espaciadora.


COMPILACIÓN EN CÓDIGO NATIVO

En última instancia se trata es de generar un archivo .hex que se puede programar en su microcontrolador. En primer lugar se debe seleccionar el número de parte de la microcontrolador, en la configuración -> menú del microcontrolador. Entonces tú debe asignar un pin de E/S a cada uno o Yname objeto Xname. Para ello, Doble clic en el nombre del objeto en la lista en la parte inferior de la pantalla. Un diálogo aparecerá donde se puede elegir un pin no asignado de una lista.

A continuación, se debe elegir el tiempo de ciclo que va a correr, y que debe decirle al compilador lo que la velocidad de reloj de las micro va a correr a estas se establecen en la configuración -> Parámetros de MCU ... menú. En general se No debería ser necesario cambiar el tiempo de ciclo; 10 ms es un buen valor para la mayoría aplicaciones. Escriba en la frecuencia del cristal que va a utilizar con el microcontrolador (o el resonador de cerámica, etc.) y haga clic bien.

Ahora se puede generar el código de su programa. Elija Compilar -> Compilar, o Compilar -> Compilar como ... si ha compilado previamente este programa y desea especificar un nombre de archivo de salida diferente. Si no hay errores a continuación LDmicro generarán un archivo listo para una programación IHEX Intel programación en su chip.

Usar cualquier software de programación y el hardware tiene que cargar el hexágono presentar en el microcontrolador. Recuerde que debe establecer los bits de configuración (fusibles)! Para los procesadores PIC16, los bits de configuración están incluidas en el archivo hexadecimal, y la mayoría del software de programación se verá de forma automática. Para los procesadores AVR debe establecer los bits de configuración manualmente.


INSTRUCCIONES DE REFERENCIA

> CONTACTO, NORMALMENTE ABIERTO 

Xname       RNAME       Yname

----] [----  ----] [----  ----] [----

Si la señal que va a la instrucción es falsa, entonces la salida la señal es falsa. Si la señal que va a la instrucción es verdadera, a continuación, la señal de salida es verdadera si y sólo si el pin de entrada dado, pin de salida o relé interno es cierto, de lo contrario es falso. Esta instrucción 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 señal que va a la instrucción es falsa, entonces la salida la señal es falsa. Si la señal que va a la instrucción es verdadera, a continuación, la señal de salida es verdadera si y sólo si el pin de entrada dado, pin de salida o relé interno es falso, de lo contrario es falso. Esta instrucción 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.

> COIL, NORMAL 

RNAME        Yname

----( )----  ----( )----

Si la señal que va a la instrucción es falsa, entonces la propuesta relé interno o pin de salida se borra falsa. Si la señal que va en esta instrucción es verdadera, entonces el relé o una salida dada interna pin se establece cierto. No es significativo para asignar una variable de entrada a una bobina. Esta instrucción debe ser la instrucción de más a la derecha en su peldaño.

> COIL, NEGADA

RNAME        Yname

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

Si la señal que va a la instrucción es verdadera, entonces el dado relé interno o pin de salida se borra falsa. Si la señal que va en esta instrucción es falsa, entonces el relé interno determinado o pin de salida se establece cierto. No es significativo para asignar una entrada variable para una bobina. Esto es lo contrario de una bobina normal. Esta la instrucción debe ser la instrucción de más a la derecha en su peldaño.

> COIL, SET-SOLO

RNAME        Yname

----(S)----  ----(S)----

Si la señal que va a la instrucción es verdadera, entonces el dado relé interno o pin de salida se establece cierto. De lo contrario el interior relé o estado del pin de salida no se cambia. Esta instrucción sólo puede cambiar el estado de una bobina de falso a verdadero, por lo que es típicamente se utiliza en combinación con una bobina de reposición de sólo. Esta instrucción debe ser la instrucción más a la derecha en su peldaño.

> COIL, RESET-SOLO 

RNAME        Yname

----(R)----  ----(R)----

Si la señal que va a la instrucción es verdadera, entonces el dado relé interno o pin de salida se borra falsa. De lo contrario el relé interno o estado del pin de salida no se cambia. esta instrucción la instrucción sólo se puede cambiar el estado de una bobina de verdadero a falso, por lo que se usa típicamente en combinación con una bobina de puesta a solamente. Esta la instrucción debe ser la instrucción de más a la derecha en su peldaño.


> ENCENDIDO RETRASO 

Tdon

-[ton 1.000 s]-

Cuando la señal de entrar en la instrucción va de falso a verdadero, la señal de salida permanece falsa para 1.000 s antes de ir verdad. Cuando el señal que entra a la instrucción va de verdadero a falso, la salida la señal se hace falso inmediatamente. El temporizador se pone a cero cada vez que la entrada se hace falsa; la entrada debe permanecer fiel a 1000 milisegundos consecutivos antes de la salida será verdad. El retraso se puede configurar.

La variable NombreT cuenta desde cero en unidades de tiempos de exploración. los     instrucción TON Salidas cierto cuando la variable contador es mayor que o igual al retardo dado. Es posible manipular el variable de contador en otro lugar, por ejemplo, con una instrucción de MOV.


> APAGADO RETRASO

Tdoff

-[tof 1.000 s]-

Cuando la señal de entrar en la instrucción va de verdadero a falso, la señal de salida se mantiene fiel a 1.000 s antes de ir falsa. Cuando la señal que entra a la instrucción va de falso a verdadero, la señal de salida se hace verdadero inmediatamente. El temporizador se pone a cero cada vez que la entrada se hace falso; la entrada debe permanecer falsa para 1000 milisegundos consecutivos antes de la salida será falsa. El retraso es configurable.

La variable NombreT cuenta desde cero en unidades de tiempos de exploración. los     instrucción TON Salidas cierto cuando la variable contador es mayor que o igual al retardo dado. Es posible manipular el variable de contador en otro lugar, por ejemplo, con una instrucción de MOV.


> RETENTIVA TIMER 

Trto

-[RTO 1.000 s]-

Esta instrucción se realiza un seguimiento de cuánto tiempo su entrada ha sido cierto. Si     su entrada ha sido así durante al menos 1.000 s, entonces la salida es cierto. De lo contrario la salida es falsa. La entrada no tiene por qué haber sido cierto para 1000 milisegundos consecutivos; si la entrada se hace verdadero durante 0,6 s, a continuación, falsos durante 2,0 s, y luego durante 0,4 s verdaderas, entonces la salida será verdad. Después de la salida se hace verdadero que se mantendrá fiel incluso después de la entrada se hace falso, siempre que la entrada ha sido cierto por más de 1.000 s. Por lo tanto, este temporizador se debe restablecer manualmente, utilizando la instrucción de restablecimiento.

La variable NombreT cuenta desde cero en unidades de tiempos de exploración. los     instrucción TON Salidas cierto cuando la variable contador es mayor que o igual al retardo dado. Es posible manipular el variable de contador en otro lugar, por ejemplo, con una instrucción de MOV.

> RESET

 Trto          Citems

----{RES}----  ----{RES}----

Esta instrucción se restablece un temporizador o un contador. TON y TOF son temporizadores restablece automáticamente cuando su entrada hace falsa o verdadera, por lo que es RES no se requiere para estos temporizadores. RTO temporizadores y CTU / CTD son contadores no restablecen automáticamente, por lo que deben hacerlo a mano utilizando una RES instrucción. Cuando la entrada es cierto, el contador o temporizador se restablece; cuando la entrada es falsa, no se toma ninguna acción. Esta instrucción debe     ser la instrucción más a la derecha en su peldaño.


> ONE-SHOT ASCENDENTE 

     _

-[OSR_/ ]-

Esta instrucción se emite normalmente falsa. Si la entrada de la instrucción es cierto durante esta exploración y era falsa durante la exploración anterior entonces la salida es cierto. Por lo tanto, genera un impulso de una exploración de ancho a cada flanco ascendente de la señal de entrada. Esta instrucción es útil si desea activar eventos fuera del borde ascendente de una señal.


> ONE-SHOT DESCENDENTE 

 _

-[OSF \_]-

Esta instrucción se emite normalmente falsa. Si la entrada de la instrucción es falsa durante esta exploración y era verdad durante la exploración anterior entonces la salida es cierto. Por lo tanto, genera un impulso de una exploración de ancho a cada flanco de bajada de la señal de entrada. Esta instrucción es útil si desea activar eventos fuera del borde descendente de una señal.


> CORTOCIRCUITO, CIRCUITO ABIERTO

----+----+----  ----+    +---- 

La condición de salida de un corto circuito es siempre igual a su condición de entrada. La condición de salida de un circuito abierto es siempre falso. En su mayoría son de utilidad para la depuración.


> RELE DE CONTROL MAESTRO

-{MASTER RLY}-

Por defecto, la condición de renglón-in de cada renglón es verdadero. Si un maestro    instrucción de relé de control se ejecuta con una condición de renglón-in de falso, entonces la condición de renglón-in para todos los siguientes peldaños se convierte falso. Esto continuará hasta que la siguiente relé de control maestro la instrucción se alcanza (independientemente de la condición de renglón en el que de instrucción). Por lo tanto, estas instrucciones deben utilizarse en pares: una para (tal vez de forma condicional) inicie la sección posiblemente discapacidad, y uno para acabar con ella.

> MOVE

{destvar :=  }      {Tret :=     }

-{ 123     MOV}-    -{ srcvar  MOV}-

Cuando la entrada de esta instrucción es verdadera, se establece el dado variable de destino igual a la variable de origen dado o  constante. Cuando la entrada de esta instrucción es falsa nada que sucede. Se pueden asignar a cualquier variable con la instrucción de movimiento; esto incluye temporizador y variables de estado de contador, que puede ser distinguido por el líder de `T 'o` C'. Por ejemplo, una instrucción 0 en movimiento en Tretentive es equivalente a una instrucción de restablecimiento (RES)     para ese temporizador. Esta instrucción debe ser la instrucción de más a la derecha en su peldaño.

> OPERACION ARITMETICA

{ADD kay :=}    {SUB Ccnt :=}

-{ 'A' + 10 }-  -{ Ccnt - 10 }-

 {MUL dest :=}    {DIV dv :=  }

 -{Var * -990 }-  -{dv / -10000}-

Cuando la entrada de esta instrucción es verdadera, se establece el dado variable de destino igual a la expresión dada. los operandos pueden ser tanto variables (incluidas las variables de temporizador y contador) o constantes. Estas instrucciones utilizan 16 bits con signo matemático. Recuerda que el resultado se evalúa en cada ciclo cuando la condición de entrada cierto. Si va a aumentar o disminuir una variable (es decir, si la variable de destino es también uno de los operandos), entonces Probablemente no quieren eso; normalmente se usaría un one-shot de manera que se evalúa sólo en el flanco ascendente o descendente de la entrada condición. Divida trunca; 8/3 = 2. Esta instrucción debe ser     la instrucción más a la derecha en su peldaño.

> COMPARAR 

[var ==]    [var>]    [1 >=]

-[ Var2 ]-  -[  1 ]-  -[Ton ]-

 [Var /=]    [-4 <]      [1 <=]

 -[Var2  ]-  -[vartwo]-  -[Copa]-

Si la entrada de esta instrucción es falsa entonces la salida es falsa. Si la entrada es cierto, entonces el resultado es verdadero si y sólo si el dado condición es verdadera. Esta instrucción puede ser utilizado para comparar (es igual, es mayor que, es mayor que o igual a, no es igual a, es inferior a, es menor que o igual a) una variable a una variable, o para comparar una variable a un 16 bits con signo constante.


> CONTADOR 

 Cname         Cname

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

Un contador se incrementa (CTU, cuentan hacia arriba) o decrementos (CTD, cuentan    hacia abajo) el número de asociados en cada flanco ascendente de la entrada escalón     condición (es decir, lo que la condición de entrada de renglón va de falso a cierto). La condición de salida del contador es cierto si el contador variable es mayor que o igual a 5, y falso en caso contrario. los condición de salida de renglón puede ser cierto incluso si la condición de entrada es falso; sólo depende de la variable de contador. Usted puede tener la UAT e instrucciones CTD con el mismo nombre, con el fin de incrementar y disminuir el mismo contador. La instrucción RES puede reiniciar un contador, o puede realizar operaciones de variables generales sobre la variable de recuento.

> CONTADOR CIRCULAR 

 Cname

-{CTC 0: 7}-

Un contador circular funciona como un contador CTU normales, excepto que después de alcanzar su límite superior, se restablece la variable de contador de nuevo a 0. Por ejemplo, el contador se muestra arriba contaría 0, 1, 2, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 2, .... Esto es útil en combinación con instrucciones condicionales de la variable `Cname '; puede utilizar esto como un secuenciador. CTC contadores de reloj en la creciente borde de la condición de entrada condición del renglón. Esta instrucción debe ser la instrucción más a la derecha en su peldaño.


> 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 flanco ascendente de la condición de renglón en el registro de desplazamiento desplazamiento a la derecha. Eso significa que asigna `reg3: = reg2 ',` reg2: = reg1 '. y `reg1: = reg0 '. `Reg0 'se deja sin cambios. Un gran cambio registrarse pueden fácilmente consumir una gran cantidad de memoria. Esta instrucción debe ser la instrucción más a la derecha en su peldaño.


> Tabla de consulta

{dest :=  }

-{LUT[i]   }-

Una tabla de consulta es un conjunto ordenado de valores de n. Cuando el renglón de la condición es verdadera, la variable entera dest se iguala a la entrada en la tabla de consulta que corresponde a la variable de número entero `I '. El índice se inicia desde cero, por lo que `i 'debe estar entre 0 y (N-1). El comportamiento de esta instrucción no está definido si el índice está fuera de este rango. Esta instrucción debe ser la más a la derecha  instrucción en sus peldaño.


> TABLA lineal por tramos 

{yvar :=   }

-{PWL[xvar] }-

Esta es una buena manera de aproximar una función complicada o curva. Podría, por ejemplo, ser útil si usted está tratando de aplicar una curva de calibración para convertir una tensión de salida en bruto de un sensor en unidades más convenientes.

Suponga que usted está tratando de aproximar una función que convierte una variable de entrada entero, x, a un número entero variable de salida, y. Tú conocer la función en varios puntos; por ejemplo, es posible 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)

Puede introducir esos 4 puntos en una tabla asociada a la instrucción lineal a trozos. El lineal a trozos la instrucción se verá en el valor de xvar, y establecer el valor de yvar. En él se fijará Yvar de tal manera que la curva lineal a trozos pasará a través de todos los puntos que se le daría; por ejemplo, si se establece xvar = 10, entonces la instrucción asignará yvar = 50.

Si se le da la instrucción de un valor de xvar que se encuentra entre dos de los valores de x para los cuales le han dado puntos, entonces la instrucción asignará yvar modo que (xvar, yvar) se encuentra en la recta línea que une los dos puntos en la tabla. Por ejemplo, xvar =  55 da una potencia de Yvar = 75. (Los dos puntos en la tabla son (10, 50) y (100, 100). 55 es un medio camino entre 10 y 100, y 75 está a medio camino entre el 50 y el 100, por lo que (55, 75) se encuentra en la línea que conecta esos dos puntos.)

Los puntos deben ser especificadas en orden ascendente por la coordenada x. Eso puede no ser posible para realizar operaciones matemáticas requeridas para ciertas tablas de consulta utilizando matemáticas entero de 16 bits; si este es el caso, entonces LDmicro le avisará. Por ejemplo, esta tabla de consulta producirá un error:

        (X0, y0) = (0, 0)
        (X1, y1) = (300, 300)

Puede corregir estos errores al hacer la distancia entre los puntos de la tabla pequeña. Por ejemplo, esta tabla es equivalente a la dado anteriormente, y que no produce un error:

        (X0, y0) = (0, 0)
        (X1, y1) = (150, 150)
        (X2, y2) = (300, 300)

Debe casi nunca ser necesario utilizar más de cinco o seis puntos. La adición de más puntos hace su código más grande y más lento para ejecutar. El comportamiento si se pasa un valor de `xvar 'mayor que los más grandes coordenada x en la tabla o menor que la más pequeña x de coordenadas en la tabla no está definido. Esta instrucción debe ser el   instrucción de más a la derecha en su peldaño.


> CONVERSOR ADC 

Aname

-{READ ADC}-

LDmicro puede generar código para utilizar los convertidores A / D integradas en ciertos microcontroladores. Si la condición de entrada de esta instrucción es cierto, entonces una sola muestra del convertidor A / D se adquiere y se almacenado en la variable `Aname '. Esta variable puede ser posteriormente manipulado con variable de operación general (menor que, mayor que, aritmética, y así sucesivamente). Asignar un alfiler para la variable `Axxx 'en el misma manera que lo haría asignar un PIN a una entrada o salida digital,   haciendo doble clic en él en la lista en la parte inferior de la pantalla. Si la condición de entrada a este renglón es falso entonces la variable `Aname ' se deja sin cambios.

Para todos los dispositivos actualmente soportados, de entrada 0 voltios corresponde a   una lectura de 0 ADC, y una entrada igual a Vdd (la tensión de alimentación) corresponde a una lectura ADC de 1023. Si está usando un AVR, a continuación, AREF conectar a Vdd. Puede utilizar operaciones aritméticas para escalar la lectura a las unidades más convenientes después, pero recuerde que usted están utilizando operaciones con números enteros. En general, no todas las clavijas estarán disponibles para su uso con el convertidor A / D. El software no le permitirá asignar pines no-A / D a una entrada analógica. Esta instrucción debe ser la instrucción más a la derecha en su peldaño.


> CICLO DE TRABAJO PWM

Duty_Cycle

-{PWM 32,8 kHz}-

LDmicro puede generar código para utilizar el PWM periférica integrada en ciertos microcontroladores. Si la condición de entrada de esta instrucción es cierto, entonces el ciclo de trabajo del periférico PWM se establece en el valor de la variable de Duty_Cycle. El ciclo de trabajo debe ser un número entre 0 y 100; 0 corresponde a siempre bajos, y 100 corresponde a siempre alta. (Si no está familiarizado con cómo funciona el periférico PWM,  a continuación, observe que eso significa que LDmicro escala automáticamente la variable de ciclo de trabajo de por ciento, a períodos de reloj PWM).

Puede especificar la frecuencia PWM de destino, en Hz. La frecuencia que se especifica que podría no ser exactamente posible, dependiendo de cómo se se divide en frecuencia de reloj del microcontrolador. LDmicro se elegir la frecuencia alcanzable más cercano; si el error es grande, entonces se le avisará. Las velocidades más altas pueden sacrificar resolución. 

Esta instrucción debe ser la instrucción de más a la derecha en su peldaño.
El tiempo de ejecución de la lógica de escalera consume un temporizador para medir el ciclo hora. Eso significa que PWM sólo está disponible en microcontroladores con por lo menos dos temporizadores adecuados. PWM utiliza CCP2 pasador (no CCP1) en chips PIC16 y OC2 (no OC1A) en RAV.


> GRABACION EN EEPORM

 saved_var 

--{PERSIS}--

Cuando la condición de renglón en de esta instrucción es verdadera, hace que el variable de entero especificado que se guarda automáticamente en la memoria EEPROM. Ese     significa que su valor persistirá, incluso cuando el micro pierde poder. No hay necesidad de guardar explícitamente la variable en la EEPROM; que va a suceder de forma automática, siempre que cambia la variable. los variable se carga automáticamente desde la EEPROM después de la reposición de encendido. Si una variable que cambia con frecuencia se hace persistente, entonces la EEPROM en sus micro puede llevar a cabo muy rápidamente, porque es sólo bueno para un número limitado (~ 100 000) de escrituras. Cuando el renglón de la condición es falsa, no pasa nada. Esta instrucción debe ser el instrucción de más a la derecha en su peldaño.


> UART (SERIAL) RECIBIR 

var

-{UART RECV}-

LDmicro puede generar código para utilizar el UART integrado en cierta 
microcontroladores. En RAV con múltiples UART única UART1 (no UART0) es compatible. Configurar la velocidad de transmisión utilizando Configuración -> MCU Parámetros. Ciertas velocidades de transmisión pueden no ser alcanzables con cierta frecuencias de los cristales; LDmicro le avisará si este es el caso. 

Si la condición de entrada a esta instrucción es falsa, entonces nada que sucede. Si la condición de entrada es cierto, entonces esta instrucción intentos para recibir un único personaje de la UART. Si se lee ningún carácter entonces la condición de salida es falsa. Si se lee un carácter y su valor ASCII se almacena en `var ', y la condición de salida es verdadera para un solo ciclo del PLC.


> UART (SERIAL) ENVIAR

var

-{SEND UART}-

LDmicro puede generar código para utilizar las UART integradas en cierta    microcontroladores. En AVRS De con múltiples UARTs solamente UART1 (no UART0) es compatible. Configurar la velocidad de transmisión utilizando Configuración -> MCU  Parámetros. Ciertas velocidades de transmisión pueden no ser alcanzables con cierta    frecuencias de los cristales; LDmicro le avisará si este es el caso.

Si la condición de entrada a esta instrucción es falsa, entonces nada que sucede. Si la condición de entrada es cierto, entonces esta instrucción escribe un solo carácter a la UART. El valor ASCII del carácter de enviar haya sido previamente objeto almacenado en `var '. La condición de salida del renglón es verdadero si el UART está ocupado (en la actualidad se transmite una carácter), y false en caso contrario.

Recuerde que los personajes toman un tiempo para transmitir. Compruebe la salida   condición de esta instrucción para asegurarse de que el primer carácter tiene sido transmitidos antes de intentar enviar un segundo personaje, o utilizar un temporizador para introducir un retraso entre los caracteres. Sólo debe traer la condición de entrada real (intente enviar un carácter) cuando la salida condición es falsa (UART no está ocupado).

Investigar la instrucción de cadena con formato (siguiente) antes de usar este instrucción. La instrucción cadena con formato es mucho más fácil de usar, y es casi seguro capaz de hacer lo que quiere.


> CADENA DE FORMATEO PARA UART 

var

-{"Presión: \3 \r \n"}-

LDmicro puede generar código para utilizar las UART integradas en cierta
microcontroladores. En AVRS De con múltiples UARTs solamente UART1 (no UART0) es compatible. Configurar la velocidad de transmisión utilizando Configuración -> MCU    Parámetros. Ciertas velocidades de transmisión pueden no ser alcanzables con cierta    frecuencias de los cristales; LDmicro le avisará si este es el caso.

Cuando el renglón en condiciones para esta instrucción va de falso a cierto, éste empieza a enviar una cadena entera a través del puerto serie. Si la cadena contiene la secuencia especial de `\ 3 ', entonces esa secuencia será reemplazado por el valor de `var ', que es automáticamente convertido en una cadena. La variable será formateado para tomar   exactamente 3 caracteres; por ejemplo, si `var 'es igual a 35, entonces la cadena exacta impresa será `Presión: 35 \ r \ n" (nota el extra espacio). Si en lugar de `var 'fuera igual a 1432, entonces el comportamiento haría es indefinido, ya que 1432 tiene más de tres dígitos. En ese caso sería necesario el uso de `\ 4 'en su lugar.

Si la variable puede ser negativo, a continuación, usar `\-3d '(o` \ -4d' etc.) en su lugar. Eso hará que LDmicro para imprimir un espacio inicial para números positivos y un signo menos para los números negativos.

Si varios formateado instrucciones de cadena se energizan a la vez (O si uno está excitado antes de que otro se complete), o si éstos instrucciones se entremezclan con las instrucciones UART TX, entonces la comportamiento no está definido.

También es posible utilizar esta instrucción a la salida de una cadena fija, sin interpolar el valor de una variable entera en el texto que es enviada por serie. En ese caso, simplemente no incluyen el especial secuencia de escape.

Use `\\ ' para una barra invertida literal. Además de la secuencia de escape para interpolar una variable entera, el siguiente control caracteres están disponibles:

        * \ R - retorno de carro
        * \ N - salto de línea
        * \ F - formfeed
        * \ B - retroceso
        * \ XAB - carácter con el valor ASCII 0xAB (hex)

La condición de salida del renglón de esta instrucción es verdadera si bien es transmisión de datos, de lo falso. Esta instrucción se consume una muy gran cantidad de memoria de programa, por lo que debe utilizarse con moderación. los implementación actual no es eficiente, pero uno mejor voluntad requerir modificaciones en todos los back-ends.


NOTA SOBRE EL USO DE MATEMÁTICAS

Recuerde que LDmicro sólo realiza operaciones aritméticas con enteros de 16 bits. Eso significa que el resultado final de cualquier cálculo que se realiza debe ser un número entero entre -32768 y 32767. También significa que el intermedio resultados de sus cálculos deben estar todos dentro de ese rango.

Por ejemplo, digamos que usted quiere calcular y = (1 / x) * 1200, donde x es entre 1 y 20. A continuación, y va entre 1,200 y 60, que encaja en un entero de 16 bits, por lo que es al menos en teoría posible realizar el cálculo. Hay dos formas en que se pueden codificar esto: puede realizar el recíproco, y luego multiplicar:

||         {DIV  temp  :=}          ||

||---------{ 1 / x       }----------||

||                                  ||

||          {MUL  y  :=  }          ||

||----------{ temp * 1200}----------||

||                                  ||

O usted podría hacer la división directamente, en un solo paso:

||           {DIV  y  :=}           ||

||-----------{ 1200 / x }-----------||

Matemáticamente, estos dos son equivalentes; pero si se los pruebe, entonces se encuentra que el primero da un resultado incorrecto de y = 0. se debe a que las variables `underflows temp. Por ejemplo, cuando x = 3, (1 / x) = 0,333, pero que no es un número entero; la operación de división se aproxima a esto como temp = 0. Entonces y = temp * 1200 = 0. En la segunda caso no hay ningún resultado intermedio de subdesbordamiento, así que todo funciona.

Si usted está viendo problemas con su matemática, a continuación, comprobar intermedia
resultados de flujo inferior (o desbordamiento, que se envuelve alrededor ` '; por ejemplo, 32767 + 1 = -32768). Cuando es posible, elegir las unidades que ponen en los valores un rango de -100 a 100.

Cuando tenga que escalar una variable por algún factor, hacerlo mediante una multiplicación y una división. Por ejemplo, a escala y = 1,8 * x, calcular y = (9/5) * x (Que es el mismo, ya que 1.8 = 9/5), y el código de esto como y = (9 * x) / 5, la realización de la multiplicación primero:

||         {MUL  temp  :=}          ||

||---------{ x * 9       }----------||

||                                  ||

||           {DIV  y  :=}           ||

||-----------{ temp / 5 }-----------||

Esto funciona para todo x <(32767/9), o <x 3640. Para valores grandes de x, la variable `temperatura 'se desbordaría. Hay un límite más bajo similar de x.


ESTILO DE CODIFICACIÓN

Me permito varias bobinas en paralelo en un solo renglón. Esto significa que que puede 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 teoría, se podría escribir cualquier programa como un peldaño gigante, y no hay necesidad de utilizar múltiples peldaños en absoluto. En la práctica esto
sería una mala idea, ya que como peldaños se vuelven más complejas se vuelven más difíciles de editar sin borrar y volver a dibujar una gran cantidad de lógica.

Aún así, a menudo es una buena idea para la lógica relacionada con el grupo en conjunto como una sola peldaño. Esto genera código casi idéntica a si ha realizado peldaños separados, pero muestra que se relacionan cuando nos fijamos en ellos en la escalera
diagrama.

*                              *                              *

En general, se considera forma pobre para escribir código de una manera tal que su producción depende del orden de los peldaños. Por ejemplo, este código no es muy buena si tanto Xa y Xb pueden nunca ser verdad:

   ||       Xa         {v  :=       }  ||

 1 ||-------] [--------{ 12      MOV}--||

   ||                                  ||

   ||       Xb         {v  :=       }  ||

   ||-------] [--------{ 23      MOV}--||

   ||                                  ||

   ||                                  ||

   ||                                  ||

   ||                                  ||

   ||      [v >]             Yc        ||

 2 ||------[ 15]-------------( )-------||

   ||                                  ||

Voy a romper esta regla si, al hacerlo, puedo hacer una pieza de código significativamente más compacto, sin embargo. Por ejemplo, aquí es cómo lo haría convertir una magnitud binario 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 instrucción MOV se trasladó a la parte inferior del escalón en lugar de la la parte superior, entonces el valor de v cuando se lee en otro lugar en el programa haría 0. La salida de este código depende, por tanto en el orden en que se evalúan las instrucciones. Teniendo en cuenta lo complicado que sería para codificar esto de otra manera, lo acepto.