C10 - Finite State Machine

Introducción

El microcontrolador cuenta con dos fuentes para el oscilador:

• Interna
  • El oscilador interno del uC TM4C va a 16Mhz con una presicón de ±1% $\Rightarrow$ poco preciso
  • Consume poca corriente
• Externa
  • Se puede configurar el cristal a diferentes velocidades según las necesidades
  • Son mucho mas preciso que el interno
  • Consumen más corriente y espacio en el PCB

Phase-Lock-Loop (PLL)

Que és? Cómo funciona?

• Permite seleccionar un cristal externo
• Permite seleccionar la velocidad del cristal y por tanto del procesador
• Permite seleccionar la velocidad del bus del sistema
• Para poder llevar a cabo estas dos operaciones necesitamos manipular dos registros
  • SYSCTL_RCC_R
  • SYSCTL_RCC2_R

En la siguiente imagen se ven los registros que van asociados al PLL


Los datos que nos interesan:

• En el registro SYSCTL_RCC_R el campo XTAL
  • Este se compone de 5 bits - del bit 10 al bit 6
  • El campo XTAL configura la velocidad del cristal. En la tabla de abajo se ven la codificacion de la velocidad en hexadecimal
• En el registro SYSCTL_RCC2_R el campo SYSDIV2
  • Este campo se compone de 7 bits - del bit 28 al bit 22
  • Configura la velocidad del bus del sistema
  • La fórmula para calcular es:

$velocidad=\frac{400}{n+1}\Rightarrow n=SYSDIV2$
Ej.
$velocidad=\frac{400}{n+1}=\frac{400}{4+1}=80Mhz\Rightarrow$ En el campo SYSDIV2 pondremos el valor 4
(Hay que tener en cuenta que a $\uparrow$ el número n $\Rightarrow$ $\downarrow$ velocidad del reloj)

Codificación velocidad cristal en hexadecimal:


Notas:

• No se si está bien explicada la función del PLL de ajustar la velocidad del reloj/bus. En las prácticas se ve como ponen a 80Mhz "algo". Yo creia que era el cristal, pero viendo la tabla de arriba el cristal como máximo puede ir a 25Mhz.
• El campo SYSDIV2 parece ser el encargado de configurar la velocidad del bus y vemos que lo puedes poner a 80Mhz, por lo tanto lo que creo que cambian en las prácticas es la velocidad de bus, no la cristal en si.
• También tendria que mirar que es el reloj del bus y como afecta a la velocidad de proceso del uC

Usar PLL

Hay dos formas de activar PLL:

• A través de una libreria
  • La mejor solucion porque es mas estable
  • El código se puede portar más fácil a otro micro
• Accediendo directamente a los registros

Accediendo manualmente

• Paso 0: Usar RCC2 porque provee más opciones
• Paso 1: Poner bit 11 de BYPASS2 a 1
  • PLL esta bypassed y no hay system clock divider
• Paso 2: Seleccionar la velocidad del cristal a través del campo XTAL
  • Los bits de OSCSRC2 se hacen clear para seleccionar el main oscillator como oscillator clock source
• Paso 3: Hacer clear al PWRDN2 (bit 13) para activar el PLL
• Paso 4: Configurar y activar el divisor del reloj usando el campo SYSDIV2
  • Explicado en el apartado anterior la fórmula para calcular el bus del reloj a través del SYSDIV2
• Paso 5: Esperar a que el PLL se estabilize
  • Cuando el PLLRIS (bit 6) del <b<SYSCTL_RIS_R sea high estará estabilizado
• Paso 6: Hacer clear al bit BYPASS2 para conectar el PLL

void PLL_Init(void){
  // 0) Use RCC2
  SYSCTL_RCC2_R |=  0x80000000;                          // USERCC2
  // 1) bypass PLL while initializing
  SYSCTL_RCC2_R |=  0x00000800;                          // BYPASS2, PLL bypass
  // 2) select the crystal value and oscillator source
  SYSCTL_RCC_R = (SYSCTL_RCC_R &~0x000007C0)             // clear XTAL field, bits 10-6
                 + 0x00000540;                           // 10101, configure for 16 MHz crystal
  SYSCTL_RCC2_R &= ~0x00000070;                          // configure for main oscillator source
  // 3) activate PLL by clearing PWRDN
  SYSCTL_RCC2_R &= ~0x00002000;
  // 4) set the desired system divider
  SYSCTL_RCC2_R |= 0x40000000;                           // use 400 MHz PLL
  SYSCTL_RCC2_R = (SYSCTL_RCC2_R&~ 0x1FC00000)           // clear system clock divider
                 + (4<<22);                              // configure for 80 MHz clock
  // 5) wait for the PLL to lock by polling PLLLRIS
  while((SYSCTL_RIS_R&0x00000040)==0){};                 // wait for PLLRIS bit
  // 6) enable use of PLL by clearing BYPASS
  SYSCTL_RCC2_R &= ~0x00000800;
}

Accurate Time Delays Using SysTick

El temporizador SysTick funciona de la siguiente manera:

• Se coloca el numero de ciclos de reloj que se quieren dejar pasar (hacer el delay) en el registro RELOAD
• Cada ciclo de reloj se resta un bit al número introducido en RELOAD
• Cuando se pasa del numero 1 al numero 0 el bit 16 del registro CTRL se pone en 1. Esto nos indica que el contador ha llegado a su fin

Delay

• Por lo visto como funciona el SysTick timer podemos utilizarlo para crear una función delay precisa
• Cada iteración de Systick tarda 1 ciclo de reloj

Ej: Si el bus del sistema va a 80Mhz
$80Mhz\Rightarrow \frac{1}{80Mhz}=12.5ns$ por operación

• Sabiendo lo que tarda cada iteración podemos calcular cuantas iteraciones son necesarias para tener un delay de Xms

Ej: Si queremos calcular un delay de 10ms. n es el número que pondremos en el registro RELOAD
$10ms=12ns*n\Rightarrow n=\frac{10ms}{12ns}=800000$

Ej código:

#define NVIC_ST_CTRL_R      (*((volatile unsigned long *)0xE000E010))  //Registro CTRL
#define NVIC_ST_RELOAD_R    (*((volatile unsigned long *)0xE000E014))  //Registro RELOAD
#define NVIC_ST_CURRENT_R   (*((volatile unsigned long *)0xE000E018))  //Registro CURRENT
void SysTick_Init(void){
 NVIC_ST_CTRL_R = 0;                                                   // disable SysTick during setup
 NVIC_ST_CTRL_R = 0x00000005;                                          // enable SysTick with core clock
}
// The delay parameter is in units of the 80 MHz core clock. (12.5 ns)
void SysTick_Wait(unsigned long delay){
 NVIC_ST_RELOAD_R = delay-1;                                           // se resta 1 a delay porque la cuenta la haria de 8000000 a 0 que son 800001 veces 
 NVIC_ST_CURRENT_R = 0;                                                // any value written to CURRENT clears
 while((NVIC_ST_CTRL_R&0x00010000)==0){                                // esperamos a que el bit 16 de CTRL pase a 1
 }
}

• Como el SysTick timer solo admite un numero de 24 bits, por lo tanto como máximo se puede hacer un delay de 200ms
• Para poder hacer un delay más grande se puede usar un bucle que vaya llamando a SysTick cada Xms
• En el ejemplo de abajo se ve como se crea un bucle que llama las veces que queramos a la función SysTick_Wait10ms que tarda 10ms en acabarse. Por lo tanto si queremos un delay de 100ms tenemos que llamar a la función 10 veces
  

// 800000*12.5ns equals 10ms
void SysTick_Wait10ms(unsigned long delay){
 unsigned long i;
 for(i=0; i<delay; i++){
   SysTick_Wait(800000);  // wait 10ms
 }
}

En la siguiente imagen se puede ver una máquina de estados finita de las dos funciones:

Structures

• Un struct en C es un "array" de variables de diferentes tipos

Ej: crearé un struct jugador

struct Player{
   unsigned int   xPos;
   unsigned int   yPos;
   unsigned short points;
}

struct Player Player1;

void main(void){
 Player1.xPos = 3;
 Player1.yPos = 2;
 Player1.points = 0;
}

• Este código declara un struct Player con 3 variables. Dos variables son del tipo int y la otra es de tipo short
• Luego declaramos un struct, Player1
• En el main lo que hacemos es acceder a cada variable que hay en el struct. Utilizamos el punto
• Con typedef podemos crear nuevos tipos de variables (como int, long, ... )

Ej: crearé un nuevo tipo de variable que será un struct de Player

 struct Player{
   unsigned int   xPos;
   unsigned int   yPos;
   unsigned short points;
}

typedef Player Ptype;
Ptype Player1;

void main(void){
 //Código
}

Al declarar un tipo Ptype cada vez que quiera crear un struct Player no tendré que poner

struct Player Player1;

Poniendo solo

Ptype Player1;

Ya estoy declarando una variable de tipo struct Player

Finite State Machine with Indexed Structures

• FSM se puede llamar a un sistema lógico que tiene inputs y outpus
• Este sistema lógico tiene estados que cambian según los inputs y producen outpus

Una FMS contiene 5 cosas:

• Conjunto de inputs
• Conjunto de outputs
• Conjunto de estados que hay en el sistema
• State Transition: Nos dice que causa que el sistema pasa de un estado a otro. Se puede representar mediante
  • Gráfico
  • Matriz numérica
• Output determination: Que condiciones genera los outpus

Tipos de FSM

• Moore FSM
  • NextState = f(current_State, Input) $\Rightarrow$ NextState va en función del current_State y de los inputs
  • Output = g(current_State) $\Rightarrow$ Output va en función del current_State
• Mealey FSM
  • NexStet igual que en Moore
  • Output = h(current_State, Input) $\Rightarrow$ Output va en función del current_State y de los inputs

Ej. Máquina cuenta 1s

Tenemos un sistema que lee por un puerto bits (0 o 1). El sistema cuenta cuantos bits 1 ha leido y por un output escribe 1 si el número de 1s es impar y 0 si es par

Definición FSM

• Input - 1 bit que puede ser 0 o 1
• Output - 1 bit que puede ser 0 o 1
• States - 2 estados
  • nº de 1 par
  • nº de 1 impar
• State Transition Graphic
  • Los círculos expresan los estados y las flechas expresan las transiciones
  • En el estado par
    • Si recibimos un 0 nos quedamos en el estado porque el número de 1 no ha cambiado
    • Si recibimos un 1 pasamos al estado impar
  • En el estado impar
  • Si recibimos un 0 nos quedamos en el estado porque el número de 1 no ha cambiado
  • Si recibimos un 1 pasamos al estado par

• Output
  • Como estamos haciendo una FSM de Moore cada estado tiene un output
  • Los outputs son los números azules del gráfico
  • Cuando estamos en el estado par ponemos un 0 en el output
  • Cuando estamos en el estado impar ponemos un 1 en el output

Programación estados

Código que plasma el STG que vemos mas arriba en un struct.

//Construimos el "contenedor" de cada estado
struct State{
   unsigned char out;       //Aqui va la salida que tendrá cada estado (los numero azules del dibujo)
   unsigned long wait;      //Entre cada estado esperaremos un tiempo para que pueda leer la entrada
   unsigned char next[2];   //En cada estado almacenamos los posibles estados siguientes
}
typedef struct State SType;

#define Even 0              //Lo hago para que sean más claros los estados
#define Odd  1

//Creamos los estados y los inicializamos
//En primer el estado el output sera 0, en el segundo estado sera 1
//El tiempo que esperaremos para cambiar de estado sera de 100ms en los dos estados
//En el primer estado si obtenemos un 0 nos mantenemos en el y si obtenemos un 1 cambiamos a Odd
//En el segundo estado si obtenemos un 0 nos mantenemos en el y si obtenemos un 1 cambiamos a Even
Stype fsm[2]={
  {0,100,{Even, Odd}},
  {1,100,{Odd, Even}}
};

Programación controlador FSM

El controlador de la máquina de estados finita es le encargado de leer las entradas, escribir las salidas y cambiar entre los diferentes estados.
Este controlador se programa en el main y se sigue este esquema:

• Escribo el output
• Espero
• Leo input
• Cambio de estado según el input y el estado en el que estoy

Nota:
No entiendo porqué no se hace así:

• Leo input
• Cambio estado según input y estado actual
• Escribo output
• Espero

El código de este ejemplo quedaria:

unsigend char cState;
void main(void){
  unsigned char input;
  
  //Inicializar puertos
  //Inicializar SysTick para función delay
  
  cState = Even;
  while(1){
   GPIO_PORT... = Fsm[cState].out;    //Escribimos el output del estado actual
   delay();                                          //Esperamos
   input = GPIO_PORT...;                   //Leemos input
   cState = Fsm[cState].next[input];  //Cambiamos de estado según el input. Si el input
                                      //es 0 vamos al estado Even y si el input es 1 vamos al estado Odd
                                      //y también según el estado en el que estamos (la variable 
                                      //cState es la que nos indica en que estado estamos)
  }
}

Ej. Semaforos

El siguiente ejemplo es sobre un cruce que tiene dos semáforos para controlar el tráfico. Hay dos sensores que detectan si hay coches en la calle 1 o en la calle 2. Dependiendo de donde hayan los coches se pone el semáforo en rojo o verde.

Definicion FSM

									Input
Estados			Output						S2S1	S2S1	S2S1	S2S1
Descripción	Nombres	Tiempo	V1	A1	R1	V2	A2	R2	00	01	10	11
Calle 1 verde. Calle 2 rojo	C1	30	1	0	0	0	0	1	C1	C1	W1	W1
Calle 1 amarillo. Calle 2 rojo	W1	5	0	1	0	0	0	1	C2	C2	C2	C2
Calle 1 rojo. Calle 2 verde	C2	30	0	0	1	1	0	0	C2	W2	C2	W2
Calle 1 rojo. Calle 2 amarillo	W2	5	0	0	1	0	1	0	C1	C1	C1	C1

Inputs:

• Coche calle 1 - S1
• Coche calle 2 - S2

Outputs:

• V1 A1 R1 $\Rightarrow$ semáforo calle 1 que cuenta con verde, amarillo y rojo
• V2 A2 R2

Imagen STG

Estado1 - C1

• Verde en calle 1 y rojo en calle 2, por lo tanto las salidas son

V1 A1 R1 V2 A2 R2
 1  0  0  0  0  1

• Siempre que S1 se mantenga en 1 nos quedamos en este estado
• Si no hay ningún coche en las dos calles también nos mantenemos en este estado
• Para pasar al siguiente estado S2 tiene que valer 1

Estado2 - W1

• Es un estado de transición entre el verde y el rojo. Hemos de pasar por el amarillo y el estado tiene una duración máxima de 5ms
• La salida es 010001 $\Rightarrow$ Activamos A1 porque vamos a cambiar de V1 a R1
• Cualquier input nos hace pasar al siguiente estado

Estado3 - C2

• Rojo calle 1 y verde calle 2 $\Rightarrow$ 001100
• Siempre que S2 se mantenga en 1 nos quedamos en este estado
• Si no hay ningún coche en las dos calles también nos mantenemos en este estado
• Para pasar al siguiente estado S1 tiene que valer 1

Estado4 - W2

• Es un estado de transición entre el verde y el rojo. Hemos de pasar por el amarillo y el estado tiene una duración máxima de 5ms
• La salida es 001010 $\Rightarrow$ Activamos A2 porque vamos a cambiar de V2 a R2
• Cualquier input nos hace pasar al siguiente estado

Programación estados

//Contenedor de cada estado
struct State{
 unsigned long out;
 unsigned long wait;
 unsigned long next[4];
};
typedef struct State SType;

#define C1 0     //Estado con el sensor de la calle 1 activo
#define W1 1     //Estado de transición de C1 a C2
#define C2 2     //Estado con el sensor de la calle 2 activo
#define W2 3     //Estado de transición de C2 a C1

//Definición estados
Stype fsm[4]={
 {0x21, 3000, {C1,W1,C1,W1}},
 {0x11, 500, {C2,C2,C2,C2}},
 {0x0C, 3000, {C2,C2,W2,W2}},
 {0x0A, 500, {C1,C1,C1,C1}}
};

Lab 10

Introducción

Diseñar un sistema que controle dos semáforos para tráfico y un semáforo para peatones.
Cada semáforo de tráfico tendrá un sensor para detectar si hay coches y el semáforo de peatones tiene otro sensor para detectar peatones.
El semáforo de coches tiene verde, amarillo y rojo. El semáforo de peatones tiene verde y rojo. Para pasar de verde a rojo el verde parpadea y luego pasa a rojo.
Cuando un semáforo está en verde los demás semáforos tienen que estar en rojo, no pueden estar en amarillo ni parpadeando.



Nomenclaturas:

• C1 será la calle 1
• C2 será la calle 2
• P1 será el paso de peatones
• W1 será le estado de transición del verde de C1 al amarillo de C1 despúes al rojo de C1
• W2 lo mismo pero de C2
• Las salidas serán:
  • V1 A1 R1 $\Rightarrow$ los colores del semáforo de C1
  • V2 A2 R2 $\Rightarrow$ los colores del semáforo de C2
  • VP1 RP1 $\Rightarrow$ los colores del semáforo de peatones

Condiciones

• Cambio de verde a rojo máximo 5 segundos
• Si los tres sensores están activos se pasa de un estado a otro sin parar
• De 9 a 30 estados es una buena implementación
• Tener 3 inputs implica 8 next state link
• Data Structure stored in ROM
• No pueden haber conditional branching
• Tiempo en cada estado (tiempo en que permanece en verde o rojo un semaforo) entre medio segundo y un segundo
• Flash de no pasar para peaton 2Hz y ejecutarlo dos veces
• Si coche llega a C2 y verde es C1 se espera que acabe C1 y luego empieza C2
• Si solo un sensor está activo en menos de 5 segundos se tiene que pasar a ese semáforo
• Siempre que haya solo un sensor activo se mantiene en ese estado el tiempo que este ese sensor activo