Microcontroladores PIC

1. www.aquihayapuntes.com
Implementación de
una Máquina de
Estados Finita en un
PIC
Ejemplo de cómo implementar una máquina de estados
en un Microcontrolador PIC utilizando Qfsm una
herramienta gráfica de diseño de Maquinas de Estados
Finitas.
Biblioman
03/09/2011

2. Implementación de una Máquina de Estados Finita en un PIC
Biblioman www.aquihayapuntes.com Página 2
Introducción
En este pequeño tutorial vamos a ver lo fácil que es crear una Máquina de Estados
Finita e implementar el código resultante en un Microcontrolador. La teoría de lo que
es una máquina de estados y como implementarla a través del DTE (Diagrama de
Transiciones de Estados) ya se explico en este artículo, por lo que si no lo habéis leído
todavía recomiendo su lectura antes de empezar a leer este.
Para ayudarnos en el diseño de la Máquina de Estados y la posterior codificación en C
nos vamos a ayudar de una herramienta gráfica concretamente Qfsm, un proyecto
Multiplataforma de software libre realizado con Qt .
Como ejemplo vamos hacer el del movimiento del robot visto en el primer artículo (así
sirve de comparación). Por lo que el diagrama de estados será el mismo, lo que vamos
a ver ahora es como crearlo con este IDE.
Creación del Diagrama de Estados
Para crear una nueva máquina de estados hacemos clic en File ->New

3. Implementación de una Máquina de Estados Finita en un PIC
Biblioman www.aquihayapuntes.com Página 3
Lo más importante en la ventana que nos aparece es lo que está dentro de los
recuadros Moore y Mealy. En el recuadro Moore pondremos el número de salidas y el
nombre de estas que tendrá el Autómata y en definitiva nuestro PIC. Las entradas las
pondremos en el apartado para Mealy, las salidas aquí no hace falta ponerlas porque
al final lo que vamos a implementar es un Autómata de Moore.
Una vez que tengamos creada la Máquina de Estados deberemos incluir los diferentes
estados que tendrá el autómata, para ello hacemos clic en State-> New o pinchando
directamente en el icono que hay en la barra de herramientas.

4. Implementación de una Máquina de Estados Finita en un PIC
Biblioman www.aquihayapuntes.com Página 4
En esta ventana pondremos: en la caja de texto identificada como Name el nombre
con el que queremos identificar el estado (es solo una etiqueta) el estado se identifica
realmente por el número en binario que hay en la caja de texto Code, (al crear el
estado ya se asigna un número por defecto). En Moore Outpts pondremos la salida de
Moore que queremos asociar al estado que acabamos de crear.
Una vez hecho esto el siguiente paso es unir los estados por medio de transiciones,
para ello hacemos clic en Add Transition en la barra de herramientas, después
hacemos clic en el estado donde queremos iniciar la transición y arrastramos la flecha
al estado de destino.
Repetimos el proceso con cada uno de los estados y transiciones que tenga nuestro
autómata.

5. Implementación de una Máquina de Estados Finita en un PIC
Biblioman www.aquihayapuntes.com Página 5
En el caso de nuestro ejemplo (el movimiento del robot) quedaría así:
Una vez creado muestro diagrama de estados podemos chequearlo, para ello hacemos
clic en Machine-> Integrity Check, nos aparecerá la siguiente ventana:

6. Implementación de una Máquina de Estados Finita en un PIC
Biblioman www.aquihayapuntes.com Página 6
Donde sí nuestro autómata es correcto aparecerán con una aspa verde los diferentes
chequeos realizados. Este tipo de test nos sirve para saber si nuestro autómata es
determinista, es decir, que no tenga estados y condiciones ambiguas, el diseño lógico
es responsabilidad nuestra y la aplicación no funcionará correctamente si está mal
diseñado, realmente está es la única complicación que hay, todo lo demás es un
proceso mecánico e igual para cualquier programa que queramos hacer.
Simulando el diagrama de Estados
Una vez creado el diagrama de estados podemos simularlo desde el propio IDE, para
ello hacemos clic en Machine-> Simulate… o directamente desde el botón Simulate
que hay en la barra de herramientas, nos aparecerá la siguiente ventana:
La simulación empezará en el estado de inicio o reset, representándose por medio de
un cuadrado de color rojo el estado en el que nos encontramos, a partir de aquí
meteremos las entradas en la caja de texto que pone Inputs y podremos ver la
evolución de los estados.

7. Implementación de una Máquina de Estados Finita en un PIC
Biblioman www.aquihayapuntes.com Página 7
Creación del programa en C
Una vez comprobado que nuestra máquina de estados funciona correctamente
exportaremos el código, el IDE permite la exportación directa a diferentes lenguajes de
descripción hardware como: AHDL, VHDL, Verilog HDL, etc. pero no tiene la opción (de
momento) de exportar el código a un lenguaje de alto nivel como el C que pueda ser
compilado para un microcontrolador, pero no importa mucho ya que el hacer la
portabilidad manualmente resulta fácil.
Para ello seleccionaremos exportar a AHDL que es un lenguaje de Descripción
Hardware propietario de Altera usado para la programación de CPLDs y FPGAs, el por
qué seleccionar AHDL y no otro es porque este tiene la ventaja de que su sintaxis es
parecida al lenguaje C.

8. Implementación de una Máquina de Estados Finita en un PIC
Biblioman www.aquihayapuntes.com Página 8
El código AHDL generado por el IDE para nuestro ejemplo es el siguiente:
% This file was generated by %
% Qfsm Version 0.52 %
% (C) Stefan Duffner, Rainer Strobel %
SUBDESIGN Ejemplo_robot
(clock, reset :INPUT;
I1,I0 :INPUT;
:OUTPUT;
M1,M2 :OUTPUT;)
VARIABLE
fsm : MACHINE OF BITS(s0, s1)
WITH STATES (
Para = B"00",
Adel. = B"01",
Atras = B"10");
reset_async : NODE;
_asyncM1, _asyncM2 : NODE;
BEGIN
reset_sync = DFF(reset,clock,VCC,VCC);
fsm.reset = reset_sync;
fsm.clk = clock;
M1 = DFF(M1_async,clock,VCC,VCC);
M2 = DFF(M2_async,clock,VCC,VCC);
CASE fsm IS
WHEN Para =>
IF (I1,I0) == B"10" THEN
END IF;
IF (I1,I0) == B"01" THEN
fsm = Adel.;
(_asyncM1, _asyncM2) = B"01";

9. Implementación de una Máquina de Estados Finita en un PIC
Biblioman www.aquihayapuntes.com Página 9
END IF;
IF (I1,I0) == B"11" THEN
fsm = Atras;
(_asyncM1, _asyncM2) = B"10";
END IF;
IF (I1,I0) == B"00" THEN
END IF;
WHEN Adel. =>
IF (I1,I0) == B"00" THEN
END IF;
IF (I1,I0) == B"01" THEN
END IF;
IF (I1,I0) == B"10" THEN
fsm = Para;
(_asyncM1, _asyncM2) = B"00";
END IF;
IF (I1,I0) == B"11" THEN
fsm = Atras;
(_asyncM1, _asyncM2) = B"10";
END IF;
WHEN Atras =>
IF (I1,I0) == B"10" THEN
fsm = Para;
(_asyncM1, _asyncM2) = B"00";
END IF;
IF (I1,I0) == B"00" THEN
END IF;
IF (I1,I0) == B"11" THEN
END IF;
IF (I1,I0) == B"01" THEN

10. Implementación de una Máquina de Estados Finita en un PIC
Biblioman www.aquihayapuntes.com Página 10
fsm = Adel.;
(_asyncM1, _asyncM2) = B"01";
END IF;
END CASE;
END;
Y el código resultante una vez portado a C para el compilador de CCS será el siguiente:
//////////////////////////////////////////////////////////////////////
//Ejemplo de Autómata de MOORE. Implementado en un PIC
//
//Basado en el código generado por Qsfm.
//
//WWW.AQUIHAYAPUNTES.COM
//////////////////////////////////////////////////////////////////////
#include <16F877.h>
#FUSES NOWDT, XT, NOPUT, PROTECT, NOBROWNOUT, NOLVP, NOCPD, NOWRT,
NODEBUG
#use delay(clock=20000000)
//Definición de registros
#byte PORTA=0x05
#byte PORTB=0x06
#bit RB0=PORTB.0
#bit RB1=PORTB.1
//Definición de los tres estados posibles.
#DEFINE PARA 0
#DEFINE ADELANTE 1
#DEFINE ATRAS 2
//Función principal.
void main()
{
//Inicialización de registros.
set_tris_b (0x00);//RB0 como salida
RB0=0;
RB1=0;
//Declaración de variables de la Máquina de estados.
int ESTADO=0;
while(true){
switch(ESTADO)
{
case PARA:
{

11. Implementación de una Máquina de Estados Finita en un PIC
Biblioman www.aquihayapuntes.com Página 11
// if (PORTA==2);
if (PORTA==1){
ESTADO=ADELANTE;
RB0=1;
RB1=0;
}
if (PORTA==3){
ESTADO=ATRAS;
RB0=0;
RB1=1;
}
//if (PORTA==0);
break;
}
case ADELANTE:
{
// if (PORTA==0);
// if (PORTA==1);
if (PORTA==2){
ESTADO=PARA;
RB0=0;
RB1=0;
}
if (PORTA==3){
ESTADO=ATRAS;
RB0=0;
RB1=1;
}
break;
}
case ATRAS:
{
if (PORTA==2){
ESTADO=PARA;
RB0=0;
RB1=0;
}
// if (PORTA==0);
// if (PORTA==3);
if (PORTA==1){
ESTADO=ADELANTE;
RB0=1;
RB1=0;
}
break;
}
default: break;
}
}
}

12. Implementación de una Máquina de Estados Finita en un PIC
Biblioman www.aquihayapuntes.com Página 12
La parte del código comentado son sentencias if que genera el IDE y que se pueden
eliminar una vez optimizado un poco el código generado.
Circuito final
Una vez compilado el código con CCS tendremos como siempre un .HEX que podremos
programar en el PIC y probar en un circuito real o simularlo en Proteus.
Fuentes de Información
qfsm
Qt
CCS Custom Computer Services
En el foro tenéis el .DTE y .DNS del ejemplo y más ejemplos de usuarios del foro que
han realizado su propia máquina de estados, como el proyecto de la lavadora del
amigo UbunPIC.
Como siempre espero vuestras sugerencias al respecto en el foro.
Un saludo

13. Implementación de una Máquina de Estados Finita en un PIC
Biblioman www.aquihayapuntes.com Página 13
Marcas registradas
Las marcas citadas en este artículo así como los programas mostrados en las imágenes
procedentes de capturas de pantallas pertenecen a sus respectivos propietarios, su
utilización en este artículo es con fines educativos y sin ánimo de lucro.
Licencia
Autor de este artículo: Biblioman
Versión: 1.01
Página Web: http:www.aquihayapuntes.com
Email: email.Biblioman@gmail.com
Este artículo esta bajo una licencia Creative Commons: Reconocimiento-No Comercial-
Compartir bajo la misma licencia.