void st_compass_init(void) {
//char response = 0;
I2C_Init(100000);
//while(1);
#ifdef DEBUG_VERBOSE
printf("Awakening Device\r\n");
#endif
//I2C_WriteReg(ACCEL_I2C_ADDRESS,CTRL_REG1_A,0b00010000);
//st_ChangeMode(STMICRO_ACTIVEMODE);
//printf("Control reg: %X",I2C_ReadReg(ACCEL_I2C_ADDRESS,CTRL_REG1_A));
short testval = 0xDEAD;
//printf("The value: %X and its switched counterpart %X",(short)testval,(short)switch_endedness(testval));
//I2C_WriteReg(MAG_I2C_ADDRESS,CRA_REG_M,0b00011100);
//I2C_WriteReg(MAG_I2C_ADDRESS,MR_REG_M,0);
//st_mag_ChangeMode(ST_MAG_CONTINUOUS_MODE);
Reg_Access.full_register = I2C_ReadReg(ACCEL_I2C_ADDRESS, CTRL_REG4_A);
Reg_Access.CTRL_REG4_A.Endedness = 1;
Reg_Access.CTRL_REG4_A.Block_Update = 0;
Reg_Access.CTRL_REG4_A.resolution = 1;
I2C_WriteReg(ACCEL_I2C_ADDRESS, CTRL_REG4_A, Reg_Access.full_register);
#ifdef DEBUG_VERBOSE
printf("Device Awakened\r\n");
#endif
return;
}
unsigned char st_accel_GetScale() {
unsigned char Scale;
Reg_Access.full_register = I2C_ReadReg(ACCEL_I2C_ADDRESS, CTRL_REG4_A);
Scale = Reg_Access.CTRL_REG4_A.Scale;
return Scale;
}
unsigned char st_mag_SetRate(char Rate) {
Reg_Access.full_register = I2C_ReadReg(MAG_I2C_ADDRESS, CRA_REG_M);
Reg_Access.ConReg_A.Rate = Rate;
I2C_WriteReg(MAG_I2C_ADDRESS, CRA_REG_M, Reg_Access.full_register);
return 0;
}
unsigned char st_mag_SetGain(char newGain) {
char regist, fun = CRB_REG_M;
//st_mag_ChangeMode(st_mag_STANDBYMODE);
Reg_Access.full_register = I2C_ReadReg(MAG_I2C_ADDRESS, CRB_REG_M);
Reg_Access.ConReg_B.Gain = newGain;
I2C_WriteReg(MAG_I2C_ADDRESS, CRB_REG_M, Reg_Access.full_register);
//st_mag_ChangeMode(st_mag_ACTIVEMODE);
return 0;
}
/**
*
* @param scale
* @return
*/
unsigned char st_accel_SetScale(char scale) {
unsigned char regist;
Reg_Access.full_register = I2C_ReadReg(ACCEL_I2C_ADDRESS, CTRL_REG4_A);
Reg_Access.CTRL_REG4_A.Scale = scale;
I2C_WriteReg(ACCEL_I2C_ADDRESS, CTRL_REG4_A, Reg_Access.full_register);
regist = I2C_ReadReg(ACCEL_I2C_ADDRESS, CTRL_REG4_A);
//printf("Regist: %X\r\n",regist);
// char regToRead;
// st_ChangeMode(STMICRO_STANDBYMODE);
// regToRead = st_ReadReg(CTRL_REG4_A);
// if (scale == STMICRO_2GSCALE)
// regToRead = (regToRead & (~SCALE_MASK))+(0b00 << 4);
// if (scale == STMICRO_4GSCALE)
// regToRead = (regToRead & (~SCALE_MASK))+(0b01 << 4);
// if (scale == STMICRO_8GSCALE)
// regToRead = (regToRead & (~SCALE_MASK))+(0b11 << 4);
// st_WriteReg(CTRL_REG4_A, regToRead);
// st_ChangeMode(STMICRO_ACTIVEMODE);
return 0;
}
void StartReadSensors(float* pfGData, float* pfAData, float* pfMData, float* pfBData)
{
if(emDMA_READ != DMA_READ_O) return;
LED_GreenOn();
pGloableGData = pfGData;
pGloableAData = pfAData;
pGloableMData = pfMData;
pGloableBData = pfBData;
emDMA_READ = DMA_READ_G;
memset(xBuffer, 0, 6);
I2C_ReadReg(ADDR_LSM330DLC_G, OUT_X_L_G, (uint8_t *)xBuffer, 6);
}
unsigned char st_accel_SetRate(char Rate) {
char regist;
Reg_Access.full_register = I2C_ReadReg(ACCEL_I2C_ADDRESS, CTRL_REG1_A);
Reg_Access.CTRL_REG1_A.Rate = Rate;
//printf("status of axis: %d%d%d\r\n",Reg_Access.CTRL_REG1_A.XEnable,Reg_Access.CTRL_REG1_A.YEnable,Reg_Access.CTRL_REG1_A.ZEnable);
I2C_WriteReg(ACCEL_I2C_ADDRESS, CTRL_REG1_A, Reg_Access.full_register);
//regist = I2C_ReadReg(ACCEL_I2C_ADDRESS, CTRL_REG1_A);
//printf("Regist: %X\r\n",regist);
//regist=I2C_ReadReg(ACCEL_I2C_ADDRESS,FIFO_CTRL_REG_A);
//printf("FIFO Regist: %X\r\n",regist);
return 0;
}
unsigned char st_mag_GetGain() {
unsigned char Gain;
/* for (Scale=0; Scale<=7;Scale++)
{
Reg_Access.Gain_Reg.Gain=Scale;
printf("Gain:%X \tReg:%X\r\n",Scale,Reg_Access.full_register);
}*/
Reg_Access.full_register = I2C_ReadReg(MAG_I2C_ADDRESS, CRB_REG_M);
Gain = Reg_Access.ConReg_B.Gain;
//printf("regist: %X\r\n",regist);
return Gain;
}
void st_mag_ChangeMode(char Mode) {
Reg_Access.full_register = I2C_ReadReg(MAG_I2C_ADDRESS, MR_REG_M);
printf("After reading of register\r\n");
switch (Mode) {
case ST_MAG_CONTINUOUS_MODE:
Reg_Access.Mode_Reg.Mode = 0;
I2C_WriteReg(MAG_I2C_ADDRESS, MR_REG_M, Reg_Access.full_register);
break;
case ST_MAG_SINGLE_MEASUREMENT_MODE:
Reg_Access.Mode_Reg.Mode = 1;
I2C_WriteReg(MAG_I2C_ADDRESS, MR_REG_M, Reg_Access.full_register);
break;
case ST_MAG_IDLE_MODE:
Reg_Access.Mode_Reg.Mode = 2;
I2C_WriteReg(MAG_I2C_ADDRESS, MR_REG_M, Reg_Access.full_register);
break;
}
}
unsigned char st_mag_GetRate() {
unsigned char Rate, regist;
Rate = 255;
//Reg_Access.full_register=0;
// for (Rate=0; Rate<=7;Rate++)
//{
// Reg_Access.Rate_Reg.Rate=Rate;
//printf("Gain:%X \tReg:%X\r\n",Rate,Reg_Access.full_register);
//}
Reg_Access.full_register = I2C_ReadReg(MAG_I2C_ADDRESS, CRA_REG_M);
Rate = Reg_Access.ConReg_A.Rate;
//regist &= RATE_MASK;
//Rate = regist >> 2;
//printf("regist: %X\r\n",regist);
/*if (regist==0)
Scale=st_mag_2GSCALE;
if (regist==1)
Scale=st_mag_4GSCALE;
if (regist==2)
Scale=st_mag_8GSCALE;
*/
return Rate;
}
int main(void) {
SERIAL_Init();
int Real_Rate=0;
char data_out=0;
Real_Rate=I2C_Init(400000);
//TRISGbits.TRISG9=0;
// _RG9=0;
//PORTClearBits(IOPORT_G,BIT_9);
INTEnableSystemMultiVectoredInt();
printf("\r\nAnima Sensor Test Board I2C driver test\r\nThis will verify I2C operation through use of a logic analyzer\r\n");
printf("Rate returned from I2C Module: %d\r\n",Real_Rate);
data_out=I2C_ReadReg(0x40,0x02);
printf("\r\n%d\r\n",data_out);
while(1);
unsigned char ch = 0;
while (1) {
if (IsTransmitEmpty() == TRUE)
if (IsReceiveEmpty() == FALSE)
PutChar(GetChar());
}
return 0;
}
/**
* initialize MAXIM module
*/
statusMAXIM_t MAXIM_Init(
handleMAXIM_t* maximHandle,
const settingsMAXIM_t* maximSettings
)
{
statusI2C_t
status = I2C_Init( &(maximHandle->protocol), maximSettings->address );
if ( STATUS_I2C_SUCCESS != status )
{
return STATUS_MAXIM_INIT_ERROR;
}
else
{
/**
* initialize intern structures,
* which will be used from now on
*/
memcpy( (void*)&self, (void*)maximHandle, sizeof(self) );
memcpy( (void*)&settings, (void*)maximSettings, sizeof(settings) );
uint8_t
foo = 0;
// read revision ID
statusI2C_t
i2cStatus = STATUS_I2C_SUCCESS;
genericI2cHandle_t
i2cProtocol = self.protocol;
uint8_t
revID = 0,
partID = 0;
// read revision ID
i2cStatus |= I2C_ReadReg( &i2cProtocol, MAXIM_REG_ID_REV, &revID );
// read part ID
i2cStatus |= I2C_ReadReg( &i2cProtocol, MAXIM_REG_ID_PART, &partID );
/**
* set up the registers
*/
// reset the module
i2cStatus |= MAXIM_Reset();
// LED amplitude -> max
i2cStatus |= I2C_WriteReg( &i2cProtocol, MAXIM_REG_LED1_PA , 0x7F );
i2cStatus |= I2C_WriteReg( &i2cProtocol, MAXIM_REG_LED2_PA , 0x7F );
i2cStatus |= I2C_WriteReg( &i2cProtocol, MAXIM_REG_LED3_PA , 0x7F );
// set the slots
// foo = ( settings.slot1 << MAXIM_SLOT_1_3_SHIFT ) | ( settings.slot2 << MAXIM_SLOT_2_4_SHIFT );
// i2cStatus |= I2C_writeReg( &i2cProtocol, MAXIM_REG_MULTILED_MODE_CR_12 , foo );
//
// foo = ( settings.slot3 << MAXIM_SLOT_1_3_SHIFT ) | ( settings.slot4 << MAXIM_SLOT_2_4_SHIFT );
// i2cStatus |= I2C_writeReg( &i2cProtocol, MAXIM_REG_MULTILED_MODE_CR_34 , foo );
foo = ( slotGreen << MAXIM_SLOT_1_3_SHIFT ) | ( slotGreen << MAXIM_SLOT_2_4_SHIFT );
i2cStatus |= I2C_WriteReg( &i2cProtocol, MAXIM_REG_MULTILED_MODE_CR_12 , foo );
foo = ( slotGreen << MAXIM_SLOT_1_3_SHIFT ) | ( slotGreen << MAXIM_SLOT_2_4_SHIFT );
i2cStatus |= I2C_WriteReg( &i2cProtocol, MAXIM_REG_MULTILED_MODE_CR_34 , foo );
// set the timings
i2cStatus |= I2C_WriteReg( &i2cProtocol, MAXIM_REG_SPO2_CFG , settings.pulseWidth << MAXIM_SPO2_LED_PW_SHIFT );
// clear FIFO pointers
i2cStatus |= I2C_WriteReg( &i2cProtocol, MAXIM_REG_FIFO_WR_PTR , 0 );
i2cStatus |= I2C_WriteReg( &i2cProtocol, MAXIM_REG_FIFO_RD_PTR , 0 );
i2cStatus |= I2C_WriteReg( &i2cProtocol, MAXIM_REG_FIFO_OV_PTR , 0 );
// set the mode
i2cStatus |= I2C_WriteReg( &i2cProtocol, MAXIM_REG_MODE_CFG , settings.mode << MAXIM_MODE_SHIFT );
// i2cStatus |= I2C_writeReg( &i2cProtocol, MAXIM_REG_MODE_CFG , modeMultiLED << MAXIM_MODE_SHIFT );
switch ( settings.mode )
{
case modeHR: {
channelsPerSample = 1;
break;
}
case modeSPO2: {
channelsPerSample = 2;
break;
}
case modeMultiLED: {
channelsPerSample = 3;
break;
}
default:
{}
}
// read FIFO pointers
i2cStatus |= I2C_ReadReg( &i2cProtocol, MAXIM_REG_FIFO_WR_PTR , &foo );
i2cStatus |= I2C_ReadReg( &i2cProtocol, MAXIM_REG_FIFO_RD_PTR , &foo );
i2cStatus |= I2C_ReadReg( &i2cProtocol, MAXIM_REG_FIFO_OV_PTR , &foo );
if ( STATUS_I2C_SUCCESS != i2cStatus )
{
catch(11);
return STATUS_MAXIM_PROTOCOL_ERROR;
}
else
{
return STATUS_MAXIM_SUCCESS;
}
}
void HAL_I2C_MemRxCpltCallback(I2C_HandleTypeDef *hi2c)
{
// printf("%s\n\r", __func__);
uint8_t i = 0;
uint8_t cDivider = 16;
int16_t RawData[3] = {0};
float sensitivity = 0.0;
// dump_xBuffer();
LED_GreenOff();
switch(emDMA_READ)
{
case DMA_READ_O:
{
}
break;
case DMA_READ_G:
{
sensitivity = LSM330DLC_Gyr_Sensitivity_500dps;
for(i=0; i<3; i++)
{
RawData[i]=(int16_t)(((uint16_t)xBuffer[2*i+1] << 8) + xBuffer[2*i]);
}
//start NEXT read A
emDMA_READ = DMA_READ_A;
memset(xBuffer, 0, 6);
I2C_ReadReg(ADDR_LSM330DLC_A, OUT_X_L_A, (uint8_t *)xBuffer, 6);
LED_GreenOn();
/* divide by sensitivity */
for(i=0; i<3; i++)
{
pGloableGData[i]=(float)RawData[i] * sensitivity;
}
}
break;
case DMA_READ_A:
{
//Read LSM330DLC output register, and calculate the acceleration
//ACC=(1/SENSITIVITY)* (out_h*256+out_l)/16 (12 bit rappresentation)
sensitivity = LSM330DLC_Acc_Sensitivity_4g;
for(i=0; i<3; i++)
{
RawData[i]=((int16_t)((uint16_t)xBuffer[2*i+1] << 8) + xBuffer[2*i])/cDivider;
}
#ifdef USE_MAGNETOMETER
//start NEXT read M
emDMA_READ = DMA_READ_M;
memset(xBuffer, 0, 6);
I2C_ReadReg(ADDR_LIS3MDL, OUT_X_L_M, (uint8_t *)xBuffer, 6);
LED_GreenOn();
#else
emDMA_READ = DMA_READ_O;
SensorsReadOK();
#endif
/* divide by sensitivity */
for(i=0; i<3; i++)
{
pGloableAData[i]=(float)RawData[i] * sensitivity;
}
}
break;
case DMA_READ_M:
{
sensitivity = LIS3MDL_Mag_Sensitivity_4guass;
for(i=0; i<3; i++)
{
RawData[i]=(int16_t)(((uint16_t)xBuffer[2*i+1] << 8) + xBuffer[2*i]);
}
#ifdef USE_BAROMETER
//start NEXT read Barometer
emDMA_READ = DMA_READ_B;
memset(xBuffer, 0, 6);
I2C_ReadReg(ADDR_LPS331AP, PRESS_OUT_L_B, (uint8_t *)xBuffer, 6);
LED_GreenOn();
#else
emDMA_READ = DMA_READ_O;
SensorsReadOK();
#endif
/* divide by sensitivity */
for(i=0; i<3; i++)
{
pGloableMData[i]=(float)RawData[i] / sensitivity;
}
}
LED_GreenOn();
break;
case DMA_READ_B:
{
}
break;
}
}
unsigned char st_accel_GetRate() {
unsigned char Rate;
Reg_Access.full_register = I2C_ReadReg(ACCEL_I2C_ADDRESS, CTRL_REG1_A);
Rate = Reg_Access.CTRL_REG1_A.Rate;
return Rate;
}
