martes, 28 de mayo de 2013

Medidor de distancia por ultrasonido HC-SR04 con pinguino

HC-SR04
MEDICIÓN DE DISTANCIA POR ULTRASONIDO CON EL HC-SR04
El HC-SR04 es modulo sensor de distancia por ultrasonido que trae 4 terminales, dos de alimentación y dos para envío y recepción.
Uno de los terminales se llama trigger o disparador, es el encargado de indicarle al dispositivo que envíe la señal ultrasonica este terminal por lo menos debe estar 10 microsegundos en alto para que envíe una señal ultrasonica.
El otro terminal se llama echo o terminal de detección de eco, este terminal se coloca en alto cuando se hace el envío de la señal ultrasonica, y se coloca en bajo cuando hace recepción por medio de eco o rebote de esta sobre un objeto.
Para determinar la distancia recorrida en centímetros, se cuenta el tiempo que trascurre desde que se coloca en alto el terminal de eco y este regresa a bajo, se puede contar cada 58 microsegundos para obtener una relación en centímetros.
Calculo De La Velocidad Del Sonido
En este ejemplo se trabajara con la velocidad a 20 grados centigrados que es V=343 m/s.
Se aplica el siguiente procedimiento para hallar el tiempo en microsegundos equivalente a un centímetro.
  • Pasamos la velocidad a centímetros por segundo, esto da V=34300 cm/s
  • Calculamos el tiempo con la ecuación distancia = velocidad/tiempo, despejamos tiempo y tenemos la ecuación t=d/v, reemplazando por los valores t=1cm/(34300cm/s) luego t = 0,000029155s
  • Como la señal va y vuelve hace el doble de la distancia que se desea medir, por lo tanto tomara el doble de tiempo, así que mediremos el doble de tiempo luego t=0,000058309s, finalmente pasamos este valor a microsegundos t=58,309us que para efecto practico lo aproximaremos a t=58us en el programa.
  • Tener en cuenta que la velocidad del sonido es mayor cuando aumenta la temperatura, aproximadamente 0.6m/s por cada grado centigrado.
Vídeo mostrando la prueba realizada.

ENLACES DE INTERÉS

MONTAJE DE PRUEBA


Montaje básico HC-SR04 en Pinguino
CÓDIGO DE PRUEBA
//Codigo probado en Pinguino 9-05
//Julio Fabio De La Cruz 28-05-2013
#define  Trig  8 //Defino el terminal 8 como trigger o disparador
#define  Echo  9 //Defino el 9 como el de recepcion del eco
int Dato;//Dato sin procesar equivalente a la distancia a medir en centimetros
void setup(){
pinMode(Trig, OUTPUT);//Disparador como salida
pinMode(Echo, INPUT);//Eco como entrada
Dato=0;//Inicio dato en 0
TRISB=0;//Configuro puerto B como salida
}
void loop() {
while (digitalRead(Echo) == LOW) {//Pin del eco en bajo
digitalWrite(Trig, HIGH);//Activa el disparador
delayMicroseconds(50);//Espera 50 microsegundos (minimo 10)
digitalWrite(Trig, LOW);//Desactiva el disparador
}
while (digitalRead(Echo) == HIGH) {//Pin de eco en alto hasta que llegue el eco
Dato++;//El contador se incrementa hasta llegar el eco
delayMicroseconds(58);//Tiempo en recorrer dos centimetros 1 de ida 1 de vuelta
}
PORTB=Dato;//Muestro dato por el puerto B
delay(1000);//Espera un segundo para visualizar el dato
Dato=0;//Reinicio dato a 0 
}
CÓDIGO DE PRUEBA EN GREAT COW BASIC
También dejo el código de prueba en basic empleando great cow basic con el fin de que pueda ser
llevado a otro microcontrolador como por ejemplo el 16F877A

'****************************************************************
' Generated by Prithvi Development Studio 0.0.1 (Build: 560)

' Description : Porgrama basico para el HC-SR04
' Author      : Julio Fabio De La Cruz Gomez
' Date        : 30/05/2013 10:32:05 a.m.

'****************************************************************
#chip 16F877A, 4
#define trig PORTC.6
#define echo PORTC.7
TRISB = 0  'Configuro puerto B como salida
dir trig out 'terminal para menejar el disparardo trigger
dir echo in  'terminal para detectar el eco echo
PORTB = 0  'Limpio el puerto B colocandolo en cero
trig = OFF 'Terminal del disparador trigger en cero
dato = 0   'Variable para guardar dato de la medicion
Inicio:
       do while echo = OFF
          trig = ON   'Activa el disparador
          wait 50 us  'Espera 50 microsegundos
          trig = OFF  'Desactiva el disparador
       loop
       do while echo = ON
          dato = dato+1 'Contador se incrementa hasta llegar el eco
          wait 58 us 'Tiempo en recorres dos centimetros 1 de ida 1 de vuelta
       loop
   PORTB=dato 'Muestro dato por el puerto B
   wait 1 s 'Espera un segundo para visualizar el dato
   dato=0   'Reinicio dato a 0 
goto inicio

jueves, 23 de mayo de 2013

Instalación De Pinguino En windows 8

INSTALACIÓN

Recién logre la instalación de pinguino en windows 8, el problema esta en que aparecía un mensaje diciendo que el controlador no estaba firmado.
Buscando en publicaciones sobre la instalación de arduino en windows 8  se logro un procedimiento similar para la instalación de pinguino.

ENLACES DE INTERÉS
Aquí dejo las fuentes que sirvieron de guía y el controlador de pinguino que funciono en windows 8.
Básicamente consiste en quitar la solicitud de controladores firmados por parte de windows, para esto se hace lo siguiente según como indica en Pagina con una guía de instalación
Las pantallas las tomo de Pagina con las imágenes de las pantallas de instalación. hasta que tenga la oportunidad de volver hacer la instalación y tomar pantallazos.
http://www.youtube.com/watch?v=A-lwH7smkvc

Pasos

  1. Descargar el controlador de Pinguino de este enlace Controlador de pinguino windows 8
  2. Presionar la tecla que tiene el símbolo de windows y 'R' de forma simultanea.
  3. Copiar en en el cuadro de texto de la ventana de ejecutar el comando entre comillas "shutdown.exe /r /o /f /t 00" y a continuación pulsa"Aceptar".
  4. Selecciona la opción "Solucionar Problemas
  5. Selecciona "Opciones Avanzadas"
  6. Selecciona "Configuración de Inicio" y pulsa "Reiniciar".
  7. Una vez se reinicie el sistema aparecerá un menú donde se pueden elegir diferentes opciones como:  Habilitar Depuración, Habilitar el registro de arranque, Habilitar modo seguro, etc. Hay que elegir la opción 7 "Deshabilitar el uso obligatorio de controladores firmados".
  8. Conectar la tarjeta pinguino.
  9. Ejecutar el asistente de instalación del controlador de pinguino, en el vídeo se muestra como se hace.
  10. Verificar que esta instalando en dispositivos e impresoras.
Se ejecuta el asistente de instalación con la tarjeta conectada.

miércoles, 22 de mayo de 2013

Comunicación serial entre dos computadores

Cable para conexión serial entre dos computadores
CONEXIÓN DEL CABLE DE COMUNICACIÓN
Conector DB9 para comunicación serial RS232
Para hacer la conexión entre los dos computadores se necesitara que estos tengan un puerto de comunicación serial, el puerto se puede verificar como un conector de 9 terminales macho DB9.
Este tipo de conector se encuentra en los equipos de que tengas puerto de comunicación serie o en los adaptadores USB - Serial RS232.
El tipo de conector en estos equipos es macho, los terminales de interés para la prueba de comunicación se muestran en la gráfica
Conector DB9 macho vista frontal
Cable De Comunicación Entre Dos Computadores
El tipo de conector que se empleara para hacer el cable es DB9 hembra, las gráficas mustran las vistas y los terminales de interés para la comunicación.
Conector DB9 hembra vista frontal
Conector DB9 hembra visto de atras
El cable de conexión debe ser un DB9 hembra cruzado con RX-TX y TX-RX el gráfico muestra la configuración.
Conexión cruzada
Conectores montados
PROGRAMA DE PRUEBA
El siguiente programa se encuentra en los ejemplos de processing en la siguiente ruta:
  • Examples/Library/Serial/SerialDuplex
Este programa sirve para probar que se realiza la comunicación entre los dos computadores enviando y recibiendo caracteres en formato ASCII. El programa es el mismo en ambos computadores.
Programa SerialDuplex
import processing.serial.*;
Serial myPort;
int whichKey = -1;
int inByte = -1;
void setup() {
  size(400, 300);
   PFont myFont = createFont(PFont.list()[2], 14);
  textFont(myFont);
  println(Serial.list());
  String portName = Serial.list()[0];
  myPort = new Serial(this, portName, 9600);
}
void draw() {
  background(0);
  text("Last Received: " + inByte, 10, 130);
  text("Last Sent: " + whichKey, 10, 100);
}
void serialEvent(Serial myPort) {
  inByte = myPort.read();
}
void keyPressed() {
  myPort.write(key);
  whichKey = key;
}
DESCRIPCIÓN DEL PROBLEMA PROPUESTO
El presente sistema a simular consiste en que un computador se utilizara para simular el envío de datos de forma serial tal como lo hace una bascula de uso industrial. El formato empleado es el siguiente:
El símbolo = se empleara para indicar que se esta enviando un nuevo valor de peso y se podrá medir hasta 999 con dos valores decimales, esto se representa como =999.99
Un ejemplo de una cadena enviada por la bascula es el siguiente:
  • =123.20=126.34=124.87
Se puede observar que no hay espacios entre tramas de peso enviadas, por eso se utiliza el símbolo =  para indicar que hay una nueva trama.
En la recepción de datos se tendrá un visualizado en pantalla mostrando en dato recibido, ademas se contara con la opción de guardar los datos en archivo.
PROGRAMAS PROPUESTOS
El programa de recepción es mas complejo que el ejemplo SerialDuplex, ya que aquí se envían cadenas de caracteres. Este programa se elaboro en processing 1.2 y se tuvo problemas de conversión de cadenas. Este inconveniente ya esta corregido en las versiones mas posteriores de processing.
Computador Que Envía Datos
import processing.serial.*;
Serial miPuerto;
String puerto[];
void setup() {
  size(200, 200);
  puerto=Serial.list();
  println(puerto[0]);
  miPuerto=new Serial(this, puerto[0], 115200);
}
void draw() {
  miPuerto.write("=123.24");//Cadena a enviar al otro computador
}
Computador Recibe Datos
import processing.serial.*;//librerira de puerto serial
Serial miPuerto;//Objeto tipo puerto serial
String puerto[];//cadena para guardar a que puerto se accede
int nInicioCadena;
int[] nDatos = new int[20];//datos leidos en formato entero
char[] cDatosChar = new char[20];//datos leidos como caracteres
String[] strPeso= new String[1];//cadena pata guardar el peso leido
String cadena = "";//cadena a guardar con los carateres leidos
int i=0;//variable contadora en cero
boolean bBanderaCaptura=false;
void setup() {
  size (250, 140);
  puerto=Serial.list();//listo los puertos y los guardo en la cadena puerto
  println(puerto[0]);//imprimo el puerto que detecto como cero
  miPuerto=new Serial(this, puerto[0], 115200);//Instancio puerto en modo 8n1 a 115200 baudios
   PFont pfLetra = createFont(PFont.list()[2], 14);//Creo un tipo de letra con las que hay en el sistema
  textFont(pfLetra);//defino la letra creada para los textos
}
void draw() {
  strPeso[0]="";//cadena con el peso vacia
  background(255);//fondo blanco
  fill(0);//relleno de texto negro
  text("PESO", 30, 60);//muestro el mensaje PESO en la posicion 30,60
  for (int j=0;j<7;j++) {//para guardar hasta 7 caracteres en la cadena srtPeso
    if (nDatos[j]=='0')
      strPeso[0]=strPeso[0]+'0';
    if (nDatos[j]=='1')
      strPeso[0]=strPeso[0]+'1';
    if (nDatos[j]=='2')
      strPeso[0]=strPeso[0]+'2';
    if (nDatos[j]=='3')
      strPeso[0]=strPeso[0]+'3';
    if (nDatos[j]=='4')
      strPeso[0]=strPeso[0]+'4';
    if (nDatos[j]=='5')
      strPeso[0]=strPeso[0]+'5';
    if (nDatos[j]=='6')
      strPeso[0]=strPeso[0]+'6';
    if (nDatos[j]=='7')
      strPeso[0]=strPeso[0]+'7';
    if (nDatos[j]=='8')
      strPeso[0]=strPeso[0]+'8';
    if (nDatos[j]=='9')
      strPeso[0]=strPeso[0]+'9';
    if (nDatos[j]=='.')
      strPeso[0]=strPeso[0]+'.';
  }
  fill(0);//relleno de texto negro
  text(strPeso[0]+" Kg", 30, 100);//muestro la cadena con el peso
  saveStrings("peso.txt", strPeso);//guarda el peso leido en un archivo
}
void serialEvent(Serial miPuerto) {//detecta si hay un evento de puerto
  nInicioCadena=miPuerto.read();//lee la cadena enviada
  println(nInicioCadena);
  if (bBanderaCaptura==false) {
    if (nInicioCadena=='=') { //el simbolo = indica un nuevo dato de peso
      bBanderaCaptura=true;//activa la bandera de recepcion de un nuevo dato
    }
  }
  else {
    if (i<=6) {//captura 6 caracters y los convierte en una cadena
      nDatos[i] = nInicioCadena;
      i++;
      print(char(nDatos[i]));
    }
    else {
      bBanderaCaptura=false;//desactiva la bandera de dato recivido
      i=0;
      miPuerto.clear();//limpia el buffer para recicibir un nuevo dato
    }
  }
}
void keyPressed() {
  saveStrings("peso.txt", strPeso);//guarda los datos en un archivo
}

domingo, 19 de mayo de 2013

Como hacer menús en Pinguino


MENÚS

Los menús de navegación se utilizan para configurar,mostrar y ejecutar procesos en una aplicación,su forma mas común de implementación en aplicaciones con microcontroladores es la de utilizar una pantalla LCD y unos cuantos botones para selección o un teclado matricial dependiendo de la aplicación a realizar.
En esta publicacion se tratara de un menu sencillo con 4 botones pulsadores para la selección de opciones.

MONTAJE DE PANTALLA LCD Y BOTONES


Este esquema muestra configurado el LCD a 4 bits y 4 botones pulsadores con resistencias de Pull Up, es por esto que cuando se presiona un pulsador tenemos un bajo y en el código aparece en la condición que se evalúa si los pulsadores son LOW.

APLICACIÓN A REALIZAR

Descripción General

Realizar un menú de navegación que permita controlar un motor paso a paso de manera que el usuario pueda indicar el sentido de giro, el numero de secuencias de pasos a ejecutar y el retardo entre pasos:

Planeación Del Menú De Navegación

Se enumeran las diferentes etapas o instancias en el programa:
  • Presentación y bienvenida.
  • Selección del sentido de giro.
  • Indicación del numero de secuencias a realizar.
  • Indicación del retardo entre pasos para controlar la velocidad del motor.
  • Ejecución del giro del motor.

Descripción De Los Menús y Los Procesos

Se describe en detalle que hace cada menú y el proceso a realizar en este.
  • Menu0: Menú de presentación y bienvenida, este menú se presentara por primera a vez al iniciar por primera vez la aplicación, deberá mostrar el nombre de la aplicación y el nombre de la institución, esperara a que se presione cualquier tecla para continuar. Una vez en ejecución la aplicación, no se debe retornar mas a este menú.
  • Menu1: Menú de selección de sentido de giro, este menú mostrara el mensaje sentido giro, que se seleccionaran con las opciones Izq o Der respectivamente. Presionada la opción ENT, se pasara al Menu2.
  • Menu2: Menú de selección del numero de secuencias de pasos a realizar, mostrara el mensaje secuencias y tendrá el valor de 12 por defecto, equivalente a un giro completo para un motor paso a paso de 7.5 grados con las opciones Dec o Inc se podrá incrementar o disminuir el numero de secuencias. Presionada la opción ENT se pasara al Menu3 o si es presionada la opción ESC ser retornara al Menu1.
  • Menu3: Menú de selección del retardo entre pasos, mostrara el mensaje retardo y tendrá el valor de 100 mili segundos por defecto, con las opciones - o + se podrá incrementar o disminuir el tiempo. Presionada la opción ENT se pasara al Menu4 o si es presionada la opción ESC ser retornara al Menu2.
  • Menu4: Menú de ejecutar el giro del motor, mostrara el mensaje Salir o Ejecutar. Presionada la opción ENT se ejecutara el giro del motor según la configuración realizada en los anteriores menús o si es presionada la opción ESC ser retornara al Menu1.

Prototipos De Pantalla

Se muestra gráficamente como se verán las opciones en la pantalla para cada uno de los menús.

Diagrama De Estados

Indica como se navega en el sistema de menús según las teclas presionadas.
Las transiciones se dan por medio de las teclas que se presionen, las teclas ENT y ESC son las que permiten avanzar o retroceder entre menús.
Cuando se entra a un menú se llama una subprograma o rutina que ejecuta el procedimiento indicado según el menú.

Diagrama De Flujo


Para entrada a cada menú se empleara una variable que indicara en que estado o menú estoy, esta variable cambiara de estado según la tecla que se presione. Se empleara un ciclo mientras por cada menú y así representar los estados.

CÓDIGO DEL PROGRAMA DE NAVEGACIÓN

El presente código contempla solo la navegación entre menús, no están las rutinas o funciones correspondientes a las partes operativas que tiene que ver con el motor paso a paso. Este código se presente como una plantilla que pueda ser utilizada para la construcción de otros menús.

NOTA: El código esta escrito para Pinguino IDE 9.05, por la tanto las instrucciones de LCD deben ser modificadas para llevarlo a las versiones PinguinoX3 y PinguinoX4.



// Manejo de menus
// Realizado en Pinguino Beta 9-05
// Julio Fabio De La Cruz G. 2013
#define PIC18F4550
//Definiciones para el LCD
#define EN 21 //21 es el terminal Enable del LCD
#define RS 22 //22 es el terminal RS del LCD
#define D4 25 //25 es el terminal de dato 4 del LCD
#define D5 26 //26 es el terminal de dato 5 del LCD 
#define D6 27 //27 es el terminal de dato 6 del LCD 
#define D7 28 //28 es el terminal de dato 7 del LCD
//Definiciones para los pulsadores por defecto
#define S1 17  //pusador S1
#define S2 18  //pusador S2
#define S3 19  //pusador S3
#define S4 20  //pusador S4
//Definiciones para los pulsadores segun la aplicacion
#define ESC 17  //Pulsador S1 como escape
#define DEC 18  //Pulsador S4 como enter
#define INC 19  //Pulsador S1 como escape
#define ENT 20  //Pulsador S4 como enter
int menu;//Varaible de navegacion o de estado actual
void setup(){
   menu=0;//Por primera vez en cero para entrar al menu 0
   lcd(RS, EN, D4, D5, D6, D7, 0, 0, 0, 0); // RS, E, D4 ~ D8 
   lcd.begin(2, 0);
   //Configuro los terminales de entrada
   pinMode(17,INPUT);//Pulsador S1
   pinMode(18,INPUT);//Pulsador S2
   pinMode(19,INPUT);//Pulsador S3
   pinMode(20,INPUT);//Pulsador S4
}
void loop(){
  while (menu==0) {
      lcd.clear();
   lcd.setCursor(0, 0); 
   lcd.print("Motor Paso-Paso");
   lcd.setCursor(0, 1);
   lcd.print("UNIAJC 2013 633");
   delay(200);
   if (digitalRead(ESC)==LOW||digitalRead(DEC)==LOW||digitalRead(INC)==LOW||digitalRead(ENT)==LOW) {
    menu=1;//pasa el menu 1
   }
  }
  while (menu==1) {
   lcd.clear();
   lcd.setCursor(0, 0); 
   lcd.print("Sentido Giro");
   lcd.setCursor(0, 1);
   lcd.print("   Izq  Der Ent");
   delay(200);
   if (digitalRead(ENT)==LOW) {
    menu=2;//pasa al menu 2
   }
  }
  while (menu==2) {
   lcd.clear();
   lcd.setCursor(0, 0); 
   lcd.print("Secuencias");
   lcd.setCursor(0, 1);
   lcd.print("Esc Dec  Inc Ent");
   delay(200);
   if (digitalRead(ENT)==LOW) {
    menu=3;//pasa al menu 3
   }
   if (digitalRead(ESC)==LOW) {
    menu=1;//retorna al menu 1
   }
  }
  while (menu==3) {
   lcd.clear();
   lcd.setCursor(0, 0); 
   lcd.print("Retardo     ms");
   lcd.setCursor(0, 1);
   lcd.print("Esc Dec  Inc Ent");
   delay(200);
   if (digitalRead(ENT)==LOW) {
    menu=4;//Pasa al menu 4
   }
   if (digitalRead(ESC)==LOW) {
    menu=2;//Retorna al menu 2
   }
  }
  while (menu==4) {
   lcd.clear();
   lcd.setCursor(0, 0); 
   lcd.print("Salir   Ejecutar");
   lcd.setCursor(0, 1);
   lcd.print("Esc          Ent");
   delay(200);
   if (digitalRead(ESC)==LOW) {
    menu=1;//Retorna al menu 1
   }
  }
}

viernes, 17 de mayo de 2013

Lógica combinatoria con GAL y WinCUPL

LÓGICA COMBINATORIA CON GAL
En esta publicación se explicar como se utiliza y programa un dispositivo GAL para realizar circuitos digitales empleando lógica digital combinatoria.
Actualmente este dispositivo es muy económico y relativamente fácil de conseguir, ademas es reprogramable y fácil de montar en un protoboard.
Para programar el dispositivo GAL se empleara el WinCupl de Atmel, se pude descargar después de registrarse en la pagina.
Una vez descargado se introduce el código de activación dado por el soporte técnico de Atmel el cual es 60008009
ENLACES DE INTERÉS

Descargas

GAL22V10
En la GAL22v10 tendremos que 22 terminales pueden ser utilizados como entradas, en el esquema están marcados como In, que 10 terminales se pueden utilizar como salidas, en el esquema están marcados como Out ademas que estas salidas pueden ser Q lo que representa la salida de un flip flop. Se puede observar que los 10 terminales comparten la opción de entrada o salida y que esta salida puede ser el Q de un flip flop. También el terminal 1 que es una entrada comparte la opción de ser la entrada de la señal de reloj Clk para los flip flop internos de la GAL siendo esto útil al diseñar circuitos digitales secuenciales.

WINCUPL
En las siguientes tablas se resumen las instrucciones mas frecuentes para la realización de aplicaciones digitales combinatorias.

Formatos Numéricos

Se utilizan los prefijos entre comillas simples para indicar el formato numerico que se esta utilizando.

Asignación De Terminales, Variables Y Constantes

Son las instrucciones que se utilizan para definir y asignar terminales a variables, o asignar a variables operaciones con variables o constantes.
Ejemplos de asignaciones de terminales:
PIN 2 = a; /*asigna al terminal 2 la variable a*/
PIN 2 = !a; /*asigna al terminal 2 la variable a negada*/
PIN [2,3,4,5,6,7,8,9]= [A0,A1,A2,A3,A4,A5,A6,A7];
PIN [2..9] = [A0,A1,A2,A3,A4,A5,A6,A7];
PIN [2..9] = [A0..A7];
Ejemplos de asignaciones con variables intermedias: Las variables intermedias no tiene terminales asignados y son útiles para simplificar las ecuaciones que generan las salidas.
X0 = A0&A1 # A1&A2;
FIELD entradas = [D,C,B,A];
Ejemplos de ecuaciones booleanas de salida: Son las ecuaciones asociadas a las varibles declaradas para los terminales de salida.
El simbolo => utilizado en las tablas significa asignación de un ecuación booleana.
S = X0#Y0;
Table input=>output {
‘d’00 => ‘d’000;
‘d’01 => ‘d’001;
‘d’02 => ‘d’004;
}

Operadores Lógicos

La jerarquía hacer referencia a que operador se tendrá en cuenta primero al hacer una operación, por ejemplo si tenemos S=!A&B, se tendrá en cuenta primero la operación de negar A y luego se hará la operación AND.

Operadores Aritméticos

Los operadores aritméticos se utilizan para realizar operaciones entre valores que sean de tipo numérico y no con variables de tipo booleano como las asignadas a lo terminales por medio de la instrucción PIN. Normalmente lo que se hace es que el resultado de una operación aritmética se asigna a una variable o registro.

Instrucciones Adicionales

Instrucción De Repetición REPEAT: Esta instuccion no es formalmente igual a la que se utiliza en otros lenguajes de programacion como BASIC por ejemplo. Esta instrucción se utiliza en WinCupl para ahorrar escritura de lineas de código y no para implimentar una estructura ciclica en el dispositvo GAL
Ejemplo:
$repeat i = [0..3]
$define D(i) 'b'(i)
$repend
esto equivale a escribir el siguiente código:
$define D0 'b'000
$define D1 'b'001
$define D2 'b'010
$define D3 'b'011

EJEMPLOS
Ejemplo 1
Implementar una compuerta AND de dos entradas en una GAL22V10.

Name Ejem01 ;
PartNo   00 ;
Date     17/05/2013 ;
Revision 01 ;
Designer Julio ;
Company  UNIAJC ;
Assembly None ;
Location  ;
Device   G22V10 ;
/*Terminales de entrada de la compuerta AND*/
PIN 3 = a ; PIN 4 = b; 
/*Terminales de salida para las compuertas*/ 
PIN 17 = s; 
s = a&b; /*Compuerta AND*/ 
Ejemplo 2

Implementar una compuerta OR y una compuerta AND de dos entradas en una GAL22V10.

Name Ejem02 ;
PartNo   00 ;
Date     17/05/2013 ;
Revision 01 ;
Designer Julio ;
Company  UNIAJC ;
Assembly None ;
Location  ;
Device   G22V10 ;
/*Terminales de entrada de la compuerta AND*/
PIN 2 = A0 ;
PIN 3 = A1; 
/*Terminales de entrada de la compuerta OR*/
PIN 4 = B0;
PIN 5 = B1;
/*Terminales de salida para las compuertas*/ 
PIN 23 = S0; /*Salida compuerta AND*/
PIN 22 = S1 ;/*Salida compuerta OR*/
/*Operaciones Logicas*/ 
S0 = A1&A0; /*Compuerta AND*/ 
S1 = B1#B0; /*Compuerta OR*/ 
Ejemplo 3

Implementar un decodificador de binario a decimal con la GAL22V10
Tabla de la verdad correspondiente al decodificador, que se empleara en el programa.
En este ejemplo no se esta empleando el punto decimal dp a pesar de que esta conectado en el esquema mostrado.

CARACTERES EN UN DISPLAY 7 SEGMENTOS

Para otras aplicaciones puede ser útil generar caracteres alfanuméricos con un display de 7 segmentos, aqui se deja una tabla con su respectivo valor decimal teniendo en cuenta que el segmento a es el menos significativo y el segmento g el mas significativo
Mapa de caracteres
Name Ejem03 ;
PartNo 00 ;
Date 17/05/2013 ;
Revision 01 ;
Designer Julio ;
Company UNIAJC ;
Assembly None ;
Location ;
Device G22V10 ;
/*Terminales de entrada */
PIN [2..5] = A, B, C, D;
/*Terminales de salida */
PIN [13..20] = sa,sb,sc,sd,se,sf,sg,sdp;
/*Declaraciones */
FIELD entradas = [D,C,B,A];
FIELD salidas = [sdp,sg,sf,se,sd,sc,sb,sa]; 
/*Ecuaciones booleanas */
TABLE entradas => salidas {
'b'0000 => 'b'00111111;
'b'0001 => 'b'00000110;
'b'0010 => 'b'01011011;
'b'0011 => 'b'01001111;
'b'0100 => 'b'01100110;
'b'0101 => 'b'01101101;
'b'0110 => 'b'01111101;
'b'0111 => 'b'00000111;
'b'1000 => 'b'01111111;
'b'1001 => 'b'01100111;
'b'1010 => 'b'00000000;
'b'1011 => 'b'00000000;
'b'1100 => 'b'00000000; 
'b'1101 => 'b'00000000;
'b'1110 => 'b'00000000; 
'b'1111 => 'b'00000000;
 }