Diferencia entre revisiones de «Código Acelerómetro para Codewarrior 10.6»

void main(void){

  PeriphInit();
  InitKBI();
  IIC_configuration();
  
  EnableInterrupts;
  
  MMA7660_configuration();
   
// Seleccionar fbus como fuente del timer1 e iniciar el temporizador
  TPM1SC = 0x08;
//  SendMsg("\fX, Y, Z\r\n");
  while (!SW1){}
  for(;;){
    while(SW4){
      if(!(IIC_Rec_Data[0]&IIC_Rec_Data[1]&IIC_Rec_Data[2]&0x40)){
        ShowAcceleration();         // Muestra los datos sobre la aceleración
      }else{                        // Actualización MMA7660 
      }
      
      if (PTHD_PTHD7 == 1) {        //Espera a que el bus del IIC esté libre
       
        while (PTHD_PTHD7 == 0);    // Esperará en un ciclo infinito mientras el pin del PTHD esté bajo
        
       	while (IIC2C1_MST == 1);    // Esperará hasta que el IIC se detenga 
       	
       	//Se lee Xout, Yout, Zout
       	mma7660[0] = 0x98;
       	mma7660[1] = 0x00;
       	Master_Read_MMA7660_register(2,3); 
      
      }else {
      
      }
            
    }
    while(SW3){_Stop;}
  } 
    
}

#Define ICSC1_FEI 0x04
#Define ICSC2_FEI 0x06
#Define ICSSC_FEI 0x80


void ICS_FEI(void) {
 if (NVICSTRM != 0xFF) 
  ICSTRM = NVICSTRM;              // Ajusta el valor del TRIM si la ubicación de NV no está en vacío.
 else
  ICSTRM = 0xAD;                  //Se ajusta para controlar la frecuencia del reloj de referencia interna y controla el periodo de referencia del reloj.
  ICSC1 = ICSC1_FEI;             // Se coloca el bit 2 del ICS1 en 1 (el de IREFS), para utilizar el Reloj Interno de referencia.
  ICSC2 = ICSC2_FEI;             // Se colocan los bits 1 y 2 del ICS2 en 1 (ERCLKEN y EREFS, respectivamente), ERCKLEN habilitará la fuente del reloj externa para ser usada como ICSERCLK y el segundo para seleccionar el Oscilador como reloj de referencia externa
  ICSSC = ICSSC_FEI;             // Se coloca el campo CLKSET en 10, para seleccionar el reloj externo de referencia con FLL desviado.
 while (ICSC1_CLKS != ICSSC_CLKST) {} // Espera si que la frecuencia del Bus (ICSC1_CLKS) sea distinta al modo del reloj (ICSSC_CLKSET)  
}

#Define KBI_SW KBI1PE_KBIPE2_MASK | KBI1PE_KBIPE3_MASK


void InitKBI(void) {
// Habilitado KBI1P[3:2] como interrupciones
  KBI1PE = KBI_SW;
  KBI1SC = 0b00000110;
/*               ||||
                 |||+---- KBIMOD = Detección de modo KBI: 0= solo borde 
                 ||+----- KBIE   = Habilitar KBI: 1=enabled
                 |+------ KBACK  = Se Habilita para limpiar la bandera
                 +------- KBF    = Está relacionado a la bandera del KBI. En 0 No se detectó interrupción por KBI.
*/
}

void InitSCI(word baud) {

  SCI1BD = baud;  // Se configura el valor de la tasa de baudios especificada
}

void PeriphInit(void)
{  
  // Desabilita las instrucciones de COP y habilita las instrucciones de STOP, RESET y BKGD
  SOPT1 = 0x23;
  
  // Selecciona el modo FEI
  // El trimming del fBUS es configurado en 25 MHz
  ICS_FEI();
  
  // Enable all pullups
  PTAPE = 0xFF; 
  PTBPE = 0xFF; 
  PTCPE = 0xFF; 
  PTDPE = 0xFF; 
  PTEPE = 0xFF; 
  PTFPE = 0xFF; 
  PTGPE = 0xFF; 
  PTHPE = 0xFF; 
  PTJPE = 0xFF; 
  
  /* Configura PTG[2:1] como la sensitividad del acelerometro
      PTG2:PTG1
        0    0  = 1.5g
        0    1  = 2.0g
        1    0  = 4.0g
        1    1  = 6.0g
  */ //
  PTGD = 0x00; // Se selecciona la sensibilidad de 1.5g
  PTGDD = 0x06; // Se selecciona como salida el puerto G 
    
  // Timer2 overflow about every 1ms
  TPM2MOD = 25000; // Es un registro que contiene el valor del contador
  // Detiene el Timer2 y selecciona 1 como un divisor prescalar
  TPM2SC = 0x00; // 
    
  // Initializes SCI Peripheral
  InitSCI(fei_baud); 
}

void IIC_configuration (void) {
 
  IIC2F = 0x90;         //Se asigna un valor de 04 que corresponde a un factor multiplicador para establecer la tasa de baudio del IIC.
  IIC2C1  = 0xC0;       //Los primeros 4 bits (1100) sirven para habilitar el modulo IIC y para habilitar las interrupciones
}

char RecChar(void) {
  byte rec_char;

  if (SCI1S1_RDRF)  // Si el buffer de transmisión esta lleno
    rec_char = SCI1D; // Se limpia el buffer
  SCI1C2_RE = 1;    //Se habilita la transmisión
  while(!SCI1S1_RDRF){  };// Se espera hasta que el buffer no esté vacío
  rec_char = SCI1D; // Se obtiene el caracter enviado
  SendChar((char) rec_char);// Se reenvía el caracter
  return (char) SCI1D;
}

void SendChar(char s_char) {

 SCI1C2 = 0x08;    // Se habilita la transmisión de datos
 while(!SCI1S1_TDRE){ } //Mientras el buffer de transmisión de datos este lleno espero
 SCI1D = (byte) s_char;   //Se escribe el caracter que será enviado
 }

void SendMsg(char msg[]) {
  byte i=0;
  char nxt_char;

  SCI1C2 = 0x08;    //Se habilita la transmisión
  nxt_char = msg[i++]; 
  while(nxt_char != 0x00) { //Mientras sea diferente de NULL
   while(!SCI1S1_TDRE){} //Mientras el buffer de transmsión de datos este lleno espero
   SCI1D = (byte) nxt_char; // Se escribe el caracter en el registro de datos
   nxt_char = msg[i++]; //Se lee el siguiente caracter del arreglo
  }
}

word hex2bcd(word hex){
 byte dec[4],i;
 word bcd;

 for (i=0;i<4;i++){
   dec[i] = (byte) (hex%10);
   hex = (word) (hex/10);
 }

 if (hex>0){
   bcd=0xffff;
 }else{
   bcd=(word)((word)(dec[3]<<12) + (word)(dec[2]<<8) + (dec[1]<<4) + dec[0]);
 }
 return bcd;
}

byte asc2byte(char n_asc) {
 byte n;

 n = (byte)(n_asc - 0x30);     //Conviere de ASCII a int
 if(n > 0x09)           // if num is $a or larger...
   n -= 0x07;           // ...sub $7 to correct
 if(n > 0x0f)           // if lower case was used...
   n -= 0x20;           // ...sub $20 to correct
 if(n > 0x0f)           // if non-numeric character...
   n = 0x00;            // ...default to '0'
 return n;
}

word asc2word(byte n_asc[2]) {
 word n,n2;
// assumes n_asc[0] is MSB, n_asc[1] is LSB
 n = (word)(n_asc[0] - 0x30);   //convert from ascii to int
 if(n > 0x09)           // if num is $a or larger...
    n -= 0x07;           // ...sub $7 to correct
 if(n > 0x0f)           // if lower case was used...
    n -= 0x20;           // ...sub $20 to correct
 if(n > 0x0f)           // if non-numeric character...
    n = 0x00;            // ...default to '0'
 n = (word)(n<<8);              // shift into high byte
 n2 = (word)(n_asc[1] - 0x30);  //convert from ascii to int
 if(n2 > 0x09)          // if num is $a or larger...
    n2 -= 0x07;          // ...sub $7 to correct
 if(n2 > 0x0f)          // if lower case was used...
    n2 -= 0x20;          // ...sub $20 to correct
 if(n2 > 0x0f)          // if non-numeric character...
    n2 = 0x00;           // ...default to '0'
 n += n2;               //
 return n;
}

char * byte2asc(byte num, byte base) {
byte n;

if (base){
n=(byte)(hex2bcd(num));
}else{
n=num;
} //end if (base)
n_str[0] = (byte)((n>>0x04)+0x30);  // convert MSN to ascii
if(n_str[0]>0x39)           // if MSN is $a or larger...
n_str[0]+=0x07;           // ...add $7 to correct
n_str[1] = (byte)((n&0x0f)+0x30);   // convert LSN to ascii
if(n_str[1]>0x39)           // if LSN is $a or larger...
n_str[1]+=0x07;           // ...add $7 to correct
n_str[2] = 0x00;            // add line feed
return  (char *) n_str;
} //end byte2asc

char * word2asc(word num, byte base) {
word n;

if (base){
n=hex2bcd(num);
}else{
n=num;
} //end if (base)

n_str[0] = (byte)((n>>12)+0x30);    // convert MSN to ascii
if(n_str[0]>0x39)           // if MSN is $a or larger...
n_str[0]+=0x07;           // ...add $7 to correct
n_str[1] = (byte)(((n>>8)&0x0f)+0x30);   // convert 2nd MSN to ascii
if(n_str[1]>0x39)           // if LSN is $a or larger...
n_str[1]+=0x07;           // ...add $7 to correct
n_str[2] = (byte)(((n>>4)&0x0f)+0x30);   // convert 2nd MSN to ascii
if(n_str[2]>0x39)           // if LSN is $a or larger...
n_str[2]+=0x07;           // ...add $7 to correct
n_str[3] = (byte)((n&0x0f)+0x30);   // convert 2nd MSN to ascii
if(n_str[3]>0x39)           // if LSN is $a or larger...
n_str[3]+=0x07;           // ...add $7 to correct
n_str[4] = 0x00;    // add line feed
return  (char *) n_str;

} //end word2asc

void ReadAcceleration(void){
  byte i;
  signed int temp;

  for(i=0;i<3;i++){ //Se realiza una extensión de signo para cada valor valor almacenado en la estructura
    temp = IIC_Rec_Data[i] & 0x3F;  //Se hace una máscara para guardar los 6bits menos significativos
    if(IIC_Rec_Data[i] & 0x20){ //Si el valor es negativo
       temp |= 0xFFC0;                                
       temp += 32;
       IIC_Converted_Data[i] = temp;
    }else{   
      IIC_Converted_Data[i] = temp + 32;
    }
  }
}

void ShowAcceleration (void)
{
  word SampleCNT;
  byte j,k;   
  
  ReadAcceleration();   // Se leen los datos de la aceleración detectados por el acelerómetro        
  //ADCSC1 = 0x01;      
  x.reading[samp]  = (dword)( IIC_Converted_Data[0] <<8);
  //ADCSC1 = 0x08;                 
  y.reading[samp]  = (dword)( IIC_Converted_Data[1] <<8);
  //ADCSC1 = 0x09;                 
  z.reading[samp]  = (dword)( IIC_Converted_Data[2] <<8);
  
  StartTPM(0);   //0 = TPM prescaler = /2

  if(samp>0){ // Se escoge el modo de funcionamiento del programa
    switch (mode){
      case filter: filter_data();   break;
      case avg   : avg_data();      break;
      default    : copy_data();
    }
  } else {
    copy_data();
  }
  
  SampleCNT = StopTPM();
  if (SampleCNT<0x0100) {
    for(j=0xff;j>0;j--){
      for(k=0x10;k>0;k--){}
    }
  }

  // Utilizado para enviar los caracteres donde se mostrará la acelración
  SendMsg("\r\n");
  SendMsg(word2asc((word)x.result[samp],dis_base));
  SendMsg(",");
  SendMsg(word2asc((word)y.result[samp],dis_base));
  SendMsg(",");
  SendMsg(word2asc((word)z.result[samp],dis_base));
  SendMsg(",");
  SendMsg(word2asc(SampleCNT,dis_base));
  
  //Se desplaza el arreglo de los resultados si llega al máximo
  if (samp >= max-1) {
    for (j=0;j<max-1;j++){
      x.result[j]  = x.result[j+1];
      x.reading[j] = x.reading[j+1];
      y.result[j]  = y.result[j+1];
      y.reading[j] = y.reading[j+1];
      z.result[j]  = z.result[j+1];
      z.reading[j] = z.reading[j+1];
    }
    samp = max-1;
  } else {
    samp++;
  } 
  
}

void MMA7660_configuration(void){
  
  mma7660[0] = 0x98; // Dirección de escritura maestra
  mma7660[1] = 0x07; // Se registra MODE del acelerómetro
  mma7660[2] = 0x01; // Se envía este valor para cambiar a 1 el bit MODE del registro para cambiar el acelerómetro a modo activo
  Master_Write_MMA7660_register(3);
  
}

void Master_Read_and_Store(void) {
  IIC_Rec_Data[rec_count++] = IIC2D;   /*Se guarda el valor enviado por el acelerómetro*/
}

void Master_Write_MMA7660_register(byte transbytes) {
  last_byte = 0;                    // Inicialización de variables en 0.
 count = 0;
  bytes_to_trans = transbytes;       
  
  if (transbytes == 0) return;    /*Si no hay ningún byte para transferir */
  
  IIC2C1_TX = 1;                    // Se setea el bit para hacer la transmisión 
  IIC2C1_MST = 1;                   // Se genera la señal de inicio (START)
  
  IIC2D = mma7660[count++];         // Se envia el primer byte. Puede ser una dirección de 7 bits mas 1 bit de W/R.    
}

void Master_Read_MMA7660_register(byte transbytes, byte recbytes) {

  rec_count = 0;                    // Inicialización de variables en 0
  last_byte = 0;                    
 count = 0;
 repeat_start_sent = 0;
 
  bytes_to_trans = transbytes;      
  num_to_rec = recbytes;
  
  
  if (transbytes == 0) return;   //Si no hay byte para transferir 
    
  IIC2C1_TXAK = 0;                  //Se coloca en 0 el bit de Acknowledge
  IIC2C1_TX = 1;                    // Se coloca el bit  en 1 para seleccionar que se va a transferir data
  IIC2C1_MST = 1;                   // Se genera la señal de START.
  
  reading_mma7660_reg = 1;
  IIC2D = mma7660[count++];         // Se envía el primer byte, puede ser una direccion de 7 bits mas 1 bit de w/r    
}

''interrupt VectorNumber_Vkeyboard ''

#Define KBI_VAL (PTAD&0x0C)>>2

void KBI_ISR(void){
  byte d,b;
  
  //Identifica cual PIN fue presionado
  mode = (byte)(KBI_VAL);
  //Cuando se suelta el botón:
  for (d=0xff;d>0;d--){
    for (b=0x80;b>0;b--){}
  }
  //Limpia el Registro KBF
  KBI1SC_KBACK = 1;
}

''interrupt VectorNumber_Viicx'' 


interrupt VectorNumber_Viicx void IIC_ISR(void) {

     IIC2S_IICIF = 1;              // Limpiar la bandera de interrupcion

     if (IIC2C1_TX) {              // Si está habilitado el bit para la transmisión

///////////////////// Transmit ////////////////////////////

       if (repeat_start_sent) {

         IIC2C1_TX = 0;                //Se coloca para recibir

         if (num_to_rec == 1)

         IIC2C1_TXAK = 1;            // Se habilita el bit para recibir el acknowledge

         IIC2D;                       

       }

       else if ((last_byte) & (reading_mma7660_reg)) {

         IIC2C1_RSTA = 1;              //Se habilita para repetir el START

         IIC2D = (mma7660[0] | 0x01);  //Setea el bit de read

         repeat_start_sent = 1;

       }

       else if (last_byte) {           // Si es el ultimo byte

         IIC2C1_MST = 0;               // Genera un STOP y el modo de operacion cambia de maestro a esclavo

       }

       else if (last_byte != 1) {            //Si no es el ultimo byte

          if (IIC2S_RXAK) { //Para verificar si se recibio o no un acknowledge. Entra en el if si no se recibió el acknowledge

               IIC2C1_MST = 0;             // Genera un STOP y el modo de operacion cambia de maestro a esclavo

               }

           else if (!IIC2S_RXAK) {      //Para verificar si se recibio o no un acknowledge.Entra en el if si se recibió el acknowledge

              IIC2D = mma7660[count++];     //Se transfiere la data

              if (count == bytes_to_trans)

             last_byte = 1;

            }

       }

     } else {

///////////////////// Receive ////////////////////////////

         if ((num_to_rec - rec_count) == 2) {

           IIC2C1_TXAK = 1;          // Se habilita para recibir acknowledge

           Master_Read_and_Store();

         }

         else if ((num_to_rec - rec_count) == 1) {

          IIC2C1_MST = 0;           // Se envia una señal de STOP y el modo de operacion ahora es del esclavo

          Master_Read_and_Store();

         }

        else {

          Master_Read_and_Store();

      }

   }
}

void filter_data(void) 
{ // guarda el valor de las coordenadas de X,Y,Z
  byte i;
  dword X, Y, Z;

  X = x.reading[samp];
  Y = y.reading[samp];
  Z = z.reading[samp];
  
  for (i=samp;i>0;i--){
    X = (X + ((x.reading[i] + x.result[i-1])>>1))>>1;
    Y = (Y + ((y.reading[i] + y.result[i-1])>>1))>>1;
    Z = (Z + ((z.reading[i] + z.result[i-1])>>1))>>1;
  }
  
  x.result[samp] = (word)X;
  y.result[samp] = (word)Y;
  z.result[samp] = (word)Z;
}

void avg_data(void) 
{// promedia el valor leido por x, y, z desde j hasta samp
  byte j;
  long x_avg=0, y_avg=0, z_avg=0;

  for (j=1;j<=samp;j++){
    x_avg += x.reading[j];
    y_avg += y.reading[j];
    z_avg += z.reading[j];
  }
  x.result[samp] = (word)(x_avg>>4);
  y.result[samp] = (word)(y_avg>>4);
  z.result[samp] = (word)(z_avg>>4);
}

void copy_data(void) { // Se copia el promedio leido en una variable resultado para x, y ,z
  
  x.result[samp] = x.reading[samp];
  y.result[samp] = y.reading[samp];
  z.result[samp] = z.reading[samp];
}

void PeriphInit(void)
{  
  // Desabilita las instrucciones de COP y habilita las instrucciones de STOP, RESET y BKGD
  SOPT1 = 0x23;
  
  // Selecciona el modo FEI
  // El trimming del fBUS es configurado en 25 MHz
  ICS_FEI();
  
  // Enable all pullups
  PTAPE = 0xFF; 
  PTBPE = 0xFF; 
  PTCPE = 0xFF; 
  PTDPE = 0xFF; 
  PTEPE = 0xFF; 
  PTFPE = 0xFF; 
  PTGPE = 0xFF; 
  PTHPE = 0xFF; 
  PTJPE = 0xFF; 
  
  /* Configura PTG[2:1] como la sensitividad del acelerometro
      PTG2:PTG1
        0    0  = 1.5g
        0    1  = 2.0g
        1    0  = 4.0g
        1    1  = 6.0g
  */ //
  PTGD = 0x00; // Se selecciona la sensibilidad de 1.5g
  PTGDD = 0x06; // Se selecciona como salida el puerto G 

  // Habilitación de los LEDs
  PTCDD = 0x3F; 
  PTEDD = 0xC0;
  
  // LEDs apagados por defecto
  PTCD = 0x3F; 
  PTED = 0xC0;
    
  // Timer2 overflow about every 1ms
  TPM2MOD = 25000; // Es un registro que contiene el valor del contador
  // Detiene el Timer2 y selecciona 1 como un divisor prescalar
  TPM2SC = 0x00; // 
    
  // Initializes SCI Peripheral
  InitSCI(fei_baud); 
}

void ShowAcceleration (void)
{
  word SampleCNT;
  byte j,k;   
  
  ReadAcceleration();            // Lee los datos de aceleración
  //ADCSC1 = 0x01;            
  x.reading[samp]  = (dword)( IIC_Converted_Data[0] <<8);
  //ADCSC1 = 0x08;                 
  y.reading[samp]  = (dword)( IIC_Converted_Data[1] <<8);
  //ADCSC1 = 0x09;               
  z.reading[samp]  = (dword)( IIC_Converted_Data[2] <<8);
  
  StartTPM(0);   //0 = TPM prescaler = /2

  if(samp>0){
    switch (mode){
      case filter: filter_data();   break;
      case avg   : avg_data();      break;
      default    : copy_data();
    }
  } else {
    copy_data();
  }
  
  SampleCNT = StopTPM();
  if (SampleCNT<0x0100) {
    for(j=0xff;j>0;j--){
      for(k=0x10;k>0;k--){}
    }
  }

  // Muestra la Aceleración
  SendMsg("\r\n");
  SendMsg(word2asc((word)x.result[samp],dis_base));
  SendMsg(",");
  SendMsg(word2asc((word)y.result[samp],dis_base));
  SendMsg(",");
  SendMsg(word2asc((word)z.result[samp],dis_base));
  SendMsg(",");
  SendMsg(word2asc(SampleCNT,dis_base));
  
  if ( (y.result[samp]>=0x32C8) && (y.result[samp]<=0x36B0) ){
	  PTCD=0x3E;
	  PTED=0xC0;
  }
  else if ( (y.result[samp]>=0x2CEC) && (y.result[samp]<=0x32C8) ){
	  PTCD=0x3D;
	  PTED=0xC0;
 }
  else if ( (y.result[samp]>=0x2328) && (y.result[samp]<=0x2CEC) ){
	  PTCD=0x3B;
	  PTED=0xC0;
 }
  else if ( (y.result[samp]>=0x1F40) && (y.result[samp]<=0x2328) ){
	  PTCD=0x27;
	  PTED=0xC0;
  }
  else if ( (y.result[samp]>=0x1388) && (y.result[samp]<=0x1F40) ){
  	  PTCD=0x1F;  
  	  PTED=0xC0;
  }
  else if ( (y.result[samp]>=0x0CE4) && (y.result[samp]<=0x1388) ){
  	  PTED=0x80;
  	  PTCD=0x3F;
  }
  else if ( (y.result[samp]>=0x07D0) && (y.result[samp]<=0x0CE4) ){
  	  PTED=0x40;
  	  PTCD=0x3F;
  }
  else{
	  PTCD=0x3F;
  	  PTED=0xC0;
  }
  // Shift array of results if we hit max
  if (samp >= max-1) {
    for (j=0;j<max-1;j++){
      x.result[j]  = x.result[j+1];
      x.reading[j] = x.reading[j+1];
      y.result[j]  = y.result[j+1];
      y.reading[j] = y.reading[j+1];
      z.result[j]  = z.result[j+1];
      z.reading[j] = z.reading[j+1];
    }
    samp = max-1;
  } else {
    samp++;
  } 
  
}