STM32F4硬件IIC+DMA使用

最新推荐文章于 2024-07-06 18:47:57 发布
最新推荐文章于 2024-07-06 18:47:57 发布
阅读量2.1w 收藏 149
点赞数 27
分类专栏： STM32 文章标签： STM32F4硬件IIC STM32F4 DMA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24896591/article/details/86287443
版权

1.STM32硬件IIC一直被大家说存在问题，实际测试发现确实是有这种情况，借助网上很多人的经验，终于把硬件IIC写完了。

2.使用DMA时，发现发送数据（写寄存器）时序和实际不符，比如发送4字节数据时，如果DMA缓冲区单字节长度配置为4，则实际时序发现只有三个，需要将DMA缓冲区单字节长度配置为5，才可以正常使用

3.当然，如果使用STM32的HAL库，这些问题其实都可以避免，因为底层ST已经做了超时及错误的处理。

4.使用的IIC为自定义的格式，

写寄存器操作为：

START+ACK（从机的ACK信号）+IIC设备地址+（从机的ACK信号）+START+ACK（从机的ACK信号）+IIC写寄存器地址+ACK（从机的ACK信号）+IIC写数据（4Byte，每个数据后都有ACK）+STOP

读寄存器操作为：

START+ACK（从机的ACK信号）+IIC设备地址+（从机的ACK信号）+START+ACK（从机的ACK信号）+IIC读寄存器地址+ACK（从机的ACK信号）+IIC读数据（4Byte，前n个数据后都有（主机发送的）ACK,最后1byte数据后如果发ACK，表示还有数据要读，如果最后1byte数据后为NACK，后面紧接着就是停止位）+STOP

硬件IIC使用DMA还是不使用DMA，通过宏定义选择，代码如下：

#ifndef _hardiic_h
#define _hardiic_h

#ifdef __cplusplus
	extern "C"{
#endif		

#include "sys.h"




#define AT24Cxx_PageSize   8  //存储器块大小
#define I2C_TIME		       ((u32)65535)
    
#define DMA_USER            1  
    
#define HARD_IIC_USER       0  //是否使用硬件IIC而不使用DMA,现在不使用DMA正常，使用DMA连续读还是有问题
#define IIC_DMA_BUFF_LEN    4  
#define IIC_READ_DATA_REG_LEN   16
#define IIC_REV_BUFF_LEN    IIC_READ_DATA_REG_LEN
  
/**********全局宏定义，结构体，枚举等***********/
extern u8 IIC_DmaRevBuff[IIC_REV_BUFF_LEN];
extern u8 IIC_RevBuff[IIC_REV_BUFF_LEN];
extern u8 IIC_SendBuff[IIC_REV_BUFF_LEN];  
extern u8 g_ackFlag; 
extern u8 g_ackErrorFlag; 
    

void Hard_IIC_Init(u8 SlaveAdd);
void IIC_DmaInit(u8 SlaveAdd);    
void IIC_TxDmaConfig(u8 *pbuff, u8 len);
void IIC_RxDmaConfig(u8 *pbuff, u16 len, u8 it_mode); 

void I2C_DMA_Read(u8 SlaveAddr,u8 ReadAddr, u8 *err);
u32 I2C_DMA_ReadReg(u8 ReadAddr, u8 *err);

void I2C_DMA_ReadDataAddrReg(void);

void I2C_DMA_Write(u8 SlaveAddr, u8 WriteAddr,u32 DataToWrite, u8 *err);
void I2C_DMA_WriteReg(u8 WriteAddr,u32 DataToWrite, u8 *err);

void Hard_IICWaiteStandby(uint8_t SlaveAdd);

void IIC_DataRegToUart(void);

//void IIC_HardWriteOneWord(u8 SlaveAdd, u8 WriteAdd, u32 write_data, u8 * err);
//u32 IIC_HardReadOneWord(uint8_t SlaveAdd, u8 ReadAdd, u8 * err);
//void IIC_HardReadNWord(void);
/**
  ****************************** Support C++ **********************************
**/
#ifdef __cplusplus
	}
#endif
/**
  *****************************************************************************
**/


#endif  /* end hardiic.h */

#include "hardiic.h"
#include "iic_link.h"
#include "uart_cmd_handle.h"
#include "delay.h"
#include "uartfifo.h"
//#include "DMA.h"

u8 IIC_DmaRevBuff[IIC_REV_BUFF_LEN] = {0x00}; 
u8 IIC_RevBuff[IIC_REV_BUFF_LEN]  = {0x00};
u8 IIC_SendBuff[IIC_REV_BUFF_LEN] = {0x00};  
u8 g_ackFlag = 0; 
u8 g_ackErrorFlag = 0; 
u8 g_continuFlag = 0;
u8 g_readDataEvent = 0;

//硬件IIC初始化 
void Hard_IIC_Init(u8 SlaveAdd)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	I2C_InitTypeDef I2C_InitStructure;
	I2C_DeInit(I2C1);	
  
	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);
	
	GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_8 | GPIO_Pin_9;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF;
	GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
	GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_NOPULL;
	GPIO_Init(GPIOB, &GPIO_InitStructure);
	
	//管脚复用
	GPIO_PinAFConfig(GPIOB, GPIO_PinSource8, GPIO_AF_I2C1);
	GPIO_PinAFConfig(GPIOB, GPIO_PinSource9, GPIO_AF_I2C1);

	//配置IIC参数
	I2C_InitStructure.I2C_Mode                = I2C_Mode_I2C;
	I2C_InitStructure.I2C_DutyCycle           = I2C_DutyCycle_2;
	I2C_InitStructure.I2C_OwnAddress1         = SlaveAdd;  //从设备地址
	I2C_InitStructure.I2C_Ack                 = I2C_Ack_Enable;
	I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
	I2C_InitStructure.I2C_ClockSpeed          = 400000;  //SCL最大400KHz
	
	I2C_Cmd(I2C1, ENABLE);
//  I2C_ITConfig(I2C1, I2C_IT_EVT | I2C_IT_ERR , ENABLE);
	I2C_Init(I2C1, &I2C_InitStructure);
	I2C_AcknowledgeConfig(I2C1, ENABLE); 
  
	//禁止时钟延长
	I2C1->CR1 |= 0x80;
//	//允许时钟延长
//	I2C1->CR1 &= 0x7F;
}

硬件IIC DMA初始化
void IIC_DmaInit(u8 SlaveAdd)
{
	NVIC_InitTypeDef NVIC_InitStruct;

	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE);
  Hard_IIC_Init(SlaveAdd);

	NVIC_InitStruct.NVIC_IRQChannel                   = DMA1_Stream0_IRQn;
	NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0;
	NVIC_InitStruct.NVIC_IRQChannelSubPriority        = 0;
	NVIC_InitStruct.NVIC_IRQChannelCmd                = ENABLE;
	NVIC_Init(&NVIC_InitStruct);
  
	NVIC_InitStruct.NVIC_IRQChannel                   = DMA1_Stream6_IRQn;
	NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0;
	NVIC_InitStruct.NVIC_IRQChannelSubPriority        = 0;
	NVIC_InitStruct.NVIC_IRQChannelCmd                = ENABLE;
	NVIC_Init(&NVIC_InitStruct);

//	DMA_ClearFlag(DMA1_Stream6, DMA_FLAG_FEIF6 | DMA_FLAG_DMEIF6 | DMA_FLAG_TEIF6 |
//															DMA_FLAG_HTIF6 | DMA_FLAG_TCIF6);                              
//	DMA_Cmd(DMA1_Stream6, DISABLE);
//	DMA_DeInit(DMA1_Stream6);      
//	IIC_TxDmaConfig(IIC_SendBuff, IIC_BUFF_LEN); //IIC TX DMA初始化

//	DMA_ClearFlag(DMA1_Stream0, DMA_FLAG_FEIF0 | DMA_FLAG_DMEIF0 | DMA_FLAG_TEIF0 |
//															DMA_FLAG_HTIF0 | DMA_FLAG_TCIF0);
//	DMA_Cmd(DMA1_Stream0, DISABLE);
//	DMA_DeInit(DMA1_Stream0);
//	IIC_RxDmaConfig(IIC_RevBuff, IIC_BUFF_LEN); //IIC RX DMA初始化

//	DMA_ITConfig(DMA1_Stream6, DMA_IT_TC, ENABLE);
//	DMA_ITConfig(DMA1_Stream0, DMA_IT_TC, ENABLE);
  
//	I2C_DMACmd(I2C1, ENABLE);
}

void Hard_IICWaiteStandby(uint8_t SlaveAdd)
{
	u16 tmp = 0;
	
	I2C1->SR1 &= 0x0000;  //清除状态寄存器1
	
	do
	{
		I2C_GenerateSTART(I2C1, ENABLE);  //产生起始信号
		tmp = I2C1->SR1;  //读取SR1寄存器，然后写入数据寄存器操作来清除SB位，EV5
		I2C_Send7bitAddress(I2C1, SlaveAdd, I2C_Direction_Transmitter);  //发送从设备地址
	} while ((I2C1->SR1 & 0x0002) == 0x0000);  //当ADDR = 1时，表明应答了，跳出循环
	I2C_ClearFlag(I2C1, I2C_FLAG_AF);  //清除应答失败标志位
	I2C_GenerateSTOP(I2C1, ENABLE);  //发送停止信号
}

#if HARD_IIC_USER

//写一个寄存器
void I2C_DMA_WriteReg(u8 WriteAdd, u32 write_data, u8 * err)
{
	u16 sta = 0;
	u16 temp = 0;
  u8 NumToWrite = 4;
  u8 write_value = 0;
	
	while (I2C_GetFlagStatus(I2C1, I2C_FLAG_BUSY))  //等待IIC
	{
		temp++;
		if (temp > 800)
		{
			*err |= 1<<0;
			I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
			return;
		}
	}
	I2C_GenerateSTART(I2C1, ENABLE);  //产生起始信号
	temp = 0;
	//EV5
	while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT))
	{
		temp++;
		if (temp > 800)
		{
			*err |= 1<<1;
			I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
			return;
		}
	}
	I2C_Send7bitAddress(I2C1, IIC_LINK_ADDR, I2C_Direction_Transmitter);  //发送设备地址
	temp = 0;
	//EV6
	while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
	{
		temp++;
		if (temp > 1000)
		{
			*err |= 1<<2;
			I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
			return;
		}
	}
	//读取SR2状态寄存器
	sta = I2C1->SR2;  //软件读取SR1寄存器后,对SR2寄存器的读操作将清除ADDR位，不可少！！！！！！！！！
	I2C_SendData(I2C1, WriteAdd);  //发送存储地址
	temp = 0;
	//EV8
	while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING))
	{
		temp++;
		if (temp > 800)
		{
			*err |= 1<<3;
			I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
			return;
		}
	}
  
  I2C_GenerateSTART(I2C1, ENABLE);  //产生起始信号
	temp = 0;
	//EV5
	while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT))
	{
		temp++;
		if (temp > 800)
		{
			*err |= 1<<1;
			I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
			return;
		}
	}
	I2C_Send7bitAddress(I2C1, IIC_LINK_ADDR, I2C_Direction_Transmitter);  //发送设备地址
	temp = 0;
	//EV6
	while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
	{
		temp++;
		if (temp > 1000)
		{
			*err |= 1<<2;
			I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
			return;
		}
	}
	//读取SR2状态寄存器
	sta = I2C1->SR2;  //软件读取SR1寄存器后,对SR2寄存器的读操作将清除ADDR位，不可少！！！！！！！！！

	//循环发送数据
	while (NumToWrite)
	{
    NumToWrite--;
    write_value = (u8)(write_data>>(NumToWrite*8));
		I2C_SendData(I2C1, write_value);  //发送数据
		temp = 0;
		//EV8_2
		while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
		{
			temp++;
			if (temp > 800)
			{
				*err |= 1<<4;
				I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
				return;
			}
		}
	}
	I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
  Hard_IICWaiteStandby(IIC_LINK_ADDR);  //等待完成操作
}


u32 I2C_DMA_ReadReg(u8 ReadAdd, u8 * err)
{
	u16 i = 0;
	u16 sta = 0;
  u8 NumToRead = 4;
  u8 pbuff[4] = {0x00};
  u32 ret = 0;
	
	while (I2C_GetFlagStatus(I2C1, I2C_FLAG_BUSY))  //等待IIC
	{
		i++;
		if (i > 800)
		{
			*err |= 1<<0;
			I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
			return 0;
		}
	}
	I2C_GenerateSTART(I2C1, ENABLE);  //发送起始信号
	i = 0;
	//EV5
	while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT))
	{
		i++;
		if (i > 800)
		{
			*err |= 1<<1;
			I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
			return 0;
		}
	}
	I2C_Send7bitAddress(I2C1, IIC_LINK_ADDR, I2C_Direction_Transmitter);  //发送设备地址
	i = 0;
	//EV6
	while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
	{
		i++;
		if (i > 800)
		{
			*err |= 1<<2;
			I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
			return 0;
		}
	}
	sta = I2C1->SR2;  //软件读取SR1寄存器后,对SR2寄存器的读操作将清除ADDR位，不可少！！！！！！！！！
	I2C_SendData(I2C1, ReadAdd);  //发送存储地址
	i = 0;
	//EV8
	while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING))
	{
		i++;
		if (i > 2000)
		{
			*err |= 1<<3;
			I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
			return 0;
		}
	}
	I2C_GenerateSTART(I2C1, ENABLE);  //重启信号
	i = 0;
	//EV5
	while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT))
	{
		i++;
		if (i > 800)
		{
			*err |= 1<<4;
			I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
			return 0;
		}
	}
	I2C_Send7bitAddress(I2C1, IIC_LINK_ADDR, I2C_Direction_Receiver);  //读取命令
	i = 0;
	//EV6
	while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED))
	{
		i++;
		if (i > 800)
		{
			*err |= 1<<5;
			I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
			return 0;
		}
	}
	sta = I2C1->SR2;  //软件读取SR1寄存器后,对SR2寄存器的读操作将清除ADDR位，不可少！！！！！！！！！

	//批量接收数据
	while (NumToRead)
	{
		if (NumToRead == 1)  //最后一个数据了，不发送应答信号
		{
			I2C_AcknowledgeConfig(I2C1, DISABLE);  //发送NACK
			I2C_GenerateSTOP(I2C1, ENABLE);
		}
    //判断RxNE是否为1，EV7
		if (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED))
		{
      NumToRead--;
			pbuff[3-NumToRead] = I2C_ReceiveData(I2C1);
		}
	}
	I2C_AcknowledgeConfig(I2C1, ENABLE);
  ret = (pbuff[0]<<24) + (pbuff[1]<<16) + (pbuff[2]<<8) + pbuff[3];  
	return ret;
}

void I2C_DMA_ReadDataAddrReg(void)
{
	u16 i = 0;
  u8 sta;
  u8 NumToRead = 4;
  u8 pbuffer[IIC_READ_DATA_REG_LEN] = {0x00};
  u8 error = 0;
  
	Hard_IIC_Init(IIC_LINK_ADDR0);
  
	while (I2C_GetFlagStatus(I2C1, I2C_FLAG_BUSY))  //等待IIC
	{
		i++;
		if (i > 800)
		{
			error |= 1<<0;
			I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
			return;
		}
	}
	I2C_GenerateSTART(I2C1, ENABLE);  //发送起始信号
	i = 0;
	//EV5
	while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT))
	{
		i++;
		if (i > 800)
		{
			error |= 1<<1;
			I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
			return;
		}
	}
	I2C_Send7bitAddress(I2C1, IIC_LINK_ADDR, I2C_Direction_Transmitter);  //发送设备地址
	i = 0;
	//EV6
	while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
	{
		i++;
		if (i > 800)
		{
			error |= 1<<2;
			I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
			return;
		}
	}
	sta = I2C1->SR2;  //软件读取SR1寄存器后,对SR2寄存器的读操作将清除ADDR位，不可少！！！！！！！！！
	I2C_SendData(I2C1, 0xff);  //发送存储地址
	i = 0;
	//EV8
	while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING))
	{
		i++;
		if (i > 2000)
		{
			error |= 1<<3;
			I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
			return;
		}
	}
	I2C_GenerateSTART(I2C1, ENABLE);  //重启信号
	i = 0;
	//EV5
	while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT))
	{
		i++;
		if (i > 800)
		{
			error |= 1<<4;
			I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
			return;
		}
	}
	I2C_Send7bitAddress(I2C1, IIC_LINK_ADDR, I2C_Direction_Receiver);  //读取命令
	i = 0;
	//EV6
	while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED))
	{
		i++;
		if (i > 800)
		{
			error |= 1<<5;
			I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
			return;
		}
	}
	sta = I2C1->SR2;  //软件读取SR1寄存器后,对SR2寄存器的读操作将清除ADDR位，不可少！！！！！！！！！
 
//    DealDataFromUart1();
    error = 0;
    i=0;
    
    NumToRead = IIC_READ_DATA_REG_LEN;
    //批量接收数据
    while (NumToRead)
    {
      if(NumToRead == 1)  //最后一个数据了，不发送应答信号
      {
        I2C_AcknowledgeConfig(I2C1, DISABLE);  //发送NACK
        I2C_GenerateSTOP(I2C1, ENABLE);
      }
      //判断RxNE是否为1，EV7
      if (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED))
      {
        NumToRead--;
        pbuffer[i++] = I2C_ReceiveData(I2C1);
      }

    }
    
  for(i=0;i<IIC_READ_DATA_REG_LEN;i++) //数据放入缓冲区
  {
    IICinfifo_DataIn(pbuffer[i]);
  }
  IICinfifo_DataIn(error);
  g_readDataEvent = 1;
  
  I2C_AcknowledgeConfig(I2C1, ENABLE);  
}

#else

void IIC_TxDmaConfig(u8 *pbuff, u8 len)
{
  DMA_InitTypeDef DMA_InitStruct;
//  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE);
//  IIC_DmaInit(IIC_LINK_ADDR0);

  DMA_ClearFlag(DMA1_Stream6, DMA_FLAG_FEIF6 | DMA_FLAG_DMEIF6 | DMA_FLAG_TEIF6 |
															DMA_FLAG_HTIF6 | DMA_FLAG_TCIF6);                              
	DMA_Cmd(DMA1_Stream6, DISABLE);
//	DMA_DeInit(DMA1_Stream6); 
  while (DMA_GetCmdStatus(DMA1_Stream6) != DISABLE);
  
  DMA_InitStruct.DMA_Channel            = DMA_Channel_1;
	DMA_InitStruct.DMA_PeripheralBaseAddr = (u32)&I2C1->DR;   
	DMA_InitStruct.DMA_Memory0BaseAddr    = (u32)&pbuff[0];
	DMA_InitStruct.DMA_DIR                = DMA_DIR_MemoryToPeripheral;
	DMA_InitStruct.DMA_BufferSize         = len+1;//IIC_BUFF_LEN;
	DMA_InitStruct.DMA_PeripheralInc      = DMA_PeripheralInc_Disable;
	DMA_InitStruct.DMA_MemoryInc          = DMA_MemoryInc_Enable;
	DMA_InitStruct.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
	DMA_InitStruct.DMA_MemoryDataSize     = DMA_MemoryDataSize_Byte;
	DMA_InitStruct.DMA_Mode               = DMA_Mode_Normal;
	DMA_InitStruct.DMA_Priority           = DMA_Priority_VeryHigh;
	DMA_InitStruct.DMA_FIFOMode           = DMA_FIFOMode_Disable;
	DMA_InitStruct.DMA_FIFOThreshold      = DMA_FIFOThreshold_Full;
	DMA_InitStruct.DMA_MemoryBurst        = DMA_MemoryBurst_Single;
	DMA_InitStruct.DMA_PeripheralBurst    = DMA_PeripheralBurst_Single;
	DMA_Init(DMA1_Stream6, &DMA_InitStruct); 
  
  DMA_ITConfig(DMA1_Stream6, DMA_IT_TC|DMA_IT_TE, ENABLE);
  I2C_DMACmd(I2C1, ENABLE);
  
  while (DMA_GetCmdStatus(DMA1_Stream6) != DISABLE);
  DMA_Cmd(DMA1_Stream6, ENABLE);
}

void IIC_RxDmaConfig(u8 *pbuff, u16 len, u8 it_mode)
{
  DMA_InitTypeDef DMA_InitStruct;
//  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE);
//  IIC_DmaInit(IIC_LINK_ADDR0);
  
  DMA_Cmd(DMA1_Stream0, DISABLE);
  while (DMA_GetCmdStatus(DMA1_Stream0) != DISABLE);
//	DMA_DeInit(DMA1_Stream0); 
  
  DMA_InitStruct.DMA_Channel            = DMA_Channel_1;
	DMA_InitStruct.DMA_PeripheralBaseAddr = (u32)&I2C1->DR;   
	DMA_InitStruct.DMA_Memory0BaseAddr    = (u32)&pbuff[0];
	DMA_InitStruct.DMA_DIR                = DMA_DIR_PeripheralToMemory;
	DMA_InitStruct.DMA_BufferSize         = len;//IIC_BUFF_LEN;
	DMA_InitStruct.DMA_PeripheralInc      = DMA_PeripheralInc_Disable;
	DMA_InitStruct.DMA_MemoryInc          = DMA_MemoryInc_Enable;
	DMA_InitStruct.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
	DMA_InitStruct.DMA_MemoryDataSize     = DMA_MemoryDataSize_Byte;
	DMA_InitStruct.DMA_Mode               = DMA_Mode_Normal;
	DMA_InitStruct.DMA_Priority           = DMA_Priority_VeryHigh;
	DMA_InitStruct.DMA_FIFOMode           = DMA_FIFOMode_Disable;
	DMA_InitStruct.DMA_FIFOThreshold      = DMA_FIFOThreshold_Full;
	DMA_InitStruct.DMA_MemoryBurst        = DMA_MemoryBurst_Single;
	DMA_InitStruct.DMA_PeripheralBurst    = DMA_PeripheralBurst_Single;
	DMA_Init(DMA1_Stream0, &DMA_InitStruct); 

  DMA_ITConfig(DMA1_Stream0, DMA_IT_TC|DMA_IT_TE, ENABLE);
  
  I2C_DMACmd(I2C1, ENABLE);
  
  while (DMA_GetCmdStatus(DMA1_Stream0) != DISABLE);
  I2C_DMALastTransferCmd(I2C1, ENABLE);

  DMA_Cmd(DMA1_Stream0, ENABLE);
}

vu32 I2C_TimeCnt = I2C_TIME;

void I2C_DMA_Read(u8 SlaveAddr,u8 ReadAddr, u8 *err)
{
  u16 sta = 0;
 
  *err = 0;
  g_ackErrorFlag = 0;
  g_ackFlag = 0;
  g_continuFlag = 0; 
  
  IIC_DmaInit(IIC_LINK_ADDR0);
  
	I2C_TimeCnt = I2C_TIME;
	while(I2C_GetFlagStatus(I2C1, I2C_FLAG_BUSY))
  {
    if((I2C_TimeCnt--) == 0)
    {
      *err |= (0x01<<0);
      I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
			return ;
    }  
  }
  I2C_GenerateSTART(I2C1, ENABLE);
	I2C_TimeCnt = I2C_TIME;
	while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT))
	{
    if((I2C_TimeCnt--) == 0)
    {
      *err |= (0x01<<1);
      I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
      return ;
    }      
  }
  
	I2C_Send7bitAddress(I2C1, SlaveAddr, I2C_Direction_Transmitter);
	I2C_TimeCnt = I2C_TIME;
	while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)) //I2C_EVENT_MASTER_BYTE_TRANSMITTING
  {
    if((I2C_TimeCnt--) == 0)
    {
      *err |= (0x01<<2);
      I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
      return ;
    } 
  }
  sta = I2C1->SR2;  //软件读取SR1寄存器后,对SR2寄存器的读操作将清除ADDR位，不可少！！！！！！！！！
  I2C_SendData(I2C1, ReadAddr);
	I2C_TimeCnt = I2C_TIME;
	while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING))
  {
    if((I2C_TimeCnt--) == 0)
    {
      *err |= (0x01<<3);
      I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
      return ;
    } 
  }
  
	I2C_GenerateSTART(I2C1, ENABLE);
	I2C_TimeCnt = I2C_TIME;
	while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT))
  {
    if((I2C_TimeCnt--) == 0)
    {
      *err |= (0x01<<4);
      I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
      return ;
    }  
  }
	I2C_Send7bitAddress(I2C1, SlaveAddr, I2C_Direction_Receiver);

  I2C_TimeCnt = I2C_TIME;
  while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED))
  {
    if((I2C_TimeCnt--) == 0)
    {
      *err |= (0x01<<5);
      I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
      return ;
    }  
  }
  sta = I2C1->SR2;  //软件读取SR1寄存器后,对SR2寄存器的读操作将清除ADDR位，不可少！！！！！！！！！
  IIC_RxDmaConfig(IIC_DmaRevBuff, IIC_DMA_BUFF_LEN, 0); //IIC RX DMA初始化
}

u32 I2C_DMA_ReadReg(u8 ReadAddr, u8 *err)
{
  u32 temp = 0;
  
	I2C_DMA_Read(IIC_LINK_WRITE_MODE, ReadAddr, err);

	I2C_TimeCnt = I2C_TIME;
  while(g_ackFlag==0)
  {
    if((I2C_TimeCnt--) == 0) 
    {
      *err |= (0x01<<6);
      break;
    }
  }
  *err |= (g_ackErrorFlag<<7);
  temp = (IIC_DmaRevBuff[0]<<24) + (IIC_DmaRevBuff[1]<<16) + (IIC_DmaRevBuff[2]<<8) + IIC_DmaRevBuff[3];  
	return temp;
}

//连续读数据
void I2C_DMA_ReadDataAddrReg(void)
{
  u16 sta = 0;

  g_ackErrorFlag = 0;
  g_ackFlag = 0;
  
  IIC_DmaInit(IIC_LINK_ADDR0);
  
	I2C_TimeCnt = I2C_TIME;
	while(I2C_GetFlagStatus(I2C1, I2C_FLAG_BUSY))
  {
    if((I2C_TimeCnt--) == 0)
    {
      g_ackErrorFlag |= (0x01<<0);
      I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
			return ;
    }  
  }
  I2C_GenerateSTART(I2C1, ENABLE);
	I2C_TimeCnt = I2C_TIME;
	while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT))
	{
    if((I2C_TimeCnt--) == 0)
    {
      g_ackErrorFlag |= (0x01<<1);
      I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
      return ;
    }      
  }
  
	I2C_Send7bitAddress(I2C1, IIC_LINK_WRITE_MODE, I2C_Direction_Transmitter);
	I2C_TimeCnt = I2C_TIME;
	while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)) //I2C_EVENT_MASTER_BYTE_TRANSMITTING
  {
    if((I2C_TimeCnt--) == 0)
    {
      g_ackErrorFlag |= (0x01<<2);
      I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
      return ;
    } 
  }
  sta = I2C1->SR2;  //软件读取SR1寄存器后,对SR2寄存器的读操作将清除ADDR位，不可少！！！！！！！！！
  I2C_SendData(I2C1, 0xff);
	I2C_TimeCnt = I2C_TIME;
	while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING))
  {
    if((I2C_TimeCnt--) == 0)
    {
      g_ackErrorFlag |= (0x01<<3);
      I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
      return ;
    } 
  }
  
	I2C_GenerateSTART(I2C1, ENABLE);
	I2C_TimeCnt = I2C_TIME;
	while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT))
  {
    if((I2C_TimeCnt--) == 0)
    {
      g_ackErrorFlag |= (0x01<<4);
      I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
      return ;
    }  
  }
	I2C_Send7bitAddress(I2C1, IIC_LINK_WRITE_MODE, I2C_Direction_Receiver);

  I2C_TimeCnt = I2C_TIME;
  while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED))
  {
    if((I2C_TimeCnt--) == 0)
    {
      g_ackErrorFlag |= (0x01<<5);
      I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
      return ;
    }  
  }

  sta = I2C1->SR2;  //软件读取SR1寄存器后,对SR2寄存器的读操作将清除ADDR位，不可少！！！！！！！！！
  g_continuFlag = 1;  //连续读取标志
  g_readDataEvent = 0;
  IIC_RxDmaConfig(IIC_DmaRevBuff, IIC_READ_DATA_REG_LEN,0); //IIC RX DMA初始化 
  
  I2C_TimeCnt = I2C_TIME;
  while(g_ackFlag==0)
  {
    if((I2C_TimeCnt--) == 0) 
    {
      break;
    }
  }
//  delay_ms(10);
   
//      goto HARD_IIC_LOOP2;
//        DMA_Cmd(DMA1_Stream0, DISABLE);                      //关闭DMA传输 
//        while (DMA_GetCmdStatus(DMA1_Stream0) != DISABLE){}	//确保DMA可以被设置  
//        DMA_MemoryTargetConfig(DMA1_Stream0, (u32)&IIC_RevBuff[0], DMA_Memory_0);
//        DMA_SetCurrDataCounter(DMA1_Stream0, IIC_DMA_BUFF_LEN-1);          //数据传输量  
//        DMA_Cmd(DMA1_Stream0, ENABLE);                      //开启DMA传输     

}

void I2C_DMA_Write(u8 SlaveAddr, u8 WriteAddr,u32 DataToWrite, u8 *err)
{
  u16 sta;
  *err = 0;
  g_ackErrorFlag = 0;
  g_ackFlag = 0;
 
  IIC_DmaInit(IIC_LINK_ADDR0);
  
	I2C_TimeCnt = I2C_TIME;
	while(I2C_GetFlagStatus(I2C1, I2C_FLAG_BUSY))
  {
    if((I2C_TimeCnt--) == 0)
    {
      *err |= (0x01<<0);
      I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
			return;
      
    }   
  }
  
	I2C_GenerateSTART(I2C1, ENABLE);
	I2C_TimeCnt = I2C_TIME;
	while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT))
	{
    if((I2C_TimeCnt--) == 0)
    {
      *err |= (0x01<<1);
      I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
			return;
    }      
  }
  
	I2C_Send7bitAddress(I2C1, SlaveAddr, I2C_Direction_Transmitter);
	I2C_TimeCnt = I2C_TIME;
	while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)) //I2C_EVENT_MASTER_BYTE_TRANSMITTING
  {
    if((I2C_TimeCnt--) == 0)
    {
      *err |= (0x01<<2);
      I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
			return;
    } 
  }
  sta = I2C1->SR2;  //软件读取SR1寄存器后,对SR2寄存器的读操作将清除ADDR位，不可少！！！！！！！！！
  I2C_SendData(I2C1, WriteAddr);
	I2C_TimeCnt = I2C_TIME;
	while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING))
  {
    if((I2C_TimeCnt--) == 0)
    {
      *err |= (0x01<<3);
      I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
			return;
    } 
  }
  I2C_GenerateSTART(I2C1, ENABLE);

	I2C_TimeCnt = I2C_TIME;
	while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT))
  {
    if((I2C_TimeCnt--) == 0)
    {
      *err |= (0x01<<4);
      I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
			return;
    }  
  }
	I2C_Send7bitAddress(I2C1, SlaveAddr, I2C_Direction_Transmitter);
  sta = I2C1->SR2;  //软件读取SR1寄存器后,对SR2寄存器的读操作将清除ADDR位，不可少！！！！！！！！！
  I2C_TimeCnt = I2C_TIME;
  while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
  {
    if((I2C_TimeCnt--) == 0)
    {
      *err |= (0x01<<5);
      I2C_GenerateSTOP(I2C1, ENABLE);  //产生停止信号
			return;
    }  
  }
  
  IIC_SendBuff[0] = (DataToWrite>>24)&0xff;
  IIC_SendBuff[1] = (DataToWrite>>16)&0xff;
  IIC_SendBuff[2] = (DataToWrite>>8)&0xff;
  IIC_SendBuff[3] = (DataToWrite>>0)&0xff;
	IIC_TxDmaConfig(IIC_SendBuff, IIC_DMA_BUFF_LEN); //IIC TX DMA初始化
}


void I2C_DMA_WriteReg(u8 WriteAddr,u32 DataToWrite, u8 *err)
{
	I2C_DMA_Write(IIC_LINK_WRITE_MODE, WriteAddr, DataToWrite, err);
  I2C_TimeCnt = I2C_TIME;
  while(g_ackFlag==0)
  {
    if((I2C_TimeCnt--) == 0) 
    {
      *err |= (0x01<<4);
      break;
    }
  }
  *err |= (g_ackErrorFlag<<5);
//  Hard_IICWaiteStandby(IIC_LINK_ADDR);  //等待完成操作
	return;
}


void DMA1_Stream6_IRQHandler( void )
{
	if(DMA_GetFlagStatus(DMA1_Stream6, DMA_FLAG_TCIF6) != RESET)  //传输完成中断
  {
		DMA_Cmd(DMA1_Stream6, DISABLE);
		DMA_ClearFlag(DMA1_Stream6, DMA_FLAG_TCIF6);

		I2C_TimeCnt = I2C_TIME;
		while(!I2C_GetFlagStatus(I2C1, I2C_FLAG_BTF))
    {
      if((I2C_TimeCnt--) == 0) 
      {
        g_ackErrorFlag = 1;
      }
      break;
    }
    
		I2C_GenerateSTOP(I2C1, ENABLE);
    g_ackErrorFlag = 0;
    g_ackFlag = 1;
	}
  else if(DMA_GetITStatus(DMA1_Stream6,DMA_IT_TEIF6) != RESET) //传输失败中断
  {
    DMA_Cmd(DMA1_Stream6, DISABLE);
    DMA_ClearITPendingBit(DMA1_Stream6,DMA_IT_TEIF6);
    I2C_GenerateSTOP(I2C1, ENABLE);
    g_ackErrorFlag = 1;
    g_ackFlag = 1;
  }

}

void DMA1_Stream0_IRQHandler( void )
{
  u8 i=0;
	if(DMA_GetFlagStatus(DMA1_Stream0, DMA_FLAG_TCIF0) != RESET) 
  {
    DMA_Cmd(DMA1_Stream0, DISABLE);
    DMA_ClearFlag(DMA1_Stream0, DMA_FLAG_TCIF0);
    I2C_GenerateSTOP(I2C1, ENABLE);
    if(g_continuFlag == 1) //连续读数据
    {
      for(i=0; i<IIC_READ_DATA_REG_LEN; i++)
      {
        IICinfifo_DataIn(IIC_DmaRevBuff[i]);
        IIC_DmaRevBuff[i] = 0;
      }  
      IICinfifo_DataIn(g_ackErrorFlag);
    }

    g_ackErrorFlag = 0;
    g_ackFlag = 1; 
    g_readDataEvent = 1;
    
	}
//  else if(DMA_GetITStatus(DMA1_Stream0,DMA_IT_HTIF0) != RESET)  //半传输完成中断
//  {
//    DMA_Cmd(DMA1_Stream0, DISABLE);
//    DMA_ClearITPendingBit(DMA1_Stream0,DMA_IT_HTIF0);	
//    g_ackErrorFlag = 0;
//    g_ackFlag = 1;
//  }
  else if(DMA_GetITStatus(DMA1_Stream0,DMA_IT_TEIF0) != RESET) //传输失败中断
  {
    DMA_Cmd(DMA1_Stream0, DISABLE);
    DMA_ClearITPendingBit(DMA1_Stream0,DMA_IT_TEIF0);
    I2C_GenerateSTOP(I2C1, ENABLE);
    g_ackErrorFlag = 1;
    g_ackFlag = 1;
  }

}

#endif

void IIC_DataRegToUart(void)
{
  u8 i, j;
  u8 pbuffer[IIC_READ_DATA_REG_LEN+10] = {0x00};

  while(g_readDataEvent!=1){}
  
    while(IICinfifo_HaveData() != 0)
    {
      i=0;
      pbuffer[i++] = 0x30;
      pbuffer[i++] = 0xff;   
      for(j=0;j<(IIC_READ_DATA_REG_LEN+1);j++)
      {
        pbuffer[i++] = IICinfifo_DataOut();
      }  
      UART1_SendCmdData(pbuffer, i);  
      delay_ms(10);
    }  
  
}

int main(void)
{
  u8 error=0;
  u32 jiCunQi_data = 0;
  
  IIC_DmaInit(IIC_LINK_ADDR0);
  
  //寄存器0x02,写0x00000001
  I2C_DMA_WriteReg(0x02, 0x00000001, &error);
  
  //读0x02寄存器
  jiCunQi_data = I2C_DMA_ReadReg(0x02, &error);
  while(1);
}

 

妥妥的藏马
关注
  • 27
    点赞
  • 踩
  • 149
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
STM32F4 DMA
beijxin0g的博客
11-28 2211
DMA是一个搬运工。
stm32f4硬件IIC读取MPU6050数据
weixin_45829708的博客
08-25 4067
stm32f4硬件IIC读取MPU6050数据 ** JY901B 串口10轴加速度计 MK695** stm32f4“硬件协议”方式，STM32 的I2C 片上外设专门负责实现I2C 通讯协议，只要置好该外设，它就会自动 根据协议要求产生通讯信号，收发数据并缓存起来，CPU 只要检测该外设的状态和访问数据寄存器，就能完 成数据收发。这种由硬件外设处理I2C 协议的方式减轻了CPU 的工作，且使软件设计更加简单。不需要关心 底层的设计。 I2C 通讯协议 I2C 通讯协议(Inter － Inte
STM32硬件IIC之DMA传输数据
热门推荐
shixiongtao的博客
12-19 1万+
这里给出一个实现用DMA传输IIC数据的实现过程 这里咱们说3个点 1.检查IIC总线上是否有指定地址的器件 2.IIC读取数据 3.IIC写数据 下面来一个一个详细说明1.检查IIC总线上是否有指定地址的器件1.判断是否总线忙，如果忙则等待 2.产生起始位 3.等待起始位产生完成 4.发送器件地址(这里选择读写都是可以的) 5.等待是否有ACK位回应,(这里有两种判断方法1.通过判断ACK
STM32使用TIM2+DMA产生PWM波形异常分析
u014319604的博客
03-16 668
使用 STM32F4 的 TIM2 结合 DMA，产生的 PWM 波形不符合预期，但是相同的配置使用在 IM3 上，得到的 PWM 波形就是符合预期的。其代码和配置都是从 F1 移植过来的，在 F1 上使用 TIM2 是没有问题的，对于 F4 的 TIM2 发生的问题，客户一直没有找到根本原因。
STMF4 硬件IIC（天空星开发板）
最新发布
weixin_62292999的博客
07-06 1258
下面只介绍不同的部分。使用宏定义，去写代码，这种函数是能够提升程序的执行速度，因为宏定义是预处理指令，在程序执行前，开始执行的，如果是将函数在次封装在调用，这种程序执行速度是比不上，宏定义。，硬件IIC效率远高于软件IIC， STMF4VET6上带有3个硬件IIC，允许与外部IIC接口进行通信，STMF4的硬件IIC使用特定的引脚复位，来进行数据和时钟信号的传输。来传输数据还有时序信号，达到IIC通信的效果目的，软件IIC通信好处是，在MCU内部没有集成硬件IIC电路的时候，可以使用软件IIC通信，
【STM32 CubeMX】I2C中断方式与DMA方式
m0_62599305的博客
02-16 3655
在STM32 CubeMX环境中，I2C（Inter-Integrated Circuit）通信协议的实现可以采用中断方式或DMA（Direct Memory Access）方式。中断方式通过触发中断来处理数据传输，而DMA方式则利用直接内存访问技术来实现数据传输，减轻了CPU的负担。在选择I2C通信方式时，开发者需要根据具体的应用需求和性能要求来选择合适的方式。STM32 CubeMX提供了图形化配置工具，使得配置I2C通信方式变得更加便捷。
stm32f4硬件iic程序
08-25
stm32f4硬件iic程序，已封装成库，直接调用库函数即可，不需要关心底层开发 亲测有效
STM32F4 硬件I2C 使用DMA
05-27
STM32F4 硬件I2C 使用DMA 測試過OK
STM32F4 硬件IIC的使用
保持每天的清醒
06-06 986
硬件平台:STM32F29IG (阿波罗F4开发板) 硬件IIC
STM32F4 I2C/IIC 驱动程序
01-25
STM32F4的I2C配置，已经写好了读函数可写函数，由I2C.c和I2C.h组成，直接可用
OLED 硬件IIC + DMA +framebuffer.zip
05-13
程序是基于正点原子STM32F407开发的，使用的OLED是中景园的0.96寸OLED （IIC协议版本） 程序可以实现字符串数字的显示以及反白显示，另外还带有改编的 画点划线 画圆画矩形的函数 可以进行简单的图形绘制 程序使用...
stm32 的I2C-DMA实现
06-15
stm32的硬件I2C+DMA实现 可以修改适合各种系列的stmcu 学习用
STM32F4系列单片机硬件i2c驱动C语言源码
03-10
STM32F4系列的硬件I2C读写函数(配合之前上传的MPU9250源码一起使用)。可以读写EEPROM,MPU9250,MS5611,BMP280等等I2C器件的数据。智能中断机制，即使地址不对或没有对应地址的器件连接，程序也不会卡死，中断返回即可。不要小看代码不多，其实它的功能很强大，这是我成熟的飞控程序的一部分，可以稳定飞行。
关于STM32的I2C硬件DMA实现
07-31
网上看到很多说STM32的I2C很难用，但我觉得还是理解上的问题，STM32的I2C确实很复杂，但只要基础牢靠，并没有想象中的那么困难。
stm32f4硬件i2c读取ms5611
07-05
stm32f4硬件i2c读取ms5611气压计，通过串口发送到电脑
STM32 IIC 状态机 DMA 控制MPU60x0和burst读取MPU6050 FIFO
10-25
STM32状态机架构 通过 硬件IIC外设 和DMA burst 读取MPU6050的 FIFO， 每10ms Timer触发一次routine work trigger进行数据采集。DMA直接读取MPU6050的FIFO并对三轴加速度和三轴陀螺仪的数据取平均值，高速，高效，剩下的系统资源可以拿来做姿态运算； 稍微加入IIC rescure 便可商业应用，当然如果有硬件IIC rescure更好 附送模拟IO操作IIC控制MPU6050，只需要重新define一下； 附送UART硬件DMA print 附送LM75A的硬件IIC操作，只需要在Timer的中断里面根据你的需要时间间隔触发一下
STM32硬件IIC主机例程（以读写EEPROM为例）
04-19
在STM32中，硬件IIC（Inter-Integrated Circuit，也称为I²C）接口是实现设备间通信的重要方式，特别适合低速、短距离的数据传输，如连接EEPROM、传感器等外围设备。本文将详细介绍如何在STM32上配置硬件IIC主机，并...
stm32f405的IIC读写程序
07-26
- `stm32f4xx_hal_i2c.c/h`：STM32 HAL库中的IIC驱动源代码和头文件，提供了与硬件交互的底层接口。 - `main.c`：项目的主要入口文件，通常包含IIC的初始化和实际读写操作。 - `i2c_helpers.c/h`：辅助函数，用于...
【STM32】CubeMX+HAL库之 硬件IIC+DMA控制OLED(兼容SSD1306&SH1106驱动)
weixin_45065888的博客
06-25 1万+
【STM32】CubeMX+HAL库之 硬件IIC+DMA控制1.3寸OLED 前言 目前网上大多数驱动OLED屏都采用软件IIC，因为HAL库的升级使得硬件IIC的稳定性得到了保障，所以想采用硬件IIC+DMA的方式控制OLED，在最初的时候，换用硬件IIC极其的方便，换到HAL库的接口函数就好了，但打开DMA就炸，仔细想了一下，知道原因 （由于DMA为非阻塞模式，反复调用函数但硬件并未准备好，所以并未执行） 经过拼包DMA发送,CPU的负担大幅降低，显示效果良好。 下文从CubeMX的配置开始说起，并
stm32f103 iic+dma发送和接收
10-29
STM32F103是意法半导体推出的一款高性能Cortex-M3内核的32位微控制器，具有丰富的外设资源，包括IIC接口和DMA功能。下面将简要介绍STM32F103中IIC和DMA的发送和接收操作。 首先，IIC接口是一种具有高速度和广泛应用的串行通信接口，适用于微控制器与外设之间的数据传输。STM32F103的IIC接口支持主机和从机模式，并能够通过硬件I2C控制器配置和驱动IIC外设。 在STM32F103中，使用DMA（Direct Memory Access）可以在不占用CPU资源的情况下实现数据的高速传输。DMA控制器是一种特殊的硬件设备，可以在外设和存储器之间直接传输数据，提高数据传输效率。 具体实现IIC和DMA的发送和接收操作的步骤如下： 发送操作： 1. 配置IIC的发送模式和相关参数，包括传输速率、地址等。 2. 配置DMA控制器，指定源数据地址和目标寄存器地址，并设置传输长度和传输方向。 3. 启动DMA传输并等待传输完成。 接收操作： 1. 配置IIC的接收模式和相关参数，包括传输速率、地址等。 2. 配置DMA控制器，指定源寄存器地址和目标数据地址，并设置传输长度和传输方向。 3. 启动DMA传输并等待传输完成。 4. 读取目标数据地址中的接收数据。 需要注意的是，使用DMA进行数据传输需要合理配置DMA通道和中断，可以通过DMA中断来判断传输是否完成，并及时处理传输结果。 综上所述，通过配置IIC接口和DMA控制器，可以实现在STM32F103上进行IIC数据的高速发送和接收操作，提高数据传输效率和系统性能。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值