An LDmicro Tutorial
(also in: Italiano in: Italiano , Deutsch , Deutsch , Français , Русский) In this tutorial, I will show you how to write a very simple program. I am assuming that you have written ladder logic before, and that you have some basic familiarity with microcontrollers, but that you have never used LDmicro. If you don't know very much about ladder logic or PLCs, then the plcs.net tutorial might be helpful to you. Our device will have one pushbutton, and one LED. At startup, the LED will be off. When you press the pushbutton once, the LED will turn steady on. The second time you press the pushbutton, the LED will start blinking. The third time that you press the button, the LED will turn off again. On subsequent subsequent presses, the cycle will repeat.
Microcontroller Selection and Schematic We will be using a PIC16F876, which is easily available from Digikey or other online distributors. It comes in a number of different packages; I chose a DIP. Note that as of Nov 2009, the PIC16F876 is no longer recommended for new design. This means that it will probably get discontinued at some point in the next few years. You may prefer to instead use a PIC16F886, which is pin-compatible. If you do, then make sure to specify the correct part when you compile, since the 'F886 is not codecompatible. This is our schematic:
The microcontroller (IC1) is part number PIC16F876-20I/SP-ND at Digikey. Almost any three-terminal resonator (U1) will do; you might try a 535 -9356-ND or an X909ND. The only thing that might confuse you is that the pushbutton goes to Vdd, and there is a pull-down. You might be more used to seeing a pushbutton to ground with a pull-up. For TTL, this mattered. For modern CMOS it does not, and I find this `active HIGH' arrangement less confusing than the traditional `active LOW' circuit. Also, I chose to use a ceramic resonator with internal capacitors, U1, instead of a crystal and two ~20 pF caps. A crystal would work just as well and it would be more accurate, but it would be a little li ttle bit more expensive, and you would need more parts. You could build this circuit in many different ways. I built i t on a solderless breadboard, and it ended up looking like this:
(The resistor values pictured are not quite the same as the schematic; none of them are critical.)
Ladder Diagram for the Program First, we are going to need an oscillator to generate the `blinking' signal for the LED. There is a standard way to do this in ladder logic: ||
Rosc Tosc_on Tosc_off || 1 ||-------] [--------[TON 250.0 ms]---[TOF 250.0 ms]--------(/)-------|| Rosc
This will flash at 1/((250+250) ms), or 2 Hz, or twice per second. The duty cycle will be 50% — 250 250 ms on, then 250 ms off. This circuit can make any kind of oscillator, with whatever period or duty cycle you require, so it is a good one to remember. Also notice that we have chosen to use an internal relay (`Rfoo') instead of one attached to an I/O pin (`Yfoo' ( `Yfoo' or `Xfoo'). This makes sense, because there is no particular reason to bring that signal out to a pin. LDmicro will automatically assign memory for the internal relay. Our program will have three states: off, steady on, and blinking. The program should change its state on each rising edge of the signal from the pushbutton. This is a good application for a circular counter. We will say that `state 0' is `off,' `state 1' is i s `steady on,' and `state 2' is `blinking.' The counter counts 0, 1, 2, 0, 1, 2, ..., so if we just let the rung-in condition of the counter be the pushbutton input, then everything will work like we want: || Cstate
Xbutton ||
2 ||-------] [---------------------------------------------{CTC 0:2}----||
Now the only thing left is to t o use the program state to set the state of the t he LED. We can do it like this: ||
[Cstate ==] || 3 ||---[ 1 ]----------- --------+---- ------------- -------( )-------|| || | || || [Cstate ==] Rosc | || ||---[ 2 ]----------] ]----------] [------+ || Yled
It should be easy to convince yourself that this does what we want. If the pr ogram is in state 1, then the `Cstate == 1' instruction energizes `Yled', as desired. In state 2, the `Cstate == 2' instruction energizes `Yled', but only when `Rosc' is also true. Since `Rosc' is oscillating, that means that the LED will bli nk, as desired. Finally, in state 0, neither of the equals instructions will be true, so there is no wa y that `Yled' could ever turn on.
Entering the Ladder Diagram Now that we have our circuit, we can draw it in LDmicro. When you start LDmicro, you will see a single empty rung:
We want to enter the first rung from the listing above. We will start with the coil, so choose Instruction -> Insert Coil. This will create a coil named `Ynew.' This is what we want, except that the name is wrong, and it should be negated. Double-click the coil; this will bring up a dialog where we can fill that in:
Now we can insert the rest of that rung in the same way. Click on the left edge of the coil, so that the cursor is vertical, and to the t he left of the coil. Now choose Instruction -> Insert TON (Delayed Turn On). Once again double-click the timer to rename it and set the period. Add the TOF timer and the contacts in the same way. Now we want to enter the second rung, so choose Edit -> Insert Rung After. Then click on the second rung to move the cursor there:
The second rung is easy: just fill in the two instructions in the right order, by placing the cursor where you want to insert and then choosing Instruction -> Insert .... Remember to assign a name (`Xbutton') to the contacts, and to set the name and upper limit of the counter. Then choose Edit -> Insert Rung After again. Your program should look like this:
The third rung will be a bit trickier, because it has parallel branches. That means means that you have to think about the order in which you insert the instructions. First, insert the coil, and rename it:
Now insert the first equals instruction to the left of the coil, as usual, and fill in the correct variable name and value. After you do that, add the parallel branch. You can do this by clicking on the bottom edge of the equals instruction; the cursor will be horizontal and below that equals instruction:
Now choose Instruction -> Insert EQU (Compare for Equals). Since your cursor is below the first equals instruction, the new equals instruction will be inserted below that instruction, in parallel with it. Rename it as usual. To fi nish the rung, you must insert the `Rosc' contacts to the right of the second equals instruction. To do this, click on the right edge of the second equals instruction:
At this point you can choose Instruction -> Insert Contacts; the contacts will be inserted in series with the t he second equals instruction, as you require. Rename it and you are done:
Simulating the Program Now we are ready to simulate our circuit. Choose Simulate -> Simulation Mode. The display will change; the ladder diagram will appear mostly greyed, but you won't see anything changing with time. That is because the PLC is not yet cycling. To start it cycling, choose Simulate -> Start Real-Time Simulation. Now you will see things happening: the oscillator is obviously running, but the LED (`Yled') is still off, which is what we want, because no one has pressed the button yet. To simulate pressing the button, double-click the text `Xbutton' in the list at t he bottom of the screen. You have now simulated bringing the pushbutton input high; this is what would happen if someone depressed (but did not yet release) the pushbutton.
You can see that the program is working: the `Cstate' counter is now equal to 1, which corresponds to the `steady on' state, which is what we want. The LED output is high; you can see that its value is 1 in i n the list, and the `Yled' coil appears red on the diagram. Double-click the `Xbutton' text in the list to simulate releasing the button, then doubleclick it again to simulate pressing it again; the `Yled' coil will start blinking, as designed. If you simulate a third button press then the output will go steady low.
Compiling to an IHEX File So now we are fairly sure that the program works. At this point we are ready to generate actual code, and try it in the micro. First, exit simulation mode by choosing Simulate -> Simulation Mode, or by pressing Escape. Next we must choose a microcontroller. We decided earlier that we would be using a PIC16F876, so choose Settings -> Microcontroller -> Microchip P IC16F876 28-PDIP or 28-SOIC. We also have to tell LDmicro what kind of crystal we will be using, and what the cycle time will be. Choose Settings -> MCU Parameters, and fill in our clock speed of 20 MHz. Leave the cycle time at 10 ms; that will usually be a good value. Now we can assign pins to our inputs and outputs. Double-click `Xbutton' in the list at the bottom of the screen, and choose pin 14 of the PIC, which corresponds to MCU port
RC3. (There is usually no reason for you to care which port you are using; just look at the pin number.)
Click `OK,' and then repeat the process for `Yled', which you can see from the schematic should go to pin 15. The other elements in the list are internal variables and bits in memory, so there is no need to assign pins to them. LDmicro will allocate memory for them when you compile. So now you are ready r eady to compile. Choose Compile -> Compile, and specify where you want to put the IHEX file. Then use whatever PIC programming equipment equipment you have available to load that into your device, and you are ready to try it out. This completes my tutorial. It is possible to write much more complex programs than that, of course. A program this simple uses only a very small fraction of your processor's memory, so there is room for many more rungs of logic. LDmicro also offers specialised instructions, for things like arithmetic, analog (A/D) inputs, PWM, and even text output to a character-based LCD. Consult the manual for details. I don't see why you would need to, but you can download the tutorial program premade. November 2009, 2009, near Seattle Seattle
Resumen Guión: Este script permite una opción de descarga en todas las diapositivas de SlideShare que tienen su discapacidad opción de descarga. También tratamos http://www.slidzy.com para descargar las diapositivas de PPT / PDF forma
De lógica de escalera para PIC y AVR
(También en: Italiano, Deutsch, Português, Русский)
Resumen rápido: me escribió un compilador que se inicia con un diagrama de escalera y genera nativos PIC16 o código AVR. Las características incluyen: entradas y salidas digitales temporizadores (TON, TOF, RTO) contadores (CTU, CTD, `contadores circular" para su uso como un secuenciador) entradas analógicas, analógicas (PWM) salidas variables enteras y las instrucciones aritméticas fácil de usar comunicaciones en serie, a una PC, LCD, u otro dispositivo registros de desplazamiento, tablas de búsqueda EEPROM variables, cuyos valores no son olvidados cuando se pierde el poder simulador, para probar el programa antes de generar PIC / AVR código Este programa es software libre, código fuente y los ejecutables están disponibles para su descarga. Introducción PLCs son a menudo programado en la lógica de escalera. Esto se debe a PLCs originalmente reemplazado los sistemas de relé de control, y cuarenta años después, todavía no hemos dejar ir. Un PLC, al igual que cualquier microprocesador, se ejecuta una lista de instrucciones en secuencia. Herramientas de lógica de escalera abstracto esto, se puede programar el PLC por po r el cableado de contactos de relé y las bobinas en la pantalla, y el tiempo de ejecución del PLC simular el circuito que has dibujado. Algunos de los contactos del relé puede estar ligado a las señales de entrada en el mundo real, r eal, algunos de los rollos pueden estar vinculados a las salidas. De esta manera usted puede hacer su circuito simulado interactuar con otros dispositivos, y de hecho las cosas de control. Ese es el punto. En realidad, es más general que, debido a que usted puede incorporar contadores co ntadores y temporizadores y operaciones aritméticas que no se podía (fácilmente) realizar sólo con relés. El concepto de circuito sigue siendo útil, sin embargo, en parte porque es intuitivo, pero también porque los resúmenes de las cuestiones de concurrencia. Se parece a esto: | | Xa Xb yout | | 1 ||-------] [------+-------] [------+-------] [------+-------( )------ - | | ||||||
| | | Xc | | | | | +-------]/[------+ | | Se trata de un simple pedazo de lógica combinatoria. Hay tres términos de entrada, Xa, Xb, Xc y. Hay un plazo de salida, yout. La expresión es: Login: Xa = y (Xb o (no Xc)). Esto tiene sentido si se piensa en Xa y Xb como contactos de relé normalmente abierto, Xc como contactos normalmente cerrados, y yout como una bobina de relé. Por supuesto, se vuelve más complicado que eso: |||| | | Asetpoint | | 1 ||-------------------------------------{ LEA ADC }----|| |||| | | UnaTemperatura | | ||------------------||------------------------------------------------{ ------{ LEA ADC }----|| |||| |||| |||| |||| | | {SUB min_temp: =} | | 2 ||------------------------{ ||------------------------{ Asetpoint - 20 }--------|| |||| | | {AÑADIR max_temp: =} | | ||------------------||------------------------{ -----{ Asetpoint + 20 }--------|| |||| |||| |||| |||| | | [UnaTemperatura>] Yheater | | 3 | | [max_temp ]+------------------------( R )-------|| ||||| | | Xenable | | | ||-------]/[------+ ||-------]/[------+ | | |||| | | [UnaTemperatura <] Yheater Xenable | | | | [Min_temp ]--------] [--------------( [--------------( S )-------|| ) -------|| |||| |||| |||| |||| | | {SUB check_temp: =} | | 4 ||-----------------------{ ||-----------------------{ Asetpoint - 30 }-------|| |||| |||| ||||
|||| | | [UnaTemperatura>] Yis_hot | | 5 | | [check_temp ]--------------------]-------------------------( ----( )-------|| |||| |||| |||| END ||------[ ]--------------------------------------- - | | |||| |||| Se trata de un simple termostato. Hay dos entradas analógicas, una de ellas es para la consigna, por lo que podría, por ejemplo, estar conectado a una olla que el usuario vuelve a seleccionar la temperatura deseada. El otro proporciona la medición de la temperatura, ya que podría ser un sensor de temperatura semiconductor, o un RTD de platino con circuitos de interfaz adecuado. No es una salida digital Yheater,. Que puedan controlar un elemento de calefacción, a través de un interruptor adecuado (un TRIAC, o un relé o un relé de estado sólido, o lo que sea). Cerramos el ciclo con una histéresis simple (bang-bang) del controlador. Hemos seleccionado más o menos 20 unidades de ADC de histéresis. Eso significa que cuando la temperatura cae por debajo (valor nominal - 20), que a su vez en el calentador, y cuando sube por encima (valor nominal + 20), apagar el calentador. Decidí agregar un bajo coste de pequeño tamaño. En primer lugar, hay una entrada de habilitación: el calentador está obligados a abandonar cuando Xenable es baja. También he añadido un indicador luminoso, Yis_hot, para indicar que la temperatura está dentro de la regulación. Esto se compara con un umbral un poco más frío que (consigna - 20), de modo que la luz no parpadea con el ciclo normal del termostato. Este es un ejemplo trivial, pero debe quedar claro que el lenguaje es bastante expresivo. La lógica de escalera no es un lenguaje de programación de propósito general, pero es Turingcompleto, aceptado en la industria, y, para una clase limitada de (en su mayoría orientados al control) problemas, sorprendentemente cómodo. Un compilador de lógica de escalera para PIC16 y AVR Modernas debajo de los 3.00 USD microcontroladores probablemente tenga sobre el poder de computación de un PLC alrededor al rededor de 1975. Por lo tanto, proporcionar más de MIPS suficiente para hacer funcionar la lógica de escalera bastante complejo, con un tiempo de ciclo de unos pocos milisegundos. Creo que por lo general los PLC tienen algún tipo de tiempo de ejecución que es algo así como un intérprete o una máquina virtual, pero si estamos haciendo la simple lógica de un procesador sin memoria mucho después de un compilador podría ser una idea mejor. Así que escribí un compilador. Se empieza con un renglón vacío. Puede agregar contactos (entradas) y bobinas (productos) y las estructuras más complicadas de preparar su programa.
Temporizadores (TON, TOF, RTO) son compatibles. La duración de máx / mín dependerá del tiempo de ciclo del PLC `', que es configurable, temporizadores pueden contar de milisegundos a varios minutos. Hay mostradores y operaciones aritméticas (más, menos, los tiempos, div). Elementos del circuito se pueden añadir en serie o en paralelo con co n los elementos existentes. Una lista de E / S está construido a partir de la lógica de escalera dibujada. Usted puede tener relés internos (Rfoo), para lo cual la memoria se asigna automáticamente, o de los insumos (Xfoo) y salidas (Yfoo), a la que se debe asignar un pin del microcontrolador. L a selección de los pines disponibles depende del microcontrolador. He tratado de apoyar a los PICs P ICs más populares y RAV (ver más abajo). Usted puede editar el programa en forma gráfica: Entonces usted puede probar el programa mediante la simulación de que en tiempo real. real . El programa aparecerá en la pantalla con la energía (true) destacó las ramas, lo que hace que sea fácil de depurar. El estado de todas las variables se muestra en la parte inferior de la pantalla en la lista de E / S. Una vez que el programa trabaja en la simulación puede asignar pines de las entradas y salidas y generar PIC o AVR código. El generador de código no es tan difícil. Si te das cuenta de que un circuito en paralelo es una O y un circuito en serie es una Y, que es una tarea de segundo año de CS, y no muy largo. El editor es realmente mucho más difícil. Se necesitaría un trabajo para hacer un compilador inteligente, sin embargo. Para el regulador que un gestor de buen registro proporcionaría una aceleración importante. Si quería llegar muy elegante a continuación, aplicar algoritmos estándar de reducción de la lógica, y tal vez la r educción del estado también. Eso sería mucho más difícil. Las cosas de tornillo hasta los temporizadores de todos modos. Incluso haciendo caso omiso de todo eso, mi generador de código para el AVR es muy pobre. La parte de atrás AVR todavía genera código PIC ... por ejemplo, que no toma ventaja del hecho de que el regulador tiene más de un registro. Parte del código que se genera es excesivamente mala. El PIC de fondo es mejor, pero no es un gran g ran verdad. Nada de esto importa mucho hasta que está tratando de ejecutar decenas de renglones de lógica con los tiempos de ciclo rápido. Yo apoyo el convertidor A / D, unidad PWM, UART y en los microcontroladores que los proveen. Eso significa que usted puede escribir la lógica de escalera que lee las entradas analógicas, y que envía y recibe más de personajes de serie (por ejemplo, a un PC, si se agrega un adecuado nivel de la palanca de cambios como un MAX232, o un personaje LCD). Es posible enviar cadenas arbitrarias en serie, así como los valores de las variables de tipo entero, como texto ASCII. Finalmente, ahora las variables de apoyo `conservados 'en dispositivos con memoria EEPROM, se puede indicar que una variable debe ser auto-guardado en la memoria no volátil cada vez que cambia, de modo que su valor es persistente a través de restauraciones por encendido. Limitaciones, y exención de responsabilidad
Por supuesto, un microcontrolador con este software no puede hacer todo lo que un PLC. La mayoría de los entornos PLC ofrece más funciones y bloques predefinidos que mi herramienta lo hace. El hardware del PLC es mejor también, por lo general las entradas y salidas están diseñadas para soportar el abuso eléctrica eléctric a increíble. Usted puede obtener un PIC16F877 en un tablero de transporte de diez o veinte dólares, sin embargo, y usted tendrá que pagar un poco más justo para un PLC con las mismas capacidades. Hasta el momento he recibido informes i nformes de errores muy pocos en comparación con el número de personas que tengan preguntas o peticiones. Todavía hay gran posibilidad de defectos, sobre todo en los objetivos o bjetivos para los microcontroladores que físicamente no tienen (y por lo tanto no puede probar). Ciertamente, no utilice para nada LDmicro críticas para la seguridad, ni nada que se rompa algo caro si no. Como se señaló anteriormente, el código que genera está lejos de ser óptima. Además, no toda la memoria RAM de datos en dispositivos PIC16 está disponible para el programa de lógica de escalera. Esto se debe a que no han implementado con mucho apoyo de todas las tonterías de paginación. Yo, sin embargo, el apoyo a la paginación de la memoria del programa, lo cual es necesario para acceder a lugares de memoria de programa en el PIC16 más allá de 2k. Descargar El software está desarrollado bajo Windows XP. Está probado en todas las versiones de Windows 2000 a Windows 7, e informes no confirmados sugieren que funciona bajo WINE. La descarga es un archivo exe,. No hay otros archivos necesarios, por lo que no hay ningún programa de instalación. Guárdelo en su ordenador y sólo se ejecuta, y va a funcionar. El manual está incluido en el archivo. Exe, pero se puede descargar por separado si lo desea. El compilador genera los archivos de Intel IHEX. La mayoría de los software de programación que he visto esta espera. Por supuesto, se necesita algún tipo de aparato de programación para obtener el archivo hex en el chip. De la RAV, te recomiendo un mkII AVRISP, que está disponible en distintos distribuidores. Por las fotos, te recomiendo PICkit Microchip 2, que está disponible en su tienda web. Ambos están soportados oficialmente, o ficialmente, conectarse a través de USB, y cuestan menos de 40 USD. Por lo general, debe ser posible utilizar código generado por LDmicro con un gestor de arranque. La mayoría de las l as partes AVR tienen fusibles especiales (BOOTRST, BOOTSZx) que tendrá que ser configurado para el gestor de arranque que esté utilizando. Las L as partes PIC16 no tienen ningún soporte de hardware específico para un gestor de arranque, pero LDmicro genera un código con el formato correcto para que el gestor de arranque para volver a escribir el vector de reset. Le agradecería cualquier reporte de errores. Los chips son compatibles: PIC16F628 (A)
PIC16F88 PIC16F819 PIC16F877 (A) PIC16F876 (A) PIC16F887 PIC16F886 ATMEGA128 ATMEGA64 ATMEGA162 ATmega32 ATmega16 ATmega8 También es posible generar código C a partir del programa de escalera. Que es menos conveniente, pero se puede utilizar en cualquier procesador para el que tenga un compilador de C. LDmicro puede generar código byte interpretable. Si usted está dispuesto a escribir un intérprete, puede utilizar esto para ejecutar código de su escalera en cualquier tipo de objetivo. No hay documentación de mucho de esto, pero me proporcionará un intérprete de la muestra en su mayoría-portátil C. Pre-construidos ejecutables están disponibles en varios idiomas: ldmicro.exe (Inglés) ldmicro-de.exe (Deutsch) ldmicro-fr.exe (Français) ldmicro-es.exe (Español) ldmicro-tr.exe (Türkçe) ldmicro-it.exe (Italiano) ldmicro-pt.exe (Português) El código fuente, y otros ficheros, también están disponibles para su descarga. Este programa se puede distribuir y modificar bajo los términos de la GPL versión 3. ldmicro-rel2.2.zip (fuente, versión 2.2) ldmicro.txt (manual) función / la historia de corrección de errores ejemplo: un semáforo simplificado ejemplo: cómo conducir un display de siete segmentos ejemplo: 'hola, mundo, "se imprime la cadena de más de serie Las versiones anteriores también están disponibles: ldmicro-rel2.1.zip (fuente, la versión 2.1)
ldmicro-rel2.0.zip (fuente, la versión 2.0) ldmicro-rel1.9.zip (fuente, la liberación 1.9) ldmicro-rel1.8.zip (fuente, versión 1.8) ldmicro-rel1.7.zip (fuente, versión 1.7) ldmicro-rel1.6.zip (fuente, versión 1.6) (Botón derecho del ratón para salvar a cualquiera de estos archivos) Por favor reportar cualquier defecto. Este software es libre, sin ningún departamento encargado del control de calidad. Ni siquiera tiene el hardware para probar muchos de los mismo objetivos. Un error que no se reporta es probable que nunca se fija. Tengo un tutorial, en el que se describe cómo entrar en un diagrama de escalera simple, simular, y luego generar un archivo de IHEX y el programa en un PIC. Esta es probablemente la forma más sencilla de empezar a trabajar con este software. Si usted tiene preguntas sobre LDmicro, a continuación, preguntar en el foro. Agosto de 2010, Nueva York, gracias a G. Mariani y Pedrazzi A. de traducción del italiano, HU Noell para el alemán, D. Corteletti y O. da Rocha para el portugués, el francés M. Vaufleury, J. Pascual para el español; A. Akici de turco
