ADXL345 三轴加速度数据SPI读取、多字节读取、DMA SPI读取和FIFO数据读取

最新推荐文章于 2024-02-20 08:35:46 发布
最新推荐文章于 2024-02-20 08:35:46 发布
阅读量1.1w 收藏 121
点赞数 22
分类专栏： 嵌入式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34430371/article/details/103859159
版权

ADXL345 三轴加速度数据SPI读取、多字节读取、DMA SPI读取和FIFO数据读取

1、简介及注意事项

  ADXL345传感器分辨率13位，测量范围±16g（可选±2、±4、±8g），输出数据格式为16位补码，可通过SPI（三线或者四线）或者IIC接口读取。同时还支持32级的FIFO数据存储，满足快速读取数据的要求。

  1. 关于初始化
    一般初始化0x31,0x2D,0x2C,0x2F,0x38,0x2E,0x1E,0x1F,0x20这些寄存器即可。关于这些寄存器的说明，具体可以参考手册。
    需要注意的一点是：如果要使用中断进行数据读取，那么初始化之前对中断寄存器清零，所有其他功能初始化完之后，再设置中断使能。
   SpiWriteCmd(0x2E,0x00);       // 中断寄存器清零
   
   SpiWriteCmd(0x31,0x0B);       // 4线SPI 全分辨率  g加速度范围
   SpiWriteCmd(0x2D,0x08);       // 传感器测量模式
   SpiWriteCmd(0x2C,0x0E);       // 传感器传输数据速率1600HZ
    
   SpiWriteCmd(0x2F,0x03);       // 中断映射
   SpiWriteCmd(0x38,0x94);       // FIFO模式设置

   SpiWriteCmd(0x1E,0x00);       // X轴偏移量
   SpiWriteCmd(0x1F,0x00);       // Y轴偏移量
   SpiWriteCmd(0x20,0x00);       // Z轴偏移量
   
   SpiWriteCmd(0x2E,0x83);       //中断寄存器使能
  1. SPI时钟要求
    在设置读取速率的时候，要和SPI的时钟匹配起来，否则可能读到错误的数据，比如设置1600HZ，SPI时钟要大于2MHZ。SPI读取数据时钟最大5MHZ。
  2. SPI总线的理解
    SPI要读取一个数据，必须先写入一个数据。在写入数据的时候，时钟线才会启动。
  3. 读写以及多字节读取指令的区别
    在这里插入图片描述
    从上面可以看出，
    读的时候，地址的最高位为1；
    写的时候，地址的最高位为0；
    在进行多字节读取的时候，次高位为1，    这样才可以多字节写和读；

2、SPI数据读取

话不多说，直接上代码，本文采用STMF407读取数据，SPI数据位8位，全双工，软件控制片选，高位在前（MB First），

SPI.h

#define ADS_SPI_PORT               GPIOB
#define ADS_SPI_CS_PIN             GPIO_Pin_12
#define ADS_SPI_SCK_PIN            GPIO_Pin_13
#define ADS_SPI_MISO_PIN           GPIO_Pin_14
#define ADS_SPI_MOSI_PIN           GPIO_Pin_15

#define ADS_SPI_CS_HIGH()          GPIO_SetBits(ADS_SPI_PORT, ADS_SPI_CS_PIN)
#define ADS_SPI_CS_LOW() 	       GPIO_ResetBits(ADS_SPI_PORT, ADS_SPI_CS_PIN)

SPI.c
unsigned char ADXL345RXBuff[250];     //DMA 接收缓存
unsigned char ADXL345TXBuff[10];      //DMA 发送缓存

// SPI IO口初始化
void Spi2IOInit(void)
{
  GPIO_InitTypeDef GPIO_InitStructure;

  // Enable GPIOC clocks 
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
  // Connect SPI2 pins to AF5
  GPIO_PinAFConfig(ADS_SPI_PORT, GPIO_PinSource13, GPIO_AF_SPI2);  // SCK
  GPIO_PinAFConfig(ADS_SPI_PORT, GPIO_PinSource14, GPIO_AF_SPI2);  // MISO
  GPIO_PinAFConfig(ADS_SPI_PORT, GPIO_PinSource15, GPIO_AF_SPI2);  // MOSI
  
  // SPI SCK¡¢MOSI pin configuration
  GPIO_InitStructure.GPIO_Pin = ADS_SPI_SCK_PIN|ADS_SPI_MOSI_PIN|ADS_SPI_MISO_PIN;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;//GPIO_PuPd_DOWN;//GPIO_PuPd_UP;//GPIO_PuPd_NOPULL;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
  GPIO_Init(ADS_SPI_PORT, &GPIO_InitStructure);
  
  //SPI2 NSS pin in output pushpull mode 
  GPIO_InitStructure.GPIO_Pin = ADS_SPI_CS_PIN;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;  //GPIO_PuPd_NOPULL;
  GPIO_Init(ADS_SPI_PORT, &GPIO_InitStructure);
	
  ADS_SPI_CS_HIGH();  // cs default state is high
  ADS_SPI_CS_LOW(); 
  ADS_SPI_CS_HIGH(); 
}

// SPI模式初始化
void SPI2Init(void)
{
  SPI_InitTypeDef  SPI_InitStructure;
  NVIC_InitTypeDef NVIC_InitStructure;

  SPI_I2S_DeInit(SPI2);
  //Enable the SPI periph 
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
  Spi2IOInit();
  
  // SPI configuration
  SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
  SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
  SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
  SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
  SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;  // SPI_CPHA_2Edge;
  SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
  SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_16;

  SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
  SPI_InitStructure.SPI_CRCPolynomial = 7;
  SPI_Init(SPI2, &SPI_InitStructure);

  // Enable the SPI2
  SPI_Cmd(SPI2, ENABLE);
}
// SPI写指令
void SpiWriteCmd(u8 cmd,u8 data)
{
  ADS_SPI_CS_LOW(); 
	
	while((SPI2->SR &0x0002)==0);  
	SPI2->DR = (cmd);
	while((SPI2->SR &0x0001)==0);
	SPI_I2S_ReceiveData(SPI2); 
	while((SPI2->SR &0x0002)==0);  
	SPI2->DR = (data);
	while((SPI2->SR &0x0001)==0);
	SPI_I2S_ReceiveData(SPI2); 

  ADS_SPI_CS_HIGH();
}
// SPI读指令
u8 SpiReadCmd(u8 cmd)
{
  ADS_SPI_CS_LOW(); 
  
	unsigned char returnvalue;
	while((SPI2->SR &0x0002)==0);  
	SPI2->DR = (cmd|0x80);
	while((SPI2->SR &0x0001)==0);
	returnvalue =  (unsigned char)(SPI_I2S_ReceiveData(SPI2)); // Return the Byte read from the SPI bus
	while((SPI2->SR &0x0002)==0);  
	SPI2->DR = (0x00);
	while((SPI2->SR &0x0001)==0);
	returnvalue =(unsigned char)(SPI_I2S_ReceiveData(SPI2)); // Return the Byte read from the SPI bus
	
  ADS_SPI_CS_HIGH();
	return(returnvalue);  
}

void ADXL345Init()
{
	u8 TempData;
	SPI2Init();
    TempData = SpiReadCmd(0x00);
	while(TempData!=0xE5)     //判断是否器件ID正确 验证SPI通信是否正常
	{
		SendData(&TempData,1);
	}
	SpiWriteCmd(0x2E,0x00);    
	
	SpiWriteCmd(0x31,0x0B);
	SpiWriteCmd(0x2D,0x08);
	SpiWriteCmd(0x2C,0x0E);
	SpiWriteCmd(0x2E,0x00);
	SpiWriteCmd(0x38,0x00);
	SpiWriteCmd(0x2F,0x00);
	
	SpiWriteCmd(0x1E,0x00);
	SpiWriteCmd(0x1F,0x00);
	SpiWriteCmd(0x20,0x00); 
}

void ReadADXL345Data()
{
  unsigned char StrBuff[50];
  short int Acc_X=0,Acc_Y=0,Acc_Z=0;
  unsigned char Buf[6];
 
  Buf[0]=SpiReadCmd(0x32);
  Buf[1]=SpiReadCmd(0x33);
  
  Buf[2]=SpiReadCmd(0x34);
  Buf[3]=SpiReadCmd(0x35);
  
  Buf[4]=SpiReadCmd(0x36);
  Buf[5]=SpiReadCmd(0x37);
  

  Acc_X = ((Buf[1]<<8|Buf[0]));
  Acc_Y = ((Buf[3]<<8|Buf[2]));
  Acc_Z = ((Buf[5]<<8|Buf[4]));
  
  
  sprintf(StrBuff,"X=%4.3f    m/s2   Y=%4.3f   m/s2   Z=%4.3f   m/s2 \r\n",Acc_X*3.9/1000*9.8,Acc_Y*3.9/1000*9.8,Acc_Z*3.9/1000*9.8);
  SendData(StrBuff,strlen(StrBuff));

读取加速度传感器结果，本文中将g转换成m/s2结果显示。
在这里插入图片描述

3、多字节读取

  多字节读取的方式和常规不同的就是：
  无需自己手动修改读取数据的地址，
  外部传感器自动修改地址并传输，
  多字节读取时序图如下：
在这里插入图片描述
  从上面可以看出，在发送0xF2之后，无论发送什么数据，都自动传回六个数据。
  有的好奇宝宝可能会问，为什么是0xF2呢？
  因为读指令最高位为1，次高位为多字节位，要置1，而寄存器的数据地址为0x32，这样或则可以得到0xF2。

void ContinuousReadADXL345Data()
{
  unsigned char StrBuff[50];
  short int Acc_X=0,Acc_Y=0,Acc_Z=0;
  unsigned char Buf[6];
 

	ADS_SPI_CS_LOW(); 
  
	unsigned char returnvalue;
	while((SPI2->SR &0x0002)==0);  
	SPI2->DR = 0x32|0xC0;
	while((SPI2->SR &0x0001)==0);
	Buf[0] =  (unsigned char)(SPI_I2S_ReceiveData(SPI2)); // Return the Byte read from the SPI bus


    while((SPI2->SR &0x0002)==0);  
	SPI2->DR = 0x00;
	while((SPI2->SR &0x0001)==0);
	Buf[0] =  (unsigned char)(SPI_I2S_ReceiveData(SPI2)); // Return the Byte read from the SPI bus//	Buf[1] =  (unsigned char)(SPI_I2S_ReceiveData(SPI2));

	while((SPI2->SR &0x0002)==0);  
	SPI2->DR = 0x00;
	while((SPI2->SR &0x0001)==0);
	Buf[1] =  (unsigned char)(SPI_I2S_ReceiveData(SPI2)); // Return the Byte read from the SPI bus
	
	while((SPI2->SR &0x0002)==0);  
	SPI2->DR = 0x00;
	while((SPI2->SR &0x0001)==0);
	Buf[2] =  (unsigned char)(SPI_I2S_ReceiveData(SPI2)); // Return the Byte read from the SPI bus
	
	while((SPI2->SR &0x0002)==0);  
	SPI2->DR = 0x00;
	while((SPI2->SR &0x0001)==0);
	Buf[3] =  (unsigned char)(SPI_I2S_ReceiveData(SPI2)); // Return the Byte read from the SPI bus
	
	while((SPI2->SR &0x0002)==0);  
	SPI2->DR = 0x00;
	while((SPI2->SR &0x0001)==0);
	Buf[4] =  (unsigned char)(SPI_I2S_ReceiveData(SPI2)); // Return the Byte read from the SPI bus
	
	while((SPI2->SR &0x0002)==0);  
	SPI2->DR = 0x00;
	while((SPI2->SR &0x0001)==0);
	Buf[5] =  (unsigned char)(SPI_I2S_ReceiveData(SPI2)); // Return the Byte read from the SPI bus
	
    ADS_SPI_CS_HIGH();
	
    Acc_X = ((Buf[1]<<8|Buf[0]));
    Acc_Y = ((Buf[3]<<8|Buf[2]));
    Acc_Z = ((Buf[5]<<8|Buf[4]));
  
    sprintf(StrBuff,"X=%4.1f***Y=%4.1f***Z=%4.1f\r\n",Acc_X*3.9/1000*9.8,Acc_Y*3.9/1000*9.8,Acc_Z*3.9/1000*9.8);
    SendData(StrBuff,strlen(StrBuff));
}

  从上面可以看出，只需填写第一个寄存器的地址之后，后面的数据可以直接读取，无需再修改寄存器。

4、DMA 多字节读取

  使用DMA进行数据读取，在这里我使用数据更新中断去读取数据。
  设置INT1数据更新中断使能，触发外中断去开始DMA数据数据传输。

void SPI2Init(void)
{
  SPI_InitTypeDef  SPI_InitStructure;
  NVIC_InitTypeDef NVIC_InitStructure;

  SPI_I2S_DeInit(SPI2);
  //Enable the SPI periph 
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
  Spi2IOInit();
  
  // SPI configuration
  SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
  SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
  SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
  SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
  SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;  // SPI_CPHA_2Edge;
  SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
  SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_16;

  SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
  SPI_InitStructure.SPI_CRCPolynomial = 7;
  SPI_Init(SPI2, &SPI_InitStructure);

  // Enable the SPI2
  SPI_Cmd(SPI2, ENABLE);
	
	
  NVIC_InitStructure.NVIC_IRQChannel = DMA1_Stream3_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);
  NVIC_InitStructure.NVIC_IRQChannel = DMA1_Stream4_IRQn;
  NVIC_Init(&NVIC_InitStructure);

  MyDMAInit();   
  EXTIX_Init();     
}

void MyDMAInit()
{
  DMA_InitTypeDef  DMA_InitStructure;
	
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1,ENABLE);//DMA时钟
  DMA_DeInit(DMA1_Stream3);  //SPI_RX
	
  /* DMA Stream 3 */
  DMA_InitStructure.DMA_Channel = DMA_Channel_0;  //
  DMA_InitStructure.DMA_PeripheralBaseAddr =(u32)(&(SPI2->DR));·
  DMA_InitStructure.DMA_Memory0BaseAddr = (u32)(&ADXL345RXBuff[0]);//
  DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;//
  DMA_InitStructure.DMA_BufferSize = FIFO_COUNT*7;//
  DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;//
  DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;//
  DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;//
  DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;//
  DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;// 
  DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;//
  DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;         
  DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
  DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;//
  DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;//
	
  DMA_Init(DMA1_Stream3, &DMA_InitStructure);//³õʼ»¯DMA Stream
  SPI_I2S_DMACmd(SPI2,SPI_I2S_DMAReq_Rx,ENABLE);
  DMA_ITConfig(DMA1_Stream3, DMA_IT_TC, ENABLE);
  DMA_Cmd(DMA1_Stream3, DISABLE);
	
  DMA_DeInit(DMA1_Stream4);  //SPI_TX
	  /* DMA Stream 4*/
  DMA_InitStructure.DMA_Channel = DMA_Channel_0;  //
  DMA_InitStructure.DMA_PeripheralBaseAddr =(u32)(&(SPI2->DR));//
  DMA_InitStructure.DMA_Memory0BaseAddr = (u32)(&ADXL345TXBuff[0]);//DMA
  DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;//
  DMA_InitStructure.DMA_BufferSize = 7;//
  DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;//
  DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;//
  DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;//
  DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;//
  DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;// 
  DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;//
  DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;         
  DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
  DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;//
  DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;//
	
  DMA_Init(DMA1_Stream4, &DMA_InitStructure);//
  SPI_I2S_DMACmd(SPI2,SPI_I2S_DMAReq_Tx,ENABLE);
  //  DMA_ITConfig(DMA1_Stream4, DMA_IT_TC, ENABLE);
}

void EXTIX_Init()
{
  NVIC_InitTypeDef   NVIC_InitStructure;
  EXTI_InitTypeDef   EXTI_InitStructure;
  GPIO_InitTypeDef GPIO_InitStructure;
	
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);//
	
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;//GPIO_PuPd_DOWN;//GPIO_PuPd_UP;//GPIO_PuPd_NOPULL;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
  GPIO_Init(GPIOD, &GPIO_InitStructure);
	
  SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOD, EXTI_PinSource8);//
	
  EXTI_InitStructure.EXTI_Line = EXTI_Line8;//LINE8
  EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;//
  EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising; //
  EXTI_InitStructure.EXTI_LineCmd = ENABLE;//
  EXTI_Init(&EXTI_InitStructure);//
	
  NVIC_InitStructure.NVIC_IRQChannel = EXTI9_5_IRQn;//
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x01;//
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x02;//
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;//
  NVIC_Init(&NVIC_InitStructure);
}

u8 ExtiFlag=0;     // 数据更新中断标志位
void EXTI9_5_IRQHandler()
{
	if(EXTI_GetITStatus(EXTI_Line8))
	{
		   
	    DMA_Cmd(DMA1_Stream3, DISABLE); 
	    DMA_Cmd(DMA1_Stream4, DISABLE); 
		u8 TempData = SpiReadCmd(0x30);
		if((TempData&0x80))
		     ExtiFlag=1;
		EXTI_ClearITPendingBit(EXTI_Line8);
	}
}

void SPIDMAReadADXL345Data()
{
	int pro=0;
	ADS_SPI_CS_LOW(); 
	
	DMA_Cmd(DMA1_Stream3, ENABLE);
	ADXL345TXBuff[0]=0xF2;
	
	ADXL345TXBuff[1]=0x00;
	ADXL345TXBuff[2]=0x00;
	ADXL345TXBuff[3]=0x00;
	ADXL345TXBuff[4]=0x00;
	ADXL345TXBuff[5]=0x00;
	ADXL345TXBuff[6]=0x00;
	
	DMA_Cmd(DMA1_Stream4, DISABLE); 
	DMA_SetCurrDataCounter(DMA1_Stream4,7);          
    DMA_Cmd(DMA1_Stream4, ENABLE);
	
	while(DMA_GetFlagStatus(DMA1_Stream4, DMA_FLAG_TCIF4) == RESET)
	{
		 pro=DMA_GetCurrDataCounter(DMA1_Stream4);
	}
	DMA_ClearFlag(DMA1_Stream4, DMA_FLAG_TCIF4);
	while(SPI_I2S_GetFlagStatus(SPI2,SPI_I2S_FLAG_BSY)==SET);       //需要等待SPI总线传输完成最后一个字节，否则Z轴数据存在问题。
	
	ADS_SPI_CS_HIGH();
	ExtiFlag=0;
}

u8 DMAReadFlag = 0;                   // DMA接收数据完成中断标志位
void DMA1_Stream3_IRQHandler()
{
	if (DMA_GetITStatus(DMA1_Stream3, DMA_IT_TCIF3) != RESET)
   {
      DMA_ClearFlag(DMA1_Stream3, DMA_IT_TCIF3);
	  DMAReadFlag=1;
	  DMA_Cmd(DMA1_Stream3, DISABLE);
   }
}

void ReadDMAData()
{

	short int Acc_X=0,Acc_Y=0,Acc_Z=0;
	unsigned char StrBuff[50];
	
	if(ExtiFlag==1)                       //数据更新中断，则开始DMA读取数据
	{
		SPIDMAReadADXL345Data();
	}
	if(DMAReadFlag)                        //读取数据完成之后，则开始计算三轴并显示
	{
	  Acc_X = ((ADXL345RXBuff[2]<<8|ADXL345RXBuff[1]));
      Acc_Y = ((ADXL345RXBuff[4]<<8|ADXL345RXBuff[3]));
      Acc_Z = ((ADXL345RXBuff[6]<<8|ADXL345RXBuff[5]));
  
      sprintf(StrBuff,"X=%4.3f    Y=%4.3f     Z=%4.3f\r\n",Acc_X*3.9/1000*9.8,Acc_Y*3.9/1000*9.8,Acc_Z*3.9/1000*9.8);
      SendData(StrBuff,strlen(StrBuff));
	  DMAReadFlag=0;
	}
}

5、DMA FIFO数据读取

  FIFO模式共分为三种，FIFO模式，流模式和触发模式，一般使用前两种，FIFO模式存满缓存区之后则不再继续填充数据，而流模式则继续回覆盖之前已存在的数据。
  FIFO最大缓存32级数据，即32个三轴数据，总共32*6=192个数据。FIFO可设置存满一定字节后触发中断，中断为水印中断（Watermark 奇怪的名字）。存满之后继续填充缓存器，直到存满32级缓存。所以不需要完全存满再去读取数据，那样时效性不高，可设置16级之后就读取数据，这样类似于半中断，效率更高。
  这个FIFO唯一一点不好的地方我觉得是，FIFO数据不是一次性读出，而是多次通过寄存器去读取，意思就是FIFO数据的读取地址就是0x32-0x37，读完之后，FIFO缓存就往寄存器里填充缓存的数据，然后再去读，直到填充完。
  使用水印中断来触发外中断去读取FIFO数据。

void ADXL345Init()
{
	u8 TempData;
	SPI2Init();
    TempData = SpiReadCmd(0x00);
	while(TempData!=0xE5)
	{
		SendData(&TempData,1);
	}
	SpiWriteCmd(0x2E,0x00);       
	
	SpiWriteCmd(0x31,0x0B);      
	SpiWriteCmd(0x2D,0x08);      
	SpiWriteCmd(0x2C,0x0E);      
	 
	SpiWriteCmd(0x2F,0x03);       
	SpiWriteCmd(0x38,0x9F);       // 设置FIFO模式   10011111   32条目  流模式   只保存最新数据

	SpiWriteCmd(0x1E,0x00);      
	SpiWriteCmd(0x1F,0x00);       
	SpiWriteCmd(0x20,0x00);      
	
	SpiWriteCmd(0x2E,0x83);       //设置INT2 为水印中断
	
    ADXL345TXBuff[0]=0xF2;        //DMA 发送缓存
    ADXL345TXBuff[1]=0x00;
	ADXL345TXBuff[2]=0x00;
	ADXL345TXBuff[3]=0x00;
	ADXL345TXBuff[4]=0x00;
	ADXL345TXBuff[5]=0x00;
	ADXL345TXBuff[6]=0x00;
}

u8 ExtiFlag=0;
void EXTI9_5_IRQHandler()
{
	if(EXTI_GetITStatus(EXTI_Line8))
	{
		DMA_Cmd(DMA1_Stream3, DISABLE); 
		DMA_Cmd(DMA1_Stream4, DISABLE); 
		u8 TempData = SpiReadCmd(0x30);    //读取中断标志位   确定中断产生
		if((TempData&0x02))
		     ExtiFlag=1;
		EXTI_ClearITPendingBit(EXTI_Line8);
	}
}


void SPIDMAReadADXL345Data()
{

	u8 i=0;
	DMA_Cmd(DMA1_Stream3, ENABLE);
	
	for(i=0;i<FIFO_COUNT;i++)       //FIFO_COUNT  代表触发FIFO缓存个数
	{
		ADS_SPI_CS_LOW(); 
		
		DMA_Cmd(DMA1_Stream4, DISABLE); 
		DMA_SetCurrDataCounter(DMA1_Stream4,7);          /
		DMA_Cmd(DMA1_Stream4, ENABLE);
		
		while(DMA_GetFlagStatus(DMA1_Stream4, DMA_FLAG_TCIF4) == RESET)
		{
			 DMA_GetCurrDataCounter(DMA1_Stream4);//
		}
		DMA_ClearFlag(DMA1_Stream4, DMA_FLAG_TCIF4);
		while(SPI_I2S_GetFlagStatus(SPI2,SPI_I2S_FLAG_BSY)==SET);
	
	    ADS_SPI_CS_HIGH();
		
  }
	
   ExtiFlag=0;
}

u8 DMAReadFlag = 0;
void DMA1_Stream3_IRQHandler()
{
	if (DMA_GetITStatus(DMA1_Stream3, DMA_IT_TCIF3) != RESET)
   {
       DMA_ClearFlag(DMA1_Stream3, DMA_IT_TCIF3);
	   DMAReadFlag=1;
	   DMA_Cmd(DMA1_Stream3, DISABLE);
    }
}

void ReadDMAData()
{
	short int Acc_X=0,Acc_Y=0,Acc_Z=0;
	unsigned char StrBuff[50];
	unsigned char C=10;    
	if(ExtiFlag==1)     
	{
		SPIDMAReadADXL345Data();      
	}
	if(DMAReadFlag)                 
	{
	  Acc_X = ((ADXL345RXBuff[7*C+2]<<8|ADXL345RXBuff[7*C+1]));
      Acc_Y = ((ADXL345RXBuff[7*C+4]<<8|ADXL345RXBuff[7*C+3]));
      Acc_Z = ((ADXL345RXBuff[7*C+6]<<8|ADXL345RXBuff[7*C+5]));
  
      sprintf((char *)StrBuff,"X=%4.3f    Y=%4.3f     Z=%4.3f\r\n",Acc_X*3.9/1000*9.8,Acc_Y*3.9/1000*9.8,Acc_Z*3.9/1000*9.8);
      SendData(StrBuff,strlen((char *)StrBuff));
      DMAReadFlag=0;
	}
}

  最后楼主分享一个完整的代码，使用STM32F407读取ADXL345三轴加速度传感器数据，keil工程。
下载链接：
工程文件 SPI协议版本
工程文件 SPI+DMA协议版本

如有雷同，纯属我抄你，有问题可以直接联系邮箱，在个人资料里面。
张一西
关注
  • 22
    点赞
  • 踩
  • 121
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 15
    评论
专栏目录
ADXL345经验总结，采用SPI和I2C总线操作
weixin_34212189的博客
06-12 2662
一、ADXL345简介 ADXL345是ADI公司推出的三轴（x，y，z）iMEMS数字加速度计（digital accelerometer），具有在16G下高分辨率（13Bit）测量能力，同时具备16Bit数字输出。ADXL345 适用于静态倾角测量以及动态加速度测量，高达4mg/LSB的灵敏度允许测量小于1度的倾角。 该传感器还具备单击 /双击探测，自由落体探测，并允许用户设...
STM32:SPI驱动ADXL345
wangzibigan的博客
03-19 8270
ADXL345为3轴数字加速度计。支持SPI或I2C访问。网上例子大多是I2C,这里使用4线SPI。 一、遇过的坑 调试过程花了几个小时，遇到一些小坑。 1.开始的时候，无论如何都无法读取芯片ID。这可是最基础的一步啊，SPI，I2C都试过。无奈之下，对照原理图与手册的管脚说明，发现Vs接到地了。其实这个管脚要接电源电压。老实说，一看名字还以为要接地，毕竟一般IC接地脚名字为Vss。让硬件工...
《STM32开发指南》第三十四章 ADXL345三轴加速度传感器实验
04-14
ADXL345三轴加速度传感器实验《STM32开发指南》第三十四章 ADXL345三轴加速度传感器实验
【STM32 CubeMX】adxl345加速度传感器
最新发布
m0_62599305的博客
02-20 3118
本篇文章使用I2C进行通信在嵌入式系统中，加速度传感器是一种常见的传感器，用于检测物体的加速度或者倾斜角度。ADXL345是一款常用的数字三轴加速度传感器，由ADI（Analog Devices）公司制造。它具有高精度、低功耗和可编程的特点，因此在很多嵌入式应用中被广泛使用。本文将介绍如何在STM32 CubeMX中配置和使用ADXL345加速度传感器。本文简要介绍了如何在STM32 CubeMX中配置和使用ADXL345加速度传感器。
基于MSP430的ADXL345和ADXL355加速度IIC的读取.rar
12-25
开发工具是CCS9.1.0，MCU为MSP430FR2155，模拟IIC的方法读取ADXL345和355的加速度数值
dsp SPI 应用经验总结以及例程FIFO
05-23
实验通过，总结，与大家分享，dsp，spi f2812
FIFO和DMA
Bloom and Grow
11-21 1万+
FIFO   SPI端口增加了FIFO，使得传输数据有了缓冲区间。    FIFO存储器是一个先入先出的双口缓冲器，即第一个进入其内的数据第一个被移出，其中一个存储器的输入口，另一个口是存储器的输出口。主要有三个方面的作用：1）对连续的数据流进行缓存，防止在进机和存储操作时丢失数据；2）数据集中起来进行进机和存储，可避免频繁的总线操作，减轻CPU的负担；3）允许系统进行DMA操作，提高数据的传
STM32 SPI TX FIFO处理
sojojoso的专栏
04-15 4906
有没有遇到这种情况，在MCU 的SPI作为slave时，为了提高传输效率，提升速率，一般会提前将数据写入TX FIFO中，一般情况下不会出问题，但有些SPI Host 的波形不规范，例如下面： 在传输数据时会多发几个CLK，这会导致TX FIFO的数据传至移位寄存器中，会让MCU 的SPI 误以为数据已经发送； 这里几点需要注意： 1. STM32 的SPI Slave 在NSS 为unselected时，并不会处理TX FIFO的数据（清除）； 2. STM32 的TX FIFO 没找到对应的
sp1连续多字节传输
二进制模----细微行动改变影响世界
01-09 6068
SPI（Serial Peripheral Interface，串行外围设备接口）是由Motorola公司开发，用来在微控制器和外围设备芯片之间提供一个低成本、易使用的接口（SPI有时候也被称为4线接口）。这种接口可以用来连接存储器（存储数据）、A/D转换器、D/A转换器、实时时钟日历、LCD驱动器、传感器、音频芯片，甚至其他处理器。支持SPI的元件很多，并且还一直在增加。 SPI接口是在CPU...
STM32HAL库实现ADXL355加速度传感器简单记步功能（SPI）
qq_41777559的博客
04-10 7465
STM32HAL库实现ADXL355加速度传感器简单记步器功能（SPI） 文章目录STM32HAL库实现ADXL355加速度传感器简单记步器功能（SPI）一、硬件连接二、STM32CubeMx配置三、程序编写1.相关寄存器宏定义2.通过SPI向ADXL355写入一个字节的数据3.通过SPI 从 ADXL355读取一个字节的数据4.通过SPI 从 ADXL355读取3个字节的数据5.ADXL355 初始化6.ADXL355加速度数据转换7.ADXL355数据扫描8.定时器回调函数（TIM2设置10Hz的采
spi的fifo与dma接口配置
FishSuperBear博客
06-17 2803
spi端的配置 transmit fifo的watermark应尽可能低以确保传输次数少、总线利用率高，但同时要防止下溢风险。 同理，receive fifo的watermark应尽可能高，但同时防止上溢风险。 同时dma端的配置应尽量满足以下关系 dma write size = transmit fifo depth - transmit fifo watermark dma read size = receive fifo watermark ...
ADXL355(1)_adxl355_ADXL355例程_源码
10-04
ADXL355在STM32上的例程，包含SPI.C ADXL355.C Commend.c
F2812 spi fifo 调试总结
04-26
spi fifo 程序调试运行期间，不可间断，哪怕是用刷新一下寄存器的值也不 可以。因为，SPI的运行是以时钟为基准的，即便是很短暂的 延时或是外界干扰，也可能导致数据不正确。而你如果刷新一 下寄存器，在实时调试期间，无论程序运行在何处，都会有很 短暂的延时，对 DSP来说，不能忽略！
ADXL345三轴加速度传感器实验.rar
06-03
STM32驱动ADXL345加速度传感器的程序，IIC协议驱动，根据ADXL345不同的IIC地址，进行了说明。淘宝上购买的ADXL345模块可以直接使用。本人测试通过。 资料清单：战舰精英板直接可以用的程序+文档教程+说明
ADXL355.rar
12-15
适用于STM32F1系列平台，在STM32F103C8T6上跑没有问题 ADXL355是AD的三方向加速度传感器，具有分辨率高噪声小三种量程可选 驱动代码包括初始化，读取加速度值 void SPI_init(void);//初始哈 u8 SPI_read_one(u8 addr);//读寄存器 void SPI_write_cmd(u8 addr , u8 data);//写寄存器 void SPI_read_three_group(u8 addr,u32 *pol);//读一个方向加速度 void SPI_read_group(u8 addr, u32 *pool);//读三个方向加速度 资源包含：ADXL355 SPEC一份，驱动的.C/.H文件。代码有详细注释
verilog fpga SPI协议读取加速度计ADXL345
09-30
verilog语言 fpga 50Mhz时钟 1600Hz SPI协议读取加速度计ADXL345
基于STM32G071RBT的SPI读取ADXL357加速度和温度.rar
01-17
该工程是基于STM32G071RBT的,通过SPI读取ADXL357的三轴加速度和温度，SPI使用了DMA的方式，采样频率为1KHz，使用STM32CubeMX自带的滴答定时器,1ms采样1次，ADXL357的最大频率为4KHz
笔记本共享台式机上网
热门推荐
张一西的博客
10-14 2万+
笔记本共享台式机上网
UART 波特率选择的认识与理解
张一西的博客
09-24 2万+
UART 波特率的认识与理解
树莓派adxl345三轴加速度
09-12
树莓派adxl345是一种能够测量三个方向上加速度的传感器。这款传感器采用数字输出方式，可以通过树莓派的GPIO接口进行连接和通讯。 首先，我们需要将adxl345与树莓派连接起来。树莓派的GPIO引脚可以提供电源、地和数据传输线路。adxl345的电源引脚需要连接到树莓派的3.3V引脚，地引脚需要连接到树莓派的地引脚。数据传输线路包括SCL和SDA线路，可以连接到树莓派的相应GPIO引脚。 一旦连接完成，我们可以通过树莓派的Python编程语言来读取adxl345传感器的数据。首先，我们需要在树莓派上安装Python库ADXL345。可以使用pip命令执行安装。然后，我们可以通过导入ADXL345库来开始编写代码。 在代码中，我们需要初始化ADXL345传感器，并设置其工作模式和测量范围。接下来，我们可以使用read()函数来读取传感器的三轴加速度值。数据可以以g为单位表示。 最后，我们可以将这些读数用于树莓派的应用。例如，我们可以将其显示在连接的显示屏上，或者将其与其他传感器数据进行比较以实现更复杂的应用。 总结而言，树莓派adxl345是一种能够测量三轴加速度的传感器。通过将其与树莓派连接，并使用ADXL345库进行编程，我们可以读取传感器的数据并将其应用于树莓派的项目中。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 15
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

张一西

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值