TM4C123 + 430BOOST-TMP006

Hi,

I'm triying get data from TMP006EVM via I2C, with eclipse, when reading values from the booster, always get the same result. I think the I2C reading code is wrong, but i'm not sure.

The code is adapted from:  https://github.com/adafruit/Adafruit_TMP006

(The relevant parts are in TMP6_Read16 and TMP6_Write16)

Here is the code:

/**
 ** TMP006 EVM + UART
 **
**/
#include <stdint.h>
#include <stdbool.h>

#include <inc/tm4c123gh6pge.h>
//#include <utils/ustdlib.h>

#include <inc/hw_memmap.h>
#include <inc/hw_types.h>
#include <inc/hw_nvic.h>

#include <driverlib/systick.h>
#include <driverlib/gpio.h>
#include <driverlib/pin_map.h>
#include <driverlib/sysctl.h>
#include <driverlib/debug.h>
#include <driverlib/i2c.h>
#include <driverlib/uart.h>
#include <driverlib/timer.h>

#include <utils/uartstdio.h>

#define SYSTICK_INT_PRIORITY 0x80

#include <inc/hw_ints.h>
#include <driverlib/interrupt.h>

#include "UART_TMP006.h"

void UARTIntHandler(void);


//#if POLLING == 0
void UARTIntHandler(void){}
//	uint32_t ui32Status;
//	// GET INSTERRUPT STATUS
//	ui32Status = UARTIntStatus(UART0_BASE, true);
//	// CLEAR ASSERTED INTERRUPTS
//	UARTIntClear(UART0_BASE, ui32Status);
//
//	// LOOP WHILE THERE ARE CHARS
//	while(UARTCharsAvail(UART0_BASE)){
//		// ECHO CHARACTER
//		UARTCharPutNonBlocking(UART0_BASE, UARTCharGetNonBlocking(UART0_BASE));
//		// BLINK LED
//		GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, GPIO_PIN_1);
//		// DELAY ~1ms
//		SysCtlDelay(SysCtlClockGet() / (1000 * 3));
//		// TURN OFF LED
//		GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, 0x00);
//	}
//}
//#endif

int main(void);
void InitUART(void);
void InitI2C(void);
void InitLeds(void);
void InitBoardLeds(void);
void InitSysTick(void);
void InitTimer(void);
void BoardLeds(uint8_t);
void SysTickWait(uint32_t);
void SysTickWait_ms(uint32_t);

uint8_t TMP6_Start(void);
uint16_t TMP6_Read16(uint8_t);
void TMP6_Write16(uint8_t, uint16_t);

void InitUART(void){
	SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
	GPIOPinConfigure(GPIO_PA0_U0RX);
	GPIOPinConfigure(GPIO_PA1_U0TX);
	GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
}

void InitI2C(void){
	// INITIALIZE I2C PERIPH 3
	SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C3);
	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);

	I2CMasterInitExpClk(I2C3_BASE, SysCtlClockGet(), false);

	GPIOPinConfigure(GPIO_PD1_I2C3SDA);
	GPIOPinConfigure(GPIO_PD0_I2C3SCL);
	GPIOPinTypeI2C(GPIO_PORTD_BASE, GPIO_PIN_1);
	GPIOPinTypeI2CSCL(GPIO_PORTD_BASE, GPIO_PIN_0);
}

void InitLeds(void){
	// ENABLE LEDS
	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
	GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1); // LED PF1
}

void InitBoardLeds(void){
	// ENABLE BOARD LEDS
	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
	GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE, GPIO_PIN_3 | GPIO_PIN_2);
}

void InitSysTick(void){
	// DEFAULTS TO 1ms
	//uint32_t microsecs = F_CPU / SYSTICK_MHZ;
	//SysTickPeriodSet(microsecs * 1000);
	// 40000 > 0.001s > 1ms
	SysTickPeriodSet(40000);
    SysTickEnable();
    IntPrioritySet(FAULT_SYSTICK, SYSTICK_INT_PRIORITY);
    SysTickIntEnable();
}

void InitTimer(void){
	uint32_t ui32Period;
	SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
	TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC);

	ui32Period = (SysCtlClockGet() / 2) / 2;
	TimerLoadSet(TIMER0_BASE, TIMER_A, ui32Period - 1);

	IntEnable(INT_TIMER0A);
	TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
	IntMasterEnable();

	TimerEnable(TIMER0_BASE, TIMER_A);
}

void SysTickWait(uint32_t delay){
    // 0x00FFFFFF > 16777215 > 0.42s(40MHZ)
 	// 120MHz > nS
    // 80MHz > 12.5nS
	// 40MHz > 25.nS
    // 16MHz > 62.5nS

    // FORCE RELOAD
    HWREG(NVIC_ST_CURRENT) = 0;
    // ENABLE SysTick
    SysTickEnable();
    uint32_t test = SysTickValueGet();
    for(uint32_t aux = 0; aux < delay; aux++) {
    	while (test > 0){
    		test = SysTickValueGet();
    		__asm__("NOP");
    	}

    }
}

void SysTickWait_ms(uint32_t delay){
	if (delay == 0) {
		SysTickWait(1);
	}
	SysTickWait(delay);
}

void BoardLeds(uint8_t onoff){
	GPIOPinWrite(GPIO_PORTA_BASE, GPIO_PIN_3, 0x8);
	GPIOPinWrite(GPIO_PORTA_BASE, GPIO_PIN_2, 0x4);
}

int main(void){
	// 400MHz > DEFAULT /2 > /5 > 40MHz
	// 40MHz SYSTEM CLOCK
	SysCtlClockSet(SYSCTL_SYSDIV_5 |SYSCTL_USE_PLL |
			SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN);

	InitUART();
	InitI2C();
	InitLeds();
	InitBoardLeds();
	InitSysTick();
	//InitTimer();


	UARTStdioConfig(0, 115200, 40000000);
//	// CONFIG UART
//	UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), 115200,
//			UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE);
//
//	// ENABLE INTERRUPTS
//	IntMasterEnable();
//	// ENABLE UART INTERRUPTS
//	IntEnable(INT_UART0);
//	// ENABLE RX AND TX INTERRUPTS
//	UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT);
//

	UARTprintf("Hello world!\n");
	UARTprintf("\n");
	UARTprintf("%u", SysCtlClockGet());
	UARTprintf("\n");

	BoardLeds(0);
	uint8_t val;
	val = TMP6_Start();
	UARTprintf("TMP_START: "); UARTprintf("%u", val); UARTprintf("\n");
	while(true){}
}

uint8_t TMP6_Start(void){
	TMP6_Write16(TMP006_CONFIG, TMP006_CFG_MODEON | TMP006_CFG_DRDYEN | TMP006_CFG_16SAMPLE);

	uint16_t mid, did;
	mid = TMP6_Read16(TMP006_MANID);
	did = TMP6_Read16(TMP006_DEVID);

	#ifdef TMP006_DEBUG
		UARTprintf("mid = 0x"); UARTprintf("%X", mid); UARTprintf("\n");
		UARTprintf("did = 0x"); UARTprintf("%X", did); UARTprintf("\n");
	#endif

	if (mid != 0x5449) return 0;
	if (did != 0x67) return 0;

	return 1;
}

uint16_t TMP6_Read16(uint8_t u8Addr) {
	uint16_t u16Return;
	uint32_t u32Aux;

	// SENDS REGISTER ADDRESS TO READ FROM
	I2CMasterSlaveAddrSet(I2C3_BASE, TMP006_I2C_ADDR, true);
	I2CMasterDataPut(I2C3_BASE, u8Addr);
	I2CMasterControl(I2C3_BASE, I2C_MASTER_CMD_SINGLE_SEND);
	while(I2CMasterBusy(I2C3_BASE)){}

	I2CMasterSlaveAddrSet(I2C3_BASE, TMP006_I2C_ADDR, true);
	I2CMasterControl(I2C3_BASE, I2C_MASTER_CMD_BURST_RECEIVE_START);
	while(I2CMasterBusy(I2C3_BASE)){}
	u32Aux = I2CMasterDataGet(I2C3_BASE);

	u16Return = ((u32Aux<<8) | 0x0000FF00);

	//I2CMasterSlaveAddrSet(I2C3_BASE, TMP006_I2C_ADDR, true);
	I2CMasterControl(I2C3_BASE, I2C_MASTER_CMD_BURST_RECEIVE_FINISH);
	while(I2CMasterBusy(I2C3_BASE)){}
	u32Aux = I2CMasterDataGet(I2C3_BASE);

	u16Return |= u32Aux;

	return u16Return;
}

void TMP6_Write16(uint8_t u8Addr, uint16_t u16Data){
	// SENDS REGISTER ADDRESS TO READ FROM
	I2CMasterSlaveAddrSet(I2C3_BASE, TMP006_I2C_ADDR, true);
	I2CMasterDataPut(I2C3_BASE, u8Addr);
	I2CMasterControl(I2C3_BASE, I2C_MASTER_CMD_BURST_SEND_START);
	while(I2CMasterBusy(I2C3_BASE)){}

	//
	//I2CMasterSlaveAddrSet(I2C3_BASE, TMP006_I2C_ADDR, true);
	I2CMasterControl(I2C3_BASE, I2C_MASTER_CMD_BURST_SEND_CONT);
	I2CMasterDataPut(I2C3_BASE, u16Data >> 8);
	while(I2CMasterBusy(I2C3_BASE)){}
	//I2CMasterControl(I2C3_BASE, I2C_MASTER_CMD_SINGLE_SEND);
	//while(I2CMasterBusy(I2C3_BASE)){}
	//
	//I2CMasterSlaveAddrSet(I2C3_BASE, TMP006_I2C_ADDR, true);
	I2CMasterControl(I2C3_BASE, I2C_MASTER_CMD_BURST_SEND_FINISH);
	I2CMasterDataPut(I2C3_BASE, u16Data);
	while(I2CMasterBusy(I2C3_BASE)){}
	//I2CMasterControl(I2C3_BASE, I2C_MASTER_CMD_SINGLE_SEND);
	//while(I2CMasterBusy(I2C3_BASE)){}

}

// SYSTICK ISR
void SysTickIntHanhdler(void) {
//	if (GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_1)){
//		GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, GPIO_PORTF_BASE & 0xfd); //SOLO LIMPIAR BIT 3 1000
//	} else {
//		GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, 0x02);
//	}
}

// TIMER0 ISR
void Timer0IntHandle(void){
	TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT);

	if (GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_1)){
		GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, GPIO_PORTF_BASE & 0xfd);
	} else {
		GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, 0x02);
	}
}

Best regards