This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

CCS/ADS1292R: get readings with ADS1292R

Part Number: ADS1292R
Other Parts Discussed in Thread: ADS1292

Tool/software: Code Composer Studio

Hello friends,
I have a problem with the ADS1292R sensor, after several months of working around this device, I finally see a small light at the end of the tunnel.

I have created all of the spi drivers and device registers, I began to create the main, but now I'm in a dead end.Someone can help me?!

ADS1292_R.c
#include <msp.h>
#include "ADS1292_R.h"
#include "main.h"


/****************************************************************/
/*                          PROTOTYPES                          */
/****************************************************************/

/****************************************************************/
/*                       GLOBAL VARIABLES                       */
/****************************************************************/

unsigned char ADC_Read_Data[16];

unsigned char ADS1292_R_SPI_CMD_F = 0,
              ADS1292_R_SPI_DATA_F = 0,
              SPI_SEND_COUNT = 0,
              SPI_Tx_COUNT = 0,
              SPI_Tx_BUF[10];

unsigned char SPI_Rx_DATA_F = 0,
              SPI_Rx_BUF[12],
              SPI_Rx_COUNT = 0,
              SPI_Rx_EXP_COUNT = 0;

unsigned char ECG_DATA_RDY;
long ADS1292R_ECG_DATA_BUF[6];
extern struct ADS1292x_STATE ecgState;
unsigned char ECG_RECORDER_DATA_BUF[256], RECORDER_HEAD, RECORDER_TAIL;
unsigned char STORE_DATA_RDY;
#define DELAY_COUNT 2

/*ADS1292_R REGISTER VALUE*/

unsigned char ADS1292R_REG_VALUE[16] = {
    0x00,                                                               /*DEVICE ID READ ONLY*/
    0x02,                                                               /*CONFIG_1*/
    0xE0,                                                               /*CONFIG_2*/
    0xF0,                                                               /*LEAD_OFF*/
    0x00,                                                               /*CH1_SET*/
    0x00,                                                               /*CH2_SET*/
    0x2C,                                                               /*RLD_SENS*/
    0x0F,                                                               /*LED_OFF_SENS*/
    0x00,                                                               /*LED_OFF_STAT*/
    0xEA,                                                               /*RESP_1*/
    0x03,                                                               /*RESP_2*/
    0x0C                                                                /*GPIO*/
};

unsigned char ADS1292R_DEFAULT_REGISTER_SETTINGS[15] = {
    0x00,                                                               /*DEVICE ID READ ONLY*/
    0x02,                                                               /*CONFIG_1*/
    0xE0,                                                               /*CONFIG_2*/
    0xF0,                                                               /*LEAD_OFF*/
    0x00,                                                               /*CH1_SET*/
    0x00,                                                               /*CH2_SET*/
    0x2C,                                                               /*RLD_SENS*/
    0x0F,                                                               /*LED_OFF_SENS*/
    0x00,                                                               /*LED_OFF_STAT*/
    0xEA,                                                               /*RESP_1*/
    0x03,                                                               /*RESP_2*/
    0x0C                                                                /*GPIO*/
};
/****************************************************************/
/*                 VARIABLES TO SPI INTERACTION                 */
/****************************************************************/

/*ADS1292R CLOCK SELECT*/

void ADS1292R_CLOCK_SELECT(unsigned char clock_in){

    if(clock_in == 1){
        P4->OUT |= (enum PORT4_ADC_CONTROL)ADC_CLK_SEL;                 /*CHOOSE INTERNAL CLOCK INPUT - 1*/

    }else{
        P4->OUT &= ~(enum PORT4_ADC_CONTROL)ADC_CLK_SEL;                /*CHOOSE EXTERNAL CLOCK INPUT - 0*/
    }

}

/*ADS1292R RESET*/

void ADS1292R_RESET(void){

    unsigned short i;
    P3->OUT |= (enum PORT3_ADC_CONTROL)RESET;                           /*SET HIGH*/
    /*PROVIDE SUFICIENT DELAY*/
    for(i = 0; i < 5000; i++);                                          /*WAIT 1 mSEC*/
    P3->OUT &= ~(enum PORT3_ADC_CONTROL)ADC_RESET;                      /*SET LOW*/
    for(i = 0; i < 5000; i++);                                          /*WAIT 1 mSEC*/
    P3->OUT |= (enum PORT3_ADC_CONTROL)ADC_RESET;
    for(i = 0; i < 35000; i++);


}

/*ADS1292R DISABLE START*/
void ADS1292R_DISABLE_START(void){
    unsigned short i;
    P3->OUT &= ~(enum PORT3_ADC_CONTROL)ADC_START;                      /*SET LOW*/
    for(i = 0; i < 35000; i++);                                         /*SMALL DELAY TO SETTLE*/
}


/*ADS1292R ENABLE START*/
void ADS1292R_ENABLE_START(void){
    unsigned short i;
    P3->OUT |= (enum PORT3_ADC_CONTROL)ADC_START;                       /*SET HIGH*/
    for(i = 0; i < 35000; i++);                                         /*SMALL DELAY TO SETTLE*/
}

/*ADS1292R CHIP ENABLE*/
void ADS1292R_CHIP_ENABLE(void){
    /*ADS1292R CS IS ACTIVE LOW*/
    P3->OUT &= ~(enum PORT3_ADC_CONTROL)ADC_START;                      /*SET LOW*/
}


/*CLEAR CHIP ENABLE*/
void CLEAR_ADS1292R_CHIP_ENABLE(void){
    unsigned char csDelay;
    for(csDelay = 0; csDelay < 100; csDelay++);
    /*ADS1292R CS IS ACTIVE LOW*/
    P3->OUT |= (enum PORT3_ADC_CONTROL)ADC_START;                       /*SET HIGH*/
}


/*INIT ADS1292R DRDY INTERRUPT*/

void INIT_ADS1292R_DRDY_INTERRUPT(void){

    P2->DIR &= ~(0x02);
    P2->REN |=   BIT5;                                                  /*ENABLE P2.5 INTERNAL RESISTENCE*/
    P2->OUT |=   BIT5;                                                  /*SET P2.5 AS PULL-UP RESISTENCE*/
    P2->IES |=   BIT5;                                                  /*P2.5 LO/HI EDGE*/
    P2->IFG &= ~(BIT5);                                                 /*P2.5 IFG CLEARED*/
    P2->IE  &= ~(BIT5);                                                 /*P2.5 INTERRUPT DISABLE*/

}

/*ENABLE ADS1292R DRDY INTERRUPT*/
void ENABLE_ADS1292R_DRDY_INTERRUPT(void){

    P2->IFG &= ~(BIT5);                                                 /*P2.5 IFG CLEARED*/
    P2->IE  |=   BIT5;                                                  /*P2.5 INTERRUPT ENABLE*/
}


/*DISABLE ADS1292R DRDY INTERRUPT*/
void DISABLE_ADS1292R_DRDY_INTERRUPT(void){

    P2->IFG &= ~(BIT5);                                                 /*P2.5 IFG CLEARED*/
    P2->IE  &= ~(BIT5);                                                 /*P2.5 INTERRUPT DISABLE*/
}

/*SET GPIO*/
void SET_GPIO(void){

    P4->SEL0 =  0x00;
    P4->DIR |=  0x8F;
    P4->OUT |=  (enum PORT4_ADC_CONTROL)POW_CE;
    P3->DIR |=  0x07;
    P3->OUT &=  0xF8;
    P3->OUT |=  (enum PORT3_ADC_CONTROL)ADC_CS;                         /*SET RESET, START TO LOW AND CS TO HIGH*/
    P3->OUT |=  (enum PORT3_ADC_CONTROL)ADC_RESET;                      /*SET RESET, START TO LOW AND CS TO HIGH*/
    P1->OUT |=
    P4->OUT  =  0x03;

}

/*SET EUSCI_B0 SP1*/
void SET_EUSCI_SPI(void){

    P3->SEL0 |= BIT5 | BIT6 | BIT7;                                     /*SET 3 PIN SPI PERIPHERAL BITS*/
    P3->DIR  |= BIT5 | BIT6;                                            /*CLOCK AND DIROUT AS OUTPUT*/
    P3->DIR  &= ~(BIT7);                                                /*DIN AS INPUT*/
    EUSCI_B0->CTLW1 |= EUSCI_B_CTLW0_SWRST;                             /*ENABLE SW RESET*/

    EUSCI_B0->CTLW0 |= EUSCI_B_CTLW0_MSB |                              /*MSB FIRST*/
                       EUSCI_B_CTLW0_MST |                              /*MASTER MODE*/
                       EUSCI_B_CTLW0_SYNC;                              /**/

    EUSCI_B0->CTLW1 |= EUSCI_B_CTLW0_SSEL__ACLK;
    UCB0BR0 = 24;
    UCB0BR1 = 0;
    EUSCI_B0->CTLW1 &= ~(EUSCI_B_CTLW0_SWRST);

}

/*SET DMA SPI*/
void SET_DMA_SPI(void){

}

/*ADS1292R SPI COMMAND DATA*/

void ADS1292R_SPI_COMMAND_DATA(unsigned char Data){
    unsigned char  delayVar;
    ADS1292R_CHIP_ENABLE();
    for(delayVar = 0; delayVar < 50; delayVar++);
        CLEAR_ADS1292R_CHIP_ENABLE();
        ADS1292R_CHIP_ENABLE();
        EUSCI_B0->TXBUF = Data;
        while ((EUSCI_B0->STATW & EUSCI_B_STATW_BBUSY));
        delayVar = EUSCI_B0->RXBUF;
        for(delayVar = 0; delayVar < 150; delayVar++);
}

/*ADS1292R INIT RESOURCE*/

void INIT_ADS1292R_RESOURCE(void){
    SET_GPIO();                                                     /*INITIALIZE ADS1292R INPUT CONTROL LINES*/
    SET_EUSCI_SPI();                                                /*INITIALIZE SPI REGISTER*/

}

/****************************************************************/
/*                  ADS1292R CONTROL REGISTERS                  */
/****************************************************************/

/*WAKE UO ADS1292R*/
void WAKE_UP_ADS1292R(void){
    ADS1292R_SPI_COMMAND_DATA(WAKE_UP);
}

/*PUT ADS1292R IN SLEEP*/
void PUT_ADS1292R_IN_SLEEP(void){
    ADS1292R_SPI_COMMAND_DATA(STAND_BY);
}
/*SOFT RESET ADS1292R*/
void SOFT_RESET_ADS1292R(void){
    ADS1292R_SPI_COMMAND_DATA(RESET);
}
/*SOFT START RESTART ADS1292R*/
void SOFT_START_RESTART_ADS1292R(void){
    ADS1292R_SPI_COMMAND_DATA(START);
    CLEAR_ADS1292R_CHIP_ENABLE();
}

/*HARD START RESTART ADS1292R*/
void HARD_START_RESTART_ADS1292R(void){
    P3->OUT |= (enum PORT3_ADC_CONTROL)ADC_START;                                       /*SET START PIN TO  HIGH*/
}
/*SOFT START ADS12P2R*/
void SOFT_START_ADS1292R(void){
    ADS1292R_SPI_COMMAND_DATA(START);
}
/*SOFT STOP ADS1292R*/
void SOFT_STOP_ADS1292R(void){
    ADS1292R_SPI_COMMAND_DATA(STOP);
}
/*######################################################################*/
/*HARD STOP ADS1292R*/
void HARD_STOP_ADS1292R(void){
    unsigned short i, j;
    P3->OUT &= ~(enum PORT3_ADC_CONTROL)ADC_START;                               /*SET START PIN TO LOW*/
    for(j=0; j < DELAY_COUNT;j++ ){
        for(i= 0; i < 35000; i++);
    }
}

/*STOP READ DATA CONTINUOUS*/
void STOP_READ_DATA_CONTINUOUS(void){
    ADS1292R_SPI_COMMAND_DATA(S_DATA_C);
}

/*START READ DATA CONTINUOUS*/
void START_READ_DATA_CONTINUOUS(void){
    ADS1292R_SPI_COMMAND_DATA(R_DATA_C);
}

/*START DATA CONVERTION COMMAND*/
void START_DATA_CONVERTION_COMMAND(void){
    ADS1292R_SPI_COMMAND_DATA(START);
}
/*INITIALIZE ADS1292R*/
void INIT_ADS1292R(void){
    ADS1292R_RESET();
    ADS1292R_DISABLE_START();
    ADS1292R_ENABLE_START();
}

/*ENABLE ADS1292R CONVERTION*/
void ENABLE_ADS1292R_CONVERTION(void){
    START_READ_DATA_CONTINUOUS();                               /*R_DATA_C COMMAND*/
    HARD_START_RESTART_ADS1292R();
}

/*ADS1292R REGISTER WRITE*/
void ADS1292R_REGISTER_WRITE(unsigned char READ_WRITE_ADDRESS, unsigned char DATA){

short i;
    switch(READ_WRITE_ADDRESS){
        case 1:
            DATA = DATA & 0x87;
        break;

        case 2:
            DATA = DATA & 0x87;
            DATA|= 0x80;
        break;

        case 3:
            DATA = DATA & 0xFD;
            DATA|= 0x10;
        break;

        case 7:
            DATA = DATA & 0x3F;
        break;

        case 8:
            DATA = DATA & 0x5F;
        break;

        case 9:
            DATA |= 0x02;
        break;

        case 10:
            DATA = DATA & 0x87;
            DATA |= 0x01;
        break;

        case 11:
            DATA = DATA & 0x0F;
        break;

        default:
        break;

    }

    SPI_Tx_BUF[0] = READ_WRITE_ADDRESS | W_REG;
    SPI_Tx_BUF[1] = 0;
    SPI_Tx_BUF[2] = DATA;
    ADS1292R_CHIP_ENABLE();

    for(i=0; i < 50; i++);

    EUSCI_B0->TXBUF = SPI_Tx_BUF[0];
    while ((EUSCI_B0->STATW & EUSCI_B_STATW_BBUSY));
    i = EUSCI_B0->RXBUF;

    EUSCI_B0->TXBUF = SPI_Tx_BUF[1];
    while ((EUSCI_B0->STATW & EUSCI_B_STATW_BBUSY));
    i = EUSCI_B0->RXBUF;

    EUSCI_B0->TXBUF = SPI_Tx_BUF[2];
    while ((EUSCI_B0->STATW & EUSCI_B_STATW_BBUSY));
    i = EUSCI_B0->RXBUF;
}

/*ADS1292R REGISTER READ*/
unsigned char ADS1292R_REGISTER_READ(unsigned char REGISTER_ADDRESS){
    unsigned char retVal;
    SPI_Tx_BUF[0] = REGISTER_ADDRESS | R_REG;
    SPI_Tx_BUF[1] = 0;
    ADS1292R_CHIP_ENABLE();


    EUSCI_B0->TXBUF = SPI_Tx_BUF[0];
    while ((EUSCI_B0->STATW & EUSCI_B_STATW_BBUSY));

    EUSCI_B0->TXBUF = SPI_Tx_BUF[1];
    while ((EUSCI_B0->STATW & EUSCI_B_STATW_BBUSY));
    retVal = EUSCI_B0->RXBUF;

    EUSCI_B0->TXBUF = 0x00;
    while ((EUSCI_B0->STATW & EUSCI_B_STATW_BBUSY));
    retVal = EUSCI_B0->RXBUF;

    CLEAR_ADS1292R_CHIP_ENABLE();

    return retVal;

}

/*ADS1292R DEFAULT REGISTER INITIALIZATION*/
void ADS1292R_DEFAULT_REGISTER_INIT(void){
    unsigned char regInit_i;
    ADS1292R_CHIP_ENABLE();
    for(regInit_i = 0; regInit_i < 100; regInit_i++);
        CLEAR_ADS1292R_CHIP_ENABLE();
        if((ADS1292R_REG_VALUE[0] & 0x20) == 0x20){
            for(regInit_i = 1; regInit_i < 12; regInit_i ++){
                ADS1292R_REGISTER_WRITE(regInit_i,ADS1292R_DEFAULT_REGISTER_SETTINGS[regInit_i]);
            }

        }else{
            for(regInit_i = 1; regInit_i < 12; regInit_i ++){
                ADS1292R_REGISTER_WRITE(regInit_i,ADS1292R_DEFAULT_REGISTER_SETTINGS[regInit_i]);
            }
        }
}

/*ADS1292R READ ALL REGISTERS*/
void ADS1292_READ_ALL_REGISTERS(unsigned char ADS1292R_REG_BUF[]){
    unsigned char regs_I;
    ADS1292R_CHIP_ENABLE();
    for(regs_I = 0; regs_I < 200; regs_I++);
        CLEAR_ADS1292R_CHIP_ENABLE();
    for(regs_I = 0; regs_I < 200; regs_I++){
        ADS1292R_REG_BUF[regs_I] = ADS1292R_REGISTER_READ(regs_I);
    }
}

/*ADS1292R POWER ON INIT*/
void ADS1292R_POWER_ON_INIT(void){
    volatile unsigned short init_I, j;
    INIT_ADS1292R_RESOURCE();
    ADS1292R_RESET();
    for(j = 0;  j < DELAY_COUNT; j++){

        for(init_I = 0; init_I < 20000; init_I++);
        for(init_I = 0; init_I < 20000; init_I++);
        for(init_I = 0; init_I < 20000; init_I++);
    }
    INIT_ADS1292R_DRDY_INTERRUPT();
    ADS1292R_CLOCK_SELECT(1);                                                                   /*SET INTERNAL CLOCK*/
    for(init_I = 0; init_I < 20000; init_I++);
    for(init_I = 0; init_I < 20000; init_I++);
    for(init_I = 0; init_I < 20000; init_I++);

    ADS1292R_DISABLE_START();
    ADS1292R_ENABLE_START();

    HARD_STOP_ADS1292R();

    START_DATA_CONVERTION_COMMAND();

    SOFT_STOP_ADS1292R();

    for(j = 0;  j < DELAY_COUNT; j++){
        for(init_I = 0; init_I < 20000; init_I++);
    }

    STOP_READ_DATA_CONTINUOUS();                                                                /*S_DATA_C COMMAND*/

    for(j = 0;  j < DELAY_COUNT; j++){
        for(init_I = 0; init_I < 35000; init_I++);
    }
    for(j = 0;  j < DELAY_COUNT; j++){
        for(init_I = 0; init_I < 35000; init_I++);
    }

    ADS1292_READ_ALL_REGISTERS(ADS1292R_REG_VALUE);
    ADS1292R_DEFAULT_REGISTER_INIT();
    ADS1292_READ_ALL_REGISTERS(ADS1292R_REG_VALUE);

}

/*ECG PACKET*/

void ADS1292R_PARSE_DATA_PACKET(void){

    unsigned char ecgChanNum;

    switch(ecgState.state){
        case DATA_STREAMING_STATE:
        {
            for(ecgChanNum = 0; ecgChanNum < 3; ecgChanNum++){
                ADS1292R_ECG_DATA_BUF[ecgChanNum] = (   signed long)SPI_Rx_BUF[3 * ecgChanNum];
                ADS1292R_ECG_DATA_BUF[ecgChanNum] = ADS1292R_ECG_DATA_BUF[ecgChanNum] << 8;
                ADS1292R_ECG_DATA_BUF[ecgChanNum]|= SPI_Rx_BUF[3 * ecgChanNum + 1];
                ADS1292R_ECG_DATA_BUF[ecgChanNum] = ADS1292R_ECG_DATA_BUF[ecgChanNum] << 8;
                ADS1292R_ECG_DATA_BUF[ecgChanNum]|= SPI_Rx_BUF[3 * ecgChanNum + 2];
            }
        }
        break;

        case ACQUIRE_DATA_STATE:
        break;

        case ECG_RECORDING_STATE:
        {
        unsigned char *ptr;

        ptr = &ECG_RECORDER_DATA_BUF[RECORDER_HEAD << 3];

        *ptr++ = SPI_Rx_BUF[0];
        *ptr++ = SPI_Rx_BUF[1];

        *ptr++ = SPI_Rx_BUF[3];
        *ptr++ = SPI_Rx_BUF[4];
        *ptr++ = SPI_Rx_BUF[5];

        *ptr++ = SPI_Rx_BUF[6];
        *ptr++ = SPI_Rx_BUF[7];
        *ptr++ = SPI_Rx_BUF[8];

        RECORDER_HEAD++;
        if(RECORDER_HEAD == 32)
            RECORDER_HEAD = 0;

        }
        break;

        default:
        break;
    }
}

/**/

void ADS1x92R_PARSE_DATA_PACKET (void){
    switch(ADS1292R_REG_VALUE[0] & 0x03){
        case ADS1292R_24BIT:
        ADS1292R_PARSE_DATA_PACKET();
        break;
    }
    ECG_DATA_RDY = 1;
}

void SET_DEVICE_OUT_BYTES(void){
    switch(ADS1292R_REG_VALUE[0] & 0x03){
        case ADS1292R_24BIT:
            SPI_Rx_EXP_COUNT = 9;
        break;
    }
}


/*SPI INTERRUPT SERVICE ROUTINE*/
void EUSCIB0_IRQHandler(void){
    SPI_Rx_BUF[SPI_Rx_COUNT] = EUSCI_B0->RXBUF;
    SPI_Rx_COUNT++;
    if(SPI_Rx_COUNT == SPI_Rx_EXP_COUNT){
        EUSCI_B0->IE &= ~(EUSCI_B_IE_RXIE);                                     /*DISABLE RX INTERRUPT*/
        ADS1292R_PARSE_DATA_PACKET();
    }else{
        EUSCI_B0->TXBUF = 0;
    }
}
/*PORT x INTERRUPT SERVICE ROUTINE*/
void PORT2_IRQHandler(void){
    if(P2->IFG &= BIT5){
        P2->IFG &= ~(BIT5);
        SPI_Rx_COUNT =EUSCI_B0->RXBUF;
        SPI_Rx_COUNT = 0;
        EUSCI_B0->TXBUF = 0;
        EUSCI_B0->IE |= EUSCI_B_IE_RXIE;

    }
}

ADS1292_R.h
2260.main.c
#include <msp.h>
//#include <intrinsics.h>
#include <string.h>
#include "main.h"
#include "ADS1292_R.h"


extern unsigned char ADS1292R_REG_VALUE[16];
extern unsigned char SPI_Rx_BUF[];
extern unsigned char ECG_DATA_RDY;
extern long ADS1292R_ECG_DATA_BUF[6];
extern unsigned char ECG_RECORDER_DATA_BUF[256], RECORDER_HEAD, RECORDER_TAIL;

struct ADS1292x_STATE ecgState;

void main(void){
    volatile unsigned short i, j;
    WATCHDOGHOLD();
    init_Start_Up();
    ADS1292R_POWER_ON_INIT();
    START_READ_DATA_CONTINUOUS();
    for(i = 0; i < 10000; i++);
    for(i = 0; i < 10000; i++);
    for(i = 0; i < 10000; i++);

    ADS1292R_DISABLE_START();
    ADS1292R_ENABLE_START();

    for(i = 0; i < 10000; i++);
    for(i = 0; i < 10000; i++);
    for(i = 0; i < 10000; i++);


    ecgState.state = IDLE_STATE;
    ecgState.command = 0;

        while(1){
            if((ecgState.state == IDLE_STATE)){
                /**/
                ADS1292R_DISABLE_START();
                ADS1292R_ENABLE_START();

                ADS1292R_DISABLE_START();

                ADS1292R_CHIP_ENABLE();

                CLEAR_ADS1292R_CHIP_ENABLE();

                ADS1292R_CHIP_ENABLE();
                START_READ_DATA_CONTINUOUS();

                ENABLE_ADS1292R_DRDY_INTERRUPT();
                ADS1292R_ENABLE_START();

                ecgState.state = ECG_RECORDING_STATE;

            }else if((ecgState.state == ECG_RECORDING_STATE)){
                ecgState.state = IDLE_STATE;
                DISABLE_ADS1292R_DRDY_INTERRUPT();
                STOP_READ_DATA_CONTINUOUS();
            }

            switch(ecgState.state){
                case IDLE_STATE:
                    if(ecgState.command!= 0){
                        ecgState.command = 0;
                    }
                break;

                case DATA_STREAMING_STATE:

                break;

                case ACQUIRE_DATA_STATE:
                break;

                case ECG_RECORDING_STATE:
                    if(RECORDER_HEAD!=RECORDER_TAIL){
                        RECORDER_TAIL++;
                        if((RECORDER_TAIL % 4) == 0){
                            /*AFTER EVERY 8 SAMPLES STORE ECG DATA TO MEMORY*/
                            if(RECORDER_TAIL == 32)                            /*RESET TAIL AFTER 32 SAMPLES*/
                                RECORDER_TAIL = 0;
                        }
                    }
                break;

                default:
                break;

            }


        }/*while*/
}/*main*/

void init_Start_Up(void){
    __disable_interrupt();
        //init_Clock();
    __enable_interrupt();
}

void WATCHDOGHOLD(void){
    WDTCTL = WDTPW + WDTHOLD;                                       /*STOP WATCHDOG TIMER*/

}
0243.main.h

  • Hello Armando,

    I'm happy that we were able to solve the last issue and look forward to continuing this project!

    Do you have a specific question that I can help you with?

    The Power-Up Sequencing and Setting the Device For Basic Data Capture sections on pgs 62 & 63 of the datasheet should provide guidance!
  • Yes the last problem was with different levels of power, I had the source with 5V, then had the launch pad to interface with the project,

    which I have to join the ground of the board, ie I have to tie all the ground's at one point.

    Now , the problem is I liked to get readings with ads1292r, I already tested spi communication, with a logic analyzer, this part is well made and functional.

    the problem now is to call the routines that can do the conversion, or even create the packages that allow to convert ... I think this part goes far beyond my knowledge.

    #include <msp.h>
    //#include <intrinsics.h>
    #include <string.h>
    #include "main.h"
    #include "ADS1292_R.h"
    
    
    extern unsigned char ADS1292R_REG_VALUE[16];
    extern unsigned char SPI_Rx_BUF[];
    extern unsigned char ECG_DATA_RDY;
    extern long ADS1292R_ECG_DATA_BUF[6];
    extern unsigned char ECG_RECORDER_DATA_BUF[256], RECORDER_HEAD, RECORDER_TAIL;
    
    struct ADS1292x_STATE ecgState;
    
    void main(void){
        volatile unsigned short i, j;
        WATCHDOGHOLD();
        init_Start_Up();
        ADS1292R_POWER_ON_INIT();
        START_READ_DATA_CONTINUOUS();
        for(i = 0; i < 10000; i++);
        for(i = 0; i < 10000; i++);
        for(i = 0; i < 10000; i++);
    
        ADS1292R_DISABLE_START();
        ADS1292R_ENABLE_START();
    
        for(i = 0; i < 10000; i++);
        for(i = 0; i < 10000; i++);
        for(i = 0; i < 10000; i++);
    
    
        ecgState.state = IDLE_STATE;
        ecgState.command = 0;
    
            while(1){
                if((ecgState.state == IDLE_STATE)){
                    /**/
                    ADS1292R_DISABLE_START();
                    ADS1292R_ENABLE_START();
    
                    ADS1292R_DISABLE_START();
    
                    ADS1292R_CHIP_ENABLE();
    
                    CLEAR_ADS1292R_CHIP_ENABLE();
    
                    ADS1292R_CHIP_ENABLE();
                    START_READ_DATA_CONTINUOUS();
    
                    ENABLE_ADS1292R_DRDY_INTERRUPT();
                    ADS1292R_ENABLE_START();
    
                    ecgState.state = ECG_RECORDING_STATE;
    
                }else if((ecgState.state == ECG_RECORDING_STATE)){
                    ecgState.state = IDLE_STATE;
                    DISABLE_ADS1292R_DRDY_INTERRUPT();
                    STOP_READ_DATA_CONTINUOUS();
                }
    
                switch(ecgState.state){
                    case IDLE_STATE:
                        if(ecgState.command!= 0){
                            ecgState.command = 0;
                        }
                    break;
    
                    case DATA_STREAMING_STATE:
    
                    break;
    
                    case ACQUIRE_DATA_STATE:
                    break;
    
                    case ECG_RECORDING_STATE:
                        if(RECORDER_HEAD!=RECORDER_TAIL){
                            RECORDER_TAIL++;
                            if((RECORDER_TAIL % 4) == 0){
                                /*AFTER EVERY 8 SAMPLES STORE ECG DATA TO MEMORY*/
                                if(RECORDER_TAIL == 32)                            /*RESET TAIL AFTER 32 SAMPLES*/
                                    RECORDER_TAIL = 0;
                            }
                        }
                    break;
    
                    default:
                    break;
    
                }
    
    
            }/*while*/
    }/*main*/
    
    void init_Start_Up(void){
        __disable_interrupt();
            //init_Clock();
        __enable_interrupt();
    }
    
    void WATCHDOGHOLD(void){
        WDTCTL = WDTPW + WDTHOLD;                                       /*STOP WATCHDOG TIMER*/
    
    }
    

  • Hi Armando,

    The application is certainly a difficult one, but you are making great progress!

    For the first step, focus on powering the device up correctly, pg 62, reading the ID register, and monitoring the DRDY toggle.

    The list of questions from this thread may help: e2e.ti.com/.../2727329
  • Hi Alexander,
    I made some changes in my application, but some problems exist I would like to share in private all my code with you, to give me some feedback, I have tried everything, but this is extremely difficult

    /*INCLUDE*/
    #include <msp.h>
    #include <stdbool.h>
    #include "main.h"
    #include <stdio.h>
    #include "ads1292r.h"
    #define LOW_STATE 0x00
    unsigned short numPackets, samplesRequired;
    unsigned char  numFrame;
    
    extern unsigned char ECG_RECORDER_DATA_BUFF[512], headRecorder, tailRecorder;
    extern unsigned char SPI_TX_BUF[];
    unsigned char ECG_TX_PACKET[64], ECG_TX_COUNT, ECG_TX_PACKET_RDY;
    unsigned char ECG_RX_PACKET[64], DUMMY ;
    
    extern long ECG_DATA_BUFF[6];
    
    unsigned char ECG_RECORD_BUFF[256];
    unsigned char *ECGPacketAcqPrt;
    unsigned char ECGR_HEAD;
    
    struct ads1292R_STATUS RECORDER_STATUS;
    
    
    /*STATICS*/
    extern unsigned char ads1292R_Adress[11];
    extern uint8_t ads1292R_RegVal[11];
    static volatile uint8_t SPI_RXCOUNT = 0;
    volatile bool ads1292dataReceived = false;
    uint8_t read1292R = 0;
    unsigned long uecgtemp = 0;
    signed long secgtemp=0;
    volatile signed long s32DaqVals[8];
    uint8_t DataPacketHeader[16];
    unsigned char SPI_RX_BUF[8]={};
    uint8_t data_len = 8;
    
    /*MAIN ROUTINE*/
    void main(void){
        volatile unsigned short i, j;
        unsigned char regInit;
        P2->DIR |= BIT0 | BIT1;
    
        WatchDogHold();                     /*FUNCTION WATCHDOG TIMMER*/
        ads1292R_Init_Resource();
    
        ads1292r_Reset();                   /**/
        ads1292R_Start_DS();                /*DISABLE START PIN*/
        delayADS1292R(20);                  /*SMALL DELAY TO SETTLE*/
        ads1292R_Start_EN();                /*ENABLE START PIN*/
        delayADS1292R(20);                  /*SMALL DELAY TO SETTLE*/
        ads1292R_Start_DS();                /*DISABLE START PIN*/
    
        ads1292R_SPI_CMD_DATA(START_);      /*SEND COMMAND DATA START*/
        ads1292R_SPI_CMD_DATA(STOP_);       /*SEND COMMAND DATA STOP*/
        delayADS1292R(50);                  /*SMALL DELAY TO SETTLE*/
        ads1292R_SPI_CMD_DATA(S_DATA_C);    /*SEND COMMAND DATA READ CONTINUOUS*/
        delayADS1292R(300);                 /*SMALL DELAY TO SETTLE*/
    
        for( regInit = 0; regInit < sizeof(ads1292R_RegVal); regInit++) {
            ads1292R_REG_WRITE(ads1292R_Adress[regInit],ads1292R_RegVal[regInit]);
            delayADS1292R(10);
        }
        ads1292R_SPI_CMD_DATA(R_DATA_C);    /*COMMAND STOP READ DATA CONTINUOUS*/
        delayADS1292R(20);
        /*ENABLE EUCIB0 INTERRUPT IN NVIC MODULE*/
        NVIC->ISER[0] = 1 << ((EUSCIB0_IRQn) & 31);
        NVIC->ISER[1] = 1 << ((PORT2_IRQn) & 31);
    
        clearPowerLosses();
        /*ENABLE GLOBAL INTERRUPT*/
           __enable_interrupt();
    
        while(1){
            if((P2->IN & BIT3) == true){
                P2->OUT |= BIT0;
                P2->OUT &= ~(BIT1);
            }else{
                P2->OUT |= BIT1;
                P2->OUT &= ~(BIT0);
                read1292R = true;
            }
            /**/
            if (ads1292dataReceived == true){
                j=0;
                     // transmit the data over USB
    
                for(i=0;i<6;i+=3){// data outputs is (24 status bits + 24 bits Respiration data +  24 bits ECG data)
    
                    uecgtemp = (unsigned long) (((unsigned long) SPI_RX_BUF[i+3] << 16) |
                                                ((unsigned long) SPI_RX_BUF[i+4] << 8) |
                                                 (unsigned long) SPI_RX_BUF[i+5]);
    
                    uecgtemp = (unsigned long) (uecgtemp << 8);
                    secgtemp = (signed long) (uecgtemp);
                    secgtemp = (signed long) (secgtemp >> 8);
    
                    s32DaqVals[j++]=secgtemp;
                }
                DataPacketHeader[0] = CES_CMDIF_PKT_START_1 ;   // Packet header1 :0x0A
                DataPacketHeader[1] = CES_CMDIF_PKT_START_2;    // Packet header2 :0xFA
    
                DataPacketHeader[2] = (uint8_t) (data_len);     // data length
                DataPacketHeader[3] = (uint8_t) (data_len>>8);
                DataPacketHeader[4] = CES_CMDIF_TYPE_DATA;      // packet type: 0x02 -data 0x01 -commmand
    
                DataPacketHeader[5] = s32DaqVals[1];            // 4 bytes ECG data
                DataPacketHeader[6] = s32DaqVals[1] >> 8;
                DataPacketHeader[7] = s32DaqVals[1] >> 16;
                DataPacketHeader[8] = s32DaqVals[1] >> 24;
    
                DataPacketHeader[9] = s32DaqVals[0];            // 4 bytes Respiration data
                DataPacketHeader[10] = s32DaqVals[0] >> 8;
                DataPacketHeader[11] = s32DaqVals[0] >> 16;
                DataPacketHeader[12] = s32DaqVals[0] >> 24;
    
                DataPacketHeader[13] = CES_CMDIF_TYPE_DATA;   // Packet footer1:0x00
                DataPacketHeader[14] = CES_CMDIF_PKT_STOP ;   // Packet footer2:0x0B
    
                for(i=0; i<15; i++){
                  // printf("value:%c\n", DataPacketHeader[i]);     // transmit the data over USB
                }
                ads1292dataReceived = false;
                SPI_RXCOUNT = 0;
    
            }
    
        }
    }
    
    void WatchDogHold(void){
            WDTCTL = WDTPW | WDTHOLD;                       /*STOP WATCHDOG TIMER*/
    }
    
    void clearPowerLosses(void){
        printf("PORT PINS LOW:%s\n", "OK");
        P2->DIR  |= 0xFF; P2->OUT  = 0;
        P3->DIR  |= 0xFF; P3->OUT  = 0;
        P4->DIR  |= 0xFF; P4->OUT  = 0;
        P5->DIR  |= 0xFF; P5->OUT  = 0;
        P6->DIR  |= 0xFF; P6->OUT  = 0;
        P7->DIR  |= 0xFF; P7->OUT  = 0;
        P8->DIR  |= 0xFF; P8->OUT  = 0;
        P9->DIR  |= 0xFF; P9->OUT  = 0;
        P10->DIR |= 0xFF; P10->OUT = 0;
    
    }
    

  • Hi Armando,

    Do you have a specific question I can help you with?

    The source code for the EVM is available and may help you debug your code. The code can be found on the ADS1292ECG-PDK product page. www.ti.com/.../ADS1292ECG-FE

    Please keep in mind this source is provided “as-is” and modifications/changes are not supported. Also note that this software is optimized for our evaluation platforms and therefore may not be well-suited to end-equipment applications.