Autómatas y Control Lógico Programable

El término PLC, de amplia difusión, significa Controlador Lógico Programable. Originalmente se denominaban PCs (Programmable Controllers), pero, con la llegada de las IBM PCs, para evitar confusión, se emplearon definitivamente las siglas PLC.

La definición más apropiada es: Sistema Industrial de Control Automático que trabaja bajo una secuencia almacenada en memoria, de instrucciones lógicas.

Es una máquina electrónica programable capaz de ejecutar un programa, o sea, un conjunto de instrucciones organizadas de una forma adecuada para solventar un problema dado, y diseñada para trabajar en un entorno industrial y, por tanto, hostil.

Listas Enlazadas

Una lista enlazada es un conjunto de elementos (nodos), en los que cada nodo contiene dos campos:

• Uno de valor del elemento (que por lo general es un registro).
• Otro que contiene la dirección o posición del siguiente elemento o nodo de la lista, llamado campo de enlace. Este campo sirve para enlazar los elementos de la lista.

Recursividad

Recursividad, recursión o recursividad es la forma en la cual se especifica un proceso basado en su propia definición. Siendo un poco más precisos, y para evitar el aparente círculo sin fin en esta definición:

• Un problema que pueda ser definido en función de su tamaño, sea este N, pueda ser dividido en instancias más pequeñas (< n) del mismo problema y se conozca la solución explícita a las instancias más simples, lo que se conoce como casos base, se puede aplicar inducción sobre las llamadas más pequeñas y suponer que estas quedan resueltas.

Características de la Recursividad

Un algoritmo recursivo consta de una parte recursiva, otra iterativa o no recursiva y una condición de terminación. La parte recursiva y la condición de terminación siempre existen. En cambio, la parte no recursiva puede coincidir con la condición de terminación. Algo muy importante a tener en cuenta cuando se usa la recursividad es que es necesario asegurarnos que llega un momento en que no hacemos más llamadas recursivas. Si no se cumple esta condición, el programa no parará nunca.

Ejemplo de Recursividad

int elevar(int base,int exponente){
  if(exponente == 1)
    return base;
  return (elevar(base,exponente-1)*base);
}

Pilas

Una pila es un tipo especial de lista abierta en la que sólo se pueden insertar y eliminar nodos en uno de los extremos de la lista. Estas operaciones se conocen como «push» y «pop», respectivamente «empujar» y «tirar». Además, las escrituras de datos siempre son inserciones de nodos, y las lecturas siempre eliminan el nodo leído.

Estas características implican un comportamiento de lista LIFO (Last In First Out), el último en entrar es el primero en salir.

El símil del que deriva el nombre de la estructura es una pila de platos. Sólo es posible añadir platos en la parte superior de la pila, y sólo pueden tomarse del mismo extremo.

Características de las Pilas

• Las pilas llevan datos que son colocados uno encima de otro como dice su propio concepto como si fuera una pila de datos.
• Solo se pueden obtener o ingresar datos desde uno de sus extremos, igualmente como si fuera una pila de platos.
• Cuando se empieza a crear una pila su tamaño es cero (pila vacía) y generalmente va creciendo de acuerdo a la cantidad de datos que se van apilando en ella.

Colas

Una cola es una estructura de datos, caracterizada por ser una secuencia de elementos en la que la operación de inserción push se realiza por un extremo y la operación de extracción pop por el otro. También se le llama estructura FIFO (del inglés First In First Out), debido a que el primer elemento en entrar será también el primero en salir. Las colas se utilizan en sistemas informáticos, transportes y operaciones de investigación (entre otros), dónde los objetos, personas o eventos son tomados como datos que se almacenan y se guardan mediante colas para su posterior procesamiento.

Características de las Colas

Las siguientes características se aplican a los sistemas de colas:

• Una población de clientes, que es el conjunto de los clientes posibles.
• Un proceso de llegada, que es la forma en que llegan los clientes de esa población.
• Un proceso de colas, que está conformado por la manera que los clientes esperan para ser atendidos y la disciplina de colas, que es la forma en que son elegidos para proporcionarles el servicio.

#include <stdio.h>
#include <stdlib.h>  //malloc: reserva memora  free: libera memoria
#include <string.h>
struct agenda
{
  char nombre[50];
  char telefono[25];
};
struct nodo
{
  struct agenda dato;
  struct nodo *proximo;
};
struct nodo *nuevo_nodo();
int cola_vacia(struct nodo *);
struct nodo *crea_cola(struct nodo *, struct agenda);
void mostrar(struct nodo *);
void main()
{
  struct nodo *pri=NULL, *ult=NULL;
  struct agenda x;
  printf("escriba el nombre: ");
  gets(x.nombre);
  while(strcmpi(x.nombre,"fin"))
  {
    printf("escriba el telefono: ");
    gets(x.telefono);
    ult=crea_cola(ult,x);
    if(pri==NULL) pri=ult;  // Si es la 1º pasada pongo en pri el valor del primer nodo
    printf("escriba el nombre: ");
    gets(x.nombre);
  }
  if(cola_vacia(pri)==1) { printf("No entraron registros"); getch(); }
  else mostrar(pri);
}
struct nodo *nuevo_nodo()
{
  struct nodo *p;
  p=(struct nodo *)malloc(sizeof(struct nodo));
  if(p==NULL)
  {
    printf("Memoria Llena");
    getch();
    exit(0);
  }
  return p;
}
struct nodo *crea_cola(struct nodo *ult, struct agenda x)
{
  struct nodo *p;
  p=nuevo_nodo();
  (*p).dato=x;
  (*p).proximo=NULL;
  if(ult!=NULL) (*ult).proximo=p;
  return p;
}
int cola_vacia(struct nodo *pri)
{
  if(pri==NULL) return 1;
  else return 0;
}
void mostrar(struct nodo *pri)
{
  struct nodo *aux;
  while(pri!=NULL)
  {
    printf("Nombre: %s - Telefono: %s \n",pri->dato.nombre,pri->dato.telefono);
    aux=pri;
    pri=(*pri).proximo;
    free(aux);
  }
  getch();
}