Implementación de una Máquina de Estados Finita en un PIC
En este 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.
MICROCONTROLADORES
Biblioman
9/3/20116 min leer
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
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.
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.
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:
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.
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.
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";
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
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. //
// //
// //
/////////////////////////////////////////////////////////////////////////////////////////////////
#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:
{
// 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;
}
}
}
La parte del código comentado son sentencias if que genera el IDE y que se pueden eliminar una vez optimizado el código.
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
Os podéis descargar este artículo en versión .pdf desde aquí.
Y el código fuente y el .DNS desde aquí.
Un saludo