Diferencia entre revisiones de «Código Acelerometro Rutinas de Interrupción»

Revisión del 13:00 29 jun 2016

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 Opercaió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.

''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

''interrupt VectorNumber_Viicx'' 




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.

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();
 }
  }
}