Contador de segundos MSP430: 10 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:42

¡Bienvenido! Making of Seconds Counter: Usando CCStudio 8 y MSP430F5529 para el proyecto.

Lenguaje C para codificar el microcontrolador. Aplicación de interrupciones, temporizadores y modos de bajo consumo. La salida se muestra a través de 7 segmentos.

Paso 1: Insight

¡Vamos a empezar!

Inicialice el temporizador de vigilancia en el estado APAGADO utilizando la contraseña requerida para el temporizador de vigilancia (ayuda a controlar los bucles infinitos, manteniendo seguro el procesador).

#incluir

/** * C Principal */

int main (vacío)

{

WDTCTL = WDTPW | WDTHOLD; // detener el temporizador del perro guardián

return 0;

}

Paso 2: inicialización del puerto

{

P3DIR = 0xFF; // P3DIR = 0x00;

P6DIR = 0xFF;

P4DIR | = 0x00;

P4REN | = 0xFF;

P4OUT | = 0xFF;

}

P3DIR | = 0x00 nos dice que todo el PORT-3 se inicializa para recibir entradas.

P3DIR | = 0xFF nos dice que la totalidad de PORT-3 se inicializa para dar salidas.

P3DIR | = 0x01 solo el pin P3.0 se inicializa a la salida en PORT-3. Esto sigue a una asignación de puerto hexadecimal.

P4REN | = 0xFF, esto indica que los pines del PORT-4 tienen habilitadas sus resistencias pull up / down.

Para seleccionarlos entre Pull UP o Pull DOWN, se utiliza la instrucción P $ OUT | = 0xFF.

Si se usa 0xFF se configuran como resistencias Pull UP y si 0x00 se configuran como Pull DOWN.

Paso 3: consumo ultrabajo

MSP430F5529 nos permite reducir la pérdida de energía del procesador. Esto es útil en aplicaciones independientes.

Esto requiere la declaración de todos los pines o puertos a la salida.

{

P7DIR | = 0xFF;

P6DIR | = 0xFF;

P5DIR | = 0xFF;

P4DIR | = 0xFF;

P3DIR | = 0xFF;

P2DIR | = 0xFF;

P1DIR | = 0xFF;

}

Paso 4: TEMPORIZADOR

Uso de temporizador para generación de retardo de un segundo. Esto usa el SMCLK de 1MHz, también el temporizador se ejecuta en modo de bajo consumo (en el siguiente paso, después de su conteo, se interrumpe desde LPM). Este proceso ahorra energía y carga en el procesador

TA0CCTL0 = CCIE;

TA0CCR0 = 999;

TA0CTL = TASSEL_2 + MC_1;

El valor es 999, ya que se necesita una cuenta más para volver a cero en el registro del temporizador.

Paso 5: Modo de bajo consumo

_BIS_SR (LPM0_bits + GIE);

Esto habilita la habilitación de interrupción general (GIE) y coloca la CPU en LPM0, donde MCLK que admite la cpu está apagado y SMCLK y ACLK se ejecutan para mantener el temporizador en funcionamiento. para que podamos ver que la CPU está apagada, ahorrando energía.

Paso 6: temporizador ISR

#pragma vector = TIMER0_A0_VECTOR

_interrupt void Timer_A (void)

{

z ++;

si (z> retraso)

{

P3OUT = código [x];

P6OUT = código1 [y];

x ++;

si (x == 10)

{

x = 0;

y ++;

}

si (y == 6)

y = 0;

z = 0;

}

}

El vector pragma es para la representación ISR en C embd.

código [x] y código1 [y] son las matrices que contienen valores de salida para los dos siete segmentos, para mostrar el contador de 60 segundos.

Paso 7: Interrupción de hardware

P2DIR = 0x00;

P2REN = 0x02;

P2OUT = 0x02;

P2IE | = BIT1;

P2IES | = BIT1;

P2IFG & = ~ BIT1;

Aquí P2.1 se declara como una interrupción de hardware, si se presiona el botón, el contador se restablece al valor.

el resto del programa está escrito dentro del ISR de esta interrupción.

Paso 8: ISR- Reset / Pulsador

#pragma vector = PORT2_VECTOR

_interrupt void port_2 (void)

{

P2IFG & = ~ BIT1;

x = 0; y = 0;

P3OUT = código [x];

P6OUT = código1 [y];

v ++;

para (i = 0; i

{

P1OUT | = BIT0; //P1.0 = alternar

_delay_cycles (1048576);

P1OUT & = ~ BIT0; // P1.0 = alternar

_delay_cycles (1048576);

}

Este ISR restablece el contador y mantiene un recuento de cuántas veces se presionó el resto.

(Aquí la visualización se realiza a través de un interruptor de led, también se puede usar otra matriz y temporizador, para mostrar esos valores como salida en 7 segmentos).

Paso 9: CÓDIGO

#incluir

#define delay 1000

código char = {0xFC, 0x60, 0xDA, 0xF2, 0x66, 0xB6, 0xBE, 0xE0, 0xFE, 0xE6};

char code1 = {0x7E, 0x30, 0x6D, 0x79, 0x33, 0x5B};

volatile unsigned int x = 0, y = 0, z = 0;

volatile unsigned int v = 0, i = 0;

vacío principal()

{

WDTCTL = WDTPW | WDTHOLD; // detener el temporizador del perro guardián

P7DIR | = 0xFF;

P7OUT | = 0x00;

P8DIR | = 0xFF;

P8OUT | = 0x00;

P4DIR | = 0xFF;

P4OUT | = 0x00;

P5DIR | = 0xFF;

P5OUT | = 0x00;

P1DIR = 0xFF;

P3DIR = 0xFF;

P6DIR = 0xFF;

P2DIR = 0x00;

P2REN = 0x02;

P2OUT = 0x02;

P2IE | = BIT1;

P2IES | = BIT1;

P2IFG & = ~ BIT1;

TA0CCTL0 = CCIE;

TA0CCR0 = 999;

TA0CTL = TASSEL_2 + MC_1;

_BIS_SR (LPM0_bits + GIE);

}

// Rutina de servicio de interrupción del temporizador A0

#pragma vector = TIMER0_A0_VECTOR

_interrupt void Timer_A (void)

{

z ++;

si (z> retraso)

{

P3OUT = código [x];

P6OUT = código1 [y];

x ++;

si (x == 10)

{

x = 0;

y ++;

}

si (y == 6)

y = 0;

z = 0;

}

}

// Rutina del servicio de interrupción de hardware

#pragma vector = PORT2_VECTOR

_interrupt void port_2 (void)

{

P2IFG & = ~ BIT1;

x = 0;

y = 0;

P3OUT = código [x];

P6OUT = código1 [y];

v ++;

para (i = 0; i

{P1OUT | = BIT0; // P1.0 = alternar

_delay_cycles (1048576);

P1OUT & = ~ BIT0; // P1.0 = alternar

_delay_cycles (1048576);

}

}

Paso 10: Código de referencia

Repositorio de GitHub