MSP430F5528: USCI_Bx_VECTOR's not triggering after starting I2C master start functions

Blair Conner said:

I'm trying to implement I2C communication and as the title states the ISR's are not running at all.

Have you tried setting a breakpoint in the ISR? Have you checked the I2C lines with a logic analyzer? I see that you're enabling interrupts, so the ISRs should be working.

Regards,

James

MSP Customer Applications

Hi James,

I have placed breakpoints in the ISR's and they are never entered. I'm going to check the I2C lines with a logic analyzer this afternoon. Does anything look out of place with my code?

Regards,
Blair

Are you disabling your compiler optimizations when debugging? I didn't notice anything wrong at a high level (yet), but I must admit it's a little abstracted with all the variables/enums. I would encourage you to hard-code these (such as I2C_BASE_ADDRESS[port] in the functions) to rule them out. Are you enabling global interrupts using GIE? Please look through the code examples again to see if you're missing anything else.

Regards,

James

MSP Customer Applications

Hi James,

All optimizations are off. Looking at the scope it looks like the address byte is sent out but I'm not getting an ACK.

What is the interrupt vector I need to use to capture these errors? I can't find example code with it...

Regards,

Blair

Functioning code for those that are interested:

typedef enum i2cPorts{
	HAL_I2C_PORT_USCI_B0,
	HAL_I2C_PORT_USCI_B1,
	HAL_I2C_PORT_COUNT
}HAL_I2C_PORT;

typedef enum i2cSpeed{
	HAL_I2C_SPEED_400KBPS,
	HAL_I2C_SPEED_100KBPS
}HAL_I2C_SPEED;

#define I2C_RESET_COUNT_MAX 5
volatile uint16_t I2C_BASE_ADDRESS[HAL_I2C_PORT_COUNT] = {USCI_B0_BASE,USCI_B1_BASE};
volatile HAL_I2C_SPEED I2C_DATA_RATE[HAL_I2C_PORT_COUNT];
volatile uint8_t I2C_RESET_COUNT[HAL_I2C_PORT_COUNT] = {0,0};
uint8_t *I2C_DATA_TX[HAL_I2C_PORT_COUNT];
uint8_t *I2C_DATA_RX[HAL_I2C_PORT_COUNT];
volatile uint8_t I2C_SLAVE_ADDRESS[HAL_I2C_PORT_COUNT];
volatile uint8_t I2C_DATA_TX_COUNT[HAL_I2C_PORT_COUNT];
volatile uint8_t I2C_DATA_RX_COUNT[HAL_I2C_PORT_COUNT];
volatile uint8_t I2C_DATA_TX_COUNTER[HAL_I2C_PORT_COUNT];
volatile uint8_t I2C_DATA_RX_COUNTER[HAL_I2C_PORT_COUNT];
volatile uint8_t *I2C_DATA_RX_BUFFER_POINTER[HAL_I2C_PORT_COUNT];
volatile bool I2C_TRANSFER_STARTED[HAL_I2C_PORT_COUNT];
volatile bool I2C_TRANSFER_COMPLETED[HAL_I2C_PORT_COUNT];
volatile uint8_t I2C_TRANSFER_ERROR[HAL_I2C_PORT_COUNT];

void HAL_I2C_setup(HAL_I2C_PORT port, HAL_I2C_SPEED speed){
	uint8_t i2cPort = 0;
	uint16_t i2cPins = 0;
	uint32_t i2cDataRate = 0;

	/* Specify variables based on selected port */
	switch(port){
		case HAL_I2C_PORT_USCI_B0:
			i2cPort = GPIO_PORT_P3;
			i2cPins = GPIO_PIN0 + GPIO_PIN1;
			break;
		case HAL_I2C_PORT_USCI_B1:
			i2cPort = GPIO_PORT_P4;
			i2cPins = GPIO_PIN1 + GPIO_PIN2;
			break;
	}

	/* Convert the speed rate variable */
	I2C_DATA_RATE[port] = speed;
	switch(speed){
		case HAL_I2C_SPEED_400KBPS:
			i2cDataRate = USCI_B_I2C_SET_DATA_RATE_400KBPS;
			break;
		case HAL_I2C_SPEED_100KBPS:
			i2cDataRate = USCI_B_I2C_SET_DATA_RATE_100KBPS;
			break;
	}

	/* Assign pins to I2C peripheral */
	GPIO_setAsPeripheralModuleFunctionInputPin(i2cPort,i2cPins);

	/* Initialize interfase as master I2C device */
	USCI_B_I2C_initMasterParam param = {0};
	param.selectClockSource = USCI_B_I2C_CLOCKSOURCE_SMCLK;
	param.i2cClk = UCS_getSMCLK();
	param.dataRate = i2cDataRate;
	USCI_B_I2C_initMaster(I2C_BASE_ADDRESS[port], &param);

	/* Enable I2C Module to start operations */
	USCI_B_I2C_clearInterrupt(I2C_BASE_ADDRESS[port],USCI_B_I2C_TRANSMIT_INTERRUPT);
	USCI_B_I2C_clearInterrupt(I2C_BASE_ADDRESS[port],USCI_B_I2C_RECEIVE_INTERRUPT);
	USCI_B_I2C_clearInterrupt(I2C_BASE_ADDRESS[port],USCI_B_I2C_NAK_INTERRUPT);
	USCI_B_I2C_clearInterrupt(I2C_BASE_ADDRESS[port],USCI_B_I2C_ARBITRATIONLOST_INTERRUPT);
	USCI_B_I2C_enable(I2C_BASE_ADDRESS[port]);
	I2C_DATA_TX_COUNT[port] = 0;
	I2C_DATA_RX_COUNT[port] = 0;
	I2C_TRANSFER_STARTED[port] = false;
	I2C_TRANSFER_COMPLETED[port] = false;
}


void HAL_I2C_close(HAL_I2C_PORT port){

}

void HAL_I2C_reset(HAL_I2C_PORT port){
	uint8_t i2cPort = 0;
	uint16_t i2cSclPin = 0;
	uint32_t i2cRateTicks = 0;

	I2C_RESET_COUNT[port]++;

	/* Specify variables based on selected port */
	switch(port){
		case HAL_I2C_PORT_USCI_B0:
			i2cPort = GPIO_PORT_P3;
			i2cSclPin = GPIO_PIN1;
			break;
		case HAL_I2C_PORT_USCI_B1:
			i2cPort = GPIO_PORT_P4;
			i2cSclPin = GPIO_PIN2;
			break;
	}

	/* Determine tick speed */
	switch(I2C_DATA_RATE[port]){
		case HAL_I2C_SPEED_400KBPS:
			i2cRateTicks = HAL_Timestamp_getTicksPerSecond()/(2*400000);
			break;
		case HAL_I2C_SPEED_100KBPS:
			i2cRateTicks = HAL_Timestamp_getTicksPerSecond()/(2*400000);
			break;
	}

	GPIO_setAsOutputPin(i2cPort,i2cSclPin);

	uint8_t tick = 0;
	for (tick = 0; tick < 7; tick++) {
		HAL_Timestamp_delayTicks(i2cRateTicks);
		GPIO_setOutputLowOnPin(i2cPort,i2cSclPin);
		HAL_Timestamp_delayTicks(i2cRateTicks);
		GPIO_setOutputHighOnPin(i2cPort,i2cSclPin);
	}

	HAL_I2C_setup(port, I2C_DATA_RATE[port]);
}

void HAL_I2C_transferStart(HAL_I2C_PORT port,
		uint8_t slaveAddress,
		uint8_t writeCount, uint8_t *writeData,
		uint8_t readCount, uint8_t *readData){

	I2C_SLAVE_ADDRESS[port] = slaveAddress;
	I2C_DATA_TX[port] = writeData;
	I2C_DATA_RX[port] = readData;
	I2C_DATA_TX_COUNT[port] = writeCount;
	I2C_DATA_RX_COUNT[port] = readCount;

	I2C_TRANSFER_STARTED[port] = true;
	I2C_TRANSFER_COMPLETED[port] = false;

    /* Check if any bytes will be written */
    if(writeCount > 0){
        /* Specify slave address */
    	USCI_B_I2C_setSlaveAddress(I2C_BASE_ADDRESS[port],slaveAddress);

		/* Set Transmit mode */
		USCI_B_I2C_setMode(I2C_BASE_ADDRESS[port],USCI_B_I2C_TRANSMIT_MODE);
		USCI_B_I2C_enable(I2C_BASE_ADDRESS[port]);

		/* Enable transmit Interrupt */
		USCI_B_I2C_clearInterrupt(I2C_BASE_ADDRESS[port],USCI_B_I2C_TRANSMIT_INTERRUPT);
		USCI_B_I2C_clearInterrupt(I2C_BASE_ADDRESS[port],USCI_B_I2C_NAK_INTERRUPT);
		USCI_B_I2C_clearInterrupt(I2C_BASE_ADDRESS[port],USCI_B_I2C_ARBITRATIONLOST_INTERRUPT);
		USCI_B_I2C_enableInterrupt(I2C_BASE_ADDRESS[port],USCI_B_I2C_TRANSMIT_INTERRUPT);
		USCI_B_I2C_enableInterrupt(I2C_BASE_ADDRESS[port],USCI_B_I2C_NAK_INTERRUPT);
		USCI_B_I2C_enableInterrupt(I2C_BASE_ADDRESS[port],USCI_B_I2C_ARBITRATIONLOST_INTERRUPT);

		/* Load TX byte counter */
		I2C_DATA_TX_COUNTER[port] = 1;

		/* Initiate start and send first character */
		USCI_B_I2C_masterSendMultiByteStart(I2C_BASE_ADDRESS[port],writeData[0]);
    }
    else if(readCount > 0){
        /* Specify slave address */
        USCI_B_I2C_setSlaveAddress(I2C_BASE_ADDRESS[port],slaveAddress);

    	/* Set receive mode */
    	USCI_B_I2C_setMode(I2C_BASE_ADDRESS[port],USCI_B_I2C_RECEIVE_MODE);
    	USCI_B_I2C_enable(I2C_BASE_ADDRESS[port]);

		/* Enable receive Interrupt */
		USCI_B_I2C_clearInterrupt(I2C_BASE_ADDRESS[port],USCI_B_I2C_RECEIVE_INTERRUPT);
		USCI_B_I2C_clearInterrupt(I2C_BASE_ADDRESS[port],USCI_B_I2C_NAK_INTERRUPT);
		USCI_B_I2C_clearInterrupt(I2C_BASE_ADDRESS[port],USCI_B_I2C_ARBITRATIONLOST_INTERRUPT);
		USCI_B_I2C_enableInterrupt(I2C_BASE_ADDRESS[port],USCI_B_I2C_RECEIVE_INTERRUPT);
		USCI_B_I2C_enableInterrupt(I2C_BASE_ADDRESS[port],USCI_B_I2C_NAK_INTERRUPT);
		USCI_B_I2C_enableInterrupt(I2C_BASE_ADDRESS[port],USCI_B_I2C_ARBITRATIONLOST_INTERRUPT);

		I2C_DATA_RX_COUNTER[port] = I2C_DATA_RX_COUNT[port];

		/* Initialize multi reception */
		I2C_DATA_RX_BUFFER_POINTER[port] = readData;
		USCI_B_I2C_masterReceiveMultiByteStart(I2C_BASE_ADDRESS[port]);
	}
}

bool HAL_I2C_transferStartBlocking(HAL_I2C_PORT port,
		uint8_t slaveAddress,
		uint8_t writeCount, uint8_t *writeData,
		uint8_t readCount, uint8_t *readData,
		uint32_t timeoutTicks){

	HAL_I2C_transferStart(port, slaveAddress, writeCount, writeData, readCount, readData);
	return 	HAL_I2C_waitForReady(port,timeoutTicks);
}

bool HAL_I2C_waitForReady(HAL_I2C_PORT port,uint32_t timeoutTicks){
	uint32_t startTimestamp = HAL_Timestamp_getTime();
	uint32_t stopTimestamp = startTimestamp + timeoutTicks;
	bool timoutOccurred = false;

	/* Wait for the transfer to complete or the timeout to occur */
	do{
		timoutOccurred = HAL_Timestamp_getTime() > stopTimestamp;
	}while((!timoutOccurred) && (!I2C_TRANSFER_COMPLETED[port]));

	return I2C_TRANSFER_COMPLETED[port];
}


#pragma vector=USCI_B0_VECTOR
__interrupt void USCI_B0_ISR (void)
{
    switch (__even_in_range(UCB0IV,12)){
        case USCI_I2C_UCTXIFG:
        {
            //Check TX byte counter
            if (I2C_DATA_TX_COUNTER[HAL_I2C_PORT_USCI_B0] < I2C_DATA_TX_COUNT[HAL_I2C_PORT_USCI_B0]){
                //Initiate send of character from Master to Slave
                USCI_B_I2C_masterSendMultiByteNext(
                	USCI_B0_BASE,
					I2C_DATA_TX[HAL_I2C_PORT_USCI_B0][I2C_DATA_TX_COUNTER[HAL_I2C_PORT_USCI_B0]]
				);

                //Increment TX byte counter
                I2C_DATA_TX_COUNTER[HAL_I2C_PORT_USCI_B0]++;
            }
            else if(I2C_DATA_RX_COUNT[HAL_I2C_PORT_USCI_B0] > 0){
            	/* Start the read transfer without sending an I2C STOP */
            	HAL_I2C_transferStart(
            		HAL_I2C_PORT_USCI_B0,I2C_SLAVE_ADDRESS[HAL_I2C_PORT_USCI_B0],
            		0,I2C_DATA_TX[HAL_I2C_PORT_USCI_B0],
					I2C_DATA_RX_COUNT[HAL_I2C_PORT_USCI_B0], I2C_DATA_RX[HAL_I2C_PORT_USCI_B0]);
            }
            else{
                //Initiate stop only
                USCI_B_I2C_masterSendMultiByteStop(USCI_B0_BASE);

                //Clear master interrupt status
                USCI_B_I2C_clearInterrupt(USCI_B0_BASE,USCI_B_I2C_TRANSMIT_INTERRUPT);

            	I2C_TRANSFER_STARTED[HAL_I2C_PORT_USCI_B0] = false;
            	I2C_TRANSFER_COMPLETED[HAL_I2C_PORT_USCI_B0] = true;
            	I2C_RESET_COUNT[HAL_I2C_PORT_USCI_B0] = 0;
            }
            break;
        }
		case USCI_I2C_UCRXIFG:
		{
			/* Decrement RX byte counter */
			I2C_DATA_RX_COUNTER[HAL_I2C_PORT_USCI_B0]--;

			if (I2C_DATA_RX_COUNTER[HAL_I2C_PORT_USCI_B0]){
				if (I2C_DATA_RX_COUNTER[HAL_I2C_PORT_USCI_B0] == 1) {
					/* Initiate end of reception -> Receive byte with NAK */
					(*I2C_DATA_RX_BUFFER_POINTER[HAL_I2C_PORT_USCI_B0]) = USCI_B_I2C_masterReceiveMultiByteFinish(USCI_B0_BASE);
					I2C_DATA_RX_BUFFER_POINTER[HAL_I2C_PORT_USCI_B0]++;
				}
				else {
					/* Keep receiving one byte at a time */
					(*I2C_DATA_RX_BUFFER_POINTER[HAL_I2C_PORT_USCI_B0]) = USCI_B_I2C_masterReceiveMultiByteNext(USCI_B0_BASE);
					I2C_DATA_RX_BUFFER_POINTER[HAL_I2C_PORT_USCI_B0]++;
				}
			}
			else {
				/* Receive last byte */
				(*I2C_DATA_RX_BUFFER_POINTER[HAL_I2C_PORT_USCI_B0]) = USCI_B_I2C_masterReceiveMultiByteNext(USCI_B0_BASE);

            	I2C_TRANSFER_STARTED[HAL_I2C_PORT_USCI_B0] = false;
            	I2C_TRANSFER_COMPLETED[HAL_I2C_PORT_USCI_B0] = true;
            	I2C_RESET_COUNT[HAL_I2C_PORT_USCI_B0] = 0;
			}
			break;
		}
		case USCI_I2C_UCALIFG:
		case USCI_I2C_UCNACKIFG:
			if(I2C_RESET_COUNT[HAL_I2C_PORT_USCI_B1] < I2C_RESET_COUNT_MAX){
				/* Reset the I2C interface */
				HAL_I2C_reset(HAL_I2C_PORT_USCI_B0);

				/* Restart the transfer */
				HAL_I2C_transferStart(HAL_I2C_PORT_USCI_B0,I2C_SLAVE_ADDRESS[HAL_I2C_PORT_USCI_B0],
					I2C_DATA_TX_COUNT[HAL_I2C_PORT_USCI_B0],I2C_DATA_TX[HAL_I2C_PORT_USCI_B0],
					I2C_DATA_RX_COUNT[HAL_I2C_PORT_USCI_B0], I2C_DATA_RX[HAL_I2C_PORT_USCI_B0]);
			}
			break;
    }
}

#pragma vector=USCI_B1_VECTOR
__interrupt void USCI_B1_ISR (void)
{
    switch (__even_in_range(UCB1IV,12)){
        case USCI_I2C_UCTXIFG:
        {
            //Check TX byte counter
            if (I2C_DATA_TX_COUNTER[HAL_I2C_PORT_USCI_B1] < I2C_DATA_TX_COUNT[HAL_I2C_PORT_USCI_B1]){
                //Initiate send of character from Master to Slave
                USCI_B_I2C_masterSendMultiByteNext(
                	USCI_B1_BASE,
					I2C_DATA_TX[HAL_I2C_PORT_USCI_B1][I2C_DATA_TX_COUNTER[HAL_I2C_PORT_USCI_B1]]
				);

                //Increment TX byte counter
                I2C_DATA_TX_COUNTER[HAL_I2C_PORT_USCI_B1]++;
            }
            else if(I2C_DATA_RX_COUNT[HAL_I2C_PORT_USCI_B1] > 0){
            	/* Start the read transfer without sending an I2C STOP */
            	HAL_I2C_transferStart(
            		HAL_I2C_PORT_USCI_B1,I2C_SLAVE_ADDRESS[HAL_I2C_PORT_USCI_B1],
            		0,I2C_DATA_TX[HAL_I2C_PORT_USCI_B1],
					I2C_DATA_RX_COUNT[HAL_I2C_PORT_USCI_B1], I2C_DATA_RX[HAL_I2C_PORT_USCI_B1]);
            }
            else{
                //Initiate stop only
                USCI_B_I2C_masterSendMultiByteStop(USCI_B1_BASE);

                //Clear master interrupt status
                USCI_B_I2C_clearInterrupt(USCI_B1_BASE,USCI_B_I2C_TRANSMIT_INTERRUPT);

                I2C_TRANSFER_STARTED[HAL_I2C_PORT_USCI_B1] = false;
                I2C_TRANSFER_COMPLETED[HAL_I2C_PORT_USCI_B1] = true;
            	I2C_RESET_COUNT[HAL_I2C_PORT_USCI_B0] = 0;
            }
            break;
        }
		case USCI_I2C_UCRXIFG:
		{
			/* Decrement RX byte counter */
			I2C_DATA_RX_COUNTER[HAL_I2C_PORT_USCI_B1]--;

			if (I2C_DATA_RX_COUNTER[HAL_I2C_PORT_USCI_B1]){
				if (I2C_DATA_RX_COUNTER[HAL_I2C_PORT_USCI_B1] == 1) {
					/* Initiate end of reception -> Receive byte with NAK */
					(*I2C_DATA_RX_BUFFER_POINTER[HAL_I2C_PORT_USCI_B1]) = USCI_B_I2C_masterReceiveMultiByteFinish(USCI_B1_BASE);
					I2C_DATA_RX_BUFFER_POINTER[HAL_I2C_PORT_USCI_B1]++;
				}
				else {
					/* Keep receiving one byte at a time */
					(*I2C_DATA_RX_BUFFER_POINTER[HAL_I2C_PORT_USCI_B1]) = USCI_B_I2C_masterReceiveMultiByteNext(USCI_B1_BASE);
					I2C_DATA_RX_BUFFER_POINTER[HAL_I2C_PORT_USCI_B1]++;
				}
			}
			else {
				/* Receive last byte */
				(*I2C_DATA_RX_BUFFER_POINTER[HAL_I2C_PORT_USCI_B1]) = USCI_B_I2C_masterReceiveMultiByteNext(USCI_B1_BASE);

				I2C_TRANSFER_STARTED[HAL_I2C_PORT_USCI_B1] = false;
				I2C_TRANSFER_COMPLETED[HAL_I2C_PORT_USCI_B1] = true;
            	I2C_RESET_COUNT[HAL_I2C_PORT_USCI_B1] = 0;
			}
			break;
		}
		case USCI_I2C_UCALIFG:
		case USCI_I2C_UCNACKIFG:
			if(I2C_RESET_COUNT[HAL_I2C_PORT_USCI_B1] < I2C_RESET_COUNT_MAX){
				/* Reset the I2C interface */
				HAL_I2C_reset(HAL_I2C_PORT_USCI_B1);

				/* Restart the transfer */
				HAL_I2C_transferStart(HAL_I2C_PORT_USCI_B1,I2C_SLAVE_ADDRESS[HAL_I2C_PORT_USCI_B1],
					I2C_DATA_TX_COUNT[HAL_I2C_PORT_USCI_B1],I2C_DATA_TX[HAL_I2C_PORT_USCI_B1],
					I2C_DATA_RX_COUNT[HAL_I2C_PORT_USCI_B1],I2C_DATA_RX[HAL_I2C_PORT_USCI_B1]);
			}
			break;
    }
}