Diferencia entre revisiones de «Código Acelerometro Rutinas de Interrupción»
(→Ejemplo de Gota en Cascada) |
|||
| (No se muestran 2 ediciones intermedias del mismo usuario) | |||
| Línea 248: | Línea 248: | ||
</syntaxhighlight> | </syntaxhighlight> | ||
| − | |||
| − | |||
== Ejemplo de Gota en Cascada == | == Ejemplo de Gota en Cascada == | ||
| Línea 332: | Línea 330: | ||
Video de Demostracion: | Video de Demostracion: | ||
| + | |||
| + | {{#ev:youtube|https://www.youtube.com/watch?v=0zxcFY4aFqI |500 | center}} | ||
Revisión actual del 19:53 3 jul 2016
Contenido
Acelerómetro MMA7660FC
El MMA7660FC es un output digital I²C, de muy bajo consumo de energía, de perfil capacitivo micro-mecanizado con un filtro de paso bajo, con compensación offset para gravedad cero, ganancia de errores y conversión a valores digitales de seis bits van en una salida de datos configurable por el usuario. El dispositivo puede ser utilizado para cambios de datos del sensor, la orientación del producto y la detección de gesticulaciones a través de un pin de interrupción (INT). El dispositivo es de 3 mm x 3 mm x 0,9 mm encapsulado en un DFN (plano, dual y libre de plomo).
Información técnica
Modos de Operación y tipos de Detecciones
•Modos de Operación:
•Modo sin Corriente
•Modo Apagado
•Modo en Espera
•Modo Activo
• Tipos de detecciones:
•Detección de Orientación
•Detección de Golpe
•Detección de Agite
•Auto-Encendido/Apagado
Interfaz Serial
-Direccionamiento Serial.
El MMA7660FC funciona como un esclavo que envía y recibe datos a través de una interfaz de 2 hilos I²C. La interfaz utiliza una Serie de Línea de Datos (SDA) y una Línea de Reloj en Serie (SCL) para lograr una comunicación bidireccional entre el maestro (M) y el esclavo (S). Un maestro (típicamente un microcontrolador) inicia todas las transferencias de datos hacia y desde el dispositivo, y genera el reloj SCL que sincroniza la transferencia de datos.
Formato de mensaje de Escritura
Formato de mensaje de lectura
Configuración del TMP
Modulo Periférico Timer/PWM
-- Cuando el MCU entra en el modo de parada, el reloj de los módulos TPM1 y TPM2 se para . los módulos de media
operación . Si la MCU está configurado para entrar en el modo de stop2 o stop1 , los módulos TPM se restablecerán
al despertar de la parada y deben ser reinstaladas .
void StartTPM(byte PS){
TPM1SC = (byte)(0x08 | (0x07&PS));
StartCount = TPM1CNT;
}
word StopTPM(void){
StopCount = (word)(TPM1CNT - StartCount);
TPM1SC = 0;
return StopCount;
}
Rutinas de Interrupción
KBI_ISR
El módulo KBI en se puede considerar como el módulo IRQ extendido. La diferencia entre estos módulos es que el módulo KBI es sensible a varios pines, y el módulo IRQ es sensible a un solo pin. La interrupción del módulo IRQ tiene mayor prioridad que la del módulo KBI. El módulo KBI no necesita ser habilitado desde CONFIG.
En el módulo KBI los modos también son por nivel y/o flanco. Se puede configurar la polaridad en cada pin KBI para que ingrese ya sea por nivel alto y/o flanco de subida o por nivel bajo y/o flanco de bajada. Ademas se puede configurar si un pin queda como pin de propósito general o como pin KBI.
El módulo de interrupciones de teclado (KBI) ofrece hasta ocho fuentes de interrupción externa habilitadas de forma independiente.
Los dispositivos de la Serie MC9S08QE128 contienen dos módulos KBI, llamados KBI1 y KBI2. Cada módulo KBI tiene hasta ocho fuentes de interrupción.
Reloj KBI
El reloj de bus KBI puede ser activado con el bit KBI en SCGC2. Este bit se restablece después de cualquier reset, que permite que el reloj de bus a este módulo sea activado. Para ahorrar energía, el bit de KBI se puede borrar,desactivar para cuando no esté en uso.
Características
Las características de KBI incluyen:
• Hasta ocho pines de interrupción del teclado con bits de habilitación para cada uno.
• Cada pin de interrupción del teclado es programable como flanco descendente (o flanco ascendente) solamente, o ambos, flanco descendente y bajo nivel (o ambos flancos de subida y de alto nivel) que interrumpen la sensibilidad.
• Un software permite la activación interrupción del teclado.
• Salir de los modos de bajo consumo.
Modos de operación
Esta sección define el funcionamiento KBI en modo espera, modo detenido y modos de depuración de fondo.
KBI en el modo de espera
El KBI continúa operando en el modo de espera si está activado antes de ejecutar la instrucción WAIT. Por lo tanto, un pasador de KBI habilitado (KBPEx = 1) se puede utilizar para llevar la MCU del modo de espera si la interrupción es KBI habilitando (KBIE = 1).
KBI en modos de parada
El KBI opera de forma asíncrona en el modo Stop3 si está activado antes de ejecutar la instrucción STOP. Por lo tanto, un pasador de KBI habilitado (KBPEx = 1) se puede utilizar para llevar la MCU de modo Stop3 si el KBI está habilitada (KBIE = 1).
Durante el modo stop2, el KBI se desactiva. Al despertar del modo stop2, el módulo KBI estará en el
estado de restablecimiento.
KBI en modo de fondo Activo
Cuando el microcontrolador está en modo de fondo activo, el KBI continuará operando normalmente.
Pines
Los pines de entrada del KBI se pueden utilizar para detectar cualquier flanco descendentes, o ambas peticiones de flanco de bajada y de bajo nivel. Los pines de entrada de KBI también se pueden utilizar para detectar cualquier flanco de subida, o ambos picos de subida y de alto nivel.
Descripción funcional
Escribiendo en los bits KBIPEn en el pin de interrupción del teclado x activa el Registro (KBIxPE) que permite de forma independiente activar cada pin del puerto. Cada puerto puede ser configurado como flanco sensible o flanco y nivel de sensibilidad basado en el bit KBIMOD en el estado de interrupción de teclado y control del registro (KBIxSC). la sensibilidad de borde puede ser configurado por un software programado para ser de bajada o subida; el nivel puede ser alto o bajo. La polaridad de la sensibilidad del borde u orilla y el nivel se seleccionan mediante los bits KBEDGn en el borde interrupción de teclado para el registro (KBIxES).
La lógica síncrona se usa para detectar flancos. Antes de detectar un flanco, la activacion de puertos deben estar en el nivel lógico no reafirmado. Un flanco descendente se detecta cuando una señal de entrada del puerto activado se ve como una lógica 1 (nivel No reafirmado) durante un ciclo de bus y entonces una lógica 0 (el nivel afirmado) durante el siguiente ciclo. Un flanco ascendente se detecta cuando la señal de entrada se ve como una lógica 0 durante un ciclo de bus y entonces una lógica 1 durante el siguiente ciclo.
Código de Ejemplo
''interrupt VectorNumber_Vkeyboard ''
#Define KBI_VAL (PTAD&0x0C)>>2
void KBI_ISR(void){
byte d,b;
//capture which pin was pushed
mode = (byte)(KBI_VAL);
//debounce button
for (d=0xff;d>0;d--){
for (b=0x80;b>0;b--){}
}
//clear KBF
KBI1SC_KBACK = 1;
}
IIC_ISR
El Modulo tiene dos registros IIC con hasta 100 kbps de máxima carga del bus ; la operación multi - maestro , direccionamiento de esclavo programable; interrumpir la transferencia de datos byte a byte ;soporta el modo de difusión y 10 bit de direccionamiento.
el IIC se puede usar con operaciones donde funge de esclavo, Se enviara una señal que sera la encargada de iniciar la comunicación . Si se implementa como como maestro inicializaremos la comunicación desde el registro IICD.
IIC habilitación de interrupción
- El bit IIC determina si se ha solicitado una interrupción IIC.
0 petición de interrupción CII no está activado. 1 solicitud de interrupción CII habilitado.
Código de Ejemplo
El siguiente código se encarga de manejar de forma adecuada la comunicación entre el modulo y el acelerometro a través del protocolo IIC. La comunicación estándar consta de cuatro partes, el maestro envía la señal de START, luego transmite la dirección del esclavo, después ocurre la transferencia de datos y el final el maestro manda una señal de STOP.
''interrupt VectorNumber_Viicx''
void IIC_ISR(void) {
IIC2S_IICIF = 1; // Clear Interrupt Flag
if (IIC2C1_TX) { // Transmit or Receive?
///////////////////// Transmit ////////////////////////////
if (repeat_start_sent) {
IIC2C1_TX = 0; // Switch to RX mode
if (num_to_rec == 1)
IIC2C1_TXAK = 1; // This sets up a NACK
IIC2D; // Dummy read from Data Register
}
else if ((last_byte) & (reading_mma7660_reg)) {
IIC2C1_RSTA = 1; //Repeat start
IIC2D = (mma7660[0] | 0x01); //Set Read bit
repeat_start_sent = 1;
}
else if (last_byte) { // Is the Last Byte?
IIC2C1_MST = 0; // Generate a Stop
}
else if (last_byte != 1) {
if (IIC2S_RXAK) { // Check for ACK
IIC2C1_MST = 0; // No ACk Generate a Stop
}
else if (!IIC2S_RXAK) {
IIC2D = mma7660[count++]; // Transmit Data
if (count == bytes_to_trans)
last_byte = 1;
}
}
} else {
///////////////////// Receive ////////////////////////////
if ((num_to_rec - rec_count) == 2) {
IIC2C1_TXAK = 1; // This sets up a NACK
Master_Read_and_Store();
}
else if ((num_to_rec - rec_count) == 1) {
IIC2C1_MST = 0; // Send STOP
Master_Read_and_Store();
}
else {
Master_Read_and_Store();
}
}
}
Ejemplo de Gota en Cascada
Para este ejemplo, usamos los leds presentes en el DemoQE y con el uso del acelerometro, logramos imitar una una gota que se balancea en los Leds.
Primeramente, como tenemos 8 leds, decidimos dividir el rango de valores que veiamos en el Toolkit en 8 intervalos y asignamos cada led a cada intervalo para valores menores a este.
Para el led asignado al PTC0 le asignamos el valor de 12000 y para el led asignado al PTE7 asignamos un valor de 900, entonces asi la gota se mueve entre estos dos puntos, manteniendose en el medio cuando esta balanceado el modulo.
En el codigo inicializamos los registros asignados a los leds con logica negada.
Luego para cada led, los 6 asignados a PTC y los dos a PTE asignamos valor minimo de encendido, y de esta forma se logro mostras en forma de cascada.
Codigo modificado
Para la inicializacion:
// Enable all pullups PTAPE = 0xFF; PTBPE = 0xFF; PTCPE = 0xFF; PTDPE = 0xFF; PTEPE = 0xFF; PTFPE = 0xFF; PTGPE = 0xFF; PTHPE = 0xFF; PTJPE = 0xFF; PTCDD = 0x3F; Se inicializa. PTEDD = 0xC0; Se inicializa. PTCD = 0x3F; Se asigna como apagados. PTED = 0xC0; Se asigna como apagados.
Para los condicionales que encienden los leds.
Dentro de la funcion void ShowAcceleration (void)
if (y.result[samp]>=0x2cec)
PTCD = 0x3E;
else if (y.result[samp]>=0x2ac9)
PTCD = 0x3D;
else if (y.result[samp]>=0x2619)
PTCD = 0x3B;
else if (y.result[samp]>=0x2169)
PTCD = 0x37;
else if (y.result[samp]>=0x1cb9)
{
PTCD = 0x2F;
PTED = 0xc0;
}
else if (y.result[samp]>=0x1809)
{
PTCD = 0x1F;
PTED = 0xc0;
}
else if (y.result[samp]>=0x1359)
{
PTED = 0x80;
PTCD = 0x3F;
}
else if (y.result[samp]>=0x0fa0)
{
PTED = 0x40;
PTCD = 0x3f;
}
Video de Demostracion:
