社区导航

 
快捷导航
  • 首页
  • 论坛
  • 查看新帖
  • 最新回复
  • 精华区
  • 社区活动
  • 联系管理员
  • 消灭零回复
  • E金币兑换
搜索
查看: 333|回复: 18

[环境传感器] LSM303电子罗盘测试结果

[复制链接]

178

TA的帖子

0

TA的资源

一粒金砂(中级)

Rank: 2

发表于 2017-9-12 20:49:36 | 显示全部楼层 |阅读模式
找到一个STM32F051的板子,发现板子基本的调试都忘光了,熟悉了半天开发板,先把数据读出来再说。串口返回数据如下,
参考其他的例程,先设置几个参数(具体的参数都打印出来 了),语文是没学好,都不知道该说些什么了,用过的朋友帮忙看下结果是否正确,传感器板子放在桌子上不动,返回的如下结果。
Start ...
SET_ODR_OK
SET_ODR_M_OK
SET_MODE_OK
SET_MODE_MAG_OK
SET_FULLSCALE_OK
SET_GAIN_MAG_OK
SET_AXIS_OK
AXIS_X value is -41
AXIS_Y value is 1
AXIS_Z value is -1058

AXIS_X value is -41
AXIS_Y value is 1
AXIS_Z value is -1058

AXIS_X value is -41
AXIS_Y value is 1
AXIS_Z value is -1058

AXIS_X value is -43
AXIS_Y value is 2
AXIS_Z value is -1058

AXIS_X value is -43
AXIS_Y value is 2
AXIS_Z value is -1058

AXIS_X value is -43
AXIS_Y value is 2
AXIS_Z value is -1058

AXIS_X value is -43
AXIS_Y value is 2
AXIS_Z value is -1058

AXIS_X value is -43
AXIS_Y value is 2
AXIS_Z value is -1062

AXIS_X value is -46
AXIS_Y value is 3
AXIS_Z value is -1062

AXIS_X value is -46
AXIS_Y value is 3
AXIS_Z value is -1062

AXIS_X value is -46
AXIS_Y value is 3
AXIS_Z value is -1062

AXIS_X value is -46
AXIS_Y value is 3
AXIS_Z value is -1062

AXIS_X value is -44
AXIS_Y value is 3
AXIS_Z value is -1063

AXIS_X value is -44
AXIS_Y value is 3
AXIS_Z value is -1063

AXIS_X value is -44
AXIS_Y value is 3
AXIS_Z value is -1063

AXIS_X value is -44
AXIS_Y value is 3
AXIS_Z value is -1063

AXIS_X value is -44
AXIS_Y value is 3
AXIS_Z value is -1063

AXIS_X value is -45
AXIS_Y value is 6
AXIS_Z value is -1059
607398720902978366.jpg
http://www.jslaser.com高性价比激光测距传感器

回复

使用道具 举报

4232

TA的帖子

8

TA的资源

版主

Rank: 6Rank: 6

发表于 2017-9-12 21:53:00 来自手机 | 显示全部楼层
看这个更像是加速度的数据

点评

您说的对,我读磁场的值都是0,不知道是那里出问题了。 Start ... SET_ODR_OK SET_ODR_M_OK SET_MODE_OK SET_MODE_MAG_OK SET_FULLSCALE_OK SET_GAIN_MAG_OK SET_AXIS_OK AXIS_X value is -39 AXIS_Y val  详情 回复 发表于 2017-9-13 11:51

回复

使用道具 举报

178

TA的帖子

0

TA的资源

一粒金砂(中级)

Rank: 2

 楼主| 发表于 2017-9-13 11:51:05 | 显示全部楼层
littleshrimp 发表于 2017-9-12 21:53
看这个更像是加速度的数据

您说的对,我读磁场的值都是0,不知道是那里出问题了。
Start ...
SET_ODR_OK
SET_ODR_M_OK
SET_MODE_OK
SET_MODE_MAG_OK
SET_FULLSCALE_OK
SET_GAIN_MAG_OK
SET_AXIS_OK
AXIS_X value is -39
AXIS_Y value is 6
AXIS_Z value is -1059

MAG_AXIS_X value is 0
MAG_AXIS_Y value is 0
MAG_AXIS_Z value is 0

AXIS_X value is -39
AXIS_Y value is 5
AXIS_Z value is -1060

MAG_AXIS_X value is 0
MAG_AXIS_Y value is 0
MAG_AXIS_Z value is 0

AXIS_X value is -40
AXIS_Y value is 6
AXIS_Z value is -1058

MAG_AXIS_X value is 0
MAG_AXIS_Y value is 0
MAG_AXIS_Z value is 0

AXIS_X value is -43
AXIS_Y value is 10
AXIS_Z value is -1055


http://www.jslaser.com高性价比激光测距传感器

回复

使用道具 举报

178

TA的帖子

0

TA的资源

一粒金砂(中级)

Rank: 2

 楼主| 发表于 2017-9-13 11:53:27 | 显示全部楼层
加速度至少读出来了,一样的函数,只是地址不同一个是0x32一个0x3C
读的时候都正确返回了,可是磁场却一直是0
G_response = GetAccAxesRaw(&L_data);
      if(G_response==MEMS_SUCCESS){
                printf("AXIS_X value is %d \r\n",L_data.AXIS_X);
                printf("AXIS_Y value is %d \r\n",L_data.AXIS_Y);  
                printf("AXIS_Z value is %d \r\n\r\n",L_data.AXIS_Z);
          
          
          }
         G_response = GetMagAxesRaw(&L_dataM);
           if(G_response==1){
                        printf("MAG_AXIS_X value is %d \r\n",L_dataM.AXIS_X);
                        printf("MAG_AXIS_Y value is %d \r\n",L_dataM.AXIS_Y);  
                        printf("MAG_AXIS_Z value is %d \r\n\r\n",L_dataM.AXIS_Z);               
          

          
         }
http://www.jslaser.com高性价比激光测距传感器

回复

使用道具 举报

178

TA的帖子

0

TA的资源

一粒金砂(中级)

Rank: 2

 楼主| 发表于 2017-9-13 12:15:47 | 显示全部楼层
这个芯片还有温度传感器的功能,读出的温度是25度
手机里显示的当前温度是26度,也算是正确,只有磁场是0,这个是怎么回事呢?
Start ...
TEMPRATURE  ENABLE OK
SET_ODR_OK
SET_ODR_M_OK
SET_MODE_OK
SET_MODE_MAG_OK
SET_FULLSCALE_OK
SET_GAIN_MAG_OK
SET_AXIS_OK
temperature value is 25

AXIS_X value is -41
AXIS_Y value is 8
AXIS_Z value is -1061

MAG_AXIS_X value is 0
MAG_AXIS_Y value is 0
MAG_AXIS_Z value is 0

temperature value is 25

AXIS_X value is -42
AXIS_Y value is 6
AXIS_Z value is -1059

MAG_AXIS_X value is 0
MAG_AXIS_Y value is 0
MAG_AXIS_Z value is 0

temperature value is 25

点评

用这个贴子里说到的官方例程试试 http://bbs.eeworld.com.cn/thread-546624-1-1.html  详情 回复 发表于 2017-9-13 13:39
http://www.jslaser.com高性价比激光测距传感器

回复

使用道具 举报

4232

TA的帖子

8

TA的资源

版主

Rank: 6Rank: 6

发表于 2017-9-13 13:39:23 | 显示全部楼层
kangkls 发表于 2017-9-13 12:15
这个芯片还有温度传感器的功能,读出的温度是25度
手机里显示的当前温度是26度,也算是正确,只有磁场是0 ...

用这个贴子里说到的官方例程试试
http://bbs.eeworld.com.cn/thread-546624-1-1.html
虾扯蛋

回复

使用道具 举报

4232

TA的帖子

8

TA的资源

版主

Rank: 6Rank: 6

发表于 2017-9-13 13:39:55 | 显示全部楼层
[C] 纯文本查看 复制代码
/******************** (C) COPYRIGHT 2016 STMicroelectronics ********************
* File Name          : LSM303C_MAG_driver.c
* Author             : MEMS Application Team
* Version            : v1.1
* Date               : 22 Nov 2016  
* Description        : LSM303C Platform Independent Driver
*
********************************************************************************
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
* CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
*
* THIS SOFTWARE IS SPECIFICALLY DESIGNED FOR EXCLUSIVE USE WITH ST PARTS.
*******************************************************************************/

/* Includes ------------------------------------------------------------------*/
#include "LSM303C_MAG_driver.h"
#include "soft_i2c.h"											//[Example]

/* Private typedef -----------------------------------------------------------*/

/* Private define ------------------------------------------------------------*/

/* Private macro -------------------------------------------------------------*/

/* Private variables ---------------------------------------------------------*/

/* Private functions ---------------------------------------------------------*/

/************** Generic Function  *******************/

/*******************************************************************************
* Function Name		: LSM303C_MAG_WriteReg
* Description		: Generic Writing function. It must be fullfilled with either
*					: I2C or SPI writing function
* Input				: Register Address, Data to be written
* Output			: None
* Return			: None
*******************************************************************************/
u8_t LSM303C_MAG_WriteReg(void *handle, u8_t Reg, u8_t *Bufp, u16_t len)
{
  /*Example*/
  HAL_I2C_Mem_Write(LSM303C_MAG_I2C_ADDRESS, Reg, 
                     Bufp, len, 1000);
  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name		: LSM303C_MAG_ReadReg
* Description		: Generic Reading function. It must be fullfilled with either
*					: I2C or SPI reading functions					
* Input				: Register Address
* Output			: Data REad
* Return			: None
*******************************************************************************/
u8_t LSM303C_MAG_ReadReg(void *handle, u8_t Reg, u8_t *Bufp, u16_t len)
{
  /*Example*/
  HAL_I2C_Mem_Read(LSM303C_MAG_I2C_ADDRESS, Reg, 
                   Bufp, len, 1000);
  return MEMS_SUCCESS;                                      
}

/**************** Base Function  *******************/

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_WHO_AM_I_
* Description    : Read WHO_AM_I_BIT
* Input          : Pointer to u8_t
* Output         : Status of WHO_AM_I_BIT 
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_WHO_AM_I_(void *handle, u8_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_WHO_AM_I_REG, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_WHO_AM_I_BIT_MASK; //coerce	
  *value = *value >> LSM303C_MAG_WHO_AM_I_BIT_POSITION; //mask	

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_W_SystemOperatingMode
* Description    : Write MD
* Input          : LSM303C_MAG_MD_t
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t  LSM303C_MAG_W_SystemOperatingMode(void *handle, LSM303C_MAG_MD_t newValue)
{
  u8_t value;

  if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_CTRL_REG3, &value, 1) )
    return MEMS_ERROR;

  value &= ~LSM303C_MAG_MD_MASK; 
  value |= newValue;
  
  if( !LSM303C_MAG_WriteReg(handle, LSM303C_MAG_CTRL_REG3, &value, 1) )
    return MEMS_ERROR;

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_SystemOperatingMode
* Description    : Read MD
* Input          : Pointer to LSM303C_MAG_MD_t
* Output         : Status of MD see LSM303C_MAG_MD_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_SystemOperatingMode(void *handle, LSM303C_MAG_MD_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_CTRL_REG3, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_MD_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_W_BlockDataUpdate
* Description    : Write BDU
* Input          : LSM303C_MAG_BDU_t
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t  LSM303C_MAG_W_BlockDataUpdate(void *handle, LSM303C_MAG_BDU_t newValue)
{
  u8_t value;

  if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_CTRL_REG5, &value, 1) )
    return MEMS_ERROR;

  value &= ~LSM303C_MAG_BDU_MASK; 
  value |= newValue;
  
  if( !LSM303C_MAG_WriteReg(handle, LSM303C_MAG_CTRL_REG5, &value, 1) )
    return MEMS_ERROR;

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_BlockDataUpdate
* Description    : Read BDU
* Input          : Pointer to LSM303C_MAG_BDU_t
* Output         : Status of BDU see LSM303C_MAG_BDU_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_BlockDataUpdate(void *handle, LSM303C_MAG_BDU_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_CTRL_REG5, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_BDU_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_W_FullScale
* Description    : Write FS
* Input          : LSM303C_MAG_FS_t
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t  LSM303C_MAG_W_FullScale(void *handle, LSM303C_MAG_FS_t newValue)
{
  u8_t value;

  if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_CTRL_REG2, &value, 1) )
    return MEMS_ERROR;

  value &= ~LSM303C_MAG_FS_MASK; 
  value |= newValue;
  
  if( !LSM303C_MAG_WriteReg(handle, LSM303C_MAG_CTRL_REG2, &value, 1) )
    return MEMS_ERROR;

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_FullScale
* Description    : Read FS
* Input          : Pointer to LSM303C_MAG_FS_t
* Output         : Status of FS see LSM303C_MAG_FS_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_FullScale(void *handle, LSM303C_MAG_FS_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_CTRL_REG2, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_FS_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_W_OutputDataRate
* Description    : Write DO
* Input          : LSM303C_MAG_DO_t
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t  LSM303C_MAG_W_OutputDataRate(void *handle, LSM303C_MAG_DO_t newValue)
{
  u8_t value;

  if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_CTRL_REG1, &value, 1) )
    return MEMS_ERROR;

  value &= ~LSM303C_MAG_DO_MASK; 
  value |= newValue;
  
  if( !LSM303C_MAG_WriteReg(handle, LSM303C_MAG_CTRL_REG1, &value, 1) )
    return MEMS_ERROR;

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_OutputDataRate
* Description    : Read DO
* Input          : Pointer to LSM303C_MAG_DO_t
* Output         : Status of DO see LSM303C_MAG_DO_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_OutputDataRate(void *handle, LSM303C_MAG_DO_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_CTRL_REG1, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_DO_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : status_t LSM303C_MAG_Get_Magnetic(u8_t *buff)
* Description    : Read Magnetic output register
* Input          : pointer to [u8_t]
* Output         : Magnetic buffer u8_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_Get_Magnetic(void *handle, u8_t *buff) 
{
  u8_t i, j, k;
  u8_t numberOfByteForDimension;
  
  numberOfByteForDimension=6/3;

  k=0;
  for (i=0; i<3;i++ ) 
  {
	for (j=0; j<numberOfByteForDimension;j++ )
	{	
		if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_OUTX_L+k, &buff[k], 1))
		  return MEMS_ERROR;
		k++;	
	}
  }

  return MEMS_SUCCESS; 
}

/**************** Advanced Function  *******************/

/*******************************************************************************
* Function Name  : LSM303C_MAG_W_SelfTest
* Description    : Write ST
* Input          : LSM303C_MAG_ST_t
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t  LSM303C_MAG_W_SelfTest(void *handle, LSM303C_MAG_ST_t newValue)
{
  u8_t value;

  if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_CTRL_REG1, &value, 1) )
    return MEMS_ERROR;

  value &= ~LSM303C_MAG_ST_MASK; 
  value |= newValue;
  
  if( !LSM303C_MAG_WriteReg(handle, LSM303C_MAG_CTRL_REG1, &value, 1) )
    return MEMS_ERROR;

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_SelfTest
* Description    : Read ST
* Input          : Pointer to LSM303C_MAG_ST_t
* Output         : Status of ST see LSM303C_MAG_ST_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_SelfTest(void *handle, LSM303C_MAG_ST_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_CTRL_REG1, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_ST_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_W_OperatingModeXY
* Description    : Write OM
* Input          : LSM303C_MAG_OM_t
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t  LSM303C_MAG_W_OperatingModeXY(void *handle, LSM303C_MAG_OM_t newValue)
{
  u8_t value;

  if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_CTRL_REG1, &value, 1) )
    return MEMS_ERROR;

  value &= ~LSM303C_MAG_OM_MASK; 
  value |= newValue;
  
  if( !LSM303C_MAG_WriteReg(handle, LSM303C_MAG_CTRL_REG1, &value, 1) )
    return MEMS_ERROR;

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_OperatingModeXY
* Description    : Read OM
* Input          : Pointer to LSM303C_MAG_OM_t
* Output         : Status of OM see LSM303C_MAG_OM_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_OperatingModeXY(void *handle, LSM303C_MAG_OM_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_CTRL_REG1, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_OM_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_W_TemperatureSensor
* Description    : Write TEMP_EN
* Input          : LSM303C_MAG_TEMP_EN_t
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t  LSM303C_MAG_W_TemperatureSensor(void *handle, LSM303C_MAG_TEMP_EN_t newValue)
{
  u8_t value;

  if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_CTRL_REG1, &value, 1) )
    return MEMS_ERROR;

  value &= ~LSM303C_MAG_TEMP_EN_MASK; 
  value |= newValue;
  
  if( !LSM303C_MAG_WriteReg(handle, LSM303C_MAG_CTRL_REG1, &value, 1) )
    return MEMS_ERROR;

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_TemperatureSensor
* Description    : Read TEMP_EN
* Input          : Pointer to LSM303C_MAG_TEMP_EN_t
* Output         : Status of TEMP_EN see LSM303C_MAG_TEMP_EN_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_TemperatureSensor(void *handle, LSM303C_MAG_TEMP_EN_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_CTRL_REG1, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_TEMP_EN_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_W_SoftRST
* Description    : Write SOFT_RST
* Input          : LSM303C_MAG_SOFT_RST_t
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t  LSM303C_MAG_W_SoftRST(void *handle, LSM303C_MAG_SOFT_RST_t newValue)
{
  u8_t value;

  if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_CTRL_REG2, &value, 1) )
    return MEMS_ERROR;

  value &= ~LSM303C_MAG_SOFT_RST_MASK; 
  value |= newValue;
  
  if( !LSM303C_MAG_WriteReg(handle, LSM303C_MAG_CTRL_REG2, &value, 1) )
    return MEMS_ERROR;

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_SoftRST
* Description    : Read SOFT_RST
* Input          : Pointer to LSM303C_MAG_SOFT_RST_t
* Output         : Status of SOFT_RST see LSM303C_MAG_SOFT_RST_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_SoftRST(void *handle, LSM303C_MAG_SOFT_RST_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_CTRL_REG2, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_SOFT_RST_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_W_Reboot
* Description    : Write REBOOT
* Input          : LSM303C_MAG_REBOOT_t
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t  LSM303C_MAG_W_Reboot(void *handle, LSM303C_MAG_REBOOT_t newValue)
{
  u8_t value;

  if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_CTRL_REG2, &value, 1) )
    return MEMS_ERROR;

  value &= ~LSM303C_MAG_REBOOT_MASK; 
  value |= newValue;
  
  if( !LSM303C_MAG_WriteReg(handle, LSM303C_MAG_CTRL_REG2, &value, 1) )
    return MEMS_ERROR;

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_Reboot
* Description    : Read REBOOT
* Input          : Pointer to LSM303C_MAG_REBOOT_t
* Output         : Status of REBOOT see LSM303C_MAG_REBOOT_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_Reboot(void *handle, LSM303C_MAG_REBOOT_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_CTRL_REG2, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_REBOOT_MASK; //mask

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : LSM303C_MAG_W_SerialInterfaceMode
* Description    : Write SIM
* Input          : LSM303C_MAG_SIM_t
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t  LSM303C_MAG_W_SerialInterfaceMode(void *handle, LSM303C_MAG_SIM_t newValue)
{
  u8_t value;

  if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_CTRL_REG3, &value, 1) )
    return MEMS_ERROR;

  value &= ~LSM303C_MAG_SIM_MASK; 
  value |= newValue;
  
  if( !LSM303C_MAG_WriteReg(handle, LSM303C_MAG_CTRL_REG3, &value, 1) )
    return MEMS_ERROR;

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_SerialInterfaceMode
* Description    : Read SIM
* Input          : Pointer to LSM303C_MAG_SIM_t
* Output         : Status of SIM see LSM303C_MAG_SIM_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_SerialInterfaceMode(void *handle, LSM303C_MAG_SIM_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_CTRL_REG3, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_SIM_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_W_FastLowPowerXYZ
* Description    : Write LP
* Input          : LSM303C_MAG_LP_t
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t  LSM303C_MAG_W_FastLowPowerXYZ(void *handle, LSM303C_MAG_LP_t newValue)
{
  u8_t value;

  if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_CTRL_REG3, &value, 1) )
    return MEMS_ERROR;

  value &= ~LSM303C_MAG_LP_MASK; 
  value |= newValue;
  
  if( !LSM303C_MAG_WriteReg(handle, LSM303C_MAG_CTRL_REG3, &value, 1) )
    return MEMS_ERROR;

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_FastLowPowerXYZ
* Description    : Read LP
* Input          : Pointer to LSM303C_MAG_LP_t
* Output         : Status of LP see LSM303C_MAG_LP_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_FastLowPowerXYZ(void *handle, LSM303C_MAG_LP_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_CTRL_REG3, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_LP_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_W_LittleBigEndianInversion
* Description    : Write BLE
* Input          : LSM303C_MAG_BLE_t
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t  LSM303C_MAG_W_LittleBigEndianInversion(void *handle, LSM303C_MAG_BLE_t newValue)
{
  u8_t value;

  if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_CTRL_REG4, &value, 1) )
    return MEMS_ERROR;

  value &= ~LSM303C_MAG_BLE_MASK; 
  value |= newValue;
  
  if( !LSM303C_MAG_WriteReg(handle, LSM303C_MAG_CTRL_REG4, &value, 1) )
    return MEMS_ERROR;

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_LittleBigEndianInversion
* Description    : Read BLE
* Input          : Pointer to LSM303C_MAG_BLE_t
* Output         : Status of BLE see LSM303C_MAG_BLE_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_LittleBigEndianInversion(void *handle, LSM303C_MAG_BLE_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_CTRL_REG4, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_BLE_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_W_OperatingModeZ
* Description    : Write OMZ
* Input          : LSM303C_MAG_OMZ_t
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t  LSM303C_MAG_W_OperatingModeZ(void *handle, LSM303C_MAG_OMZ_t newValue)
{
  u8_t value;

  if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_CTRL_REG4, &value, 1) )
    return MEMS_ERROR;

  value &= ~LSM303C_MAG_OMZ_MASK; 
  value |= newValue;
  
  if( !LSM303C_MAG_WriteReg(handle, LSM303C_MAG_CTRL_REG4, &value, 1) )
    return MEMS_ERROR;

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_OperatingModeZ
* Description    : Read OMZ
* Input          : Pointer to LSM303C_MAG_OMZ_t
* Output         : Status of OMZ see LSM303C_MAG_OMZ_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_OperatingModeZ(void *handle, LSM303C_MAG_OMZ_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_CTRL_REG4, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_OMZ_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_NewXData
* Description    : Read XDA
* Input          : Pointer to LSM303C_MAG_XDA_t
* Output         : Status of XDA see LSM303C_MAG_XDA_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_NewXData(void *handle, LSM303C_MAG_XDA_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_STATUS_REG, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_XDA_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_NewYData
* Description    : Read YDA
* Input          : Pointer to LSM303C_MAG_YDA_t
* Output         : Status of YDA see LSM303C_MAG_YDA_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_NewYData(void *handle, LSM303C_MAG_YDA_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_STATUS_REG, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_YDA_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_NewZData
* Description    : Read ZDA
* Input          : Pointer to LSM303C_MAG_ZDA_t
* Output         : Status of ZDA see LSM303C_MAG_ZDA_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_NewZData(void *handle, LSM303C_MAG_ZDA_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_STATUS_REG, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_ZDA_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_NewXYZData
* Description    : Read ZYXDA
* Input          : Pointer to LSM303C_MAG_ZYXDA_t
* Output         : Status of ZYXDA see LSM303C_MAG_ZYXDA_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_NewXYZData(void *handle, LSM303C_MAG_ZYXDA_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_STATUS_REG, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_ZYXDA_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_DataXOverrun
* Description    : Read XOR
* Input          : Pointer to LSM303C_MAG_XOR_t
* Output         : Status of XOR see LSM303C_MAG_XOR_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_DataXOverrun(void *handle, LSM303C_MAG_XOR_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_STATUS_REG, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_XOR_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_DataYOverrun
* Description    : Read YOR
* Input          : Pointer to LSM303C_MAG_YOR_t
* Output         : Status of YOR see LSM303C_MAG_YOR_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_DataYOverrun(void *handle, LSM303C_MAG_YOR_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_STATUS_REG, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_YOR_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_DataZOverrun
* Description    : Read ZOR
* Input          : Pointer to LSM303C_MAG_ZOR_t
* Output         : Status of ZOR see LSM303C_MAG_ZOR_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_DataZOverrun(void *handle, LSM303C_MAG_ZOR_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_STATUS_REG, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_ZOR_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_DataXYZOverrun
* Description    : Read ZYXOR
* Input          : Pointer to LSM303C_MAG_ZYXOR_t
* Output         : Status of ZYXOR see LSM303C_MAG_ZYXOR_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_DataXYZOverrun(void *handle, LSM303C_MAG_ZYXOR_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_STATUS_REG, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_ZYXOR_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_W_InterruptEnable
* Description    : Write IEN
* Input          : LSM303C_MAG_IEN_t
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t  LSM303C_MAG_W_InterruptEnable(void *handle, LSM303C_MAG_IEN_t newValue)
{
  u8_t value;

  if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_INT_CFG, &value, 1) )
    return MEMS_ERROR;

  value &= ~LSM303C_MAG_IEN_MASK; 
  value |= newValue;
  
  if( !LSM303C_MAG_WriteReg(handle, LSM303C_MAG_INT_CFG, &value, 1) )
    return MEMS_ERROR;

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_InterruptEnable
* Description    : Read IEN
* Input          : Pointer to LSM303C_MAG_IEN_t
* Output         : Status of IEN see LSM303C_MAG_IEN_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_InterruptEnable(void *handle, LSM303C_MAG_IEN_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_INT_CFG, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_IEN_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_W_LatchInterruptRq
* Description    : Write LIR
* Input          : LSM303C_MAG_LIR_t
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t  LSM303C_MAG_W_LatchInterruptRq(void *handle, LSM303C_MAG_LIR_t newValue)
{
  u8_t value;

  if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_INT_CFG, &value, 1) )
    return MEMS_ERROR;

  value &= ~LSM303C_MAG_LIR_MASK; 
  value |= newValue;
  
  if( !LSM303C_MAG_WriteReg(handle, LSM303C_MAG_INT_CFG, &value, 1) )
    return MEMS_ERROR;

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_LatchInterruptRq
* Description    : Read LIR
* Input          : Pointer to LSM303C_MAG_LIR_t
* Output         : Status of LIR see LSM303C_MAG_LIR_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_LatchInterruptRq(void *handle, LSM303C_MAG_LIR_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_INT_CFG, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_LIR_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_W_InterruptActive
* Description    : Write IEA
* Input          : LSM303C_MAG_IEA_t
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t  LSM303C_MAG_W_InterruptActive(void *handle, LSM303C_MAG_IEA_t newValue)
{
  u8_t value;

  if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_INT_CFG, &value, 1) )
    return MEMS_ERROR;

  value &= ~LSM303C_MAG_IEA_MASK; 
  value |= newValue;
  
  if( !LSM303C_MAG_WriteReg(handle, LSM303C_MAG_INT_CFG, &value, 1) )
    return MEMS_ERROR;

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_InterruptActive
* Description    : Read IEA
* Input          : Pointer to LSM303C_MAG_IEA_t
* Output         : Status of IEA see LSM303C_MAG_IEA_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_InterruptActive(void *handle, LSM303C_MAG_IEA_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_INT_CFG, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_IEA_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_W_InterruptOnZ
* Description    : Write ZIEN
* Input          : LSM303C_MAG_ZIEN_t
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t  LSM303C_MAG_W_InterruptOnZ(void *handle, LSM303C_MAG_ZIEN_t newValue)
{
  u8_t value;

  if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_INT_CFG, &value, 1) )
    return MEMS_ERROR;

  value &= ~LSM303C_MAG_ZIEN_MASK; 
  value |= newValue;
  
  if( !LSM303C_MAG_WriteReg(handle, LSM303C_MAG_INT_CFG, &value, 1) )
    return MEMS_ERROR;

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_InterruptOnZ
* Description    : Read ZIEN
* Input          : Pointer to LSM303C_MAG_ZIEN_t
* Output         : Status of ZIEN see LSM303C_MAG_ZIEN_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_InterruptOnZ(void *handle, LSM303C_MAG_ZIEN_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_INT_CFG, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_ZIEN_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_W_InterruptOnY
* Description    : Write YIEN
* Input          : LSM303C_MAG_YIEN_t
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t  LSM303C_MAG_W_InterruptOnY(void *handle, LSM303C_MAG_YIEN_t newValue)
{
  u8_t value;

  if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_INT_CFG, &value, 1) )
    return MEMS_ERROR;

  value &= ~LSM303C_MAG_YIEN_MASK; 
  value |= newValue;
  
  if( !LSM303C_MAG_WriteReg(handle, LSM303C_MAG_INT_CFG, &value, 1) )
    return MEMS_ERROR;

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_InterruptOnY
* Description    : Read YIEN
* Input          : Pointer to LSM303C_MAG_YIEN_t
* Output         : Status of YIEN see LSM303C_MAG_YIEN_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_InterruptOnY(void *handle, LSM303C_MAG_YIEN_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_INT_CFG, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_YIEN_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_W_InterruptOnX
* Description    : Write XIEN
* Input          : LSM303C_MAG_XIEN_t
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t  LSM303C_MAG_W_InterruptOnX(void *handle, LSM303C_MAG_XIEN_t newValue)
{
  u8_t value;

  if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_INT_CFG, &value, 1) )
    return MEMS_ERROR;

  value &= ~LSM303C_MAG_XIEN_MASK; 
  value |= newValue;
  
  if( !LSM303C_MAG_WriteReg(handle, LSM303C_MAG_INT_CFG, &value, 1) )
    return MEMS_ERROR;

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_InterruptOnX
* Description    : Read XIEN
* Input          : Pointer to LSM303C_MAG_XIEN_t
* Output         : Status of XIEN see LSM303C_MAG_XIEN_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_InterruptOnX(void *handle, LSM303C_MAG_XIEN_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_INT_CFG, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_XIEN_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_W_InterruptFlag
* Description    : Write INT
* Input          : LSM303C_MAG_INT_t
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t  LSM303C_MAG_W_InterruptFlag(void *handle, LSM303C_MAG_INT_t newValue)
{
  u8_t value;

  if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_INT_SRC, &value, 1) )
    return MEMS_ERROR;

  value &= ~LSM303C_MAG_INT_MASK; 
  value |= newValue;
  
  if( !LSM303C_MAG_WriteReg(handle, LSM303C_MAG_INT_SRC, &value, 1) )
    return MEMS_ERROR;

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_InterruptFlag
* Description    : Read INT
* Input          : Pointer to LSM303C_MAG_INT_t
* Output         : Status of INT see LSM303C_MAG_INT_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_InterruptFlag(void *handle, LSM303C_MAG_INT_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_INT_SRC, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_INT_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_W_MagneticFieldOverflow
* Description    : Write MROI
* Input          : LSM303C_MAG_MROI_t
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t  LSM303C_MAG_W_MagneticFieldOverflow(void *handle, LSM303C_MAG_MROI_t newValue)
{
  u8_t value;

  if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_INT_SRC, &value, 1) )
    return MEMS_ERROR;

  value &= ~LSM303C_MAG_MROI_MASK; 
  value |= newValue;
  
  if( !LSM303C_MAG_WriteReg(handle, LSM303C_MAG_INT_SRC, &value, 1) )
    return MEMS_ERROR;

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_MagneticFieldOverflow
* Description    : Read MROI
* Input          : Pointer to LSM303C_MAG_MROI_t
* Output         : Status of MROI see LSM303C_MAG_MROI_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_MagneticFieldOverflow(void *handle, LSM303C_MAG_MROI_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_INT_SRC, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_MROI_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_W_NegativeThresholdFlagZ
* Description    : Write NTH_Z
* Input          : LSM303C_MAG_NTH_Z_t
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t  LSM303C_MAG_W_NegativeThresholdFlagZ(void *handle, LSM303C_MAG_NTH_Z_t newValue)
{
  u8_t value;

  if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_INT_SRC, &value, 1) )
    return MEMS_ERROR;

  value &= ~LSM303C_MAG_NTH_Z_MASK; 
  value |= newValue;
  
  if( !LSM303C_MAG_WriteReg(handle, LSM303C_MAG_INT_SRC, &value, 1) )
    return MEMS_ERROR;

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_NegativeThresholdFlagZ
* Description    : Read NTH_Z
* Input          : Pointer to LSM303C_MAG_NTH_Z_t
* Output         : Status of NTH_Z see LSM303C_MAG_NTH_Z_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_NegativeThresholdFlagZ(void *handle, LSM303C_MAG_NTH_Z_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_INT_SRC, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_NTH_Z_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_W_NegativeThresholdFlagY
* Description    : Write NTH_Y
* Input          : LSM303C_MAG_NTH_Y_t
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t  LSM303C_MAG_W_NegativeThresholdFlagY(void *handle, LSM303C_MAG_NTH_Y_t newValue)
{
  u8_t value;

  if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_INT_SRC, &value, 1) )
    return MEMS_ERROR;

  value &= ~LSM303C_MAG_NTH_Y_MASK; 
  value |= newValue;
  
  if( !LSM303C_MAG_WriteReg(handle, LSM303C_MAG_INT_SRC, &value, 1) )
    return MEMS_ERROR;

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_NegativeThresholdFlagY
* Description    : Read NTH_Y
* Input          : Pointer to LSM303C_MAG_NTH_Y_t
* Output         : Status of NTH_Y see LSM303C_MAG_NTH_Y_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_NegativeThresholdFlagY(void *handle, LSM303C_MAG_NTH_Y_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_INT_SRC, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_NTH_Y_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_W_NegativeThresholdFlagX
* Description    : Write NTH_X
* Input          : LSM303C_MAG_NTH_X_t
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t  LSM303C_MAG_W_NegativeThresholdFlagX(void *handle, LSM303C_MAG_NTH_X_t newValue)
{
  u8_t value;

  if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_INT_SRC, &value, 1) )
    return MEMS_ERROR;

  value &= ~LSM303C_MAG_NTH_X_MASK; 
  value |= newValue;
  
  if( !LSM303C_MAG_WriteReg(handle, LSM303C_MAG_INT_SRC, &value, 1) )
    return MEMS_ERROR;

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_NegativeThresholdFlagX
* Description    : Read NTH_X
* Input          : Pointer to LSM303C_MAG_NTH_X_t
* Output         : Status of NTH_X see LSM303C_MAG_NTH_X_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_NegativeThresholdFlagX(void *handle, LSM303C_MAG_NTH_X_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_INT_SRC, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_NTH_X_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_W_PositiveThresholdFlagZ
* Description    : Write PTH_Z
* Input          : LSM303C_MAG_PTH_Z_t
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t  LSM303C_MAG_W_PositiveThresholdFlagZ(void *handle, LSM303C_MAG_PTH_Z_t newValue)
{
  u8_t value;

  if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_INT_SRC, &value, 1) )
    return MEMS_ERROR;

  value &= ~LSM303C_MAG_PTH_Z_MASK; 
  value |= newValue;
  
  if( !LSM303C_MAG_WriteReg(handle, LSM303C_MAG_INT_SRC, &value, 1) )
    return MEMS_ERROR;

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_PositiveThresholdFlagZ
* Description    : Read PTH_Z
* Input          : Pointer to LSM303C_MAG_PTH_Z_t
* Output         : Status of PTH_Z see LSM303C_MAG_PTH_Z_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_PositiveThresholdFlagZ(void *handle, LSM303C_MAG_PTH_Z_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_INT_SRC, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_PTH_Z_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_W_PositiveThresholdFlagY
* Description    : Write PTH_Y
* Input          : LSM303C_MAG_PTH_Y_t
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t  LSM303C_MAG_W_PositiveThresholdFlagY(void *handle, LSM303C_MAG_PTH_Y_t newValue)
{
  u8_t value;

  if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_INT_SRC, &value, 1) )
    return MEMS_ERROR;

  value &= ~LSM303C_MAG_PTH_Y_MASK; 
  value |= newValue;
  
  if( !LSM303C_MAG_WriteReg(handle, LSM303C_MAG_INT_SRC, &value, 1) )
    return MEMS_ERROR;

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_PositiveThresholdFlagY
* Description    : Read PTH_Y
* Input          : Pointer to LSM303C_MAG_PTH_Y_t
* Output         : Status of PTH_Y see LSM303C_MAG_PTH_Y_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_PositiveThresholdFlagY(void *handle, LSM303C_MAG_PTH_Y_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_INT_SRC, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_PTH_Y_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_W_PositiveThresholdFlagX
* Description    : Write PTH_X
* Input          : LSM303C_MAG_PTH_X_t
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t  LSM303C_MAG_W_PositiveThresholdFlagX(void *handle, LSM303C_MAG_PTH_X_t newValue)
{
  u8_t value;

  if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_INT_SRC, &value, 1) )
    return MEMS_ERROR;

  value &= ~LSM303C_MAG_PTH_X_MASK; 
  value |= newValue;
  
  if( !LSM303C_MAG_WriteReg(handle, LSM303C_MAG_INT_SRC, &value, 1) )
    return MEMS_ERROR;

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : LSM303C_MAG_R_PositiveThresholdFlagX
* Description    : Read PTH_X
* Input          : Pointer to LSM303C_MAG_PTH_X_t
* Output         : Status of PTH_X see LSM303C_MAG_PTH_X_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_R_PositiveThresholdFlagX(void *handle, LSM303C_MAG_PTH_X_t *value)
{
 if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_INT_SRC, (u8_t *)value, 1) )
    return MEMS_ERROR;

  *value &= LSM303C_MAG_PTH_X_MASK; //mask

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : status_t LSM303C_MAG_Get_Temperature(u8_t *buff)
* Description    : Read Temperature output register
* Input          : pointer to [u8_t]
* Output         : Temperature buffer u8_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_Get_Temperature(void *handle, u8_t *buff) 
{
  u8_t i, j, k;
  u8_t numberOfByteForDimension;
  
  numberOfByteForDimension=2/1;

  k=0;
  for (i=0; i<1;i++ ) 
  {
	for (j=0; j<numberOfByteForDimension;j++ )
	{	
		if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_TEMP_OUT_L+k, &buff[k], 1))
		  return MEMS_ERROR;
		k++;	
	}
  }

  return MEMS_SUCCESS; 
}


/*******************************************************************************
* Function Name  : status_t LSM303C_MAG_Set_MagneticThreshold(u8_t *buff) 
* Description    : Set MagneticThreshold data row
* Input          : pointer to [u8_t]
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_Set_MagneticThreshold(void *handle, u8_t *buff) 
{
  u8_t  i;

  for (i=0; i<2;i++ ) 
  {
	if( !LSM303C_MAG_WriteReg(handle, LSM303C_MAG_INT_THS_L+i,  &buff[i], 1) )
		return MEMS_ERROR;
  }
  return MEMS_SUCCESS;  
}

/*******************************************************************************
* Function Name  : status_t LSM303C_MAG_Get_MagneticThreshold(u8_t *buff)
* Description    : Read MagneticThreshold output register
* Input          : pointer to [u8_t]
* Output         : MagneticThreshold buffer u8_t
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LSM303C_MAG_Get_MagneticThreshold(void *handle, u8_t *buff) 
{
  u8_t i, j, k;
  u8_t numberOfByteForDimension;
  
  numberOfByteForDimension=2/1;

  k=0;
  for (i=0; i<1;i++ ) 
  {
	for (j=0; j<numberOfByteForDimension;j++ )
	{	
		if( !LSM303C_MAG_ReadReg(handle, LSM303C_MAG_INT_THS_L+k, &buff[k], 1))
		  return MEMS_ERROR;
		k++;	
	}
  }

  return MEMS_SUCCESS; 
}

/*******************************************************************************
* Function Name		: SwapHighLowByte
* Description		: Swap High/low byte in multiple byte values 
*                     It works with minimum 2 byte for every dimension.
*                     Example x,y,z with 2 byte for every dimension
*
* Input				: bufferToSwap -> buffer to swap 
*                     numberOfByte -> the buffer length in byte
*                     dimension -> number of dimension 
*
* Output			: bufferToSwap -> buffer swapped 
* Return			: None
*******************************************************************************/
void LSM303C_MAG_SwapHighLowByte(u8_t *bufferToSwap, u8_t numberOfByte, u8_t dimension)
{
  u8_t numberOfByteForDimension, i, j;
  u8_t tempValue[10];
  
  numberOfByteForDimension=numberOfByte/dimension;
    
  for (i=0; i<dimension;i++ )
  {
	for (j=0; j<numberOfByteForDimension;j++ )
		tempValue[j]=bufferToSwap[j+i*numberOfByteForDimension];
	for (j=0; j<numberOfByteForDimension;j++ )
		*(bufferToSwap+i*(numberOfByteForDimension)+j)=*(tempValue+(numberOfByteForDimension-1)-j);
  } 
}
虾扯蛋

回复

使用道具 举报

4232

TA的帖子

8

TA的资源

版主

Rank: 6Rank: 6

发表于 2017-9-13 13:48:15 | 显示全部楼层
[C] 纯文本查看 复制代码
int lsm303c_test(void)
{
 
  char outBuf[64];
  whoAmI = 0;
  LSM303C_MAG_R_WHO_AM_I_(0, &whoAmI);
  
  LSM303C_ACC_ReadReg(0, LSM303C_ACC_WHO_AM_I_REG, &whoAmI, 1);
  
     
 //Initialize Magnetometer 
 //set ODR (turn ON device)
 response = LSM303C_MAG_W_OutputDataRate(0, LSM303C_MAG_DO_10Hz);
 if(response==MEMS_ERROR) while(1); //manage here comunication error

 //set Fullscale
 response = LSM303C_MAG_W_FullScale(0, LSM303C_MAG_FS_16Ga);
 if(response==MEMS_ERROR) while(1); //manage here comunication error
  
   //set Block Data Update
 response = LSM303C_MAG_W_BlockDataUpdate(0, LSM303C_MAG_BDU_ENABLE);
 if(response==MEMS_ERROR) while(1); //manage here comunication error
  
     //set XY Axis Operation Mode
 response = LSM303C_MAG_W_OperatingModeXY(0, LSM303C_MAG_OM_HIGH);
 if(response==MEMS_ERROR) while(1) //manage here comunication error
  
     //set Z Axis Operation Mode
 response = LSM303C_MAG_W_OperatingModeZ(0, LSM303C_MAG_OMZ_HIGH);
 if(response==MEMS_ERROR) while(1); //manage here comunication error
  
     //set Continuous Mode
 response = LSM303C_MAG_W_SystemOperatingMode(0, LSM303C_MAG_MD_CONTINUOUS);
 if(response==MEMS_ERROR) while(1); //manage here comunication error  
  
 //this flag is used for reading data only when there are new data
 u8_t flag_LSM303C_ACC_STATUS_FLAGS;
 LSM303C_MAG_ZYXDA_t flag_LSM303C_MAG_XYZDA;  
 
 //Initialize Accelerometer 
 //set Fullscale
 response = LSM303C_ACC_SetFullScale(0, LSM303C_ACC_FS_2g);
 if(response==MEMS_ERROR) while(1); //manage here comunication error
  
   //set Block Data Update
 response = LSM303C_ACC_BlockDataUpdate(0, LSM303C_ACC_BDU_ENABLE);
 if(response==MEMS_ERROR) while(1); //manage here comunication error
  
 //Enable Axis 
 response = LSM303C_ACC_EnableAxis(0, LSM303C_ACC_X_ENABLE|LSM303C_ACC_Y_ENABLE|LSM303C_ACC_Z_ENABLE);
 if(response==MEMS_ERROR) while(1); //manage here comunication error
  
 //set ODR (turn ON device)
 response = LSM303C_ACC_SetODR(0, LSM303C_ACC_ODR_100_Hz);
 if(response==MEMS_ERROR) while(1); //manage here comunication error
 
//main loop
  while(1)
  {
       //get Acceleration Raw data  
       response = LSM303C_ACC_Status_Flags(0, &flag_LSM303C_ACC_STATUS_FLAGS);
       if(response==MEMS_ERROR) while(1); //manage here comunication error
       //read only if new data are available from accelerometer  
       else if (flag_LSM303C_ACC_STATUS_FLAGS&LSM303C_ACC_ZYX_NEW_DATA_AVAILABLE)
       {
          response = LSM303C_ACC_GetAccRaw(0, data.u8bit);
          //convert from LSB to mg
          mgData_X=data.i16bit[0]*SENSITIVITY_ACC;
          mgData_Y=data.i16bit[1]*SENSITIVITY_ACC;
          mgData_Z=data.i16bit[2]*SENSITIVITY_ACC;
          sprintf(outBuf,"acc:\tx=%.2f\ty=%.2f\tz=%.2f\r\n",mgData_X,mgData_Y,mgData_Z);
          uart_tx_string(outBuf);//输出到PC
          uart_tx_string("\r\n");//换行
       }
	   //get Magnetic Raw data 

       response = LSM303C_MAG_R_NewXYZData(0, (LSM303C_MAG_ZYXDA_t*) &flag_LSM303C_MAG_XYZDA);
       if(response==MEMS_ERROR) while(1); //manage here comunication error
       //read only if new data are available  
       else if ((LSM303C_MAG_ZYXDA_t) flag_LSM303C_MAG_XYZDA & LSM303C_MAG_ZYXDA_AVAILABLE)
       {
          response = LSM303C_MAG_Get_Magnetic(0, data.u8bit); 
          //convert from LSB to Gauss
          gaussData_X=data.i16bit[0]*SENSITIVITY_MAG;
          gaussData_Y=data.i16bit[1]*SENSITIVITY_MAG;
          gaussData_Z=data.i16bit[2]*SENSITIVITY_MAG;
          sprintf(outBuf,"mag:\tx=%.2f\ty=%.2f\tz=%.2f\r\n",gaussData_X,gaussData_Y,gaussData_Z);
          uart_tx_string(outBuf);//输出到PC
          uart_tx_string("\r\n");//换行
       }
  }
}

点评

非常感谢您的回复,我太想当然的去考虑问题了,两个型号虽然貌似差别不大,但是,寄存器的地址是不一样的。找了半天也没找到LSM303AGR的例程。之前以为测试就是跑跑现成的,看来这次不行了,其他小伙伴注意了,别犯  详情 回复 发表于 2017-9-13 16:16
虾扯蛋

回复

使用道具 举报

178

TA的帖子

0

TA的资源

一粒金砂(中级)

Rank: 2

 楼主| 发表于 2017-9-13 16:16:03 | 显示全部楼层
littleshrimp 发表于 2017-9-13 13:48
[mw_shl_code=c,true]int lsm303c_test(void)
{

  char outBuf[64];
  whoAmI = 0;
  LSM303C_MAG_R ...

非常感谢您的回复,我太想当然的去考虑问题了,两个型号虽然貌似差别不大,但是,寄存器的地址是不一样的。找了半天也没找到LSM303AGR的例程。之前以为测试就是跑跑现成的,看来这次不行了,其他小伙伴注意了,别犯我的错哦!
303AH寄存器地址.bmp
303AGR寄存器地址.bmp

点评

ST的传感同一型号不同尾缀寄存器不同、功能不同这个问题我也遇到过 感觉这种命名很不规范,用起来比较麻烦  详情 回复 发表于 2017-9-13 19:45
http://www.jslaser.com高性价比激光测距传感器

回复

使用道具 举报

4232

TA的帖子

8

TA的资源

版主

Rank: 6Rank: 6

发表于 2017-9-13 19:45:55 | 显示全部楼层
kangkls 发表于 2017-9-13 16:16
非常感谢您的回复,我太想当然的去考虑问题了,两个型号虽然貌似差别不大,但是,寄存器的地址是不一样的 ...

ST的传感同一型号不同尾缀寄存器不同、功能不同这个问题我也遇到过
感觉这种命名很不规范,用起来比较麻烦



lsm303agr.rar (33.24 KB, 下载次数: 1)
虾扯蛋

回复

使用道具 举报

178

TA的帖子

0

TA的资源

一粒金砂(中级)

Rank: 2

 楼主| 发表于 7 天前 | 显示全部楼层
littleshrimp 发表于 2017-9-13 19:45
ST的传感同一型号不同尾缀寄存器不同、功能不同这个问题我也遇到过
感觉这种命名很不规范,用起来比较麻 ...

文件缺少好几个结构定义,方便发一下吗?这个应该是其他工程里摘出来的吧,可否发一下原链接?
..\lLSM303AGR_ACC_driver_HL.c(63): error:  #20: identifier "DrvStatusTypeDef" is undefined
http://www.jslaser.com高性价比激光测距传感器

回复

使用道具 举报

4232

TA的帖子

8

TA的资源

版主

Rank: 6Rank: 6

发表于 7 天前 | 显示全部楼层
kangkls 发表于 2017-9-14 10:11
文件缺少好几个结构定义,方便发一下吗?这个应该是其他工程里摘出来的吧,可否发一下原链接?
..\lLSM3 ...

产品页面
http://www.st.com/content/st_com ... sses/lsm303agr.html找到STM32 OPEN DEVELOPMENT ENVIRONMENT

QQ图片20170914105650.png


进入X-NUCLEO-IKS01A2 页面
http://www.st.com/content/st_com ... nucleo-iks01a2.html
找到MCUS EMBEDDED SOFTWARE下的X-CUBE-MEMS1
QQ图片20170914105827.png
点Get Software,登陆,下载
解压en.x-cube-mems1.zip
找到Drivers\BSP\Components\lsm303agr
具体的宏定义和配置可以打开工程查看

点评

非常感谢您的如此详细的细心的答复,本想尽快有了结果给您回复,可是,遇到点挫折,我尝试下载,开始总是到下载界面就没有了,注册了不行,又单独申请下载链接,折腾好几次,最终发现申请两次连接,第二次的下载连接  详情 回复 发表于 4 天前
虾扯蛋

回复

使用道具 举报

178

TA的帖子

0

TA的资源

一粒金砂(中级)

Rank: 2

 楼主| 发表于 4 天前 | 显示全部楼层
littleshrimp 发表于 2017-9-14 11:05
产品页面
http://www.st.com/content/st_com/en/products/mems-and-sensors/e-compasses/lsm303agr.html ...

非常感谢您的如此详细的细心的答复,本想尽快有了结果给您回复,可是,遇到点挫折,我尝试下载,开始总是到下载界面就没有了,注册了不行,又单独申请下载链接,折腾好几次,最终发现申请两次连接,第二次的下载连接才能用,总算是下载成功了,可是,我用的是051的discovery板,没找到合适的工程,拿来驱动没法直接用,折腾半天最终还是回答自己修改寄存器地址去了,
现在总算是有了结果,磁场的数据挺稳定
Start ...
TEMPRATURE  ENABLE OK
SET_ODR_OK
SET_ODR_M_OK
SET_MODE_OK
SET_MODE_MAG_OK
SET_FULLSCALE_OK
SET_GAIN_MAG_OK
SET_AXIS_OK
temperature value is 25

AXIS_X value is -43
AXIS_Y value is 2
AXIS_Z value is -1055

MAG_AXIS_X value is 3
MAG_AXIS_Y value is -15
MAG_AXIS_Z value is -7

temperature value is 25

AXIS_X value is -42
AXIS_Y value is 0
AXIS_Z value is -1053

MAG_AXIS_X value is 3
MAG_AXIS_Y value is -15
MAG_AXIS_Z value is -7

temperature value is 25

AXIS_X value is -42
AXIS_Y value is 0
AXIS_Z value is -1053

MAG_AXIS_X value is 3
MAG_AXIS_Y value is -15
MAG_AXIS_Z value is -7

temperature value is 25

AXIS_X value is -40
AXIS_Y value is 0
AXIS_Z value is -1053

MAG_AXIS_X value is 3
MAG_AXIS_Y value is -15
MAG_AXIS_Z value is -7

temperature value is 25

AXIS_X value is -40
AXIS_Y value is 0
AXIS_Z value is -1053

MAG_AXIS_X value is 3
MAG_AXIS_Y value is -15
MAG_AXIS_Z value is -7

temperature value is 25

AXIS_X value is -41
AXIS_Y value is 1
AXIS_Z value is -1056

MAG_AXIS_X value is 3
MAG_AXIS_Y value is -15
MAG_AXIS_Z value is -7
再次感谢您的回复。

点评

ST的例程你可以用来参考 看看他在读取磁场数据时是怎么配置的  详情 回复 发表于 4 天前
http://www.jslaser.com高性价比激光测距传感器

回复

使用道具 举报

4232

TA的帖子

8

TA的资源

版主

Rank: 6Rank: 6

发表于 4 天前 来自手机 | 显示全部楼层
kangkls 发表于 2017-9-17 10:31
非常感谢您的如此详细的细心的答复,本想尽快有了结果给您回复,可是,遇到点挫折,我尝试下载,开始总是 ...

ST的例程你可以用来参考 看看他在读取磁场数据时是怎么配置的

点评

非常感谢您的建议,先跑个边,完成任务再回去研究。 现在读LPS22HB,读出来的器件ID是对的,可是,气压和温度不对, LPS22HB DeviceID is 177 湿度 =75882, 温度=0 temperature value is 25 AXIS_X va  详情 回复 发表于 4 天前

回复

使用道具 举报

178

TA的帖子

0

TA的资源

一粒金砂(中级)

Rank: 2

 楼主| 发表于 4 天前 | 显示全部楼层
littleshrimp 发表于 2017-9-17 11:09
ST的例程你可以用来参考 看看他在读取磁场数据时是怎么配置的

非常感谢您的建议,先跑个边,完成任务再回去研究。
现在读LPS22HB,读出来的器件ID是对的,可是,气压和温度不对,
LPS22HB DeviceID  is 177

湿度 =75882, 温度=0
temperature value is 25

AXIS_X value is -39
AXIS_Y value is 4
AXIS_Z value is -1057

MAG_AXIS_X value is -1
MAG_AXIS_Y value is 5
MAG_AXIS_Z value is 6


LPS22HB DeviceID  is 177

湿度 =75882, 温度=0
temperature value is 25

AXIS_X value is -39
AXIS_Y value is 3
AXIS_Z value is -1060

MAG_AXIS_X value is -1
MAG_AXIS_Y value is 5
MAG_AXIS_Z value is 6
http://www.jslaser.com高性价比激光测距传感器

回复

使用道具 举报

178

TA的帖子

0

TA的资源

一粒金砂(中级)

Rank: 2

 楼主| 发表于 4 天前 | 显示全部楼层
本帖最后由 kangkls 于 2017-9-18 09:03 编辑

LPS22HB_Set_I2C(0,LPS22HB_ENABLE);
        LPS22HB_Init(0);
        LPS22HB_Get_DeviceID(0, &WhoAmI);
        printf("\r\nDeviceID  is %d \r\n\r\n",WhoAmI);
LPS22HB_Get_Measurement(0, &Measurement_Value);
                printf(" 气压 =%d, 温度=%d\r\n",Measurement_Value.Pout, Measurement_Value.Tout);
http://www.jslaser.com高性价比激光测距传感器

回复

使用道具 举报

178

TA的帖子

0

TA的资源

一粒金砂(中级)

Rank: 2

 楼主| 发表于 4 天前 | 显示全部楼层
本帖最后由 kangkls 于 2017-9-18 09:04 编辑

LSM303的温度跟 HTS221的温度相差5度,其他小伙伴的测试结果有吗?对比一下,
Start ...
TEMPRATURE  ENABLE OK
SET_ODR_OK
SET_ODR_M_OK
SET_MODE_OK
SET_MODE_MAG_OK
SET_FULLSCALE_OK
SET_GAIN_MAG_OK
SET_AXIS_OK

DeviceID  is 177

LSM303 temperature value is 25

LSM303 AXIS_X value is -38
LSM303 AXIS_Y value is 8
LSM303 AXIS_Z value is -1063

LSM303 MAG_AXIS_X value is -1
LSM303 MAG_AXIS_Y value is 5
LSM303 MAG_AXIS_Z value is 6


LPS22HB DeviceID  is 177

LPS22HB 气压 =75882, 温度=0
HTS221温度=19
HTS221湿度=20
http://www.jslaser.com高性价比激光测距传感器

回复

使用道具 举报

4232

TA的帖子

8

TA的资源

版主

Rank: 6Rank: 6

发表于 3 天前 | 显示全部楼层
kangkls 发表于 2017-9-17 22:02
LSM303的温度跟 HTS221的温度相差5度,其他小伙伴的测试结果有吗?对比一下,
Start ...
TEMPRATURE  ENA ...

LPS22HB 你先对比一下官方例程,看看他们是怎么配置的
然后读一下 WHO AM I看看通信是否正常
虾扯蛋

回复

使用道具 举报

178

TA的帖子

0

TA的资源

一粒金砂(中级)

Rank: 2

 楼主| 发表于 昨天 16:11 | 显示全部楼层
littleshrimp 发表于 2017-9-18 19:30
LPS22HB 你先对比一下官方例程,看看他们是怎么配置的
然后读一下 WHO AM I看看通信是否正常

LPS22HB 的ID 我读取是正确的,datasheet里的值是0xb1也就是10进制的177
LPS22HB DeviceID  is 177

LSM303AGR的ID 我读取也是正确的,datasheet里的值是0x33也就是10进制的51
LSM303AGR DeviceID  is 51
现在的问题是我读取LSM33agr的温度不对,STATUS_REG_AUX_A (07h)的值应该是0x44,读取正常,
最终读取温度的时候,TEMP_OUT_H_M的值一直是0,导致输出温度是25度,TEMP_OUT_H_M的地址是0x0D,这些都核对过了。
The LSM303AGR is supplied with an internal temperature sensor. Temperature data can be
enabled by setting the TEMP_EN[1:0] bits to ‘1’ in the TEMP_CFG_REG_A (1Fh) register.
To retrieve the temperature sensor data the BDU bit in CTRL_REG4_A (23h) must be set
to ‘1’.
Both the OUT_TEMP_L_A (0Ch), OUT_TEMP_H_A (0Dh) registers must be read.
Temperature data is stored inside OUT_TEMP_H as two’s complement data in 8-bit format
left-justified.
status_t GetTempRaw(i16_t* val) {
  u8_t valueH;

        valueH=SetTemperature(MEMS_ENABLE);
       
       
       
        if( !ReadReg(ACC_I2C_ADDRESS, TEMP_OUT_L_M, &valueH) )
      return MEMS_ERROR;
       
       
       
        //KLS                lsm303agr
  if( !ReadReg(ACC_I2C_ADDRESS, TEMP_OUT_H_M, &valueH) )
      return MEMS_ERROR;
  if(valueH & 0x80){
        valueH &= 0x7F;
        valueH = 0x7F - valueH;
    *val = 25 - (i16_t)(valueH);
  } else {
          *val = 25 + (i16_t)(valueH);
  }
  return MEMS_SUCCESS;  
}
http://www.jslaser.com高性价比激光测距传感器

回复

使用道具 举报

您需要登录后才可以回帖 登录 | 注册

本版积分规则

  • 论坛活动 E手掌握

    扫码关注
    EEWORLD 官方微信

  • EE福利  唾手可得

    扫码关注
    EE福利 唾手可得

小黑屋|手机版|Archiver|电子工程世界 ( 京ICP证 060456

GMT+8, 2017-9-21 02:27 , Processed in 0.584724 second(s), 26 queries , Redis On.

快速回复 返回顶部 返回列表