STL Español PDF

30/01/02
Programación en Statement List

Para los PLC de Festo
Programación en STL para los PLC de Festo – Ing. Jorge Chiesa/Marketing/Festo S.A -1
30/01/02
Order no.: 18352

Descripción: MANUAL AWL
Designación: E.HB-AWL-SP
Edición: 1/99
Author: R. Conde, Festo Corporation
Editor: S. Baerwald, YC-ECI
Traducción: J. Chiesa, MKTNG/F-RA
3ra edición en inglés/1ra. edición en español
© Copyright 1997 Festo KG, 73734 Esslingen, Germany
All rights reserved, including translation rights. No part of
this documentation may be reproduced by any means
(printing, copying, microfilming or any other process) without
the written consent of Festo KG.
30/01/02
1. Introducción
A quienes está
destinado este
texto
Este manual ha sido escrito para aquellos que tienen conocimientos

básicos en controles industriales.
El objetivo es brindar el soporte necesario a quién programa los
Controladores Lógicos de Festo usando el lenguaje Statement List
(STL)
30/01/02
1. Introducción
Organización del
Manual
Contenido
Este manual está dividido en las siguientes secciones:
Capítulo 1 Introducción .....................................................................4

Una breve introducción a la organización y contenido de este
documento.
Capítulo 2 Ambiente de Programación FST.................................... 7

Introducción a la familia de software de programación Festo FST y
definición de términos comunes que serán usados en este manual.
Capítulo 3 Uso del Software FST ...................................................11

Descripción del proceso requerido para crear, editar, cargar y poner en
funcionamiento programas en Statement List (STL) usando las
herramientas del FST (Festo Software Tools).
Capítulo 4 Operandos de los PLC’s de Festo ...............................15

Describe los Operandos que pueden usarse (elementos internos al
PLC) de los controladores programables Festo en forma resumida. Los
operadores del lenguaje STL
Se presentan con el concepto de Operandos Locales y Operandos
Globales.
Capítulo 5 Estructura del Programa STL...................................... 23

Cómo se direccionan los elementos e instrucciones del Lenguaje STL
así como los factores que influyen en el flujo del programa.
Capítulo 6 Resumen de las instrucciones STL............................. 35

Breve introducción de cada instrucción STL ordenadas
alfabéticamente.
Capítulo 7 Referencia de las Instrucciones STL.......................... 39

Descripción detallada de cada instrucción de comando STL incluyendo
su propósito, la sintaxis adecuada y ejemplos de uso. Los comandos
se listan en orden alfabético para acceso rápido.
30/01/02
1. Introducción
Organización de Contenido (continuación)
Capítulo 8 Accediendo a las Entradas y Salidas Digitales......... 75

Información detallada de como direccionar Entradas y Salidas digitales
del PLC.
Capítulo 9 Usando Timers ..............................................................81

Describe cómo usar timers en STL. Detalla los distintos elementos del
sistema que comprenden la función de temporizado.
Capítulo 10 Usando Contadores .................................................... 89

Este capítulo muestra como implementar contadores usando el
lenguaje STL.
Capítulo 11 Usando Registros........................................................ 99

Explica la estructura y usos de los Registros programando en STL en
los controladores Festo.
Capítulo 12 Flags y Flag Words.................................................... 103

Proporciona importante información teniendo en cuenta los usos y
estructura de Flags y Flag Words.
Capítulo 13 Aplicando funciones Especiales del PLC............... 109

Incluye información básica aplicada a funciones de Entradas/Salidas
Analógicas, Redes, Field Bus y Posicionamiento.
Apéndice A Operandos de los Controladores Festo.................. 117

Listado de los operandos disponibles para los controladores Festo de
forma tabular.
Apéndice B Programas de Ejemplo............................................. 121

Se presentan diferentes tareas de control, acompañadas de soluciones
en lenguaje STL.
Apéndice C Programas Múltiples, Multiprocesamiento y Multitarea ..... .....

..... ..... ..... ..... ..... ..... ..... ..... ..... ..... ..... ..... .....137
Explica el significado de esto términos, cómo están implementados y
qué modelos de controladores soportan estas características.
Apéndice D Comprendiendo los números Binarios................... 143

Ofrece una presentación básica de cómo convertir números binarios
en decimales y viceversa.
30/01/02
1. Introducción
Organización Física
Muchas secciones de este manual están, a su vez, subdivididas en la

siguiente estructura:
RESUMEN, en aquellos temas en los que sea apropiado, se ha ubicado

al comienzo de cada sección y describe los puntos importantes
tratados en esta sección. Los programadores con experiencia y
aquellos que hayan estudiado la sección pueden dirigirse al Resumen
de modo de obtener, de una manera condensada, la información
necesaria. Para los programadores que se inicien el Resumen puede
usarse como una introducción y guía a las ideas importantes y
conceptos que serán tratados en la sección.
DETALLES es el corazón de cada sección. Contiene una detallada

explicación del tópico, que puede incluir teoría, propósito y ejemplos
típicos.
30/01/02
2. Ambiente de Programación FST
30/01/02
Contenidos
RESUMEN........................................................................................ 9
DETALLES ....................................................................................... 9
Lenguajes.......................................................................................... 9
Organización y Definiciones.............................................................. 9
30/01/02

RESUMEN
Esta sección brinda la información básica necesaria para utilizar la
herramienta de programación de software Festo FST
(Festo Software Tools) programming software. El FST tiene un
ambiente de programación totalmente integrado y proporciona también
facilidades de modificación y visualización en-línea.
DETALLES
Lenguajes
El software FST puede usarse en cualquier sistema IBM XT/AT

compatible
Que use un sistema operativo PC/MS-DOS o compatible. El FST
software soporta los siguientes lenguajes de programación:
• Matrix
• Statement List
• Ladder Diagram (Diagrama Escalera)
• BASIC
Lenguajes adicionales de programación están en desarrollo. Contacte

por cualquier consulta a su representante regional de Festo.
Organización y
Definiciones
Antes de describir el lenguaje STL propiamente dicho, es conveniente

definir los elementos que componen al sistema, y cómo están
organizados, de manera de tener una mejor comprensión.
Al hablar de las funciones y forma del lenguaje STL, pueden aplicarse

las siguientes definiciones:
FST Project
Un FST project incluye todos los proyectos de todas las CPU del
mismo (sean estas una o más), las cuales estén vinculadas mediante
un bus primario entre las CPU.
El FST software organiza todas las actividades en el nivel de project
(proyecto).
Los sistemas de control complejos, pueden tener múltiples proyectos

en FST, y estar conectados mediante una red.
Si el sistema de control incluye un sistema de Festo Field Bus (Bus de
Campo de Festo), la totalidad de las estaciones esclavas del Field Bus
de Festo, pertenecerían al proyecto que incluye a la estación maestra
(Master) de Field Bus.
CPU
30/01/02
El nivel que sigue en la organización es la CPU. Dependiendo del

modelo, PLC de Festo pueden llevar entre 1 y 5 CPU's, y estar
interconectadas al nivel del project. El acrónimo CPU significa (Central
Processing Unit) Unidad Central de Proceso y CCU (Central Control
Unit) Unidad Central de Control, términos que se usarán con el mismo
significado en este documento. Por otra parte se mantendrán las
denominaciones originales en inglés de los componentes de manera
que el lector se familiarice con los nombres y pueda interpretar textos
o documentación con esa lengua de origen.
Programa
Cada CPU puede uno o más programas de aplicación del usuario.
El máximo número de programas que pueden almacenarse, así como
el de programas que pueden procesarse simultáneamente depende
del modelo de controlador de Festo.
Este manual se concentra en la estructura e implementación a nivel de

programación.
Programación en STL para los PLC de Festo – Ing. Jorge Chiesa/Marketing/Festo S.A - 10
30/01/02
3. Usando el Software FST
30/01/02

Contenidos
RESUMEN........................................................................................ 1
DETALLES ..................................................................................... 14
Pasos preliminares ..................................................................…... 13

Creando un programa..................................................................... 13
Escribiendo un Programa................................................................ 14
Cargando en el PLC programas...................................................... 14
30/01/02

RESUMEN
Este capítulo describe la organización y principales funciones del FST

software y cómo emplearlo en los PLC de Festo. Se recomienda al
lector consultar el manual que acompaña al PLC para una más
detallada información.
Esta sección presenta un resumen de los pasos necesarios para
comenzar un programa en STL.
DETALLES
Pasos Preliminares
1. Instalación y configuración: Una vez obtenido el paquete de software

FST, debería ser instalado en su computadora siguiendo las
instrucciones provistas con el mismo.
2. FST Project: (Proyecto FST) seleccionando uno ya existente o

Creando uno Nuevo (Create) mediante el FST menú.
Creando un
Programa
3. Program Creation: (Creación de un Programa) El Editor STL se usa

para crear un programa en STL Nuevo o modificar uno existente. Al
seleccionar el editor de programa STL, y si está creando un Nuevo
programa, (o si está modificando uno existente); el FST solicitará
información sobre el programa a ser creado.
Dependiendo del modelo de controlador usado, podrá requerirse uno o
más de los datos siguientes:
Consulta del Definición
Editor FST
permite especificar el número de CPU para el modelo

CCU FPC405, e IPC
Prgm./Module Entre „P“ para un programa o „B“ para un módulo de

[P/B] programa
define el número de programa o del modulo de

Program No programa a crear. El rango varía según el modelo de
controlador.
Ocho versiones del mismo programa pueden
Version No guardarse. Especificar un número entre 1-9.
Ingrese aquí una descripción (opcional) del programa

Description : para futura referencia.

Escribiendo
un Programa
30/01/02
4. Usando el Editor de STL: El Editor de STL permite la edición y

modificación de programas sin estar conectado al PLC (off-line),
usando de teclas de función predefinidas para simplificar el ingreso de
comandos.
Se dispone de ayuda presionando la tecla de función F9. La tecla F8
File Menu ofrece alternativas para guardar la tarea realizada. Es
posible también realizar una revisión de la sintaxis del programa
mediante Syntax Check.
De esta forma, puede comprobarse la correcta escritura de los
comandos (syntaxis). Cualquier discrepancia será mostrada y deberá
corregirse antes de que el programa pueda transferirse al controlador.
Carga de Programas
5. Transferencia de programas al controlador: una vez finalizada la edición

de el o los programas, estos deben transferirse (load) desde la
computadora personal al controlador programable.
El FST software, comunicado a través del Puerto serie RS232 de la
computadora se usa para llevar a cabo esta transferencia.
Dependiendo del modelo de controlador en uso, un adaptador o un
cable especial puede requerirse para interconectar los equipos. Para
determinar el elemento adecuado, por favor, refiérase al manual del
modelo correspondiente o a su oficina local de Festo quien le
informará y suministrará los elementos necesarios.
El software FST tiene la capacidad de transferir programas o proyectos
al controlador (Load Programs o Load Projects) . Seleccione la opción
de cargar el programa (Load Project) desde el FST Menu hasta que se
acostumbre a usar el FST. Esto le la correcta operación de
transferencia de los datos.
6. Operación On-Line: Esta facilidad permite monitorear al controlador

programable en cualquier momento. Cualquier información contenida
en el controlador, incluyendo estado de las entradas/salidas,
Temporizadores, Contadores, Registros, etc. puede ser visualizada.
En el caso de programas STL, la búsqueda de errores (debugging) es
particularmente favorecida, ya que es posible revisar con el paso de
programa (Step) en ejecución.
Algunas versiones del FST permiten ver un programa STL en el modo
'dynamic source'. Esto significa ver el código del programa original, así
como el número de paso (step) que se está ejecutando conjuntamente
con el estado de los operandos monobit y multibit que se usan en el
mismo.
30/01/02
4. Operandos de los PLC’s de Festo
30/01/02

Contenidos
RESUMEN...................................................................................... 17
DETALLES ..................................................................................... 17
Operandos Monobit (Single) y Operandos Multibit.................. 17

Operandos Monobit (Single)........................................................... 18
Operandos Multibit.......................................................................... 19
Operandos Locales y Globales.................................................... 20

Operandos Globales....................................................................... 20
Operandos Locales......................................................................... 20
Operadores.................................................................................... 21
30/01/02

RESUMEN
Este capítulo introducirá los identificadores usados con los
controladores programables de Festo al referirse a elementos del
sistema (tanto a hardware como a software).
Estos identificadores del sistema (es decir Temporizadores, Entradas,
Salidas etc.) se denominarán Operandos. Los Operandos son
elementos dentro del controlador que pueden ser interrogados o
manipulados usando instrucciones de programa y operadores. El
concepto de operandos Local y Global también será analizado.
DETALLES
El software FST facilita que los programas sean escritos usando
Operandos Absolutos (Absolute Operands) (por ej. T1 es el operando
absoluto para el Timer (temporizador) número 1), así como Operandos
Simbólicos (Symbolic operands) (por ej. MOTOR pueda ser asignado a
la Output 1.6-Salida 1.6-). Para ser más claro, este manual se referirá
siempre con operandos absolutos.
Antes de usar el lenguaje STL es conveniente familiarizarse con los
operandos del controlador y cómo ellos son direccionados.
Dependiendo del modelo del controlador pueden existir diferencias en
el tipo y alcance del operando. El lector deberá referirse al Apéndice A
y al manual del controlador en particular para más información.
Operandos Monobit
(Single) y Operandos Multibit
Debe diferenciarse adecuadamente entre Operando Monobit (Single) y

Operando Multibit. Los operandos monobit (SBO) pueden evaluarse
como verdadero / falso en la parte condicional de una instrucción de
programa, y pueden ser activados (Set) o desactivados (Reset) en la
parte ejecutiva de una instrucción. Durante las operaciones de
consulta y carga los operadores monobit SBO's se almacenan en un
acumulador de un bit (
Monobit Accumulator) (SBA) de la CPU.
Los operandos Multibit (MBO) pueden compararse por valor (<, >, =,
etc.),
(rango 0-255, 0-65535, +/- 32767 etc.) o compararse contra otros
operandos multibit en la parte condicional de la instrucción. En la parte
ejecutiva de la instrucción del programa, los operandos multibit pueden
ser cargados con un valor, decrementados o incrementados, o
manipulados gracias a un interesante juego de operaciones aritméticas
o lógicas.
Durante las operaciones de consulta y carga los MBO's se cargan en
el acumulador MultiBit (MBA) de la CPU.
Más adelante se da información completa del uso de operandos Single
y Multibit.
La sección siguiente presenta un sumario de los operandos

disponibles Monobit (Single) y (Multibit) para los controladores
programables de Festo. Más adelante se proporciona una completa
descripción, junto con ejemplos de uso.
30/01/02
Dependiendo del operando específico, puede ser posible usar a éste

en la parte Condicional, en la Ejecutiva, o en ambas partes de una
instrucción.
Una instrucción del PLC siempre cuenta con ambas partes, una
Condicional, en la que se fijan las condiciones a ser tenidas en cuenta,
y otra ejecutiva, en la que se realizan tareas si, y solo si se cumplen
las condiciones prefijadas en la otra parte. Son condiciones comprobar
el estado (activo / inactivo) de un sensor, acciones activar (set) un
actuador o desactivarlo (reset).
De ahora en más se usará la palabra set para denominar la activación
y reset para la operación contraria.
Operandos Monobit (Single Bit Operands=Operandos de un bit)
La tabla siguiente proporciona información relativa a los operandos
Monobit, cómo se abrevian en el lenguaje STL y también un ejemplo.
La columna part indica si el ejemplo respectivo es válido para la parte
Condicional (c) o Ejecutiva (e) de la instrucción.
Una explicación detallada de cada operando en STL puede
encontrarse más adelante en este documento.
Operando FormatoS Sintaxis Parte Ejemplo Típico

TL
Input I In.n c IF I2.0
Output O On.n c IF O2.6

Output O On.n e SET O2.3
Flag F Fn.n c IF F7.16 (nota: estas son
llamadas 'bobinas internas'
por otros proveedores no
Festo)
Flag F Fn.n e RESET F9.3
Counter C Cn c IF C3
Counter C Cn e SET C5
Timer T Tn c IF T7
Timer T Tn e SET T4
Program P Pn c (*) IF P2
Program P Pn e (*) SET P3
Processor Y Yn c (*) IF Y2
Processor Y Yn e (*) RESET Y1
Error Status E E (*) IF E
Auto Restart ARU ARU (*) IF ARU
NOTA: Los operandos marcados con '*' pueden diferir o no estar

disponibles en todos los modelos de controladores.
Se han mantenido los nombres en inglés de los operandos de modo
de no confundir al lector y acostumbrarlo a una nomenclatura única.

Operandos Multibit
30/01/02
La tabla siguiente proporciona información general de los operandos

Multibit, cómo se abrevian en el lenguaje STL y también un ejemplo.
Operando FormatoS Sintaxis Parte Ejemplo Típico

TL
Input Word IW IWn c IF (IW3=V 255)
Output Word OW OWn c IF (OW2=V80)

Output Word OW OWn e LOAD V128 TO OW3
Flag Word FW FWn c IF (FW3=V220)
Flag Word FW FWn e LOAD V21000 TO FW1
Function Unit FU FUn c IF (FU32=V16)
Function Unit
FU FUn e LOAD FU34 TO R60
Timer Word TW TWn c IF (TW2<V2000)
Timer Word TW TWn e LOAD V1345 TO TW6
Timer Preselect TP TPn c IF (TP0<V20)
Timer Preselect TP TPn e (*) THEN LOAD V500
TO TP4
Counter Word CW CWn c IF (CW3<>V50)
Counter Word CW CWn e THEN INC CW5
Count.Preselect CP CPn c IF (CP3=V555)
Count.Preselect CP CPn e LOAD V67 TO CP5
Register R Rn c IF (R60=V2113)
Register R Rn e LOAD (R53+R45)
TO R32
Error Word EW EW c IF (EW AND V15)
Error Word EW EW e LOAD V0 TO EW
NOTA: Los operandos marcados con '*' pueden diferir o no estar

disponibles en todos los modelos de controladores.
Se han mantenido los nombres en inglés de los operandos de modo
de no confundir al lector y acostumbrarlo a una nomenclatura única.
30/01/02

Operandos Locales y Globales
Algunos modelos de controladores admiten multiples CPU en un

mismo sistema (ver Apéndices A y C). Al construir tales sistemas,
algunos operandos se denominan locales (local), mientras que otros
son llamados globales (global).
Operandos Globales
Los operandos Global (globales) son aquellos que son parte de un
sistema en el que pueden ser accedidos por cualquier programa en
cualquiera de las CPU. Ejemplos típicos de elementos globales
incluyen, Entradas (Inputs), Salidas (Outputs) y Flags (Marcas).
Para que este acceso global sea posible, estos operandos deben ser
únicos en sus convenciones de denominación.
Operandos Locales (Local)
Los operandos Local (locales) son parte de un sistema en el cual solo
pueden ser accedidos por programas en una única y particular CPU.
Generalmente estos operandos residen dentro de la CPU local y no
tienen nombres globales únicos, sino que pueden repetirse.
Si el modelo de controlador a usar no admite un numero de CPU o un
número de Módulo al referirse a un operando, entonces éste es
clasificado típicamente como local.
Por ejemplo, si un sistema contiene múltiples CPU, cada una de ellas

podría tener Timers 0-31 los que se referenciarían como T0-T31 en los
programas STL.
Aún más, podría darse el caso de un programa corriendo en CPU 0
que haga referencia al Timer 6 (T6) y también tener un programa en
CPU 1 que se refiera al Timer 6 (T6). En esta situación, el sistema,
contiene dos (2) timers totalmente independientes, ambos
denominados T6.... pero uno en cada CPU.
Aunque esto debería aclararlo el manual del modelo del controlador
que use, los siguientes operandos son generalmente tomados como
locales:
• Registers (Registros)
• Timers (Temporizadores)
• Counters (Contadores)
• Function Units (Unidades de Función)
• Programs (Programas)
• Processors (Procesadores)
30/01/02

Operadores
El lenguaje STL usa los siguientes operadores y notaciones para usar

en la construcción de instrucciones.
Símbolo Propósito
N NOT (negación)
V VALOR asignación para operandos Multibit (decimal)
V$ VALOR asignación para operandos Multibit (hexadecimal)
V% VALOR asignación para operandos Multibit (binary)
+ Suma de operandos Multibit y constantes
- Resta de operandos Multibit y constantes
* Multiplicación de operandos Multibit y constantes
/ División de operandos Multibit y constantes
< Comparación Multibit ...Menor que
> Comparación Multibit...Mayor que
= Comparación Multibit...Igual a
<> Comparación Multibit...No Igual a
<= Comparación Multibit...Menor o Igual que

>= Comparación Multibit...Mayor que o Igual a
() Apertura/Cierre de paréntesis usados para especificar o

calificar el orden de Precedencia de los operandos en las
operaciones Aritméticas y Lógicas.
30/01/02
30/01/02
5. Estructura del Programa STL
30/01/02

Contenidos
RESUMEN...................................................................................... 25
DETALLES ..................................................................................... 25
Jerarquía de los Elementos STL................................................. 26

Instrucción Step............................................................................... 26
Sentencias....................................................................................... 26
Sentencias Típicas ......................................................................... 27
Más ejemplos ................................................................................. 27
Comparación con el Ladder Diagram.............................................. 28
Instrucción Step............................................................................ 29
Reglas de Ejecución..................................................................... 30
Modificando el Flujo del

Programa ....................................................................................... 32
Instrucción NOP.............................................................................. 32
Instrucción JuMP............................................................................. 33
Instrucción OTHRW........................................................................ 34
30/01/02

RESUMEN
Este capítulo presenta la arquitectura básica del lenguaje STL e

introduce los elementos más importantes.
Se incluyen fragmentos de programas para ilustrar los puntos
importantes.
Aunque algunos de los programas puedan usar términos que al lector
no le sean familiares, los comentarios incluidos deberían
proporcionarle aclaración suficiente.
El lenguaje STL le permite al programador resolver tareas de control
usando expresiones sencillas en Inglés, las que describen la operación
deseada del controlador.
La naturaleza modular del lenguaje permite al programador resolver
tareas complejas de una manera eficiente.
El lenguaje STL como se describe aquí se aplica a los controladores
de Festo
Modelos FPC100B/AF, FPC405, FEC, IPC y SF03.
La estructura del lenguaje STL permanece consistente en todos estos
modelos.
Características particulares en el Hardware que solo están disponibles
en modelos específicos, no serán analizadas en detalle en este
documento. La información de tales características puede encontrarse
en el manual del equipo respectivo.
La información contenida en este documento se corresponde con el
lenguaje STL
Según la implementación del FST Software Versión 3.X.
DETALLES
Los programas en Statement List están construidos usando
diferentes elementos importantes. No es necesaria la totalidad de
estos elementos, siendo además importante la forma en que esos
elementos son combinados ya que influyen de modo importante en la
operación del programa.
Esta sección introducirá esos elementos y cómo ellos trabajan juntos
en un programa. Después de esta breve introducción, se proporciona
una más detallada presentación de cada elemento.
30/01/02

Jerarquía de los
Elementos STL
PROGRAM
STEP
SENTENCE
CONDITIONAL PART
EXECUTIVE PART
Instrucción Step
Aunque el uso de la instrucción STEP (Paso) es opcional, la mayoría

de los programas requieren su uso. La instrucción STEP se utiliza para
marcar el comienzo de un bloque lógico de código de programa. Cada
programa STL puede contener hasta 255 STEPS discretos, pudiendo
cada uno de estos STEP incluir una o más Sentences (o enunciados).
Cada Step puede tener asignada una etiqueta (label), esto es a
voluntad del programador, y puede ser requerida para referencia futura
del Step.
Un Label para un Step solo es requerido si el Step respectivo será
asignado como destino por una instrucción de salto (Jump). Más
adelante, después de la introducción de Sentences se presenta una
descripción más detallada de Step.
Sentences
La Sentence (Sentencia: oración o enunciado) forma el nivel más

básico de la organización del programa. Cada Sentence consiste en
una Parte Condicional y una Parte Ejecutiva .
La Parte Condicional sirve para enumerar una o más condiciones que
deben evaluarse cuando el programa está corriendo y que pueden ser
ciertas o falsas. La parte Condicional siempre comienza con la
expresión IF y continúa con uno o más enunciados que describen las
condiciones a ser evaluadas.
Si las condiciones programadas son evaluadas como true (verdaderas) ,
entonces cualquier instrucción programada en la parte Ejecutiva será
cumplida. El comienzo de la parte Ejecutiva está marcado por la
expresión THEN .
30/01/02

Sentencias Típicas
La siguiente sección presenta varias sentencias típicas en STL sin el

uso de la instrucción Step.
IF I1.0 Si Input 1.0 está activa

THEN SET O1.2 entonces conmutar a si Output 1.2
IF N I2.0 Si Input 2.0 NO está activa


AND N I2.1 y la Input 2.1 no está activa
AND O3.1 y la Output 3.1 está activa
THEN RESET O2.1 entonces apagar Output 2.1
RESET T6 y reset Timer 6
En el ultimo ejemplo, se ha introducido el principio de condiciones

compuestas. Es decir, todas las condiciones establecidas en la
sentencia deben cumplirse (ser verdaderas) para que las acciones
después de la expresión THEN sean ejecutadas.
Más Ejemplos
IF I3.2 Si Input 3.2 está Activa

OR N T6 o Timer 6 NO está corriendo
THEN INC CW1 entonces incrementar Counter 1
SET T4 y arrancar Timer 4 con parámetros
preexistentes
Este ejemplo muestra el uso de la estructura OR en la parte

condicional de una sentencia. Por lo tanto, la sentencia será evaluada
como verdadera (y se incrementará el Contador 1 y se arrancará el
Timer 4) si alguna o ambas de las condiciones establecidas son ciertas.
La próxima sentencia introduce el uso de paréntesis en la parte

condicional para establecer la forma en que las condiciones son
evaluadas.
IF ( I1.1 Si Input 1.1 está Activa Y

AND T4 ) Timer 4 está corriendo
OR ( I1.3 O si Input 1.3 está Activa
AND I1.2 ) e Input 1.2 está Activa
Hemos usado la instrucción OR para combinar por medio del

paréntesis dos condiciones compuestas.
30/01/02

Los ejemplos previos se han introducido para mostrar el uso de
sentencias en el Lenguaje Statement List. Es posible crear programas
enteros que consistan solo en múltiples sentencias sin usar la
instrucción STEP .
A los programas construidos de esta forma se les llaman programas
paralelos. Estos programas se comportan casi de la misma forma que
los programas en el Lenguaje Ladder Diagram. Esto es sin usar la
instrucción Step. Para que estos programas puedan funcionar y ser
procesados continuamente, es necesario agregar la instrucción PSE
(ver los capítulos 7 y 8).
Comparación con el
Ladder Diagram
Para quienes están familiarizados con el Lenguaje Ladder Diagram,

puede decirse que hay gran similitud entre una sentencia STL y una
rama en Ladder Diagram.
Por ejemplo, una rama en Ladder Diagram para activar una salida
(ponerla a ON) siempre que la entrada esté activa, y apagarla (OFF)
cuando la entrada esté inactiva sería de la siguiente forma:
I1.0 O2.6
|----] [----------------------------( )--------|
Mientras que la sentencia equivalente STL sería:

PSE fin de programa
OTHRW RESET O2.6 de otra forma apagar Output 2.6
PSE fin de programa
Se verá la inclusión de la instrucción OTHRW en este ejemplo. El

lenguaje STL requiere instrucciones explícitas para alterar el estado de
cualquier operando (por ej. Output, Timer, Counter).
La instrucción PSE se coloca al final de la sección del programa
paralelo para forzar al programa a ejecutarse continuamente
retornando a la primera sentencia del Step corriente o a la primera
sentencia del programa si no hubiera Steps. Vea el capítulo 7.
30/01/02

Instrucción Step
Los programas que no usan la instrucción STEP son procesados en

forma paralela (barrido).Aunque este tipo de programa puede ser apto
para resolver cierto tipo de tareas de control, el lenguaje STL provee la
instrucción STEP. Esta instrucción permite que los programas sean
divididos en secciones discretas (STEPS) que serán ejecutadas
independientemente.
En su forma más simple un STEP, incluye al menos una sentencia y
toma la siguiente forma:
STEP (label)
IF I1.0 Si la Input 1.0 es Activa
THEN SET O2.4 entonces activar Output 2.4 y
proceder al próximo step
Es importante comprender que el programa esperará en este Step
hasta que las condiciones sean ciertas, en ese momento las acciones
serán ejecutadas y entonces, sólo entonces, el programa seguirá al
próximo Step.
La etiqueta (label) del Step solo es requerida si un Step será el destino

de una instrucción de salto (JUMP) Debe notarse que cuando el
software FST carga los programas STL en el PLC, asigna números
relativos de Step a cada uno de estos. Estos números son
reproducidos en los listados de programas, siendo de gran ayuda para
monitorear la ejecución de programas On-Line con propósito de
búsqueda de fallas (debugging). Los Step de un programa, pueden,
incluir múltiples sentencias:
STEP
IF I2.2 Si Input 2.2 es Activa
THEN SET O4.4 Conmutar a activa Output 4.4
IF I1.6 Si Input 1.6 es Active
THEN RESET O2.5 Apagar Output 2.5
SET O3.3 y activar Output 3.3
En el ejemplo previo, se ha introducido el concepto de múltiples

Sentencias dentro de un Step único. Cuando el programa alcanza este
Step, procesará la primera sentencia (en este caso en particular
activando la salida Output 4.4 si la entrada Input 2.2 está activa) y
luego se moverá a la segunda sentencia sin importar si las condiciones
de la primera sentencia fueron verdaderas.
Cuando la última (en este caso la segunda) sentencia de un Step es

Procesada, si la parte Condicional es verdadera, entonces la parte
Ejecutiva será llevada a cabo y el programa procederá al próximo
Step.
Si la parte Condicional de la última sentencia es no verdadera ,
entonces el programa retornará a la primera sentencia del Step actual.
30/01/02

Reglas de Ejecución
Las siguientes líneas pueden aplicarse como guía para determinar

como los Steps y las sentencias serán procesados por el PLC:
• Si las Condiciones de una Sentencia se cumplen, entonces las

Acciones programadas serán Ejecutadas.
• Si las Condiciones de la última (o única) sentencia dentro de un

Step se cumplen, entonces las Acciones programadas serán
Ejecutadas y el programa procederá al próximo Step.
• Si las Condiciones de una Sentencia no se cumplen, entonces

el programa se moverá a la Sentencia siguiente en el Step
actual.
• Si las Condiciones de la última (o única) sentencia dentro de un
Step no se cumplen, entonces el programa retornará a la
primera sentencia del Step actual.
Nota:
Es importante comprender al desarrollar programas o Steps que
contengan múltiples Sentencias, que estas serán procesadas en
forma paralela (barrido); que cada vez que la parte Condicional de
una Sentencia sea evaluada como verdadera, las instrucciones
programadas en la parte Ejecutiva serán Ejecutadas. Esto
debe ser considerado para evitar ejecución múltiple y
descontrolada tales como SET TIMER (arrancar un timer) o
INC/DEC counter (incrementar/decrementar un contador).
El lenguaje STL no usa condiciones de ‘disparo por flancos’...las
condiciones se evalúan por verdadero o falso sin importar el estado
previo.
Esta situación es fácilmente manejada usando Steps, Flags u otro
medio de control. Vea el Apéndice B por ejemplos.
30/01/02

La Figura 5-1 ilustra la estructura de proceso de un Step STL. Usando
varias combinaciones de Steps con una o varias Sentencias, el
lenguaje STL brinda un amplio rango de posibilidades para resolver las
más complejas tareas.
Primera sentencia
o sentencia previa
en STEP X
¿Parte
Condicional
verdadera?
No
Acción
Si
¿Es esta ¿Es esta la

la última No No última
Sentencia Sentencia
del STEP del STEP
Si Si
Ir al próximo
Próxima Retornar a la
STEP primera
Sentencia del Sentencia del
STEP X STEP X
Figura 5-1 Reglas de Ejecución Básicas de Steps en STL
30/01/02

Modificando
el Flujo del Programa
Además de las estructuras de control inherentes dentro de la

instrucción Step, hay varias instrucciones adicionales STL disponibles
para modificar el criterio de ejecución de los Steps y Sentencias del
programa.
Instrucción NOP
La instrucción NOP puede usarse en la parte Condicional o en la

Ejecutiva de una sentencia.
Si es usada NOP en la parte Condicional, siempre es evaluada como

verdadera. La instrucción NOP puede usarse para la ejecución
incondicional de una sentencia.
IF NOP esto siempre es verdadero

THEN SET O1.0 entonces Output 1.0 será
siempre activada cuando el programa
ejecute esta línea.
El uso típico puede verse en el ejemplo siguiente. El programador

desea que cuando la ejecución del programa llegue al Step 50, se
verifiquen determinadas condiciones, y en caso de ser estas
verdaderas se ejecuten las acciones apropiadas.
Sin embargo, sin importar si alguna de las condiciones se cumplen,

después de pasar exactamente una vez el programa encenderá la
Output 3.6 y procederá al próximo Step .... esto es porque hemos
forzado la última sentence a ser verdadera mediante la instrucción
NOP.
STEP 50
THEN SET O2.2 entonces activar Output 2.2
IF N I3.5 Si Input 3.5 NO es Activa

AND I4.4 e Input 4.4 es Activa
THEN RESET O1.2 entonces apagar Output 1.2
IF T3 Si Timer 3 está corriendo

THEN SET F0.0 entonces set Flag 0.0
IF NOP en cualquier caso...nos

aseguramos que la ULTIMA sentencia sea
SIEMPRE verdadera
THEN SET O3.6 encender Output 3.6 , salir de

Este Step e ir al próximo Step.
30/01/02

La instrucción NOP puede usarse en la parte Ejecutiva de una
sentencia. Cuando se la usa de esta forma, un NOP es equivalente a
'hacer nada'. Se usa a menudo cuando el programa debe esperar por
ciertas condiciones y luego proceder al próximo Step.

THEN NOP no hacer nada e ir al
próximo Step.
Instrucción JuMP
Otra instrucción STL que puede usarse para modificar el flujo de

ejecución del programa es la instrucción JMP.
00La instrucción JMP permite al programa ramificarse. Modificando el
ejemplo previo es posible consultar las condiciones de cada sentencia
y si se cumplen ejecutar la acción programada y luego saltar (JuMP) al
Step designado del programa.
STEP 50
THEN SET O2.2 encender Output 2.2
JMP TO 70 y saltar a Step label 70
IF N I3.5 Si Input 3.5 NO es Activa

AND I4.4 e Input 4.4 es Activa
THEN RESET O1.2 apagar Output 1.2
JMP TO 6 y saltar a Step label 6
IF T3 si Timer 3 está corriendo

THEN SET F0.0 entonces set Flag 0.0
IF NOP Siempre verdadero, luego...

THEN SET O3.6 encender Output 3.6 e ir al próximo paso.
Puede verse que no solamente hemos alterado el flujo del programa,

sino que además hemos establecido prioridades entre las sentencias.
Por ejemplo, las sentencias 2, 3 y 4 solamente tendrán la posibilidad a

ser procesadas si la sentencia 1 es falsa y por lo tanto no ejecutada; si
la sentencia 1 se ejecuta, el programa saltará (Jump) al Step 70 sin
haber procesado ninguna de las sentencias siguientes en el Step 50.
30/01/02

Instrucción OTHRW
La instrucción OTHRW (otherwise – traducido: por otra parte/sino-)

puede cambiar el flujo del programa. Esta instrucción se ejecuta
cuando la última cláusula IF encontrada es evaluada como (not true )
no válida.

OTHRW SET O4.5 sino encender Output 4.5
Primera Sentencia o
Sentencia Previa en
STEP X
¿Parte
Condicional
Verdadera?
¿OTHRW
En esta
Sentencia?
Acción Ejecutar
Instrucción
OTHRW
¿Es esta la ¿Es esta la

ULTIMA ULTIMA
Sentencia del Sentencia del
STEP X? STEP X?
Ir al Póximo Próxima Retornar a la

STEP Sentencia del Primera Sentencia
STEP X del STEP X
Figura 5-2 Ejecución del Step con la instrucción OTHRW
30/01/02
6. Sumario de Instrucciones STL
30/01/02

El lenguaje STL tiene las siguientes instrucciones que permiten
resolver en forma rápida y sencilla tareas de control simples y
complejas. Una información detallada y ejemplos de uso se
presentarán en la próxima sección.
Instrucción Propósito
Lleva a cabo una operación Y-lógica en un operando

AND
monobit o multibit y en constantes.
Convierte el contenido del Acumulador Multibit de
BID
formato Binario a BCD.
Comienza la ejecución o inicialización de un Módulo
CFM n
de Función.
CMP n Comienza la ejecución de un Módulo de Programa.
Produce el complemento a dos del contenido del
CPL
Acumulador Multibit.
DEC Decrementa un Acumulador/Operando Multibit.
Convierte el contenido del Acumulador Multibit de
DEB
formato BCD a Binario.
Realiza una operación lógica EXOR en operandos
EXOR
monobit o multibit y constantes.
Este comando marca el comienzo de la parte
IF
Condicional de una sentencia.
INC Incrementa un Operando/Acumulador Multibit.
Produce el complemento a uno del contenido del
INV
acumulador multibit.
JMP TO Hace que el programa siga ejecutándose en el Step
(Step label) especificado por el label (etiqueta)
Realiza la carga de operandos especificados
LOAD (monobit o multibit) / constantes al acumulador
monobit o multibit.
Es una instrucción especial que siempre es
verdadera (siempre se cumple) en la parte
NOP
Condicional de una sentencia. En la Parte Ejecutiva
es equivalente a 'no hacer nada '.
Realiza la operación lógica OR en operandos
OR
monobit o multibit y constantes.
30/01/02
Instrucción Propósito
Permite continuar la ejecución del programa si la

OTHRW
parte Condicional de una sentencia es false .
La instrucción PSE significa (Program Section
End=Fin de la Sección del Programa).
PSE
RESET La instrucción Reset se usa para modificar
operandos monobit a su estado lógico '0'.
Rota a Izquierda una posición todos los bits
contenidos en el Acumulador Multibit . El bit más
ROL
significativo se mueve a la posición del menos
significativo.
Rota a Derecha una posición todos los bits
contenidos en el Acumulador Multibit . El bit menos
ROR
significativo se mueve a la posición del más
significativo.
La instrucción Set se usa para modificar operandos
SET
monobit a su estado lógico '1'.
Realiza la operación de transferencia (swap) entre un
SHIFT
Operando Monobit y el Acumulador Monobit.
Desplaza a izquierda todos los bit contenidos en el
acumulador Multibit una posición. El bit más
SHL
significativo se pierde, el menos significativo se llena
con un cero (0).
Desplaza a Derecha todos los bits contenidos en el
Acumulador Multibit una posición. El bit menos
SHR
significativo se pierde y el más significativo es
llenado con un cero (0).
Intercambia los bytes alto y bajo del Acumulador
SWAP
Multibit.
Se usa en conjunción con la instrucción LOAD para
TO
especificar un operando de destino.
Instrucción que marca el comienzo de la parte
THEN
Ejecutiva de una sentencia.
Instrucción usada para pasar parámetros con
WITH algunas instrucciones del tipo CFM/CMP. En algunos
modelos de PLC especifica velocidades de reloj.
30/01/02
30/01/02
7. Referencia de Instrucciones en STL
30/01/02

Contenido
AND..............................................................……............................ 41
BID.......................................................................….…................... 43
CFM...............................................................................….............. 44
CMP.....................................................................................…........ 46
CPL......................................................................................…….... 48
DEB................................................................................................. 49
DEC................................................................................................. 50
EXOR................................................................................…........... 51
INC.........................................................................................…...... 53
INV................................................................................................…54
JMP TO.…....................................................................................... 55
LOAD...TO....................................................................................... 58
NOP................................................................................................. 61
OR................................................................................................... 63
PSE..................................…............................................................ 65
RESET.....................................….................................................... 66
ROL.................................................. .............................................. 67
ROR......................................................…....................................... 68
SET..............................................................…................................ 69
SHIFT.................................................................…......................... 70
SHL...........................................................................…................... 71
SHR.................................................................................…............ 73
SWAP.............................................................................................. 74
30/01/02

AND
Propósito
1. Para combinar dos o más operandos Monobit o Multibit usando la

operación lógica AND.
2. Para llevar a cabo la operación lógica de AND de dos operandos
multibit o de Variables (Valores) tanto en la parte Condicional como en
la Ejecutiva de una sentencia.
Ejemplos
Monobit

AND T6 y Timer 6 está corriendo
Multibit
El siguiente ejemplo muestra la operación lógica AND aplicada a

dos operandos de 8 bit:
0 0 1 0 1 1 0 1 operando 1 = 45 decimal
1 1 1 0 1 1 0 0 AND operando 2 = 236 decimal
0 0 1 0 1 1 0 0 resultado = 44 decimal
La función AND puede usarse con operandos Multibit tanto en la parte

Condicional como en la Ejecutiva de una Sentencia.
Cuando es usada en la parte Condicional de una Sentencia, esta

función puede usarse para realizar la operación AND con un tercer
operando Multibit o constante al resultado de aplicar la misma función
a dos operadores Multibit.
IF ( R6 el valor del Registro 6

AND R7 ) es AND'eados al del
Registro 7. El resultado
= V34 se compara con la
constante 34 decimal. Si
la igualdad se cumple,
THEN ... se realizarán las acciones
listadas a continuación del
THEN.
30/01/02

Es importante comprender que las sentencias anteriores no deben ser
interpretadas como:
"Si R6 =34 y R7=34 entonces ..."
Esta sentencia en STL debería ser escrita así:
IF ( R6 si esto es cierto...
= V34 )
AND y
( R7 si esto es cierto...
= V34 )
THEN ... entonces...
El próximo ejemplo muestra cómo usar la capacidad multibit de los

controladores Festo de poder leer un grupo entero (Word) de entradas
(Inputs). Luego el resultado es lógicamente ANDeado con el valor 15
decimal (00001111 binario).
Comparando los resultados de esta operación para ver si el resultado
es mayor que cero, estaremos capacitados para controlar si alguna de
las entradas entre 0.0 y 0.3 están activas.
IF ( IW0 Si la Input Word 0

AND V15 ) es AND'eada con la constante
Decimal 15, y el resultado es
Comparado si es mayor
> V0 que el valor 0
THEN .... la sentencia será verdadera
El próximo ejemplo muestra el uso de la función AND con operandos

multibit
en la parte Ejecutiva de una sentencia.
IF ... Si las condiciones son ciertas
THEN LOAD ( R38 entonces transferir el Registro
38 al Acumulador Multibit
AND R45 ) AND'ear lógicamente al Registro
45 y colocar el resultado
TO R17 en el Registro 17
30/01/02

BID
Propósito
Para convertir el acumulador multibit del formato Binario al formato

BCD.
Esta instrucción a menudo se usa en conjunción con un dispositivo
conectado a las salidas del PLC (por ejemplo pantallas MMI, control de
motores, etc.).
Estos dispositivos esperan comandos de entrada en formato BCD.

Refiérase a la instrucción DEB para la conversión de formato BCD a
formato Binario.
Ejemplos
El valor a ser convertido debe primero ser cargado al acumulador
multibit.
IF I1.0 Botón de Arrancar Servo motor

THEN LOAD R26 Registro 26 contiene la nueva
Información de posición
BID Convertir al formato BCD
AND V15 enmascarar todos los bits excepto 0-3
TO OW2 y transferir el resultado a la
Output Word 2 (conectada al servo
controlador)
Por favor, nótese que el rango permitido máximo es de 0-9999.
30/01/02

CFM
Propósito
La instrucción CFM (Call Function Module=Llamada al Módulo de

Funciones) se usa para requerir la ejecución de una rutina estándar
del sistema que reside en la memoria interna del Sistema del
controlador.
Debe dirigirse al manual que acompaña el controlador que está
usando para ver cuales son los CFM que puede llamar en su equipo
en particular. Estas rutinas estándar no pueden ser escritas por el
usuario ya que son parte integral del hardware del sistema operativo
del controlador.
Algunos Módulos de Función pueden usar Unidades de Función
(Function Units (FU)) para pasar información hacia y desde los
programas del usuario.
Ejemplos
Dependiendo del modelo específico de controlador, así como de la

rutina CFM a llamar, puede ser necesario suministrar ciertos
parámetros cuando se programa una rutina CFM.
Ejemplo 1:
FPC100
Esta rutina del sistema puede usarse para limpiar o resetear
incondicionalmente una variedad de operandos. La llamada a estos
CFM acepta un parámetro numérico único. Si usamos un Valor de, el
Módulo de Función hará el Reset de TODOS los Flags a 0's.
IF I1.2 Si es Presionado el botón de Reset

THEN CFM 0 Call Function Module 0
WITH V2 pasa un valor de 2 como
parámetro número 1, lo que aquí
significa que TODOS LOS FLAGS
sean puestos en el estado de RESET.
30/01/02

Ejemplo 2:
FPC405
Esta rutina del sistema puede usarse para habilitar el conteo de
eventos alta velocidad manejados por interrupciones en la Input 0 de la
CPU de Interrupciones del FPC405. Este CFM requiere que varios
parámetros acompañen la llamada del sistema.
El primer parámetro especifica el número del programa que queremos
ejecutar cuando nuestro conteo final sea alcanzado. El segundo
parámetro nos permite especificar si queremos reconocer el flanco
ascendente o el descendente de la señal. El Tercer parámetro permite
especificar el número preseleccionado de pulsos que queremos contar
antes de ejecutar programa cuyo número es especificado en el
parámetro número 1.
IF I2.2 Si es Presionado el botón de Reset AND

N O2.1 y el motor está parado
THEN SET O2.1 Arranque el Motor
CFM 2 Call Function Module 2,
Habilitando la función de interrupción
Para la CPU Input 0
WITH V6 Número de Programa a correr cuando
La cuenta final se alcance
WITH V0 especifica mirar el flanco ascendente
De la señal
WITH V200 cuenta final es 200
30/01/02

CMP
Propósito
La instrucción CMP (Call Program Module=Llamada de Módulo de

Programa) se usa para solicitar la ejecución de una rutina de programa
externa. Los módulos de Programa pueden considerarse similares a
subrutinas.
NOTA: NO es posible usar la instrucción CMP dentro de un Módulo de
Programa.
Los Módulos de Programa pueden ser escritos en diferentes
lenguajes, incluyendo STL y Assembler. Festo puede suministrar un
número de módulos de programa optimizados para el manejo de
tareas especiales, tales como:
• Entrada/Salida de texto
• Conteo de Alta Velocidad
• Funciones aritméticas de 32 bit
Si usted tiene una tarea que no puede manejar usando las facilidades
estándar provistas con el lenguaje, contacte por favor a su oficina
Festo ... ¡puede ser que ya hayamos resuelto su problema!
Algunos Módulos de Programa pueden usar Unidades de Función

(denominadas en Inglés Function Units (FU), para transferir la
información hacia y desde los programas del usuario.
Refiérase por favor a la instrucción CFM para llamar a rutinas estándar
de Festo residentes en Rom (Read Only Memory).
Ejemplos
Dependiendo del modelo específico de controlador, así como del

módulo de Programa a ser llamado, puede ser necesario suministrar
algunos parámetros al usar el CMP.
Ejemplo: FPC100
Este módulo de programa puede usarse para transmitir texto. La

llamada a este CMP en particular acepta distintos parámetros
dependiendo de la función deseada.
IF I1.5 si el sensor de nivel alto del tanque

THEN CMP 7 entonces llamar Módulo de Programa 7
WITH V0 especifica salida cadena de caracteres
WITH 'Tanque #1 Lleno'
30/01/02

El ejemplo previo sirve solamente para tener una idea general sobre la
forma en que los Módulos de Programa son llamados. Los
procedimientos reales pueden variar mucho de lo descrito. Se
recomienda por ello al lector leer la documentación que acompaña al
controlador lógico en particular.
Módulos Simples:
En aquella situación en la que el usuario solamente escriba una
subrutina como un módulo de programa, no es necesario pasar ningún
parámetro. En tales casos, la llamada simplificada puede hacerse de la
siguiente forma:
IF...
THEN CMP 4 llamar un módulo de programa no
Requiere ningún parámetro
30/01/02

CPL
Propósito
Este comando complementa al acumulador multibit usando el método
del complemento a dos.
En principio, el efecto de usar la instrucción CPL es lo mismo que

multiplicar un número por -1 cuando se aplica a enteros con signo.
Ejemplos
Lo siguiente ilustra el uso de la instrucción CPL a un número de 16 bit

que ha sido cargado al acumulador multibit.
0 0 0 1 0 0 1 0 0 1 1 0 0 1 1 4711
1 1 1 0 1 1 0 1 1 0 0 1 1 0 0 CPL = - 4711
El valor a ser procesado debe primero cargarse en el acumulador

multibit. En el ejemplo siguiente, el programa verá si el Registro 32
contiene un número negativo, si es así convertirá el número a un valor
positivo y lo almacenará en el Registro 22.
IF ( R32 comprobar que el Registro 32 es

< V0 ) menor que 0....un valor negativo
THEN LOAD R32 si es negativo cargarlo al

Acumulador multibit
CPL aplicar la instrucción de complemento
Y copiar el resultado
TO R22 al Registro 22.
30/01/02

DEB
Propósito
Convertir el contenido multibit del formato BCD al formato Binario.

Es común que varios equipos periféricos reporten información (valores,
etc.) a un PLC a través de las entradas estándar del PLC. Para
minimizar el número de Entradas requeridas, los equipos periféricos
pueden usar codificación BCD.
Ya que la instrucción DEB opera sobre el acumulador multibit, el valor
a convertir debe primero ser cargado en el acumulador Multibit.
Ejemplos
Por ejemplo, si usamos dos llaves tipo "thumbwheel" BCD para
ingresar el número de ciclos que una máquina debería andar, podría
usarse el programa que se detalla a continuación.
Hemos conectado las llaves BCD a las Inputs 0-7 de la Input Word 1 e
Input 0.3 es usada para entrar los valores actuales, los que son
almacenados en la Counter Word 2.
IF I0.3 Cuando Input 0.3 es activa,

THEN LOAD ( IW1 copiar Input Word COMPLETA
Al Acumulador Multibit
Y luego usar la función AND
AND V255) para enmascarar Inputs 0.8-15.
Dependiendo si o no
Inputs 0.8-15 existen, esto
Asegura que solo tengamos el
Verdadero valor de las llaves BCD
En el acumulador.
DEB Realiza la conversión BCD a
Decimal y luego copia el resultado
TO CW2 al Counter Word 2.
Por favor note que el rango permitido es 0-9999.
30/01/02

DEC
Propósito
La instrucción DECrementar reduce el valor de cualquier operando

multibit en una cuenta de 1. A diferencia de otras instrucciones
aritméticas, la operación DECrementar debe ejecutarse directamente
sin la necesidad de cargar los operandos a ser DECrementedos al
acumulador multibit.
Mientras la instrucción DECrementar puede usarse con cualquier

operando multibit, es a menudo más usada con Counters
(Contadores).
El Capítulo 10 contiene información detallada y específica de cómo
trabajar con ellos.
Ejemplos
En el siguiente ejemplo que en una línea de llenado de botellas, la

Input 1.3 se activa cada vez que una botella pasa por una estación de
conteo. El número total de botellas será almacenado en el Register 9.
Sin embargo, algunas veces una botella no es llenada completamente,
esto que es controlado más adelante en el proceso de producción. Si
se detecta una botella parcialmente llena, la cuenta total debe ser
reducida en 1.
IF I1.3 Input 1.3 sensa todas las botellas

Que queremos contabilizar
THEN INC R9 le sumamos 1 a la cuenta almacenada
IF I2.2 Cuando llega una botella
A la estación
AND N I3.6 y no se la ha llenado completamente
THEN DEC R9 restar 1 del total
La instrucción DECrementar anterior (DEC) es equivalente a:
IF...
THEN LOAD R9 carga R9 al acumulador Multibit
- V1 resta 1
TO R9 y copia el resultado a R9 nuevamente
30/01/02

EXOR
Propósito
Combinar dos o más operandos monobit o multibit en la parte

Condicional o Ejecutiva de una Sentencia usando la operación lógica
EXOR (EXclusive OR).
Ejemplos
Monobit
En el siguiente ejemplo, la Output 1.3 será conmutada a Sí cuando

I1.1 lo sea o cuando I1.2 lo sea, pero NO cuando ambos sean activas.
IF I1.1 Si I1.1 o I1.2 son activos

EXOR I1.2 (PERO NO AMBOS!)
THEN SET O1.3 activar Output 1.3
Multibit
Lo siguiente ilustra la operación lógica EXOR aplicada a dos
operandos de 8 bit:
EXOR with operand 2
1 1 1 0 1 1 0 0
=236decimal
1 1 0 0 0 0 0 1 resulta = 193 decimal
Cuando se usa en la parte Condicional de una Sentencia, esta función

permite que el resultado de dos operandos Multibit sean comparados
contra un tercer operando Multibit o una constante.
En el siguiente ejemplo, usaremos el poder de la función EXOR para
controlar una estación de llenado de 8 botellas. Las 8 posiciones de
llenado están localizadas en parte de un sistema de transporte de
botellas. A medida que las botellas pasan éstas deben ser controladas.
En cualquiera de las 8 posiciones es posible que la botella esté o no
presente. Cualquier botella no llenada deberá ser llenada y cuando
todas las botellas presentes sean llenadas la línea de botellas
continuará moviéndose estando preparada para el nuevo grupo a
llenar.
30/01/02

La Input word 0 (I0.0-I0.7) está conectada a los sensores de botella
presente y la Input word 1 (I1.0-I1.7) está conectada a los sensores de
botellas llenadas.
La Output word 0 (O0.0-O0.7) controla los llenadores de líquido,
mientras que la Output 1.0, cuando está set (activa) cierra una
compuerta, manteniendo así las botellas en el lugar de llenado.
STEP 10
IF N O1.0 las botellas no son detenidas
AND I0.7 y existe botella en la posición 7
THEN SET O1.0 entonces detener movimiento botellas
LOAD ( IW0 ver cuales botellas están presentes
EXOR IW1 ) y si NO están llenas. Entonces encender
TO OW0 las salidas para llenar botellas
IF ( OW0 Si todas las salidas están apagadas
= V0 )
AND O1.0 y las botellas estuvieron detenidas
Para ser llenadas...
THEN RESET O1.0 permitir a las botellas moverse
JMP TO 10 volver al Step 10
30/01/02

INC
Propósito
La instrucción INCrementar (INC) incrementa el valor de cualquier

operando multibit en 1.
A diferencia de otras instrucciones aritméticas, la operación
INCrementar puede realizarse sin necesidad de cargar primero el
operando a ser INCrementado al acumulador multibit.
Mientras que la instrucción INCrementar puede usarse con cualquier
operando multibit, a menudo es más usada en conjunción con
Counters.
El Capítulo 10 contiene información específica y detallada sobre cómo
trabajar con Counters.
Ejemplos
En el siguiente ejemplo supondremos que en una línea de llenado de

botellas, la Input 1.3 se activa cada vez que la botella pasa por una
estación de conteo. El número total de botellas debe ser almacenado
en el Register 9.
Sin embargo, algunas veces, una botella no es completamente
llenada, esto es controlado más adelante en la línea de producción. Si
se detecta una botella parcialmente llenada la cuenta total existente
debe ser reducida en 1.
IF I1.3 Input 1.3 sensa todas las botellas

Las que queremos totalizar
THEN INC R9 entonces sumar 1 a la cuenta existente
IF I2.2 Cuando una botella llega a la estación
De control de nivel
AND N I3.6 y no está adecuadamente llenada
THEN DEC R9 restar 1 del total
La instrucción INCrementar anterior es equivalente a:
IF ...
THEN LOAD R9 cargar R9 al Acumulador Multibit
+ V1 sumar 1
TO R9 y copiar el resultado a R9
30/01/02

INV
Propósito
Este comando hace el complemento (INVierte) el contenido del

acumulador usando el método del complemento a uno.
Cuando se aplica a enteros con signo, esto es equivalente a multiplicar
un número por –1 y luego adicionarle –1.
Ejemplos
Lo siguiente ilustra la aplicación de la instrucción INV a un número de

16 bit el que ha sido cargado en el acumulador multibit.
0 0 0 1 0 0 1 0 0 1 1 0 0 1 1 1 INV
1 1 1 0 1 1 0 1 1 0 0 1 1 0 0 0 =
La instrucción INV puede usarse cuando se desea invertir ('flip') todos

y cada uno de los bits contenidos en el acumulador multibit.
En el siguiente ejemplo, una máquina de mezcla tiene 16 estaciones.

El ciclo de mezclado consiste en alternar períodos de tiempo de
vibrado y de reposo.
Durante la operación normal, los trabajadores agregan o remueven
contenedores, de forma aleatoria. Solamente aquellas estaciones que
tienen contenedores en el lugar deberán ser activadas. Se suministran
sensores para saber cuales estaciones deben ser activadas.
STEP 10
IF N T1 No hay ciclos de tiempo en progreso
THEN LOAD OW1 Estado actual Outputs 0-15 para
Cada estación de vibrado se copia
Al acumulador multibit
INV ahora 'invertimos' el estado de cada
output...aquellas en Si a No
etc. (esto se hace solamente dentro
del MBA!)
AND IW1 ahora corregimos para cualquier estación
Que estaba NO, pero al pasar a SI
No tenían envase.
TO OW1 finalmente solo conmutamos en las
apropiadas Outputs.
SET T1 Arranca el timer
STEP 20 espera finalizar el proceso

IF N T1 fin periodo de tiempo
THEN JMP TO 10 volver Step 10
30/01/02

JMP TO
Propósito
Proveer un medio de alterar la secuencia de ejecución del programa,

basada en un criterio. Es análoga a la instrucción del BASIC
denominada GOTO.
Por favor, notar que el uso de la instrucción JMP TO puede remover el
requerimiento de que la última sentencia de un STEP sea cierta para
que la ejecución del programa continúe.
La instrucción JMP TO puede también usarse para priorizar la
ejecución de sentencias dentro de un Step.
Ejemplos
En el primer ejemplo la instrucción JuMP se usa dentro de un

programa paralelo para detectar, y luego reaccionar, a una condición
ESTOP (Emergency STOP=Parada de Emergencia. El Step 20
contiene todas las sentencias que serán procesadas en forma
paralela.
Notar que ESTOP es un botón normal-cerrado.
STEP 20
... sentencias prioritarias en Step 20
IF N I1.1 ver si ESTOP fue pulsada
THEN LOAD V0 si es así, APAGAR TODAS las Outputs
En grupo
TO OW0 Output Word 0
TO OW1 y Output Word 1
JMP TO 80 ir entonces a la rutina especial
... Sentencias restantes en el Step 20
STEP 80 Rutina ESTOP

IF I1.1 esperar aquí hasta que ESTOP
No sea más detectada
AND I2.1 y el botón de RESET sea apretado
THEN JMP TO 20 continuar en Step 20
El siguiente ejemplo usa saltos múltiples dentro de un Step e ilustra

una situación en la que el operador de la máquina debe seleccionar
entre 1 de 3 posibles opciones.
30/01/02

STEP 40 El operador DEBE elegir solo 1
de 3 posibles opciones
IF I1.1 secuencia 1 elegida
AND N I1.2 y no secuencia 2
THEN JMP TO 100 sección para secuencia 1
Sea cuidadoso al ordenar múltiples sentencias dentro de un Step,

junto con el uso adecuado de la instrucción JuMP, es sencillo dar
prioridad a secuencias operativas.
El próximo ejemplo supone que Steps más arriba del 50 contienen

instrucciones para el procesamiento de la máquina, y que una vez
alcanzado el STEP 60 la máquina debe controlar las Inputs 1.1, 1.2 y
1.3 y esperar hasta que la PRIMERA entrada aparezca, procesando
luego una de estas entradas con la Input 1.1 teniendo la más alta
prioridad e Input 1.3 teniendo la más baja.
STEP 60
IF N I1.1 esperar hasta que por lo menos una
AND N I1.2 de las input requeridas sea activa
AND N I1.3
THEN JMP TO 60
IF I1.1 input de más alta prioridad

THEN JMP TO 100 a step 100
IF N I1.1 nos aseguramos que no haya

AND I1.2 requerimiento de alta prioridad
THEN JMP TO 150 entonces a step 150
IF N I1.1 nos aseguramos que no haya

AND N I1.2 requerimiento de alta prioridad
AND I1.3
THEN NOP ok para seguir con el próximo
Sep del programa
30/01/02

LOAD... TO
Propósito
La instrucción LOAD realiza la copia (carga) de operandos Monobit y

Multibit
En el acumulador de un Bit y en el acumulador Multibit
(respectivamente) en preparación de:
1. realizar operaciones matemáticas y/o lógicas.

2. o como paso requerido intermedio para transferir información
entre operandos.
La parte ...TO de la instrucción sirve para especificar el destino del

operando.
La instrucción LOAD...TO es más menudo usada con operandos

Multibit.
Ejemplos
Cargas Monobit
Sintaxis Monobit
Origen Operación Opcional Destino
LOAD SBO ninguna TO SBO

LOAD I1.0 TO O1.0
LOAD SBO AND SBO TO SBO
LOAD I1.0 AND N I1.1 TO O1.0
Nota: SBO = cualquier Single Bit O perand (Operando Monobit)
Mientras que los ejemplos anteriores son instrucciones STL válidas, no

son típicamente usadas. Pero son equivalentes a:
IF I1.0 Si Input 1.0 es Activa entonces

THEN SET O1.0 activar Output 1.0 sino
OTHRW RESET O1.0 apagar Output 1.0
IF I1.0 Si Input 1.0 es Activa y
AND N I1.1 Input 1.1 NO es Activa
THEN SET O1.0 encender Output 1.0 sino
OTHRW RESET O1.0 apagar Output 1.0
30/01/02

Cargas Multibit
Sintaxis Multibit
Origen Operación Opcional Destino
LOAD MBO/V ninguno TO MBO
LOAD R6 TO TW1
LOAD MBO/V AND MBO/V TO MBO
LOAD R11 SHL TO CW4
LOAD CW2 + V3199 TO R28
Nota: MBO/V = cualquier Multi Bit Operand (Operando Multibit) o Valor
El uso de la instrucción LOAD con operandos Multibit y valores,

cuando se usa en conjunción con las operaciones matemáticas o
lógicas disponibles, suministra capacidades de procesamiento muy
poderosas.
Los siguientes ejemplos ilustran algunas de las diversas funciones que

pueden llevarse a cabo usando la instrucción LOAD.
Conmutando a apagado (off) TODAS las Outputs de un sistema

Supondremos que nuestro sistema tiene 64 Outputs organizadas en
palabras (words) de 4x16 bit. Usando la instrucción RESET típica
requeriría una lógica de programa de la siguiente forma:
IF I1.0 por ej.: Botón de Reset

THEN RESET O1.0 apagar 1 Output
RESET O1.1 y otra ....
.... hasta repetir este comando
para cada una de las 64 Outputs.
Usando la instrucción LOAD el mismo resultado puede lograrse con:
IF I1.0 por ej.: Botón de Reset

THEN LOAD V0 poner a cero el Acumulador
Multibit
TO OW1 apagar Outputs 1.0 - 1.15
Note que una vez que un valor (en este caso 0 ) ha sido cargado en el
acumulador Multibit, puede copiarse (usando TO) a múltiples destinos
sin tener que ser recargado.
30/01/02

Sumario
La instrucción LOAD puede ser una de las más poderosas en el

lenguaje STL.
Es importante recordar que la instrucción LOAD solamente prepara el
sistema para las instrucciones que siguen.
Nota:
Cuando una instrucción LOAD se ejecuta, el Operando Multibit
especificado o el Valor es cargado en el Acumulador Multibit
(MBA).
El MBA es de un tamaño de 16 bits. Si el operando Multibit
especificado como origen (es decir LOAD MBO) es de un largo de
solo 8 bits (por ej. Un modulo de entradas/salidas con solo 8
puntos discretos) entonces el byte más alto del MBA será llenado
de ceros (0's).
De la misma forma, si el MBA es transferido (mediante la
instrucciónTO) a un destino de 8 bit de ancho, los 8 bits de la
parte alta se perderán.
Ejemplos adicionales que incluyen la instrucción LOAD pueden

encontrarse a lo largo de este capítulo como parte de las explicaciones
y ejemplos provistos por muchas de las instrucciones STL incluyendo:
SHL, SHR, ROR, ROL, SWAP, WITH, AND, OR, EXOR etc.
30/01/02

NOP
Propósito
La instrucción NOP (No Operation=No Operar, que en principio parece

carecer de valor es a menudo de mucha ayuda al programar.
La consecuencia real de la instrucción NOP depende de si es usada
en la parte Condicional o en la parte Ejecutiva de una sentencia.
Ejemplos
Parte Condicional
Al usarla en la parte Condicional de una sentencia, con la instrucción

NOP puede construirse una sentencia que siempre será evaluada
como cierta (siempre se cumple) de modo que cualquier instrucción
programada en la parte Ejecutiva será cumplida.
STEP 45
IF NOP siempre verdadero
THEN SET T6 arranca timer 6
SET O1.2 encender Output 1.2
Procesamiento Paralelo
Cuando un step de un programa contiene múltiples sentencias que
deban ser procesadas (barridas) continuamente, la instrucción NOP
puede usarse para controlar el flujo del programa.
STEP 11
IF I1.4 Si Input 1.4 es activa
THEN SET T4 arrancar Timer 4
IF I3.0 Input Marcha Manual
THEN SET O1.6 arranca Motor
OTHRW RESET O1.6 Sino detener Motor
IF T4 Si el Timer 4 está corriendo
AND O1.6 y el motor está funcionando
THEN INC CW3 incrementar conteo de ciclos
IF I2.2 Botón de Emergencia
THEN JMP TO 90 Salir de este barrido ...
IF NOP siempre ...
THEN JMP TO 11 continuar este barrido ...
STEP 90 rutina especial
IF N I2.2 Botón Emergencia liberado
AND I3.3 Botón Reset presionado
THEN JMP TO 11 volver a Step 11, sino esperar
30/01/02
7. Referencia de Instr ucciones en STL

Parte Ejecutiva
Cuando se usa en la parte Ejecutiva de una sentencia, la instrucción

NOP se evalúa como una instrucción ‘no hacer nada’. Aunque esto
pueda parecer que no tenga ningún valor práctico, es a menudo de
mucha utilidad cuando el programador desea esperar hasta que las
condiciones programadas sean ciertas antes de continuar con la
ejecución del programa.
STEP 60
IF I1.5 Input 1.5 activa
AND T7 Timer 7 corriendo
AND N C2 Counter 2 no activo
THEN NOP después que las condiciones anteriores
Sean todas satisfechas … proceder
STEP 70 ....
30/01/02

OR
Propósito
1. Para combinar dos o más operandos Monobit o Multibit en la parte

Condicional 1 de una sentencia usando la operación lógica OR.
2. Para llevar a cabo la operación lógica de OR de dos Operandos
multibit (o valores)
tanto en la parte Condicional como en la Ejecutiva de una sentencia.
Ejemplos
Monobit
IF I1.1 Si Input 1.1 Activa

OR T6 o Timer 6 corriendo
Multibit
El ejemplo siguiente ilustra la operación OR aplicada a dos operandos

de 8 bit:
1 1 1 0 1 1 0 0 OR operando 2 = 236 decimal
1 1 1 0 1 1 0 1 resultado = 237 decimal
La función OR puede usarse con operandos Multibit y valores tanto en

la parte Condicional como en la Ejecutiva de una Sentencia.
Cuando se usa en la parte Condicional de una Sentence, esta función
permite que el resultado de la función lógica OR de dos operandos
Multibit o valores, sea comparado a un tercer operando o valor Multibit.
IF ( R43 el contenido del Registro 43

OR R7 ) es OR'eado al contenido del
Registro 7. Y comparado si es
= V100 el resultado igual a 100
THEN ... si es así ejecutar las
Instrucciones previstas.
30/01/02

La sentencia anterior no debe ser interpretada como:
"If R43 =100 or R7=100 then ..."
ésta debería escribirse así:
IF ( R43 si esto es cierto...

= V100 )
OR o
( R7 si esto es cierto...
= V100 )
THEN ... entonces ...
El próximo ejemplo es el de una máquina que consiste en 16 rampas

de transporte paralelas, cada una de las cuales lleva componentes a
un área de ensamble. Los componentes son cargados manualmente a
uno o más de tres posibles ubicaciones en cada rampa. Cada rampa
tiene 3 sensores que verifican si las partes han sido cargadas.
Cuando las 16 rampas tienen al menos un componente cargado,
entonces cada una comenzará a moverse. Cuando una parte llegue a
la posición final de la rampa, ésta deberá detenerse. Cada rampa tiene
un sensor para detectar cuando una parte está presente en la posición
final.
STEP 50 El criterio para comenzar

IF ( OW1 todas las rampas están
detenidas (outputs 1.0 - 1.15 )
OR IW4 Y TODAS las 16 posiciones finales
Están limpias
= V0 )
AND ( IW1 sensores estación 1 cargada para
rampas 1,2,3
OR IW2 sensores estación 2 cargada para
rampas 1,2,3
OR IW3 Sensores estación 3 cargada para
rampas 1,2,3
= V65535 ) las 16 rampas tienen al menos
1 componente cargado
THEN LOAD V65535 poner entonces en marcha las 16 rampas
TO OW1 que son controladas por
Outputs 1.0 - 1.15
STEP 60 apagar cada rampa
THEN LOAD IW4 a medida que los componentes alcanzan
TO OW4 la posición final
IF ( OW4 cuando todas las rampas están
= V0 ) detenidas
THEN JMP TO 50 entonces comenzar de nuevo
30/01/02

PSE
Propósito
Marcar el fin del programa (Program Section End=Fin de la Sección del

Programa) y provocar un cambio de programa. Resultará también en
una transferencia Virtual de Procesador (Virtual Processor Swap) para
modelos de controlador que soporten multitarea (ver el Apéndice C).
Esta instrucción no está disponible para el FEC y la IPC.
Al retornar al programa que ejecutó la instrucción PSE, este continuará
procesando:
· en la primera sentencia del Step actual o

· en la primera sentencia del programa cuando no existan Steps
Ejemplos
Si un programa STL termina con una sentencia normal, y no hay más

instrucciones el programa se detendrá. Los programas o las secciones
de programas terminarán usando la instrucción PSE o la instrucción
JUMP TO.
Ejemplo 1
STEP 10
IF I1.1 Pulsador de arranque
THEN SET O2.1 Extender Cilindro
STEP 20
IF I3.1 Cilindro extendido
THEN RESET O2.1 retraer cilindro
PSE ir a la primera sentencia
OTHRW PSE ir a la primera Sentencia
Cuando el programa ha sido hecho sin etiquetas en los Steps (Step

labels), y debe ser procesado continuamente, como si fuera un barrido,
el programa debería terminar con la instrucción PSE.
Ejemplo 3
... sentencias anteriores
... "
... "
IF NOP siempre verdadero
THEN PSE fin sección de programa....volver
A la primera sentencia del programa
30/01/02

RESET
Propósito
La instrucción RESET se usa para cambiar el estado de operandos

Monobit a un nivel lógico cero 0 (cero).
RESETeando un operando que ya está reseteado no tiene efecto.
El efecto real de usar una instrucción RESET varía de acuerdo al
operando direccionado. La siguiente tabla resume el uso de la
instrucción RESET.
Información detallada usando la instrucción RESET puede encontrarse
en los capítulos 8, 9, 10 y 12.
Ejemplos
Operando Sintaxis Efecto

Output RESET O1.6 Desactiva Output 1.6
Flag RESET F2.12 Fuerza el estado del Flag 12.2 a
ser ‘0’
Counter RESET C6 El estado del Counter 6 pasa a
inactivo
Timer RESET T4 El estado del Timer 4 pasa a
inactivo
Program RESET P2 Programa 2 es detenido
Program status RESET PS2 Programa 2 suspendido
Error Status RESET E Borra Bit de Estado de Error
30/01/02

ROL
Propósito
La instrucción ROL (ROtate Left) o Rotar a Izquierda produce el

desplazamiento del Acumulador Multibit hacia la izquierda en una
posición. El bit más significativo (bit 15) es transferido a la a la posición
del bit menos significativo. Vea también las instrucciones ROR, SHR y
SHL.
Debería recordarse que la instrucción LOAD...TO se usa normalmente
con anterioridad para preparar al acumulador Multibit y nuevamente,
después de la instrucción ROL para copiar el resultado al deseado
MBO.
Ejemplos
Lo siguiente ilustra el efecto de usar la instrucción ROL.
0 1 0 1 0 1 1 0 0 0 0 1 1 1 0 1 LOAD
MBO
1 0 1 0 1 1 0 0 0 0 1 1 1 0 1 0 Primer
ROL
0 1 0 1 1 0 0 0 0 1 1 1 0 1 0 1 Segundo
ROL
0 1 0 1 1 0 0 0 0 1 1 1 0 1 0 1 A MBO
IF N T6 Si el Timer 6 no está corriendo

THEN LOAD OW1 cargar los 16 bit de la Output
Word 1 al MBA
ROL rotar izquierda primera vez
ROL rotar izquierda segunda vez
TO OW1 y copiar el resultado
En el mismo lugar....podría ser un
MBO!
Esta instrucción puede encontrar buen uso al aplicarla a maquinaria

que usa diferentes tipos de tablas rotativas o contenedores de modo
de seguir los índices de la maquina conociendo así el estado de la
producción.
30/01/02

ROR
Propósito
La instrucción ROR ROtate Right (o Rotar a derecha) desplaza el

acumulador Multibit a la Derecha una posición.
El bit menos significativo (bit 0) es transferido a la posición del bit más
significativo. Véase también las instrucciones ROL, SHR y SHL.
Debería recordarse que la instrucción LOAD...TO se usa normalmente
con anterioridad para preparar al acumulador Multibit y nuevamente,
después de la instrucción ROR para copiar el resultado al deseado
MBO.
Ejemplos
El ejemplo a continuación ilustra el efecto de usar la instrucción ROR.
0 1 0 1 0 1 1 0 0 0 0 1 1 1 0 1 LOAD
MBO
1 0 1 0 1 0 1 1 0 0 0 0 1 1 1 0 Primer
ROR
0 1 0 1 0 1 0 1 1 0 0 0 0 1 1 1 Segundo
ROR
0 1 0 1 0 1 0 1 1 0 0 0 0 1 1 1 A MBO
IF N T6 Si el Timer 6 no está corriendo

THEN LOAD OW1 cargar los 16 bit de la Output
Word 1 al MBA
ROR rotar derecha primera vez
ROR rotar derecha segunda vez
TO OW1 y copiar el resultado
En el mismo lugar....podría ser un
MBO!
Esta instrucción puede encontrar buen uso al aplicarla a maquinaria

que usa diferentes tipos de tablas rotativas o contenedores de modo
de seguir los índices de la máquina conociendo así el estado de la
producción.
30/01/02

SET
Propósito
La instrucción SET es empleada para cambiar el estado de operandos

Monobit al nivel lógico 1 (uno).
El efecto de usar la instrucción SET varía de acuerdo al operando

direccionado. La siguiente tabla proporciona un resumen de la
instrucción SET.
Puede encontrarse información detallada sobre el uso de la instrucción

SET en los Capítulos 8, 9, 10, y 12.
Ejemplos
Operando Sintaxis Efecto
Output SET O1.6 Conmuta Output 1.6 a activo
Flag SET F2.12 Fuerza el estado del Flag 12.2 a ser ‘1’
Counter SET C6 1. Counter Word 6 se le carga el valor 0

2. El bit de estado del Counter 6
(C6) es puesto a activo (=1).
Timer SET T4 1. El contenido de la Preselección del Timer
4 es copiado a la Timer Word 4.
2. El bit de estado del Timer 4 (T4) es
puesto a activo (=1).
Program SET P2 Programa Program 2 es arrancado desde el
inicio
Program SET PS2 Programa Program 2 continuará desde
donde fue suspendido por la instrucción
RESET PS2
30/01/02

SHIFT
Propósito
La instrucción SHIFT ejecuta un desplazamiento entre el Acumulador

de un bit (Single Bit
Accumulator o SBA) y un operando de un bit Single Bit Operand
(SBO).
Esta instrucción puede usarse para crear registros de desplazamiento
(Shift Registers) de diferente longitud... lo que puede ser mayor o
menor a los 16 bit manipulados por las instrucciones SHL y SHR.
Para operar correctamente, el SBA debe primero ser cargado y luego
cualquier numero de desplazamientos de un bit (SHIFT’s) pueden ser
programados.
Ejemplos
En el siguiente ejemplo, cada vez que la Input 1.0 se activa, el estado

de las Outputs 1.1 a 1.4 deben ser actualizadas:
Output 1.4 tomará el estado previo de la Output 1.3

Output 1.1 tomará el estado previo de la Input1.1
STEP 10
IF I1.0 Input Activada
THEN LOAD I1.1
TO F0.0 Un Flag se usa para evitar
'escribir' a una Input, lo que
de otra forma ocurriría.
SHIFT O1.1 SWAP F0.0 <-> O1.1
SHIFT O1.2 SWAP O1.1<-> O1.2
STEP 20
IF N I1.0 esperar por la Input seguir
THEN JMP TO 10 repetir
Ver la sección 12 (Flags y Flag Words) para un método alternativo de

construir Shift Registers.
30/01/02

SHL
Propósito
La instrucción SHift Left (Desplazar a Izquierda) desplaza el

acumulador Multibit (shifts) una posición hacia la izquierda.
El bit más significativo (bit 15) es descartado y la posición menos
significativa es llenada con un cero 0. Vea también las instrucciones
ROL, ROR, y SHR.
Un uso típico de la instrucción SHL es emular un Shift Register
(Registro de Desplazamiento).
La instrucción SHL puede usarse también para multiplicar cualquier
MBO (Operando Multibit) o un Valor por 2. El programador debe
controlar si hay desbordamiento (overflow).
Debería recordarse que la instrucción LOAD...TO es normalmente
usada antes para preparar el Acumulador Multibit y ejecutar luego la
instrucción SHL para copiar los resultados al MBO deseado.
Ejemplos
1 1 0 1 0 1 1 0 0 0 0 1 1 1 0 1 LOAD
MBO
1 0 1 0 1 1 0 0 0 0 1 1 1 0 1 0 SHL
1 0 1 0 1 1 0 0 0 0 1 1 1 0 1 0 Al MBO
Shift Register
Los ejemplos siguientes muestran el uso de la instrucción SHL en

combinación con un MBO para emular un shift register. A pesar de que
cualquier operando multibit puede usarse, hemos elegido usar una
Flag Word, esto es así puesto que las Flag
Words pueden ser direccionadas como un bit (monobit) y como una
word (ver Capítulo 12).
Supondremos que estamos controlando una máquina que ensambla
cartuchos de cinta para impresoras de computadora. El proceso
comienza en la estación 1 donde envases vacíos son colocados en la
línea de ensamble; hasta la estación 10, donde los envases llenos son
descargados a una máquina de empaque. En cada estación (1-10),
después de la respectiva operación de armado, se realiza una
comprobación de calidad. Aquellas piezas defectuosas son quitadas
inmediatamente. Además, solamente las estaciones con componentes
válidos son procesadas, cuando la máquina arranca por primera vez a
la mañana, cuando la máquina es apagada por la noche.
30/01/02

Mientras cada estación incluye sensores para asegurarse que ciertas
partes se posicionen adecuadamente previo a la operación, el uso de
un registro de desplazamiento simplificará enormemente nuestras
necesidades de procesamiento.
Para simplificar este ejemplo, consideraremos solamente a las
estaciones 1-3.
STEP 40 Procesar estaciones válidas...FW1

Contiene un patrón de bits de donde
Hay ensamblados válidos
IF F1.1 parte válida en Estación 1
AND N T1 operación hecha
AND N I2.1 Calidad Mala en Estación 1
THEN RESET F1.1 PARTE MALA REMOVIDA
IF T1 operaciones hechas
THEN SET O1.1 Índice línea de ensamble
STEP 50
IF N I2.0 Línea es indexada...
THEN LOAD FW1 obtener el registro de desplazamiento
SHL actualizarlo
TO FW1 alamacenarlo
STEP 60
IF I2.0 Indexado hecho
THEN RESET O1.1
JMP TO 20 continuar procesando...
Multiplicación
La instrucción SHL puede usarse para multiplicar el contenido del

acumulador multibit por 2 (MBA).
IF I1.0 Sensor de Partes

THEN LOAD R6 Registro 6
SHL multiplicar por 2
SHL otra vez, en realidad por x4
TO R6 y almacenar el resultado
30/01/02

SHR
Propósito
La instrucción SHift Right mueve, es decir desplaza (shifts) al

acumulador Multibit a la derecha una posición.
El bit menos significativo (bit 0) se descarta y la posición del bit más
significativo se llena con un 0. Vea también las instrucciones ROL,
ROR, SHL.
La instrucción SHR puede usarse para dividir un MBO (MultiBit
Operando) por 2.
El programador deberá controlar si hay algún tipo de desborde
(overflow/underflow) o si los dividendos son números impares, en cuyo
caso el resultado será incorrecto ya que solo se pueden usar números
enteros.
Debería recordarse que la instrucción LOAD...TO es normalmente
usada antes para preparar el Acumulador Multibit y ejecutar luego la
instrucción SHR para copiar los resultados al MBO deseado.
Ejemplos
División
1 1 0 1 0 1 1 0 0 0 0 1 1 1 0 1 LOAD
MBO
0 1 1 0 1 0 1 1 0 0 0 0 1 1 1 0 SHR
1 0 1 0 1 1 0 0 0 0 1 1 1 0 1 0 Al MBO
30/01/02

SWAP
Propósito
Intercambia (swaping) el byte de orden alto (bits 8-15) y el de bajo

orden (bits 0-7) del acumulador Multibit.
El acumulador Multibit debe cargarse con el MBO (Operando Multibit)

apropiado antes de ejecutar la instrucción SWAP.
Ejemplos
1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 LOAD MBO / V
0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 SWAP
0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 TO MBO
30/01/02
8. Direccionando Inputs y Outputs
30/01/02
30/01/02
RESUMEN.......................................................................................... 77
DETALLES ........................................................................................ 77
Organización de Entradas/Salidas ................................................. 77

Words de Entradas/Salidas................................................................. 77
Etapas Discretas de I/O .................................................................... 78
Usando Inputs en Programas.......................................................... 78

Inputs Discretas.................................................................................. 78
Input Words ........................................................................................ 79
Usando Outputs en el Programa......................................................80

Outputs (Salidas) Discretas................................................................ 80
Output Words ......................................................................................80
30/01/02
8. Direccionando Entradas y Salidas (Inputs y Outputs)

RESUMEN
Este capítulo detalla como acceder a las entradas digitales (Inputs) y a

las salidas digitales (Outputs) usando el lenguaje STL. Inputs y
Outputs están conectados a la CPU (en donde los programas de
control en STL son almacenados) por medio de las siguientes formas:
• Sistema de Field Bus

• Redes
Las entradas/salidas analógicas no son tratadas en esta sección.

Refiérase por favor al Capítulo 13 y a la documentación que cubre al
sistema que Ud. tiene para más información.
DETALLES
Organización I/O
Los controladores lógicos programables de Festo organizan las Inputs

y Outputs (I/O) como un word (grupo). Dependiendo del modelo de
controlador particular (o del módulo de I/O para sistemas modulares)
cada grupo usualmente consiste en 8 o 16 Inputs o Outputs discretas.
I/O Words
Estos grupos completos de words se referencian por su tipo (Input u

Output) y la dirección de la Word (n). Este número de dirección es
generalmente fijo en controladores pequeños y configurable (por
medio de llaves) en sistemas modulares.
La Word de entrada (Input Words) a menudo son identificadas con IWn
mientras que las Word de Salida (Output Words) son declaradas como
OWn.
Los ejemplos incluyen:
IW1 Input Word 1

IW7 Input Word 7
OW0 Output Word 0
OW2 Output Word 2
Debería notarse que cada entrada (Input) y salida (Output) dentro de

un sistema debe tener un número de dirección único.
Por ejemplo: no es posible para un sistema tener direcciones
duplicadas de I/O.
Sin embargo, es generalmente aceptable para un sistema incluir un
Input Word con el mismo número de direcciones que el de un Output
Word (por ej. IW1 y OW1). Refiérase por favor al manual de hardware
del controlador específico que Ud. tiene.
30/01/02

Terminales de Entradas/Salidas (I/O)
Las entradas y salidas individuales (Inputs o Outputs) que están en un

grupo de I/O están identificadas de la siguiente forma:
Si es Entrada o Salida (I u O) + el número de dirección de la Word (n)
+ "." seguido por el número particular de posición de I/O (Sn).
Los números de la Posición pueden estar entre 0 - 7 o 0-15
dependiendo del tamaño del grupo de I/O.
Por ejemplo:
I3.2 Posición Input 2 de la Input Word 3

I0.15 Posición 15 de la Input Word 0
O2.7 Posición Output 7 de la Output Word 2
O0.0 Posición Output 0 de la Output Word 0
Usando Inputs
en Programas
Las Inputs son elementos del sistema de control que están diseñados
para ser leídos o consultados. Están conectadas a dispositivos
externos tales como sensores, llaves, etc., los que pueden o no
suministrar una señal a una entrada (input) individual.
Entradas Discretas
Ejecutando las instrucciones STL apropiadas dentro de la parte

condicional de una sentencia, el controlador es capaz de determinar el
estado corriente de una entrada discreta.
IF I1.1 Verifica una señal válida en Input 1.1

IF N I3.3 Verifica una señal falsa en la Input 3.3
Entradas Múltiples, así como otras condiciones pueden combinarse

lógicamente. Se encontrarán ejemplos en el Capítulo 7.
30/01/02
8. Direccionando Entradas y Salidas (Inputs y Outputs

Input Words
Algunas veces puede ser deseable o necesario verificar el estado de

Words de Entrada (Input Words) completas. Para determinar el estado
de una Input Word completa, es necesario leer el valor de la word
entera y determinar si cumple el criterio deseado.
Aquellos lectores que no estén familiarizados en determinar los valores
de los números binarios, pueden consultar el Apéndice D.
Por ejemplo, para verificar si todas las 8 Inputs de la Input Word 2

están recibiendo señales válidas podríamos hacer un AND lógico a
cada Input:
IF I2.0 aquí verificamos si todas las 8 inputs

AND I2.1 de una Input Word de 8 bit están recibiendo
AND I2.2 señales válidas
AND I2.3
AND I2.4
AND I2.5
AND I2.6
AND I2.7
o usando la ventaja del lenguaje STL de evaluar Words completas, la

siguiente podría ser la secuencia del programa:
IF ( IW2 solamente verifica si todas las 8 inputs

= V255 ) están en ...11111111 (binario) = 255
Tareas más complejas, las que requerirían largos listados si se

programaran bit a bit, son fácilmente llevadas a cabo usando Input
Words combinadas con otras instrucciones lógicas.
Para ver si una o más de las Inputs 1.5, 1.6 1.7 son válidas, esto puede
hacerse de la siguiente forma:
IF ( IW1 primero obtiene la Word entera

AND V224) = 11100000 binario
> V31 si el resultado es mayor que ...
aquí tendremos ...
Lo que es equivalente a:
IF I1.5
OR I1.6
OR I1.7
30/01/02

Usando Outputs
en Programas
Las Outputs de un controlador programable pueden usarse para

controlar distintos tipos de dispositivos eléctricos, mediante
instrucciones de programa lo que activará (SET) o desactivará
(RESET) las salidas requeridas (Output).
Nota: Mientras las Inputs pueden solo ser leídas (consultadas), las
salidas (outputs) pueden ser escritas a (SET o RESET) y pueden
también ser consultadas en la misma forma que las entradas. Por lo
tanto, referencia a las Outputs pueden aparecer tanto en la parte
Condicional como en la parte Ejecutiva de una sentencia STL.
Outputs Discretas
Ejecutando las instrucciones STL apropiadas en la parte Ejecutiva de
una sentencia, el controlador puede conmutar una Output particular a
SI o NO.
La instrucción SET se usa para conmutar a si una Output, mientras que
la instrucción
RESET conmutará la Output a no.
IF... cualesquiera condiciones necesarias

THEN SET O1.2 activar Output 1.2
RESET O3.3 apagar Output 3.3
SETeando una Output que ya está SET o RESETeando una Output

que ya está RESET no tendrá ningún efecto.
Como se nota, las Outputs pueden ser consultadas en la parte
Condicional ...La siguiente instrucción verifica si la Input 2.4 está
recibiendo una señal válida y si la Output 2.2 está en este momento
activa:
IF I2.4 input 2.4 activa

AND O2.2 Output 2.2 activa
THEN .... acciones deseadas
Output Words
Algunas veces puede ser deseable o necesario verificar o alterar el
estado de Output Words enteras. De la misma forma, las entradas
pueden ser manipuladas tomando como base grupos de Word, los
mismos principios se aplican a las Outputs.
Por ejemplo, la sentencia STL:
THEN LOAD V0
TO OW2
Resultará que en la totalidad de las Outputs asociadas con la Output
Word 2 sean apagadas.
30/01/02
9. Usando Timers
9. Usando Timers
30/01/02
9. Using Timers
RESUMEN.......................................................................................... 83
DETALLES ......................................................................................... 83
Información General............................................................................ 83
Usando un timer .............................................................................. 83

Inicializando la Preselección de un Timer.................................... 84
Ej.: Inicializando la Preselección de un Timer con el tiempo del
reloj...84
Ej.: Inicializando la Preselección de un Timer sin el tiempo del reloj...
84
Arrancando un Timer....................................................................... 85
Verificando el Estado de un Timer................................................. 85
Deteniendo un Timer....................................................................... 85
Ejemplos............................................................................................ 87
Evitando rearranques usando la estructura Step del STL...................87
Evitando rearranques continuos de Timers
en procesamiento Paralelo ............................................................... 87
30/01/02
9. Usando Timers
RESUMEN
Este capítulo analiza cómo se programan los Timers usando el
lenguaje STL. Además se presenta el funcionamiento interno de los
Timers en STL.
Se recomienda al lector dirigirse al Apéndice A de este manual para
determinar la cantidad de Timers disponibles en cada controlador en
particular.
DETALLES
Información General
Cada Timer implementado en el lenguaje STL consiste de los
siguientes elementos:
Elemento/Operando Ref. Función
Bit de Estado del Tn permite a un programa consultar

Timer si el Timer está activo (corriendo).
El bit cambia a activo cuando el
timer se arranca (SET), y
mientras el período del timer está
activo (corriendo). Al completarse
el tiempo programado o si el
Timer es detenido (RESET) el bit
de estado se vuelve inactivo.
Timer Preselect TPn es un operando de 16 bit que
(Preselección del contiene el valor que define el
Temporizador) período para el Timer n.
Timer Word TWn

es un operando de 16 bit al que el
operando TP (Tiempo de
Preselección) es transferido
automáticamente cuando el Timer
es arrancado (SET), luego este
valor es decrementado por el
sistema a intervalos regulares.
Nota: Los modelos de controladores que incorporan baterías de
resguardo de memoria (back-up batteries) mantienen los valores de
Preselección de los Timers durante los períodos en que el controlador
está desconectado o apagado. También estos valores son mantenidos
en controladores que no tienen baterías de respaldo pero que tienen
tecnologías más modernas como por ejemplo FLASHROM, o Zero
Power RAM (Estos dispositivos son RAM mantenidos por baterías
montadas en el mismo chip).
Usando un Timer
Se requieren varios pasos para usar un timer en un programa STL:
• debe establecerse una Preselección del Timer válida
• debe haber una instrucción para arrancar el Timer
• el estado del Timer puede comprobarse (activo/detenido).
9. Usando Timers
30/01/02
Inicializando la
Preselección del Timer
Nota:
Dependiendo de que modelo de controlador esté usando, podría
o no requerirse la especificación del reloj así el valor del
temporizador. Por favor refiérase al manual del controlador que
Ud está usando.
Antes que pueda usarse cualquier Timer, deberá inicializarse el

Timer Preselect con un valor correspondiente al período de tiempo
deseado.
Esta inicialización solo es necesaria llevarla nuevamente a cabo si el
valor preseleccionado de tiempo debe ser cambiado. No es
necesario cargar nuevamente el Timer Preselect cada vez que el
Timer es arrancado. Esta inicialización necesita ser realizada con un
valor (constante) o con cualquiera de los contenidos de un MBO (por
ej. Registro, Input Word, Flag Word etc.)
Ejemplo: Inicialización de la Preselección de Timer con la
velocidad del reloj:
STEP 1 lo hacemos primero !
IF NOP incondicionalmente
LOAD V10 valor 10
TO TP4 a la Preselección del Timer 4
WITH SEC velocidad reloj=seconds ...Timer 4
Será ahora un timer de 10 segundos
Las velocidades de reloj son:

HSC cientos de segundos
TSC decenas de segundos
SEC segundos
MIN minutos
Ejemplo: Inicialización de la Preselección de Timer sin una

velocidad de reloj:
STEP 1 lo hacemos primero !
IF NOP incondicionalmente
LOAD V100 valor 100....la velocidad del reloj
Estándar (sin especificar) será en
Incrementos de 1/100 de segundo
TO TP0 a la Preselección del Timer 0 = 1 seg.
El ejemplo precedente ha inicializado el Timer 0 para tener una
duración de 1 segundo ( 100 x 1/100 segundo). El rango permitido es
de 0-65535 lo que habilita a períodos del timer entre 0.01s y 655.35 s
(aprox. 10 minutos).
30/01/02
9. Usando Timers
Arrancando un Timer
Arrancar (start) un timer requiere solamente emplear una instrucción
SET especificando además cual es el timer a ser puesto en marcha:
IF I1.0 cualquier condición para comenzar

THEN SET T6 entonces arrancar timer 6
Siempre que la instrucción SET Tn se ejecute, ocurre lo siguiente:
1. El valor almacenado en TPn (Timer Preselect n o Preselección del

Timer n) se copia a la TWn (Timer Word n).
2. Tn (Timer Status n o Estado del Timer n) se activa poniéndose en '1'
(activo/corriendo).
3. El controlador automáticamente decrementa el valor almacenado en
TWn a intervalos regulares.
3. Cuando el valor almacenado en TWn alcanza 0 (cero), Tn (Timer
Status) se convierte en '0' (inactivo/detenido).
Nota:
Si una instrucción de SET un Timer se ejecuta, Y el timer
especificado YA está funcionando (activo), será REARRANCADO y
un NUEVO período de tiempo comenzará.
Consultando el
Estado (Status)
Del Timer
Para que los timers puedan ser útiles en el control de procesos, es

necesario saber cuando el tiempo programado ha sido completado. El
lenguaje STL permite verificar si el timer está activo de la misma forma
que se hace para verificar si una Input (entrada) está activa.
IF T5 verifica si el Timer 5 está activo (corriendo)

IF N T3 verifica si el Timer 3 no está active (detenido)
Deteniendo
un Timer
Detener un timer solo requiere de una instrucción RESET además de
especificar cual es el timer que debe detenerse:
IF I2.0 Input para detener el timer

THEN RESET T5 Detener Timer 5
Cuando se ejecute la instrucción RESET Tn el bit de estado del timer (Tn) se vuelve 0
(inactivo). Si el timer ya estaba inactivo, esto no tiene efecto.
30/01/02
9. Usando Timers
La Figura 9-1 ilustra la relación entre las instrucciones Bit de Estado
del Timer (Timer Status Bit) (Tn), el SET Tn, el RESET Tn y el período
normal de tiempo.
La línea sólida representa una secuencia de temporizado normal en la
cual el estado del timer se vuelve activo cuando la instrucción SET Tn
se ejecuta y el estado retorna a inactivo cuando el período programado
de tiempo se ha completado.
La línea de puntos indica que con una instrucción RESET Tn
inmediatamente retornará el estado del timer a inactivo.
Timer activo = 1 Tiempo Programado
Timer inactivo = 0 SET Tn RESET Tn
Figure 9-1 Timer Status Bit Tn
Cuidado:
Es importante comprender al construir Programas o Steps que
contienen multiples sentencias que serán procesadas en una
manera paralela (barrido) que cada vez que la parte Condicional
de una Sentencia evalúe esta como verdadera, las instrucciones
programadas en la parte Ejecutiva serán procesadas. Esto debe
considerarse para evitar ejecuciones múltiples no controladas
que incluyan SET TIMER o INC/DEC Counter Word, SHL, etc.
El lenguaje STL no usa “disparo por flancos” ... las condiciones

son evaluadas por ‘verdaderas’ cada vez que se procesan sin
importar su estado previo.
Esta situación es fácilmente manejada usando ya sea Steps,

Flags u otro medio de control. Los siguientes ejemplos muestran
dos posibles formas en las cuales estos efectos son
minimizados.
30/01/02
9. Usando Timers
Ejemplos
Evitar arranques indeseados usando la estructura Step STL

El próximo ejemplo muestra una sección de programa en la que se
desea poner en marcha un motor durante 3 segundos, cada vez que
se presiona un botón, si el motor no está ya en marcha, y han pasado
a por lo menos 9 segundos de la última vez que el motor fue puesto en
marcha.
Se ha eliminado en este programa la posibilidad de continuos re-
arranques de los temporizadores combinando la estructura Step del
STL con la instrucción N Timer.
Step 1
IF NOP inicializar al conectar energía
THEN LOAD V900 900 * .01seg unidad de tiempo
TO TP0 Timer 0 es 2 seg tiempo de pausa
LOAD V300 300 * .01 seg unidad de tiempo
TO TP2 Timer 2 es timer de motor
SET T0 correr pause timer
STEP 10
IF N T0 Timer 0 ha terminado
AND N T2 Timer 2 no está corriendo
AND N O1.0 Motor no en marcha
AND I1.2 Botón presionado
THEN SET T2 Arrancar Timer
SET O1.0 Arrancar motor
STEP 20
IF N T2 tiempo del motor finalizado
THEN RESET O1.0 detener el motor
SET T0 arrancar timer de pausa
JMP TO 10 arrancar de nuevo
Evitar continuos re-arranques de Timers al procesar en Paralelo
Es importante que el programador de STL entienda que el bit de

estado del Timer (por Ej. T2) puede ser consultado usando las
siguientes instrucciones:
IF T2 Esta consulta es verdadera si Timer 2

Está activo y temporizando
IF N T2 Esta consulta es verdadera si Timer 2
no está activo en este momento
Es vital comprender que ninguna de estas instrucciones dará

información de si el Timer 2 ha sido arrancado y se ha completado su
temporización. Es importante por ello, al construir programas en STL
con sentencias que serán procesadas múltiples veces, tomar las
medidas necesarias para evitar resultados inesperados.
30/01/02
9. Usando Timers
El siguiente ejemplo muestra una sección de programa en la que un
botón pulsador se usa para hacer que un cilindro extienda su vástago
por un tiempo predeterminado (preset).
La lógica del programa evitará los siguientes problemas, que de otra
forma estarían presentes:
Manteniendo el botón pulsador presionando o presionando y soltando
el botón múltiples veces dentro del período de tiempo definido, esto no
alterará el tiempo programado.
STEP 1 inicialización solo la primera vez

THEN LOAD V0
TO OW0 apagar todas las salidas
RESET F3.0 borrar Flag 3.0
LOAD V100 inicializar timer
TO TP0 Que el timer T0 sea de 1 segundo
STEP 2 sección de barrido principal
IF I1.0 Botón 1 es presionado
AND N T0 y el Timer 0 no está corriendo
AND N F3.0 forma de detección de flanco
THEN SET T0 arrancar Timer 0
SET O1.0 extender cilindro 1
SET F3.0 memorizar flanco positivo de Pulsador
IF N T0 Timer 0 no activo
AND O1.0 y el cilindro está extendido
THEN RESET O1.0 luego retraer el cilindro
IF N T0 Timer 0 no activo
AND F3.0 y tuvimos previamente un flanco
ascendente
AND N I1.0 y el botón pulsador es liberado
Se detecta el flanco descendente!
THEN RESET F3.0 estar preparados para el próximo flanco
IF NOP entonces continuar barriendo
THEN JMP TO 2 el step actual.
30/01/02
10. Usando Contadores
30/01/02
RESUMEN.......................................................................................... 91
DETALLES ........................................................................................ 91
Contadores Estándar........................................................................ 91
Usando Contadores Estándar.......................................................... 92
Inicializando la Preselección de un Counter....................................... 92
Ejemplo: Inicializando la Preselección de un Counter con un
Valor absoluto...........................................................................92
Ejemplo: Inicializando la Preselección de un Counter con un
MBO........................................................................................ 92
Arrancando un Counter ...................................................................... 93
Consultando el Estado de un Counter................................................ 93
Contando Eventos............................................................................... 93
Deteniendo un Counter....................................................................... 93
Ejemplos............................................................................................ 94
Counter Estándar.............................................................................. 94
Contadores crecientes y decrecientes (UP/DOWN) .................... 97
Ejemplo: Uso de un registro como counter ........................................ 97
30/01/02
10. Usando Counters

RESUMEN
Este capítulo describe como usar los contadores (Counters) con el
lenguaje STL. La información que concierne a los elementos que están
asociados a cada contador también es provista.
Esta sección no intenta describir la operación o la implementación de
ningún contador de alta velocidad especial, ni manejado por
interrupciones que están disponibles en algunos modelos de
controladores. Detalles teniendo en cuenta el uso de estas
características especiales serán encontrados en el manual del
hardware del controlador en cuestión.
Se recomienda al lector dirigirse al Apéndice A de este documento
para obtener información sobre el número de Contadores disponible
en cada modelo de controlador.
DETALLES
Counters Estándar
Cada Counter como está implementado en el lenguaje STL puede
programarse en cualquiera de dos formas. El método estándar (a
menudo referido como el el del counter INCremental) se describirá
primero.
Elemento/Operando Ref. Función
Counter Status Bit Cn Permite a un programa consultar si el

(Bit de Estado del Counter es activo (no ha alcanzado su
Contador) valor final). Este Bit se cambia a activo
cuando el Counter se arranca (SET).
Cuando el número de cuentas
programadas se alcanza, o si el counter
es detenido (RESET) el Bit de Estado
se vuelve inactivo.
Counter Preselect CPn Un operando de 16 bit que contiene el
valor deseado de la cuenta
Counter Word CWn Un operando de 16 bit que contiene el

número corriente de cuentas almace-
nadas mediante las instrucciones
DECrementar o INCrementar. Al usar
Counters estándar y ejecutar la
instrucción SET Cn, la Counter Word es
automáticamente puesta en cero (0)
Nota: Los modelos de controladores que incorporan baterías de

respaldo mantienen los valores de Preselección del Counter, Bits de
Estado y Words durante los períodos sin energía de red. Igualmente
con los nuevos equipados con EEPROM.
30/01/02
10. Usando Counters

Usando Counters
Estándar
Un Counter Estándar es útil para conteo de eventos determinados y

llevar luego a cabo una acción deseada cuando se arribe a la cuenta
predefinida.
Los Counters estándar operan de la siguiente forma:
• el valor a ser contado es almacenado en el Counter Preselect
(Preselección del Contador)
• el Counter arranca lo que:
• coloca el valor (cero) 0 en la Counter Word (CWn=0)
• cambia el estado del Counter a activo (Cn=1)
• la cuenta actual puede ser INCrementada o DECrementada
• cuando la cuenta actual (CWn) = preselect (CPn) el Estado del
Counter (Cn) cambia a inactivo (Cn=0)
Inicializando el Counter Preselect
Antes que un Counter estándar pueda usarse, el respectivo Counter
Preselect debe primero ser ser inicializado con un valor
correspondiente al número de eventos a ser contado.
Esta inicialización solo necesita ser realizada nuevamente si el valor
para actividades de conteo subsecuentes debe ser cargado. No es
necesario cargar de nuevo al Counter Preselect cada vez que el
contador es arrancado.
Counter preselects puede ser cargado con valores absolutos o con el

contenido de cualquier MBO (por ej. Registro, Input Word, Flag Word
etc.)
Ejemplo: Inicializando el Counter Preselect con un valor

absoluto
IF I1.0 o cualquier condición deseada ...

THEN LOAD V100 cargamos un valor absoluto de 100
Como el número de eventos a contar
TO CP4 al Counter Preselect 4
Ejemplo: Inicializando el Counter Preselects con un valor MBO
IF I1.0 o cualquier condición deseada ...

THEN LOAD IW1 Input Word 1 como el valor de entrada
TO CP5 al Counter Preselect 4
Por medio de la instrucción DEB podríamos usar llaves externas BCD
para establecer la cuenta. Ver la instrucción DEB en la Referencia de
Instrucciones STL en el Capítulo 7.
30/01/02
10. Usando Counters

Arrancando un Counter
Arrancar un contador solo requiere de una instrucción SET y
especificar que counter debe arrancarse:
IF I1.2 condiciones deseadas

THEN SET C2 activar Counter 2
Siempre que la instrucción Set Cn sea ejecutada, lo siguiente ocurre:

1. La respectiva Counter Word (CWn) es cargada con un cero 0.
2. Cn (Counter Status n=estado del contador) se vuelve activo '1'.
Nota:
Si una instrucción para SET un Counter es ejecutada, Y el Counter
especificado está YA activo, el Counter será REARRANCADO y la
cuenta actual (en CWn) será puesta a cero (0).
Consultando el estado de un Counter
Para utilizar contadores de forma útil, es necesario poder determinar
cuando la cuenta preseleccionada ha sido alcanzada.
Conteo de Eventos
Una vez que el counter ha sido activado (SET), la cuenta actual es
mantenida en la respectiva Counter Word, la que puede ser
actualizada usando tanto la instrucción INC CWn como la DEC CWn.
Deteniendo un Counter
Un counter puede ser detenido (desactivado) en cualquier momento
con la instrucción RESET Cn. Cuando la instrucción RESET Cn sea
ejecutada el Bit de estado del Counter (Counter Status Bit) (Cn) sea 0
(cero). El contenido de la Counter Word permanece sin cambiar.
Cuidado:
En Programas o Steps que contienen múltiples Sentencias que serán
procesadas en paralelo (modo barrido), cada vez que la parte
condicional de una Sentencia es evaluada como verdadera, las
instrucciones programadas en la parte ejecutiva serán ejecutadas. Esto
debe ser considerado para evitar ejecuciones múltiples descontroladas
de instrucciones que incluyan SET TIMER o INC/DEC Counter Word,
SHL, etc.
El lenguaje STL no usa ‘disparo por flancos’...las condiciones son
evaluadas por verdaderas cada vez que son procesadas sin importar sus
estados previos.
30/01/02
10. Usando Counters

Ejemplos
Counter
Estándar
El primer ejemplo se presenta usando un counter estándar en conjunción con
la estructura Step para evitar INCrementos múltiples descontrolados en los
Steps 10 y 15.
Un botón pulsador se usa para comenzar un ciclo de máquina. El ciclo
arrancará una rampa y contará las botellas que pasan por un sensor. Una vez
que 25 botellas hayan pasado el sensor, la rampa es detenida, y un
mecanismo posiciona corchos de cierre en cada botella. Finalmente todos los
corchos son presionados en las botellas 2 veces durante un segundo cada
uno.
30/01/02
10. Usando Counters
STEP 1 Encendido
THEN RESET C0 contador de botellas
RESET C1 contador de pulsadas
RESET O1.0 apagar rampa
RESET O1.1 apagar presión de corchos
LOAD V25 cuántos para contar
TO CP0 preselección counter 0
LOAD V2 cuántas pulsadas
TO CP2 preselección counter 2
LOAD V100 100 x .01s = 1 segundo
TO TP0 Timer 0 Preselect
STEP 5 Esperar botón de Marcha
IF I1.0 Botón de Marcha
THEN SET C0 activar contador
SET O1.0 arrancar rampa
STEP 10 Comenzar contando botellas
IF I1.1 una botella fue sensada
THEN INC CW0 incrementar contador de botellas
STEP 15 25 botellas ya ?
IF N C0 hemos hecho todo, entonces...
THEN RESET O1.0 detener rampa
SET C2 activar contador de pulsadas
JMP TO 50 salir lazo de conteo
OTHRW sino
IF N I1.1 esperar por la última botella contada
Que se mueva fuera del sensor
THEN JMP TO 10 y seguir contando
STEP 50 25 botellas fueron contadas
THEN SET O1.1 Presionar los corchos
SET T2 arrancar Timer de presionado
INC CW2 contar este presionado
STEP 60 Timer espera 1 segundo
IF N T2 tiempo finalizado
THEN RESET O1.1 detener el presionado
STEP 70 hecho ?
IF N C2 corchos presionados 2 veces
THEN JMP TO 5 volver a Step 5
OTHRW JMP TO 50 presionar de nuevo
30/01/02
10. Usando Counters

El próximo ejemplo es un contador estándar en una sección de
programa tipo paralelo en la que la estructura del Step no es usada
para evitar INCrementos múltiples e incontrolados del counter. Por lo
tanto se usa una solución alternativa mediante un Flag.
El programa espera por el Botón de Marcha, y entonces cicla un
cilindro entre las posiciones completamente extendida y
completamente 100 veces.
Sin el uso del Flag, un programa de barrido INCrementaría el counter
en cada barrido (scan) del programa más que en cada vez que el
cilindro fue nuevamente extendido.
STEP 1 inicialización 1 vez solamente

IF I1.0 Botón de marcha apretado
THEN LOAD V0
TO OW1 todas las outputs a apagado
RESET F3.0 borrar Flag 3.0
LOAD V100 inicializar timer
TO CP0 Hacer un contador de ciclo de 100
SET CO arrancar el counter
STEP 2 sección principal de barrido
IF AND I1.1 Cilindro retraído
AND C0 y el Counter 0 está activo
AND N F3.0 para detectar flanco
AND N O1.0 válvula para extender cilindro apagada
THEN SET O1.0 comenzar a extender Cilindro
SET F3.0 perfecto para ver una nueva extensión
IF I1.2 cilindro está extendido
AND F3.0 nuevo flanco
THEN INC CW0 contar el ciclo
RESET F3.0 actualizar control de flancos
RESET O1.0 comenzar retraer cilindro
IF N C0 100 cuentas fueron hechas
THEN JMP TO 1 comenzar todo de nuevo
30/01/02
10. Usando Counters

Contadores
INCREMENTALES/
DECREMENTALES
Además de usar los contadores previamente descriptos (Estándar) el

lenguaje STL, a través del uso de Operandos Multibit, es posible crear
counters (contadores) comúnmente denominados como Up/Down,
ARRIBA/ABAJO (incrementales/decrementales) que se pueden armar
con cualquier Operando Multibit tal como la Counter Word, Registros,
etc. A diferencia de Counters estándar, no hay necesidad de
inicialización un counter preselect y no existe bit dedicado al estado
del contador. Por ello tampoco son aplicables las instrucciones
SET/RESET.
Los steps siguientes son requeridos para usar este tipo de contador:
· Inicializar el apropiado MBO
· El MBO pude ser INCrementado o DECrementado
· El MBO puede ser comparado a un valor o a otro MBO
Ejemplo: Usando un Registro como Counter
En el siguiente ejemplo un proceso es arrancado y corre hasta que
100 partes de Buena calidad son producidas.
STEP 10 esperar por la señal de Marcha

IF I1.0 Botón de Marcha
THEN LOAD V100 número a producir
TO R50 Registro 50 es el contador
SET O1.1 Arrancar la máquina
STEP 20 mirar por cualquier parte en el área
de calidad
IF ( I1.1 listo para verificar
AND I2.3 ) calidad es buena
THEN DEC R50 1 buena, 1 menos para hacer
JMP TO 30 continuar en Step 30
IF ( I1.1 listo para verificar
AND N I2.3 ) calidad bien sensor perdidos=mal
THEN NOP no contra las malas
STEP 30 ver si ya tenemos las 100
IF ( R50
= V0 ) trabajo terminado
THEN RESET O1.1 detener la máquina
JMP TO 10 volver al comienzo
OTHRW NOP o si no está hecho, seguir
STEP 40 esperar por la última parte para mover
IF N I1.1 área de calidad limpia
THEN JMP TO 20 seguir corriendo/verificando
10. Usando Counters

30/01/02
30/01/02
11. Usando Registros
30/01/02
RESUMEN..................................................................................... ...101
DETALLES ...................................................................................... 101
Ejemplos.......................................................................................... 101
Usando Registros en la Parte Condicional de una Sentencia.......... 101
Usando Registros en la Parte Ejecutiva de una Sentencia............... 101
30/01/02

RESUMEN
Este Capítulo explica el concepto de Registro, como se ha
implementado en los Controladores Programables de Festo.
DETALLES
Los controladores Programables de Festo que pueden programarse
usando el lenguaje STL poseen todos Registros de 16 bit. La cantidad
exacta de estos Registros varía de acuerdo al modelo y puede
encontrarse en el Apéndice A.
Estos Registros son Operandos Multibit y pueden usarse para
almacenar números en el rango de:
• 0 - 65535 Enteros sin Signo

• +/- 32767 Enteros con signo
si el modelo de controlador que Ud. está usando incluye batería de

respaldo, o algún sistema de memoria permanente, los contenidos de
los Registros serán mantenidos mientras no haya energía conectada al
equipo. Los Registros que no hayan sido inicializados contendrán
valores aleatorios (no existen en el sistema rutinas de limpieza).
Se utilizan los Registros en conjunción con la instrucción LOAD TO y
operaciones lógicas multibit. Los Registros no son direccionables en
una base bit por bit. Si este tipo de acceso es necesario, los Flag
Words serían los aconsejados para la tarea. (ver capítulo 12).
Los Registros pueden usarse para simplificar el control múltiple de
procesos secuenciales dentro de una única sección de programa
barrida (ver en el apéndice B ejemplos).
Ejemplos
Usando Registros en la Parte Condicional de una Sentencia
IF ( R51 si el contenido del Registro 51

= V111 ) iguala 111
AND T7 y el Timer 7 está corriendo
AND ( R3 y el Registro 3 es menor que
< R8 ) el Register 8
THEN... hacer lo programado...
Using Registers in the Executive Part of a Sentence
IF... condiciones programadas

THEN LOAD R12 load el contenido del Registro
12 al MBA
+ R50 sumar el Contenido del Registro
50
TO R45 y almacenar el resultado en
Registro 45
30/01/02
30/01/02
12. Usando Flags y Flag Words
12. Flags y Flag Words
30/01/02
RESUMEN..............................................................................……... 105
DETALLES ........................................................................……....... 105

Similaridades con otros Operandos Multibit..................................... 105
Diferencias comparadas a otros Operandos Multibit........................ 105
Ejemplos...........................................................................….……... 106
Ejemplos Parte Condicional ............................................................. 106
Ejemplos Parte Ejecutiva................................................................. 107
Shift Registers (Registros de

Desplazamientos) .......................................................................... 107
30/01/02

RESUMEN
Esta sección describe la construcción lógica y uso de Flags y Flag

Words para los controladores programables de Festo.
El Apéndice A brinda información sobre la cantidad de Flag Words, la
que varía de un equipo a otro.
DETALLES
Similarities to other Multibit Operands

Las Flag Words son, de muchas formas, casi idénticas a los Registros.
Las Flag Words contienen, cada una, unidades de 16 bits de
información. Cuando sean llamadas como unidades completas de 16
bit (Operandos Multibit), el término Flag Word se aplica. Dentro del
lenguaje STL se usará la abreviatura FW . Los Flag Words son capaces
de almacenar datos numéricos dentro del rango:
• 0 - 65535 Enteros sin Signo
• +/- 32767 Enteros con Signo
Si el modelo del controlador que Ud. está usando incluye memoria del
tipo Flash RAM o ZPRAM, o en su defecto batería de respaldo, el
contenido será mantenido durante los períodos de corte o interrupción
de la alimentación de energía, aquellos Flags que nunca hayan sido
inicializados contendrán valores aleatorios. Los Flag Words difieren de
otros Operandos Multibit en varias formas importantes:
Diferencias en comparación a otros Operandos Multibit

1. La mayor diferencia entre Flags y otros Operandos Multibit tales
como Registros, Counter Words, etc., es que cada 16 bit Flag Word es
también direccionable de a un bit. Por ejemplo el FPC100 contiene 16
Flag Words, direccionadas como FW0 a FW15.
Es también posible direccionar bits individuales (Flags) de cada Flag
Word mediante la siguiente sintaxis:
F(número de Flag Word).Número de Bit
donde el Número de Bit varía entre 0 y 15.

Por ejemplo, F7.14 hace referencia al Bit 14 del Flag 7.
Este esquema de direccionamiento es muy similar al usado cuando se
accede a puntos de entrada/salida (I/O) digitales, como se ha descrito
previamente.
Mientras que los Flag Words pueden usarse con cualesquiera
instrucciones STL para Operandos Multibit, los Flags individuales son
sólo accesibles usando instrucciones STL diseñadas para Operandos
de Bit (ver Capítulo 4).
Los Flags de Bit Único son a menudo usados como medio conveniente
para memorizar eventos. En este aspecto son similares a “bobinas
internas o relés” encontrados a menudo en el Diagrama Escalera
(Ladder Diagram).
30/01/02

2. El FPC405, que soporta Múltiples módulos de CPU (Multi-
procesamiento),
permite que cualquier programa en cualquiera de las CPU acceda los
Flags de FW0 a FW23 (FW externa) desde cualquiera otra CPU. Esto
es, cada CPU es capaz de leer desde o escribir a los Flags de
cualquier otra CPU.
Por lo tanto, los Flags pueden dar un medio conveniente para
implementar comunicaciones entre CPU.
En sistemas con múltiples CPU, cada Word es direccionada como:
CPU número.Flag Word número
Por ejemplo, FW2.14 se direcciona Flag Word 14 en CPU 2.

De la misma manera es posible direccionar Flags monobit en otras
CPU’2 extendiendo la sintaxis de la dirección:
CPU número.F(número de Flag Word).Bit número
Por ejemplo, F0.11.9 se refiere al Flag Bit 9 en la Flag Word 11
localizada en la CPU 0.
Ejemplos
Flags Individuales (así como también Flag Words) pueden
programarse en tanto la parte Condicional como la Ejecutiva se una
Sentencia. En la parte condicional, los Flags pueden ser interrogados
por sus estados (0=RESET, 1=SET); mientras que las Flags Words
pueden ser comparadas a valores u otros MBO's (Multi Bit
Operandos).
Parte Condicional Ejemplos
IF F1.1 Si el Bit 1 de la Flag Word 1 es

SET
IF F2.1 Si el Bit 1 de la Flag Word 2 es
SET
AND N F4.0 y el Bit 0 de la Flag Word 4 es
no SET.
Igual que con los otros Operandos Monobit o Multibit, los Flags pueden
combinarse con otros operandos.
IF ( I3.0 Si Input 3.0 es valida

AND F0.0 ) y Flag 0.0 es SET
OR (( FW3 o el valor de todos los 16 bits del
Flag Word 3
= V500 ) son iguales a 500
AND N T7 ) y el Timer 7 no está activo
30/01/02

Executive Part Ejemplos
IF I1.1 Si Input 1.1 es válida entonces

THEN SET F2.2 SET Bit 2 del Flag Word 2
IF T6 Si T6 en la CPU local está corriendo
THEN SET F3.3 SET Flag 3.3 de modo que otra CPU
Pueda verificar el estado de T6
OTHRW RESET F3.3
En la parte Ejecutiva de las Sentencias, los Flag Words pueden usarse

como la fuente o destino de cualquier instrucción Multibit.
Shift Registers
El hecho de que los Flags puedan direccionarse sobre la estructura de

una Word así como desde el punto de vista de una estructura de Bits
estos resultan como un medio conveniente para construir registros de
desplazamiento (shift registers).
Como un ejemplo, podríamos necesitar programar una línea de
maquinado en las cuales filas de moldes sean cargadas en la estación
0 y a continuación varias operaciones deban ser llevadas a cabo a lo
largo de las siguientes 15 estaciones. La máquina completa cicla cada
2 segundos y durante ese tiempo una nueva fila de moldes puede o no
ser cargada en la estación 1... lo que puede verificarse por medio de
un sensor.
Las estaciones 1-15 no incluyen sensores, pero se requiere que
solamente opere la estación cuando haya una parte en el lugar.
Esto presenta una situación ideal para usar un registro de
desplazamiento.
Usaremos la Flag Word 6 para tener el seguimiento de cuales
estaciones contienen materiales a ser maquinados. La instrucción Shift
Left (SHL) -desplazar a la izquierda- se usará para mover realmente
los bits individuales dentro del Flag Word.
Se usarán las siguientes I/O's:
Input 1.0 Botón de Marcha

Input 1.1 Sensor de Partes en la Estación 0
Input 2.2 se indexa Línea Transfer
Output 2.0 Indexa línea de maquinado
Outputs 1.0 - 1.15 controla la operación de maquinado en
las estaciones 0 - 15 respectivamente
30/01/02

STEP 10 Arranque
IF I1.0 Botón de Arranque
THEN
AND
LOAD
I2.2
V200
La línea es indexada
2 segundos
TO TP0 a la Preselección Timer 0
LOAD V0 supone nueva producción corriendo
TO FW6 no partes en ninguna estación
STEP 15 esperar hasta que algunas partes
estén listas
IF I1.1 parte fue encontrada en estación 0
THEN SET F6.0 memorizarlo
IF ( FW6 alguna parte para procesar?
> V0 ) algo existe !
THEN LOAD FW6
TO OW1 arrancar motor en estaciones con partes
SET T0 arrancar timer proceso
STEP 20 time de maquinado hecho ?
IF N T0 tiempo terminado
THEN LOAD V0 apagar todos los motores de la estación
SET O2.0 arrancar línea indexado
STEP 25 esperar hasta que el index arranque
IF N I2.2 arrancado al index
THEN LOAD FW6 obtener el estado todas estaciones
SHL mover bits para adaptar partes
TO FW6 y almacenarlo
STEP 30 esta completo el index ?
IF I2.2 nuevo punto de index
THEN RESET O2.0 Detener index del motor
JMP TO 15 volver al Step 15 por más
30/01/02
13. Funciones Especiales
30/01/02
RESUMEN........................................................................................ 111
DETALLES ........................................................................……....... 111
Entradas/Salidas (I/O) Analógicas...................................……… 111

Señales Analógicas Comunes.......................................................... 111
Funciones Analógicas Comunes...................................................... 112
Redes .............................................................................................. 113

Funciones de Redes ........................................................................ 113
Controlando Posición .................................................................... 114
Field Bus.......................................................................................... 115

Introducción al Field Bus................................................................... 115
30/01/02

RESUMEN
Este capítulo suministra información básica concerniente a las

siguientes áreas:
• Entradas Salidas Analógicas
• Redes
• Controlando Posición
• Field Bus
Algunas de estas funciones pueden no aplicarse a todos los modelos

de controladores y pueden manejarse de diferentes formas
dependiendo del modelo de controlador.
Esta sección no está destinada a explicar profundamente estas
funciones, sino para explicar las generalidades y dónde puede
buscarse información específica sobre el tema.
DETALLES
Entradas/Salidas
Analógicas
Contrariamente a las Entradas/Salidas digitales, (1 or 0), las señales

analógicas toman la forma de una señal variable continuamente dentro
de un rango predefinido.
Ya que la CPU es solo capaz de funcionar internamente usando
señales digitales, conectar un PLC a entradas analógicas o salidas
analógicas requiere componentes de hardware especial.
Estos componentes pueden ser partes estándar de los controladores
(por ej. FPC101AF) o puede ser un componente opcional.
El hardware que convierte los datos internos digitales del PLC a
salidas analógicas se llama conversor D/A.
El hardware que convierte señales analógicas externas de entrada al
formato digital requerido por el PLC internamente se lo conoce como
un conversor A/D.
Señales Analógicas Comunes
Hay varios rangos, o tipos de señales análogas que son populares en
el control industrial. Si excluimos señales analógicas especializadas
del tipo relacionado al control de temperatura, los siguientes rangos
comunes quedan:
• +/- 10 volts
• 0/4 a 20 miliampere de corriente
30/01/02

Funciones Analógicas Comunes
Para que las entradas y salidas analógicas sean útiles, el software de

programación debe suministrar los medios de llevar a cabo las
funciones deseadas. Las funciones analógicas básicas usadas en
control industrial incluyen:
· setear un nivel analógico de salida basado en un valor digital
· convertir una señal de entrada analógica en un valor digital
Para efectuar estas funciones dentro del lenguaje de programación del
PLC usado, se usan, en general, procedimientos especializados CFM
o FN. La información general sobre los CFM (Call Function Module)
puede encontrarse en el Capítulo 7.
Información específica que cubra las funciones disponibles y la sintaxis
adecuada del lenguaje STL apropiado se encontrará en el manual del
hardware del PLC en cuestión.
30/01/02

Redes
En el contexto de este manual y del lenguaje STL, Redes se refiere al

hardware y software que proporciona los medios para interconectar
sistemas de control que son de otra forma unidades independientes.
Una Red es típicamente empleada para conectar varios elementos de
un sistema de procesamiento distribuido en el cual cada sub-sistema
controla una específica sección (física o lógica) de la tarea total. El
Uso de una red facilita a estas secciones combinarse de una manera
ordenada. Sin importar el lenguaje de programación a ser usado,
hardware especializado así como software de red se requieren para
implementar la red. Dependiendo del modelo de controlador, el
hardware especializado puede tomar la forma de un procesador de red
o un módulo que contiene las rutinas especializadas de software que
pueden ser direccionadas por el lenguaje STL.
Funciones de Red
Las funciones típicas que deben ser llevadas a cabo en una red
incluyen:
• Inicialización de estaciones de red
• Requerir a otra estación ejecutar un comando
• Gerenciamiento de transmisiones de red
La interfase entre el lenguaje STL y el software especializado de red

es efectuado mediante la instrucción CFM. Se puede encontrar
información general sobre la instrucción CFM en el capítulo 7.
Información específica explicando las llamadas del software de red
disponible para un modelo específico de controlador puede
encontrarse en el correspondiente manual u hoja de datos del
controlador.
30/01/02

Control de Posicionamiento
Puede ser necesario controlar rápidamente y con precisión la posición

de componentes mecánicos como partes de un sistema de control.
Tales movimientos son generalmente llevados a cabo usando varios
tipos de motores.
Dependiendo de los requerimientos de:
• Velocidad
• Precisión
• Efectividad del costo
• Confiabilidad
Diversos tipos de motores están disponibles. Estas elecciones incluyen

motores de pasos y servo motores así como motores de múltiple
velocidad los que pueden incorporar componentes de frenado.
Variaciones adicionales pueden o pueden no incorporar control a lazo
cerrado.
Las más precisas (y costosas) soluciones tales como servo motores
incorporan microprocesadores dedicados, mientras que soluciones
menos sofisticadas pueden confiar en la velocidad e inteligencia del
controlador programable.
A causa de la amplia variedad de sub-sistemas de posicionamiento
que pueden conectarse, no hay instrucciones STL dedicadas para
posicionar. Sin embargo, Festo puede suministrar programas
especializados y módulos de programa que han sido optimizados y/o
adaptados para control de posición.
Además, Festo ofrece controladores dedicados de posición. Debería
Ud. referirse a los manuales y hojas de datos para el hardware
correspondiente a fin de obtener más información sobre la
disponibilidad de módulos de software específicos.
30/01/02

Field Bus
Introducción al Field Bus
El Festo Field Bus está basado en el estándar eléctrico RS485, el cual
define los parámetros de la estructura de un bus serie de alta
velocidad.
Debe hacerse una diferenciación entre los elementos que forman la
estructura del bus interna del controlador y el sistema de Field Bus.
Las I/O's estándar están conectadas de forma muy cercana, tanto
eléctrica como físicamente a la estructura de bus paralela interna del
controlador. Mientras que esta estructura provee accesos de alta
velocidad, su naturaleza pone límites al hardware en cuanto al número
de I/O únicas direccionables posibles.
El concepto de Field Bus utiliza el antes mencionado bus serie para
unir una estación Maestra (Master) y Múltiples estaciones esclavas a
velocidades de transmisión hasta 375,000 bits por segundo.
Ya que estas estaciones pueden localizarse en relativamente largas
distancias (300-1200 metros), éstas son a menudo genéricamente
referidas como "I/O Remotas".
Las altas velocidades de transmisión, cuando se combinan con el
ahorro en costos al usar un par de cables trenzados para la conexión
del bus, hace que el concepto de Field Bus se vuelva realmente
atractivo.
Inputs y Outputs localizadas en las estaciones esclavas del Field Bus
pueden ser interrogadas y controladas por la estación Field Bus
Master. El lenguaje STL permite acceder a estas I/O's usando las
mismas instrucciones SET y RESET que usan las I/O estándar ubicadas
físicamente en el controlador (ver capítulo 8).
Para acomodar la configuración extendida usando el Field Bus, la
sintaxis de instrucciones I/O debe también ser extendida. Inputs y
Outputs son por lo tanto direccionadas de la siguiente forma:
Ipa[.m.s] para Inputs
Opa[.m.s] para Outputs
donde:
p = Dirección de sistema del procesador Master del Field
Bus
a = dirección estación esclava de Field Bus [1... 99]

m = dirección de modulo opcional [0... 15]
s = número de terminal opcional [0...15]
Refiérase por favor al hardware apropiado para detalles específicos

del controlador.
30/01/02
30/01/02
Apéndice A - Operandos
30/01/02
RESUMEN..................................................................................... 119
DETALLES ...............................................................…................. 119
30/01/02
RESUMEN
Esta sección proporciona un resumen del rango disponible de
Operandos en cada modelo de controlador. El lector debería tener en
claro que la información provista se refiere a los operandos que están
disponibles cuando se programa en el lenguaje STL.
El número de operandos puede variar dependiendo del lenguaje de
programación usado. Este listado deberá ser usado solo como una
guía. El lector deberá referirse al manual apropiado del controlador de
su interés para informarse de posibles cambios o actualizaciones.
DETALLES
La tabla siguiente incluye aquellos operandos más a menudo usados
cuando se programa en STL. Para los modelos que permiten múltiples
CPU's las cantidades mostradas son por CPU.
Modelo de Controlador
Operandos
FPC100 FPC405 FEC IPC
Counters 16 64 256 256
Timers 32 64 256 256

160.000/ 160.000/
Flags/ 256/ 1024/
10.000 x 10.000 x
Flag Words 16 x 16 bit 64 x 16 bit
16 bit 16 bit
Registers 64 128 256 256
Multi-tasking yes yes yes yes

(max. tasks) 8 64 64 64
30/01/02
30/01/02
Apéndice B – Programas de Ejemplo
30/01/02
RESUMEN........................................................................…............ 123
DETALLES .........................................................................……...... 123
Ejemplos.............................................................................………....123
Ejemplo 1. Completamente Secuencial........................................... .123

Ejemplo 2. Mayormente Secuencial con eventos Aleatorios ............125
Ejemplo 3. Eventos completamente Aleatorios................................ 128
Ejemplo 4. Secuencias Múltiples y eventos Aleatorios................... .129
30/01/02

RESUMEN
Esta sección presenta algunos ejemplos de problemas de control y
soluciones usando el lenguaje STL. Los ejemplos presentados son
generalizados para ser útiles al lector sin importar que modelo de
controlador en particular vaya a usar.
Si el modelo de controlador a ser programado soporta Multitarea,
debería consultarse el Apéndice C.
DETALLES
La mayoría de las tareas de control se dividen en 3 categorías:
• Completamente secuencial
• Mayormente secuencial con algunos eventos aleatorios
• Completamente aleatorio
Además, en muchas situaciones se presenta la situación de tener que
manejar varias secuencias de control simultaneamente. Los siguientes
ejemplos presentarán soluciones para todas las posibilidades
descriptas anteriormente.
Ejemplos
Ejemplo 1: Completamente Secuencial
Las tareas completamente secuenciales son especialmente aptas para
el lenguaje STL a causa de la estructura implícita del Step.
La tarea secuencial consiste en controlar 3 cilindros neumáticos por
medio de 3 válvulas solenoide 3/2 en una secuencia definida.
Cuando se aplica alimentación de energía al sistema y el Botón de
Arranque es presionado, el cilindro A debe extenderse completamente
por 3 segundos y luego retraerse.
A continuación el cilindro B debe extenderse completamente y
retraerse cuatro veces y luego extenderse completamente y
permanecer extendido.
Finalmente el cilindro C, debe extenderse completamente en cuyo
momento el cilindro A debe otra vez extenderse. Después el cilindro A
es otra vez extendido, y todos los tres cilindros se retraerán y
esperarán la presión del botón de arranque.
Se utilizan las siguientes conexiones:
Input 1.0 Botón de Arranque

Input 1.1 Cilindro A retraído
Input 1.2 Cilindro A extendido
Input 1.3 Cilindro B retraído
Input 1.4 Cilindro B extendido
Input 1.5 Cilindro C retraído
Input 1.6 Cilindro C extendido
Output 1.0 Cilindro A extendido (solenoide)
Output 1.1 Cilindro B extendido (solenoide)
Output 1.2 Cilindro C extendido (solenoide)
30/01/02

STEP 1 inicialización en el arranque
IF NOP hacer siempre esto
THEN LOAD V0 incondicionalmente apagar todas las
TO OW1 Outputs
LOAD V300 Preparar Timer 0 para 3 segundos
TO TP0 unidades = 0.01 segundos
LOAD V4 Preparar Counter 2
TO CP2
STEP 5 asegurarse todas las posiciones ok

IF I1.0 Botón Arranque Presionado
AND I1.1 Cilindro A está retraído
AND I1.3 Cilindro B está retraído
AND I1.5 Cilindro C está retraído
THEN SET O1.0 comenzar extendiendo cilindro A
STEP 10 Cilindro A completamente extendido?

IF I1.2 ahora está totalmente extendido
THEN SET T0 arrancar timer 3 segundos
STEP 12 esperar 3 segundos

IF N T0 si timer completó tiempo
THEN RESET O1.0 comenzar retraer cilindro A
STEP 15 Cilindro A completamente retraído?

IF I1.1 Cilindro A está retraído
THEN SET C2 set counter 2 - 4 cuentas
SET O1.1 comenzar extender cilindro B
STEP 20 Cilindro B completamente extendido?
IF I1.4 ahora está completamente extendido
THEN INC CW2 contar este ciclo
RESET O1.1 comenzar retraer cilindro B
STEP 22 es esta la 4ta extensión ?
IF I1.3 Cilindro B retraído y 4
AND C2 carreras no terminado
THEN SET O1.1 comenzar a extender cilindro B
JMP TO 20 ciclos continuos
AND N C2 carreras hechas
THEN SET O1.1 comenzar a extender cilindro B
30/01/02

IF I1.4 Cilindro B completamente extendido 5 x
THEN SET O1.2 comenzar extendiendo cilindro C
STEP 35 Cilindro C completamente extendido?
IF I1.6 Cilindro C completamente extendido
THEN SET O1.0 Comenzar extendiendo cilindro A
STEP 40 Todos cilindros extendidos?
IF I1.2 cilindro A completamente extendido
también
THEN RESET O1.0 retraer Cilindro A
RESET O1.1 retraer Cilindro B
RESET O1.2 retraer Cilindro C
Ejemplo 2: Mayormente Secuencial con eventos Aleatorios
Mientras que algunas máquinas simples pueden ser completamente

secuenciales en la operación, habría una o más excepciones que
cambian la clasificación de las tareas de modo de no ser totalmente
secuencial.
Si la mayoría de las tareas de control fueran secuenciales y el modelo

del controlador lógico permitiese Multitarea (ver Apéndice A), una
solución posible sería dividir la parte secuencial y los procesos de
procesamiento aleatorio en programas separados (ver el Apéndice C).
Sin embargo es posible manejar esas situaciones con un único

programa STL. Si el evento aleatorio (o los eventos aleatorios) a ser
monitoreados son pocos y el balanceo de los programas es
relativamente simple, entonces podría manejarse los requerimientos
adicionando una Sentencia de programa en cada Step.
Otras posibles soluciones incluyen el uso de procesamiento por

interrupciones (sólo soportada en algunos controladores) o
construyendo la secuencia entera como una sección de programa en
paralelo (barrido). Este método se demostrará en los ejemplos 3 y 4.
El Ejemplo 2 ilustra la inserción de una Sentencia de programa en

cada Step existente del programa presentado en el Ejemplo 1 como
medio de detectar y responder a un simple botón pulsador de "pausa";
el cual al ser presionado resulta en la suspensión de la ejecución del
programa hasta que este esté liberado nuevamente.
30/01/02

STEP 1 inicialización al energizar
IF NOP hacer siempre esto
THEN LOAD V0 incondicionalmente apagar todas
TO OW1 las Outputs
LOAD V300 Preparar Timer 0 como de 3 segundos
TO TP0 unidad = 0.01 segundos
LOAD V4 Preparar Counter 2
TO CP2
STEP 5 asegurarse todas las posiciones bien
IF I1.0 Botón de Marcha pulsado
AND I1.1 Cilindro A retraído
AND I1.3 Cilindro B retraído
AND I1.5 Cilindro C retraído
AND N I1.7 botón de pausa no activo
THEN SET O1.0 comenzar extender cilindro A
STEP 10 Cilindro A completamente extendido?
IF I1.7 botón de pausa
THEN JMP TO 10 si es así quedarse acá
IF I1.2 ahora completamente extendido
THEN SET T0 arrancar timer 3 segundos
STEP 12 esperar 3 segundos
IF N T0 timer completo
THEN RESET O1.0 comenzar retraer cilindro A
STEP 15 Cilindro A completamente retraído?
IF I1.1 Cilindro A está retraído
THEN SET C2 prefijado del contador 2 - 4 cuentas
SET O1.1 comenzar a extender cilindro B
IF I1.4 ahora completamente extendido
THEN INC CW2 contar este ciclo
RESET O1.1 comenzar retraer cilindro B
30/01/02

STEP 22 es esta la 4ta extensión?
THEN JMP TO 22 permanecer aquí
AND C2 carreras no hechas
THEN SET O1.1 comenz. extender Cilindro B
JMP TO 20 continúe ciclos
AND N C2 carreras no hechas
THEN SET O1.1 comenz. extender Cilindro B
STEP 30 Cilindro B completam. extendido ?
IF I1.4 Cilindro B completamente extendido 5 x
THEN SET O1.2 comenzar a extender Cilindro C
STEP 35 Cilindro C completam. extendido ?
THEN JMP TO 35
IF I1.6 Cilindro C complet. extendido
THEN SET O1.0 comenz. extender Cilindro A
STEP 40 Todos los Cilindro extendido ?
IF I1.2 cilindro A completamente extendido
también
THEN RESET O1.0 retraer Cil. A
RESET O1.1 retraer Cil.. B
RESET O1.2 retraer Cil. C
En resumen, es posible manejar cantidades limitadas de condiciones

en paralelo dentro de lo que de otra forma sería un estricto proceso
secuencial usando la instrucción Step.
30/01/02

Ejemplo 3: Eventos Completamente Aleatorios
Algunas situaciones de control no pueden organizarse en una
secuencia lógica ya que las operaciones pueden surgir en u orden
totalmente aleatorio. Un ejemplo típico de una situación así podría ser
el control de la programación de Puesta a Punto(Setup) de una
máquina cualquiera. La operación es definida por el operador de la
máquina presionando distintos botones tipo pulsador, cada uno de los
cuales tiene asignada una función única. El siguiente programa
desarrolla el programa de Setup para una máquina de moldeo de
inyección de plástico.
STEP 10 inicialización
IF NOP siempre cierto
THEN LOAD V0
TO OW1 apagar todas outputs
STEP 20 step de barrido
IF I1.0 Botón pulsador cierre Molde
THEN SET O1.0 Cierre de Molde
IF I1.1 Botón pulsador Inyecta Plástico
AND I2.0 Sensor Molde Cerrado
THEN SET O1.3 Solenoide Inyección
OTHRW RESET O1.3
IF I1.2 Botón pulsador apertura Molde
AND N O1.3 Inyección no activa
THEN RESET O1.0 Apertura Molde
IF I1.3 mecanismo Rota Tornillo
THEN SET O1.1 Solenoide Rota Tornillo
OTHRW RESET O1.1 mecanismo detención tornillo
IF I1.4 Sensor Molde completamente abierto
AND I1.5 Botón pulsador Ejector de Molde
THEN SET O1.4 Solenoide Eyector de Molde
OTHRW RESET O1.4 Proceso de detención de Eyección
IF NOP hacer siempre
THEN JMP TO 20 seguir procesando
30/01/02

Ejemplo 4: Multiple Sequences & Random Events
Los programas de ejemplo combinan muchos de los elementos que se
han presentado en este manual con cada Nuevo tópico.
Debe mencionarse que si el modelo de controlador a programarse
soporta Multitarea, debe consultarse el Apéndice C.
Máquina de Tabla Rotativa Multi-Estación
Este programa en STL se usa para controlar una máquina de tabla
rotativa de 4 estaciones. Cada estación debe realizar su propia
secuencia en concordancia con las otras estaciones. Las diferentes
estaciones tienen diferentes números de Steps asociados con sus
funciones individuales.
El operador tiene la habilidad de activar o desactivar cualquier
estación. Una vez que todas las estaciones han completado sus
respectivas secuencias, la tabla rotativa indexará y comenzará un
nuevo ciclo. Además una Flag Word se usará como Shift Register
(Registro de Desplazamiento) para determinar cuales estaciones
deberían operar basadas en la presencia de una parte en el lugar.
El proceso total será controlado por medio de la asignación de un
Registro a cada estación. Mientras que los Flags individuales podrían
usarse, el uso de Registros mejora enormemente los diagnósticos si
se produjera alguna detención de la máquina.
Este método de estructura de programa admite que sean llevados a
cabo tantos procesos en paralelo como el número de Registros y
además permita que haya más de 65000 Steps por proceso.
La operación de la máquina es como se indica a continuación:
Estación 1: La Estación 1 se usa para cargar cartuchos vacíos de cinta

de impresión. Si no hay cartuchos presentes en esta estación pero los
hay en las estaciones 2,3 o 4, entonces aquellas estaciones operarán.
Cuando la máquina indexe, el estado de cada estación (parte a
procesar: si/no) será actualizado.
Estación 2: La Estación 2 consiste en diferentes eventos secuenciales

los que insertan 2 vástagos vacíos en los cartuchos de cinta.
Estación 3: La Estación 3 lleva a cabo steps en los cuales una longitud

de cinta es adherida al vástago izquierdo, la cinta entonces es
completamente bobinada sobre el vástago izquierdo y finalmente
asegurada al vástago derecho.
Estación 4: La Estación 4 completa colocando la parte superior del

cartucho de cinta a la mitad inferior soldándolo mediante ultrasonido.
Finalmente el cartucho terminado es eyectado en una caja de
embalaje.
30/01/02

STEP 10 inicialización
THEN LOAD V0
TO OW0 apagar todas las outputs
TO OW1
TO OW2
TO OW3
TO OW4
TO FW0 inicializar "shift register"
TO R0 Tabla Indice Registro de Control
TO R1 Estación 1 Registro de Control
LOAD V25
TO TP2 Timer 2 de 1/4 segundo
LOAD V250
TO TP3 Timer 3 de 2.5 segundos
LOAD V300
TO TP4 Timer 4 de 3 segundos
STEP 20 todas las estaciones en home ?
IF N I0.0 E_Stop Activo
THEN JMP TO 99 Rutina Especial
IF I0.2 tabla es indexada
AND I2.1 Estación 2 insert. Izq.Cil. Ret.
AND I2.3 Estación 2 insert derech. Cil. Ret.
AND N I2.5 Estación 2 vástago izq en lugar
AND N I2.6 Estación 2 vástago derecho en lugar
AND I3.1 Estación 3 gripper de cinta abierto
AND I3.4 Estación 3 Cil avance cinta esta retraído
AND I3.6 Estación 3 cinta lado derecho
Sujetar cilindro retraído
AND I4.1 Estación 4 cilindro inserción retr'd.
N I4.3 no en el lugar tope mitad anterior
AND I4.4 Estación 4 Eject. Cil. Home
AND I0.1 Llave de Marcha en Marcha
AND I0.0 E.Stop no Activo
AND ( I1.1 Cartucho en Estación 1
o partes en alguna estación
OR ( FW0 word de 16 bit entera
AND V15 enmascara todo menos bits 0,1,2,3
> V0 )) entonces existe una parte activa
THEN NOP Ok para seguir, sino esperar
30/01/02

STEP 30 ESTACION 1 primero
IF ( R1 estación 1 registro de control
= V0 ) comenzando
AND ( R2 s estación 2 registro de control
= V255 ) indica está hecho
AND ( R3 estación 3 registro de control
AND ( R4 estación 4 registro de control
THEN LOAD V10 todas otras estaciones hechas, entonces
TO R1 tiempo correcto para ver si una parte
fue cargada en Estación1
= V10 ) listo para leer sensor
AND I1.1 sensor de parte en el lugar
THEN SET F0.0 colocar un '1' en 'shift register'
IF ( R1 cuando estamos acá, TODAS
= V10 ) estaciones estuvieron hechas
THEN LOAD V255
TO R1
STATION 2 sección
= V0 )
AND (
N I2.0 estación 2 no activada
OR N F0.1 ) o no partes en estación 2
THEN LOAD V255 entonces marcar estación 2 como hecho
TO R2
= V0 ) comenzando
THEN SET O2.0 extender vastag. Lado izq.Cil.
SET O2.1 extender vastag. Lado der.Cil..
LOAD V20
TO R2 secuencia control avance
= V20 )
AND I2.2 lado izquierdo totalmente extendido
AND I2.4 lado derecho totalmente extendido
AND I2.5 vástago izq en fixture
AND I2.6 vástago der en fixture
THEN SET O2.2 conmutar a si manteniendo vacío
SET T2 arrancar Timer
LOAD V30
TO R2 actualizar estación 2 Reg. control
30/01/02

IF ( R2 Actualizar Reg. Control estación 2
= V30 )
AND N T2 tiempo de rocío completo 1/4 seg.
THEN RESET O2.0 retraer Lado izq vástago Cil.
RESET O2.1 retraer Lado der vástago Cil.
LOAD V40
TO R2 actualizar estación 2 registro de control
= V40 )
AND I2.1 lado izq Spool Cil. Está en home
AND I2.2 lado derecho spool Cil. Está en
home
THEN RESET O2.2 apagar vacío
LOAD V255
TO R2 Marcar estación 2 como completa
STATION 3 sección
IF ( R3 Reg. Control estación 3
= V0 )
AND (
N I3.0 estación 3 no activada
THEN LOAD V255 marca estación 3 como hecha
TO R3
= V0 )
THEN SET O3.1 solenoide cerrado del gripper de cinta
LOAD V10
TO R3 Actualizar Reg. Control estación 3
= V10 )
AND I3.2 gripper completamente cerrado
THEN SET O3.2 insertar cinta vástago izq
LOAD V30
= V30 )
AND I3.3 Ribbon insertada en spool
THEN RESET O3.2 retraer inserción cilindro
RESET O3.1 liberar cinta del gripper
LOAD V40
30/01/02

= V40 )
AND I3.4 cilindro de inserción en home
SET O3.3 arrancar motor rebobinado cinta
SET T3 arrancar timer rebobinado
LOAD V50
= V50 )
AND N T3 tiempo de rebobinado completo
THEN RESET O3.3 detener motor de bobinador
SET O3.4 Rt. lado Cil inserción de cinta
LOAD V60
= V60 )
AND I3.5 sensor de inserción vastago derecho
THEN RESET O3.4 Retraer Rt. Cyl. Inserción lado
LOAD V70
= V70 )
AND I3.6 Rt. Side cil inserción.= home
THEN LOAD V255
TO R3 marca estación 3 completa
STATION 4 sección
= V0 )
AND (
N I4.0 estacion 4 no activada
THEN LOAD V255 entonces marcar estación 4 como hecho
TO R4
= V0 )
THEN SET O4.1 bajar cartucho superior
LOAD V10
30/01/02

IF ( R4 Registro de Control estación 4
= V10 )
AND I4.2 cilindro de cartucho extendido
AND I4.3 Cartucho lleno
THEN SET O4.2 Arrancar soldadura ultrasónica
SET T4 Arrancar tiempo soldado
LOAD V20
IF ( R4 Registro control estación 4
= V20 )
AND N T3 Timer de soldado completado
THEN RESET O4.2 detener soldado
RESET O4.1 liberar cil. Cartucho
LOAD V30
TO R4 Actualizar Reg. Control estación 4.
= V30 )
AND I4.1 mitad superior cobertura cil en home
THEN SET O4.3 extender cil eyección
LOAD V40
TO R4 Actualizar Reg. Control estación 4.
= V40 )
AND I4.5 cil eyección extendido
THEN RESET O4.3 retraer cil. eyección
LOAD V50 Actualizar Reg. Control estación 4
= V50 )
AND I4.4 cil. Eyección en casa
THEN RESET F0.3 posición vacía en shift register
LOAD V255
TO R4 marcar estación 4 como completa
IF ( R1 estationes 1-4 hechas
= V255 )
THEN LOAD V10 Registro de control de índice
TO R0
Sección TABLE INDEX
IF ( R0 Registro índice de control
= V10 )
AND (( FW0 unidad de 16 bit completa
AND V15 ) enmascarar todo excepto bits 0,1,2,3
> V0 ) como mucho 1 estación ocupada
THEN LOAD V20 actualizar registro índices control.
TO R0
30/01/02

IF ( R0 Registro Control de Índice
= V10 ) no se requiere índice
THEN JMP TO 10 Continue Proceso
IF ( R0 Register Control de Índice
= V20 ) un índice es necesario
THEN SET O0.0 Comenzar índice de la Tabla
LOAD V30 Actualizar Registro Control de Índice
= V30 )
AND N I0.2 indexado
THEN LOAD V40
TO R0 Actualizar el registro control índice
LOAD FW0 Cargar Shift Register al MBA
SHL desplazar bits a la izquierda para adaptar
TO FW0 partes actuales
Secuencia de Index completa
= V40 )
AND I0.2 nuevo índice encontrado
THEN RESET O0.0 detener indexado
LOAD V0 borrar registros de control
TO R0
TO R1
TO R2
TO R3
TO R4
JMP TO 20 Continuar procesando
IF N I0.0 E_Stop Activo
THEN JMP TO 99 Rutina especial
Continuar barriendo
IF NOP continuar incondicionalmente
THEN JMP TO 30 procesando Step 30
STEP 99 RUTINA ESTOP
IF I0.0 esperar E_Stop hasta que sea liberado
THEN JMP TO 10 y manejar como en el arranque
30/01/02
30/01/02
Apéndice C - Multitarea ...

Apéndice C – Multitarea ...
30/01/02
RESUMEN........................................................................................ 139
DETALLES ...................................................................................... 139
Conceptos General ......................................................................... 139

Multitarea.......................................................................................... 139
Asignando Programas ................................................................... 140

FEC .................................................................................................. 140
FPC100B/AF .................................................................................... 140
FPC405 ............................................................................................ 140
IPC......................................................................................…........... 140
Usando Multitarea ...........................................................…………. 141
Ejemplos.......................................................................................... 141
Multiprocesamiento....................................................................... 142
30/01/02

RESUMEN
Esta sección da información relativa al concepto, definición, propósito
y estructura de Multitarea (Multitasking) y Multiprocesamiento
(Multiprocessing) en los controladores programables de Festo.
Refiérase por favor al Apéndice A de este documento, el que detalla
que controladores soportan Multitarea y Multiprocesamiento. El
Multipocesamiento es solo aplicable al FPC405 y la IPC.
DETALLES
Conceptos Generales
Multitarea
Todos los controladores programables Festo admiten almacenamiento

de múltiples programas en memoria. Adicionalmente, todos los
modelos tienen la capacidad de ejecutar simultáneamente más de un
programa por medio de la Multitarea.
Las CPU modernas están construidas usando microprocesadores de
alta velocidad. Estos dispositivos están generalmente capacitados
para realizar una única función a la vez. Sin embargo, aprovechando
que la operación del microprocesador es tan rápida (millones de
operaciones por segundo), es posible dividir el tiempo de
procesamiento en múltiples partes asignándoles una tarea específica a
cada una de esas partes. Cuando el poder de un procesador es
dividido de tal forma, a las partes resultantes, se las llama
Procesadores Virtuales.
Mediante el software de operación interna del controlador y el lenguaje
de instrucciones de programación disponible, es posible asignar
programas múltiples para ser procesados en esta forma de
intercambio interno de tareas.
Para funcionar adecuadamente, debe existir un estricto juego de
reglas que determinen cómo y cuando cada tarea (programa) será
procesada.
Cuando se ejecutan múltiples programas en STL en un única CPU se
aplican las siguientes reglas:
1. Un programa, a la vez, se le asignan los recursos del procesador.
2. Un Step completo (o un programa completo si no se han usado
Steps) es procesado Sentencia por Sentencia.
3. Si la parte Condicional de cualquier Sentencia es verdadera, la parte
Ejecutiva de la Sentencia es ejecutada. Vea el Capítulo 5 para más
detalles.
30/01/02

4. Cuando la última Sentencia de un Step ha sido procesada, sin
importar si la parte Condicional es verdadera o no, la CPU
almacenará el estado corriente del programa y ...
5. Si otros programas están asignados, el próximo programa será
puesto activo y será procesado (1-4 antes).
Este proceso "circular" continua hasta que al programa original se le
asignan nuevamente las tareas del procesador.
Asignando Programas
Cuando a un controlador se le suministra poder operativo, y
suponiendo que las inputs del sistema de hardware que se requieren
(por ej. RUN, etc) se suministran con los niveles de señal apropiados,
el procesamiento comenzará:
FEC: Program 0 comenzará el procesamiento. El FEC permite que

hasta 64 programas
STL sean procesados simultáneamente. Los programas pueden ser
arrancados por medio de la instrucción SET Pn y detenidos mediante la
instrucción RESET Pn.
FPC100B/AF: Program 0 comenzará el procesamiento. Usando el

módulo de función
CFM2, hasta 8 programas STL adicionales pueden procesarse
simultáneamente P0.
FPC405: Program 0 comenzará el procesamiento. El FPC405 permite

que hasta 64 programas STL sean procesados simultáneamente en
cada CPU. Los Programas pueden ser arrancados mediante la
instrucción SET Pn y detenidos con la instrucción RESET Pn.
IPC: Program 0 comenzará el procesamiento. La IPC permite que
hasta 64 programas STL programas sean procesados
simultáneamente. Los Programas pueden ser arrancados mediante la
instrucción SET Pn y detenidos con la instrucción RESET Pn.
30/01/02
Apéndice C – Multitarea ...

Usando Multitarea
(Multitasking)
La capacidad de almacenar múltiples programas en la memoria del
controlador junto con la capacidad de multitasking, proporciona
interesantes posibilidades de resolver tareas de mando complejas.
Ejemplos
Una máquina típica podría tener los siguientes requisitos:
1. Funcionamiento Manual
2. Ciclo Automático
Durante el funcionamiento, además de algunas tareas secuenciales,
deben supervisarse funciones en forma continua, tales como Parada
de Emergencia, Parada, Timer del Watch Dog, posición de arranque
del sistema, etc.
Estas tareas podrían ser resueltas dividiendo los requisitos de mando
globales en partes manejables fácilmente:
Programa 0: Realiza todas las inicializaciones y acciones necesarias

como programa de arranque, de modo de activar y detener otros
programas que dependen del funcionamiento deseado. Este programa
también proporciona las funciones de supervisión continuas (tales
como por ej. Parada de Emergencia).
Programa 1: Este programa proporciona la lógica requerida para el
funcionamiento manual. Además, por medio de los Flags (véase
capítulo 12), este programa puede verificar las posiciones de los
componentes de la máquina según lo establecido mediante el
programa 3.
Programa 2: Este programa proporciona la lógica requerida para el
funcionamiento automático. Además, por medio de Flags (véase
capítulo 12), este programa puede verificar las posiciones de los
componentes de la máquina según lo establecido mediante el
programa 3.
Programa 3: Este programa constantemente consulta las posiciones de
varias partes de la máquina, y de acuerdo a éstas Setea Flags o los
Resetea. Estos Flags pueden ser leídos por otros programas. A
menudo se elimina lógica duplicada de programa.
En este ejemplo, los programas siguientes serían activos dependiendo

del modo de funcionamiento:
Modo Manual Modo Automático
Programa 0 Programa 0
Multiprocesamiento
El Multiprocesamiento es posible en sistemas que emplean múltiples
CPU. Con el uso de múltiples CPU, un procesamiento, verdadero de
múltiples programas es posible.
30/01/02
30/01/02
30/01/02
Apéndice D – Números Binarios

30/01/02
RESUMEN........................................................................................ 145
DETALLES ....................................................................................... 145
Números Decimales.............................................…......................... 145
Números Binarios ............................................................................. 145

..
30/01/02

RESUMEN
Esta sección proporciona información básica sobre números binarios y
números decimales. Estos conceptos serán importantes en la medida
que el lector desee hacer uso extensivo de la aritmética multibit e
instrucciones lógicas provistas en el lenguaje STL.
DETALLES
Los Operandos Multibit (MBO) usados por los controladores
programables de Festo
Son de 8 o 16 bits de ancho. Ya que el ancho de cada MBO es fijo, el
rango de valores que pueden almacenarse es fijo.
Números Decimales
En la vida cotidiana usamos el sistema numérico decimal para todas
las necesidades. Las reglas matemáticas que se aplican a todos los
sistemas de numeración son a menudo pasadas por alto. Por ejemplo,
si el siguiente formulario fue proporcionado, junto con las instrucciones
"Entre su edad en años":
y se nos indicó sólo entrar (1) un dígito por cada casillero en blanco,
rápidamente entenderíamos que la edad máxima que podría ser
ingresada sería de 99. En total, podríamos hacer 100 entradas
diferentes, yendo de 0 a 99.
Esto es posible ya que cada casilla puede aceptar un dígito cualquiera

de 10 posibles entradas (0-9).
Números Binarios
En el mundo de las computadoras digitales, el formato binario es muy

común debido a razones técnicas. Si la pregunta anterior fuera
replanteada diciendo "Entre su edad en años binarios:" y los mismos
dos casilleros fueran provistos:
entonces la edad máxima que podría entrarse sería de 3 en decimal u

"11" en binario. Por consiguiente, un total de sólo 4 entradas diferentes
(0-3 decimal) sería posible porque sólo un ' 0 ' o ' 1 ' puede entrarse en
cada caja.
30/01/02

Las siguientes combinaciones y sus decimales equivalentes existen:
= 0 decimal
0 0
= 1 decimal
0 1
= 2 decimal
1 0
= 3 decimal
1 1
Igual que en el formato decimal, puede verse que en cada cuadro, o

columna hay un valor con cierto peso. En los números decimales
decimos que estas columnas son :
La columna de ‘las unidades’

La columna de ‘las decenas’
La columna de ‘las centenas’
Las descripciones equivalentes al trabajar con números binarios serán:
La columna de los "unos"

La columna de los "dos"
La columna de los "cuatro " etc.
Para convertir un valor de formato binario a formato decimal y

viceversa es necesario saber el peso de cada columna o posición.
Suponiendo que estemos trabajando con enteros sin signo los
siguientes valores pueden tomarse:
8 bit MBO rango 0 - 255 decimal
16 bit MBO rango 0 - 65535
30/01/02

Numerosas tablas de conversión y calculadoras de bajo costo están
disponibles para ayudar en el proceso de conversión. La tabla a
continuación suministra información básica teniendo en cuenta el valor
del peso en cada columna para un número binario de 16 bit.
15 Bit número 0 valor

decimal
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 2
0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 4
0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 8
0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 16
0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 32
0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 64
0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 128
0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 256
0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 512
0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1024
0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 2048
0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 4096
0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 8192
0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 16384
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 32768
30/01/02
30/01/02
Indice
Indice
30/01/02
Index
A
Análoga 111-112
AND (Y) 27, 37, 41-42
B
BID 37, 43
Binario 37, 43, 145
C
CCU 10
CFM 37, 44-45
CMP 37, 46-47
Control registers 129
Counters
Initializing 92
Preselect 91
Standard 91
Starting 93
Status 91, 93
Stopping 93
Updating 93
UP/DOWN 97
Word 91-92
CPL 37, 48
CPU 10
D
DEB 37, 49
DEC 37, 50
Decimal 49, 145
E
Edge triggering 30
EXOR 37, 51-52
F
Field Bus 77, 115
Flags 105-107
FST 9
I
IF 26-27, 37
INC 37, 53
Inputs 78-79
Installation 13
I/O 77-78
INV 37, 54
J
JMP 33, 37, 55-57
L
Ladder Diagram
Comparison to 28
Language
Elements of 26
Structure 25
LOAD 37, 58-60
30/01/02
M
MBA 17
MBO 17
Motors 114
Multibit Operands 17
Listing of 19
Multiprocessing 142
Multitasking 115, 139,
140, 141
N
Network 77, 111, 113
NOP 32, 37, 61-62
NOT 21, 27
O
On-line Mode 14
Operands 17
Absolute 17
Global 20
Listing by model 119
Local 20
Multibit 19
Monobit 18
Symbolic 17
Operators 21
OR 27, 37, 63-64
OTHRW 34, 38
Outputs 80
P
Parallel processing 30,61
Positioning 114
Program 10
Creating 13
Execution 26-29
Loading 14
Samples 123-136
Starting 140
Structure 25-34, 123
Types 123
Version 13
Writing 14
Project 10
PSE 38, 65
R
Random events 125, 128
Registers 101, 129
RESET 38, 66, 85
ROL 38, 67
ROR 38, 68
S
Sample programs 123-
136
SBA 17
30/01/02
SBO 17
Scanning 30, 61
Sentences 26-31
Sequential task 123
SET 38, 69
SHIFT 38, 70
Shift Register 107
SHL 38, 71-72
SHR 38, 73
Monobit Operands 18
Listing of 18
STEP instruction 26, 27,
29
Conditional Part 26
Execution rules 30-31
Executive Part 26
Label 26, 29
SWAP 38, 74
T
THEN 26, 38
Timers 83, 87
Clock rate 84
Preselect 83, 84
Resetting 85-86
Starting 85
Status 83, 85
Stopping 85
Word 83
TO 38

STL Español PDF

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

STL Español PDF

Încărcat de

Drepturi de autor:

Formate disponibile

30/01/02

Programación en Statement List

Order no.: 18352

Este manual ha sido escrito para aquellos que tienen conocimientos

Este manual está dividido en las siguientes secciones:

Capítulo 1 Introducción .....................................................................4

Capítulo 2 Ambiente de Programación FST.................................... 7

Capítulo 3 Uso del Software FST ...................................................11

Capítulo 4 Operandos de los PLC’s de Festo ...............................15

Capítulo 5 Estructura del Programa STL...................................... 23

Capítulo 6 Resumen de las instrucciones STL............................. 35

Capítulo 7 Referencia de las Instrucciones STL.......................... 39

Capítulo 8 Accediendo a las Entradas y Salidas Digitales......... 75

Capítulo 9 Usando Timers ..............................................................81

Capítulo 10 Usando Contadores .................................................... 89

Capítulo 11 Usando Registros........................................................ 99

Capítulo 12 Flags y Flag Words.................................................... 103

Capítulo 13 Aplicando funciones Especiales del PLC............... 109

Apéndice A Operandos de los Controladores Festo.................. 117

Apéndice B Programas de Ejemplo............................................. 121

Apéndice C Programas Múltiples, Multiprocesamiento y Multitarea ..... .....

Apéndice D Comprendiendo los números Binarios................... 143

Muchas secciones de este manual están, a su vez, subdivididas en la

RESUMEN, en aquellos temas en los que sea apropiado, se ha ubicado

DETALLES es el corazón de cada sección. Contiene una detallada

2. Ambiente de Programación FST

2. Ambiente de Programación FST

2. Ambiente de Programación FST

2. Ambiente de Programación FST

El software FST puede usarse en cualquier sistema IBM XT/AT

Lenguajes adicionales de programación están en desarrollo. Contacte

Antes de describir el lenguaje STL propiamente dicho, es conveniente

Al hablar de las funciones y forma del lenguaje STL, pueden aplicarse

Los sistemas de control complejos, pueden tener múltiples proyectos

El nivel que sigue en la organización es la CPU. Dependiendo del

Este manual se concentra en la estructura e implementación a nivel de

3. Usando el Software FST

3. Usando el Software FST

3. Usando el Software FST

Pasos preliminares ..................................................................…... 13

3. Usando el Software FST

Este capítulo describe la organización y principales funciones del FST

1. Instalación y configuración: Una vez obtenido el paquete de software

2. FST Project: (Proyecto FST) seleccionando uno ya existente o

3. Program Creation: (Creación de un Programa) El Editor STL se usa

permite especificar el número de CPU para el modelo

Prgm./Module Entre „P“ para un programa o „B“ para un módulo de

define el número de programa o del modulo de

Ingrese aquí una descripción (opcional) del programa

3. Usando el Software FST

4. Usando el Editor de STL: El Editor de STL permite la edición y

5. Transferencia de programas al controlador: una vez finalizada la edición

6. Operación On-Line: Esta facilidad permite monitorear al controlador

4. Operandos de los PLC’s de Festo

4. Operandos de los PLC’s de Festo

4. Operandos de los PLC’s de Festo

Operandos Monobit (Single) y Operandos Multibit.................. 17

Operandos Locales y Globales.................................................... 20

4. Operandos de los PLC’s de Festo

Debe diferenciarse adecuadamente entre Operando Monobit (Single) y

La sección siguiente presenta un sumario de los operandos

Dependiendo del operando específico, puede ser posible usar a éste

Operando FormatoS Sintaxis Parte Ejemplo Típico