Siguenos en ...

Google+facebooktwitter

youtubepinterest RSS aquihayapuntes

Últimos Tutoriales

Licencia

Creative Commons

 

Todo el contenido de este sitio está bajo una licencia de Creative Commons

 

Implementación de una Máquina de Estados Finita en un PIC

Máquina de Estados Implemetada en un PICEn 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.

 

 

qfsn

 

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

 

Nueva Máquina de Estados

 

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.

 

Nuevo Estado

 

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í:

 

DTE movimiento robots

 

Una vez creado muestro diagrama de estados podemos chequearlo, para ello hacemos clic en Machine-> Integrity Check, nos aparecerá la siguiente ventana:

 

Chek Integridad Máquina de Estados

 

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:

 

Simulación Máquina de Estados

 

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.

 

Exportar código

 

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.                                   // 
//                                                                        // 
//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: 
 {      
 // 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.

 

Circuito 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.

Os podéis descargar este artículo en versión .pdf desde aquí.


Un saludo

© 2007-2017 AquiHayapuntes.com