Connecting an MSP430 to ADS1248 via SPI

/*============================================================================*
* *
* FICHERO....: main.c *
* PROYECTO...: *
* AUTORES....:  *
* FECHA......:  *
* VERSI�N:....  *
* ESTADO.....: *
* *
* DESCRIPCION:  *
* *
*============================================================================*/


/*----------------------------------------------------------------------------*
* DEFINICI�N DE LAS CABECERAS A INCLUIR *
*----------------------------------------------------------------------------*/

#include "math.h"
#include "stdbool.h"
#include "SPIADS1248.h"
#include "Medidas.h"
#include "msp430x21x2.h"

/*----------------------------------------------------------------------------*
* C�DIGO DE LAS FUNCIONES GLOBALES DEL M�DULO *
*----------------------------------------------------------------------------*/

void Inicia (void);

/*============================================================================*
* Comienzo de la funci�n main() *
* *
* Programa principal, se encarga de inicializar todos los perif�ricos y del *
 * tratamiento de los datos capturados. es un bucle que se est� siempre *
 * ejecut�ndose y se corresponde con el proceso de menor prioridad. *
*============================================================================*/


int main(void)
{
  //Variables locales de la funci�n
  float Rtd = 0; //Almacenna el resultado calculado de las medidas
  unsigned int i=0,j=0;
  unsigned long Code=0; //Valor de Lectura Instantaneo
  
  //C�digo de la funci�n
  Inicia(); //iniciar perifricos del uP
   
  ADS1248CargaInicial();

  
  
  //Bucle infinito del programa principal
  while(1) //Ejecutar siempre
  {
    

    Code = ADS1248ReadData();
    
    //Usando una PT100
    //Rtd = 2*Rref*Code/((2^23-1)*Gain)   Rref=1K  Gain=64
    Rtd = 3.725290742E-6*(float)(Code);  
    
        
    }
  
}
//Fin de la funci�n main()

/*============================================================================*
* Comienzo de la funci�n Inicia() *
* *
* Se encarga de inicializar los perif�ricos, los puertos de E/S y de *
* arrancar las comunicaciones modbus. *
*============================================================================*/

void Inicia (void)
{
  //Variables locales de la funci�n
  int i=0; //Variable auxiliar para recorrer las tablas

  //C�digo de la funci�n
  P1DIR|=1; //Se configuran los puertos de salida
            //P1.0 Led de Indicacion
            //P1.1 Boton de Reset para Ajustes por Defecto
  P1OUT&=(~BIT0); //Se apaga el Led

  
  WDTCTL = WDTPW + WDTHOLD;                 // Stop watchdog timer

  //Inicializaci�n de los relojes de forma segura, tal y como recomienda TI
  //Cuando Inicia el MCLK esta aliemntado con el DCO a aprox. 1.1Mhz
  __delay_cycles(250000); //Realim b    zamos una pausa aprox 150uS es el TURN ON del Regulador

  if (CALBC1_8MHZ ==0xFF || CALDCO_8MHZ == 0xFF)                                     
  {  
    while(1);                               // If calibration constants erased
    // do not load, trap CPU!!
  }   
  BCSCTL1 = CALBC1_8MHZ;                    // Set DCO to 8MHz
  DCOCTL = CALDCO_8MHZ;
    

 
}
//Fin de la funci�n Inicia()

/*============================================================================*
* *
* FICHERO....: SPIAD1248.c *
* PROYECTO...: Modulo Remoto de Entradas Analogicas*
* AUTORES....: Diego Villarraza *
* FECHA......: 14 de Julio de 2012 *
* VERSI�N:.... 1.0 *
* ESTADO.....: Inicio *
* *
* DESCRIPCION:Funciones para comunicarse via SPI con el AD ADS1248  *
* *
*============================================================================*/

#include "msp430x21x2.h"
#include "SPIADS1248.h"


/*----------------------------------------------------------------------------*
* DEFINICI�N DE VARIABLES GLOBALES DEL M�DULO *
*----------------------------------------------------------------------------*/

unsigned char regreadads[15]; //Tabla con los registros de control del AD
unsigned char regwriteads[15]; //Tabla con los registros de control del AD


/*----------------------------------------------------------------------------*
* C�DIGO DE LAS FUNCIONES GLOBALES DEL M�DULO *
*----------------------------------------------------------------------------*/



void ADS1248AssertCS( int fAssert)
{
   if (fAssert)
      P3OUT &= ~ADS1248_CS;
   else
      P3OUT |=  ADS1248_CS;
}

int ADS1248SPIInit(void)
{
  //Configuramos el puerto 3 para utilizar las siguientes salidas
  //P3.3 SCLK -> Serial Clock Out (Salida)
  //P3.1 UCBOTXD -> Master Out (Salida)
  //P3.2 UCBORXD -> Master In (Entrada)
  P3SEL |= ADS1248_SCLK + ADS1248_DOUT_DRDY + ADS1248_DIN; // P3.1,2,3 USCI_B0 option select
  
  P3DIR |= ADS1248_CS; //P3.7 Como salida para manejar la habilitacion del AD 
  P1DIR |= ADS1248_RESET + ADS1248_START; //P1.5 (Salida) Reset del AD
                                          //P1.6 (Salida) Start el AD
                                          //P1.7 (Entrada) DRDY el AD
  
  
  //Definimos el registro de control: 8 bit, Modo Master, MSB se recibe primero, Modo Sincronico  
  UCB0CTL0 |= UCMST + UCMSB + UCSYNC;  
  //Definimos el segundo registro de control: Fuente de Reloj SMCLK 
  UCB0CTL1 |= UCSSEL_2;  // SMCLK
  //Pre-escalamos el Clk a SMCLK/2 = 8Mhz/2 
  UCB0BR0 = 0x02; // /2
  UCB0BR1 = 0;    //
  //UCB0MCTL = 0;  // No modulation  
  //Habilitamos para que funcione el Modulo de Comunicacion
  UCB0CTL1 &= ~UCSWRST; // **Initialize USCI state machine**  
 
    
  //Secuencia de Encendido
  
  ADS1248AssertCS(0);  
  P3OUT |= ADS1248_START; //Start High
  P3OUT |= ADS1248_RESET; //Reset High
  
  __delay_cycles(128000); //Pausa de 16ms -> Fosc*16ms=8Mhz*16ms = 128000 segun datasheet
                          
  ADS1248AssertCS(1);
  
  
  
  return 0;
        
}


int ADS1248CargaInicial(void)
{
  
  int i;
  int resultado;
  
  
  //Iniciamos puertos del uC para comunicarse con el AD y configuramos el UART para utilizar SPI
  ADS1248SPIInit();
  
  //Realizamos un reset del AD
  ADS1248SendResetCommand();
    
  //Enviamos el comando SDATAC ya que por default el AD empieza con RDATAC
  ADS1248Stop();
  
  //Leemos todos los registros del AD para guardar los registros que nos se modifican y despues 
  //poder comparar todos los registros
  ADS1248ReadRegister();
  
  //Copiamos registro tabla de registros leidos a tabla de registros a escribir 
  for(i=0;i<15;i++)
    regwriteads[i] = regreadads[i];
  
  //Configuramos los primeros cuatro registros
  /* MUX0 = 00 Corriente de Burnout off
            000 AIN0 es positivo
            001 AIN1 es negativo
            = 0x01 */
  regwriteads[ADS1248_MUX0_REGISTER] = 0x01;

  /* VBIAS = 0x00 No se aplica Vbias */
  regwriteads[ADS1248_VBIAS_REGISTER] = 0x00;

  /* MUX1 = 0 Oscilador Interno
            01 Referencia interna siempre ON (necesario para usar IDAC)
            00 REF0 se utiliza una Rbias externa
            000 Operacion Normal
          = 0x20 */
 regwriteads[ADS1248_MUX1_REGISTER] = 0x20;
  
  
  /*SYS0 = 0 Siempre es 0
           110 Ganancia es 64
           0000 5SPS 
         = 0x60
  */
  regwriteads[ADS1248_SYS0_REGISTER] = 0x60;
  
  //Escribimos los primeros cuatro registros
  ADS1248WriteRegister(ADS1248_MUX0_REGISTER , 4);
  
  //Configuramos registro IDAC0 y IDAC1
  /*IDAC0 = 0000 siempre es 0
            0 DOUT//DRDY funcionamiento pin solo como datos de salida
            110 IDAC = 1ma 
          = 0x06*/
  regwriteads[ADS1248_IDAC0_REGISTER] = 0x06;  
  /*IDAC1 = 0000 La primer fuente de corriente en AIN0
            0001 La segunda fuente de corriente en AIN1
          = 0x01*/
  regwriteads[ADS1248_IDAC1_REGISTER] = 0x01;  
  //Escribimos registro
  ADS1248WriteRegister(ADS1248_IDAC0_REGISTER , 2);
  
  
  //Leemos registros para comprobar que la escritura fue exitosa
  ADS1248ReadRegister();
  
  //Comparamos registros
  resultado = 0;
  for(i=0;i<15;i++)
  {
    if (regwriteads[i] != regreadads[i])
      resultado = 1;
  }
  
  
    __delay_cycles(10000); //Pausa
  
  
  return resultado;
  
  
}



/*
******************************************************************************
*/

/*Escribe los parametros en los registros de control*/
int ADS1248WriteRegister(int StartAddress, int NumRegs)
{
  int i;
  unsigned char dummy;
  unsigned char reg[15]; //Tabla que datos a escribir
  
  
  //Copia datos de tabla general a tabla a transmitir
  for (i=0;i<NumRegs;++i)
  {
    reg[i] = regwriteads[StartAddress + i];
  }
  
  
  ADS1248Stop(); //Detiene la recopilacion de datos
  
  // assert CS to start transfer
  ADS1248AssertCS(1); // CS goes low
   
  //Primer Comando: La direccion del primer registro a escribir
  while(!(IFG2 & UCB0TXIFG));
  UCB0TXBUF= ADS1248_CMD_WREG + StartAddress;
  
  //Segundo Comando: El numero de Registros a escribir
  while(!(IFG2 & UCB0RXIFG));
  dummy=UCB0RXBUF;
  while(!(IFG2 & UCB0TXIFG));
  UCB0TXBUF=NumRegs - 1;
  
  //Bytes de Datos: Datos de los registros a escribir
  while(!(IFG2 & UCB0RXIFG));
  dummy=UCB0RXBUF;
  for (i=0;i<NumRegs;++i)
  {
    while(!(IFG2 & UCB0TXIFG));
    UCB0TXBUF=reg[i];
    while(!(IFG2 & UCB0RXIFG));
    dummy=UCB0RXBUF;
  }

  __delay_cycles(1000); //Pausa
                          
  ADS1248AssertCS(0); // CS goes high
  
  return 0;
  

}

/*Lee los datos de los registros de control*/
void ADS1248ReadRegister()
{
  unsigned char dummy;
  unsigned char reg[15];
  int i;
  
  ADS1248Stop(); //Detiene la recopilacion de datos
  __delay_cycles(40); //Pausa

  // Reset SPI
  ADS1248AssertCS(0); // CS goes high
  __delay_cycles(10); //Pausa 
  ADS1248AssertCS(1); // CS goes low

  while(!(IFG2 & UCB0TXIFG));
  UCB0TXBUF=ADS1248_CMD_RREG;	// Command for register read
  while(!(IFG2 & UCB0RXIFG));
  dummy=UCB0RXBUF;
  

  while(!(IFG2 & UCB0TXIFG));
  UCB0TXBUF=0x0E;		// Command for number of registers to read
  while(!(IFG2 & UCB0RXIFG));
  dummy=UCB0RXBUF;

  for (i=0; i<15; ++i) 
  {
    UCB0TXBUF=0xff;
    while(!(IFG2 & UCB0RXIFG));
    reg[i]=UCB0RXBUF;           // Lee los datos de los registros
  }

  //Copia tabla leida a la tabla general
  for(i=0;i<15;i++)
    regreadads[i] = reg[i];
  
  ADS1248AssertCS(0); // CS goes high
  
}

//Lee u
long ADS1248ReadData()
{
  char dummy;
  unsigned int data1, data2, data3;   
  long dato;
  
  // assert CS to start transfer
  ADS1248AssertCS(1); // CS goes low

  //Espero por RDY sea bajo
  while(P1IN & ADS1248_DRDY);
  
  //Se envia comando RDATA
  while(!(IFG2 & UCB0TXIFG));
  UCB0TXBUF=ADS1248_CMD_RDATA;
  while(!(IFG2 & UCB0RXIFG));
  dummy=UCB0RXBUF;
  __delay_cycles(20); //Pausa 
    
  //Lee datos como palabra de 24 bits.
  UCB0TXBUF=0xff;
  while(!(IFG2 & UCB0RXIFG));
  data1=UCB0RXBUF; //MSB

  //Lee datos como palabra de 24 bits.
  UCB0TXBUF=0xff;
  while(!(IFG2 & UCB0RXIFG));
  data2=UCB0RXBUF; //Mid-Byte

  //Lee datos como palabra de 24 bits.
  UCB0TXBUF=0xff;
  while(!(IFG2 & UCB0RXIFG));
  data3=UCB0RXBUF; //LSB
  
  dato = ((long)data1<<16)+((long)data2<<8)+((long)data3);
  
  ADS1248AssertCS(0); // CS goes high  
  
  return dato;
  
}

int ADS1248SendResetCommand(void)
{

  char dummy;
  
  // assert CS to start transfer
   ADS1248AssertCS(1); // CS goes low

   // send the command byte
    while(!(IFG2 & UCB0TXIFG));
    UCB0TXBUF= ADS1248_CMD_RESET;
    while(!(IFG2 & UCB0RXIFG));
    dummy=UCB0RXBUF;

   // de-assert CS
   ADS1248AssertCS(0); // CS goes high
   
   __delay_cycles(48000); //Pausa de 0.6ms -> Fosc*0.6ms=8Mhz*0.6ms = 128000 segun datasheet
   
   return 0;
}

/* stop collecting data */
void ADS1248Stop(void)
{
      unsigned char dummy;
      
      // Reset SPI
      ADS1248AssertCS(0); // CS goes high
      __delay_cycles(30); //Pausa 
      ADS1248AssertCS(1); // CS goes low
      
      // Command to stop taking continous readings
      
      //Analizar espera que DRDY sea bajo
      //Espero por RDY sea bajo
      while(P1IN & ADS1248_DRDY);
      
      while(!(IFG2 & UCB0TXIFG));
              UCB0TXBUF=ADS1248_CMD_SDATAC;
      while(!(IFG2 & UCB0RXIFG));
              dummy=UCB0RXBUF;
      __delay_cycles(20); //Pausa 
 
      ADS1248AssertCS(0); // CS goes high
      
}