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:

$v e l o c i d a d = \frac{400}{n + 1} \Rightarrow n = S Y S D I V 2$
Ej.
$v e l o c i d a d = \frac{400}{n + 1} = \frac{400}{4 + 1} = 80 M h z \Rightarrow$ En el campo SYSDIV2 pondremos el valor 4
(Hay que tener en cuenta que a $↑$ el número n $\Rightarrow$ $↓$ 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
$80 M h z \Rightarrow \frac{1}{80 M h z} = 12.5 n s$ 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
$10 m s = 12 n s * n \Rightarrow n = \frac{10 m s}{12 n s} = 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. FMS y STG

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

Archivo:Edx-fsm-1odd.png

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

C10 - Finite State Machine

Sumario

Introducción

Phase-Lock-Loop (PLL)

Que és? Cómo funciona?

Usar PLL

Accediendo manualmente

Accurate Time Delays Using SysTick

Structures

Finite State Machine with Indexed Structures

Ej. FMS y STG

Menú de navegación

C10 - Finite State Machine

Introducción

Phase-Lock-Loop (PLL)

Que és? Cómo funciona?

Usar PLL

Accediendo manualmente

Accurate Time Delays Using SysTick

Structures

Finite State Machine with Indexed Structures

Ej. FMS y STG

Menú de navegación

Buscar