分享DS18B20单线式温度测量利用stm32cubemx的配置和完整程序代码,芯片是stm32f407

admin 发表了文章 • 9 个评论 • 4148 次浏览 • 2014-12-19 16:03 • 来自相关话题

今天去某coocox论坛,看到有人问DS18B20怎么使用,才想起来以前生成并测试过此代码
其实早就分享到了本站的资源下载里面了.
这两天也没分享和研究过什么代码,只好把它拿出来了,呵呵
代码没什么特别的,很普通的代码,关键问题是要知道单线式芯片的使用方法,知道了这个编写代码也简单
有兴趣的可以去搜搜这个片子的资料,类似这种片子还不少,使用方法大致相同
下面说说用软件stm32cubemx怎么配置和生成代码后怎么使用
本站利用管脚PA2来实现功能,只需将PA2管脚定义为[输出,无上拉,快速]模式就行了,
我这里利用usart来输出读取的温度值,故还需配置下usart1串口,串口配置暂且不提了,以前帖子里面写了很多了
生成代码后,打开工程,添加ds18b20的驱动程序,如下:
文件名: ds18b20.c


#include "ds18b20.h"
#include "delay.h"

//复位DS18B20
void DS18B20_Rst(void)
{
CLR_DS18B20(); //拉低DQ
delay_us(750); //拉低750us
SET_DS18B20();; //DQ=1
delay_us(15); //15US
}


//等待DS18B20的回应
//返回1:未检测到ds18b20的存在
//返回0:存在
uint8_t DS18B20_Check(void)
{
uint8_t retry=0;

while (DS18B20_DQ_IN&&retry<200)
{
retry++;
delay_us(1);
};
if(retry>=200)return 1;
else retry=0;
while (!DS18B20_DQ_IN&&retry<240)
{
retry++;
delay_us(1);
};
if(retry>=240)return 1;
return 0;
}


//从DS18B20读取一个位
//返回值:1/0
uint8_t DS18B20_Read_Bit(void) // read one bit
{
uint8_t data;

CLR_DS18B20(); //拉低DQ
delay_us(2);
SET_DS18B20();; //DQ=1
delay_us(12);
if(DS18B20_DQ_IN)data=1;
else data=0;
delay_us(50);

return data;
}


//从ds18b20读取一个字节
//返回值:读取到的数据
uint8_t DS18B20_Read_Byte(void) // read one byte
{
uint8_t i,j,dat;
dat=0;

for (i=1;i<=8;i++)
{
j=DS18B20_Read_Bit();
dat=(j<<7)|(dat>>1);
}
return dat;
}

//*本程序由 www.stm32cube.com 提供
//写一个字节到DS18B20
//dat:要写入的字节
void DS18B20_Write_Byte(uint8_t dat)
{
uint8_t j;
uint8_t testb;

for (j=1;j<=8;j++)
{
testb=dat&0x01;
dat=dat>>1;
if (testb)
{
CLR_DS18B20(); //DS18B20_DQ_OUT=0;// Write 1
delay_us(2);
SET_DS18B20(); //DS18B20_DQ_OUT=1;
delay_us(60);
}
else
{
CLR_DS18B20(); //DS18B20_DQ_OUT=0;// Write 0
delay_us(60);
SET_DS18B20(); //DS18B20_DQ_OUT=1;
delay_us(2);
}
}
}


//开始温度转换
void DS18B20_Start(void)// ds1820 start convert
{
DS18B20_Rst();
DS18B20_Check();
DS18B20_Write_Byte(0xcc);// skip rom
DS18B20_Write_Byte(0x44);// convert
}


//初始化DS18B20的IO口DQ同时检查DS的存在
//返回1:不存在
//返回0:存在
uint8_t DS18B20_Init(void)
{
//配置PA2口
GPIO_InitTypeDef GPIO_InitStruct;

/[i] GPIO Ports Clock Enable [/i]/
__GPIOA_CLK_ENABLE();

/[i]Configure GPIO pin : PA2 [/i]/
GPIO_InitStruct.Pin = DS18B20_BIT;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FAST;
HAL_GPIO_Init(DS18B20_PORT, &GPIO_InitStruct);

SET_DS18B20(); //使PA2输出高电平

DS18B20_Rst();
return DS18B20_Check();
}


//从ds18b20得到温度值
//精度:0.1C
//返回值:温度值(-550~1250)
short DS18B20_Get_Temp(void)
{
uint8_t temp;
uint8_t TL,TH;
short tem;

DS18B20_Start (); // ds1820 start convert
DS18B20_Rst();
DS18B20_Check();
DS18B20_Write_Byte(0xcc);// skip rom
DS18B20_Write_Byte(0xbe);// convert
TL=DS18B20_Read_Byte(); // LSB
TH=DS18B20_Read_Byte(); // MSB

if(TH>7)
{
TH=~TH;
TL=~TL;
temp=0; //温度为负值
}else temp=1; //温度为正
tem=TH; //获得高8位
tem<<=8;
tem+=TL; //获得低8位
tem=(float)tem*0.625; //转换
if(temp)return tem; //返回温度值
else return -tem;
}



文件名: ds18b20.h


#ifndef __DS18B20_H
#define __DS18B20_H
#include "stm32f4xx_hal.h"


#define DS18B20_BIT GPIO_PIN_2
#define DS18B20_PORT GPIOA

#define CLR_DS18B20() HAL_GPIO_WritePin (DS18B20_PORT,DS18B20_BIT,GPIO_PIN_RESET )
#define SET_DS18B20() HAL_GPIO_WritePin (DS18B20_PORT,DS18B20_BIT,GPIO_PIN_SET )

#define DS18B20_DQ_IN HAL_GPIO_ReadPin(DS18B20_PORT, DS18B20_BIT)


uint8_t DS18B20_Init(void); //初始化DS18B20
short DS18B20_Get_Temp(void); //获取温度
void DS18B20_Start(void); //开始温度转换
void DS18B20_Write_Byte(uint8_t dat);//写入一个字节
uint8_t DS18B20_Read_Byte(void); //读出一个字节
uint8_t DS18B20_Read_Bit(void); //读出一个位
uint8_t DS18B20_Check(void); //检测是否存在DS18b20
void DS18B20_Rst(void); //复位DS18B20

#endif


文件名: delay.c


#include "delay.h"

/***************************************************************************
*函数名:delay_nus()
*参数u32 n 时钟延时的微妙数
*返回值:void
*功能:使用系统节拍时钟精准延时n个微妙函数
*本程序由 www.stm32cube.com 提供
*****************************************************************************/
void delay_us(uint32_t value)
{
uint32_t i;
i = value * 50;
while(i--);
}

文件名:delay.h


#ifndef __DELAY_H
#define __DELAY_H
#include "stm32f4xx_hal.h"
/***************************************************************************
*函数名:delay_nus()
*参数u32 n 时钟延时的微妙数
*返回值:void
*功能:使用系统节拍时钟精准延时n个微妙函数
*本程序由 www.stm32cube.com 提供
*****************************************************************************/
void delay_us(uint32_t value);

#endif



以上是ds18b20所要使用的驱动程序文件,将这两个c文件添加至工程中
在main.c文件中
添加ds18b20的驱动头文件和uart的printf函数栈定义


/[i] USER CODE BEGIN 0 [/i]/
#include "ds18b20.h"
#include "stdio.h"
#ifdef __GNUC__
/* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf
set to 'Yes') calls __io_putchar() */
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif /[i] __GNUC__ [/i]/

/**
* @brief Retargets the C library printf function to the USART.
* @param None
* @retval None
*/
PUTCHAR_PROTOTYPE
{
/[i] Place your implementation of fputc here [/i]/
/[i] e.g. write a character to the EVAL_COM1 and Loop until the end of transmission [/i]/
HAL_UART_Transmit(&huart1 , (uint8_t *)&ch, 1, 0xFFFF);
return ch;
}
/[i] USER CODE END 0 [/i]/


主函数mian()中是以下代码
int main(void)
{

/ USER CODE BEGIN 1 /
short temp;
/ USER CODE END 1 /

/ MCU Configuration----------------------------------------------------------/

/ Reset of all peripherals, Initializes the Flash interface and the Systick. /
HAL_Init();

/ Configure the system clock /
SystemClock_Config();

/ System interrupt init/
/ Sets the priority grouping field /
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_0);
HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);

/ Initialize all configured peripherals /
MX_GPIO_Init();
MX_USART1_UART_Init();

/ USER CODE BEGIN 2 /
printf ("start:\r\n");

while(DS18B20_Init()) //初始化并检测18B20
{
printf ("DS18B20 Check Failed!");
HAL_Delay (500);
printf ("Please Check!");
HAL_Delay (500);
}




/ USER CODE END 2 /

/ USER CODE BEGIN 3 /
/ Infinite loop /
while (1)
{
HAL_Delay (500);
HAL_GPIO_TogglePin (GPIOF ,GPIO_PIN_6 ); //闪烁led指示程序运行正常
temp=DS18B20_Get_Temp();//获取温度值
printf ("Temperate:%d \r\n",temp );//输出得到的温度值到终端
}
/ USER CODE END 3 /

}
编译,后运行,串口调试助手里面会显示测量的温度值........
注意啊,ds18b20.c文件里面
uint8_t DS18B20_Init(void)
{

GPIO_InitTypeDef GPIO_InitStruct;

/ GPIO Ports Clock Enable /
__GPIOA_CLK_ENABLE();

/Configure GPIO pin : PA2 /
GPIO_InitStruct.Pin = DS18B20_BIT;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FAST;
HAL_GPIO_Init(DS18B20_PORT, &GPIO_InitStruct);

SET_DS18B20(); //ʹGPIOAµÄPin_2Êä³ö¸ßµçƽ

DS18B20_Rst();
return DS18B20_Check();
}
这个代码,上面初始化的部分由于stm32cubemx生成的时候已经初始化了,可以删掉...额
我是直接把初始化的这个剪切到了这里
如果你要用以上的代码在其他端口,只需要修改ds18b20.h中的
#define DS18B20_BIT GPIO_PIN_2
#define DS18B20_PORT GPIOA
这个就可以了.
最简洁的办法是,不要用stm32cubemx定义你准备使用的连接到ds18b20的管脚,
到时候用的时候直接来这个h文件里面修改!
结束! 查看全部
今天去某coocox论坛,看到有人问DS18B20怎么使用,才想起来以前生成并测试过此代码
其实早就分享到了本站的资源下载里面了.
这两天也没分享和研究过什么代码,只好把它拿出来了,呵呵
代码没什么特别的,很普通的代码,关键问题是要知道单线式芯片的使用方法,知道了这个编写代码也简单
有兴趣的可以去搜搜这个片子的资料,类似这种片子还不少,使用方法大致相同
下面说说用软件stm32cubemx怎么配置和生成代码后怎么使用
本站利用管脚PA2来实现功能,只需将PA2管脚定义为[输出,无上拉,快速]模式就行了,
我这里利用usart来输出读取的温度值,故还需配置下usart1串口,串口配置暂且不提了,以前帖子里面写了很多了
生成代码后,打开工程,添加ds18b20的驱动程序,如下:
文件名: ds18b20.c


#include "ds18b20.h"
#include "delay.h"

//复位DS18B20
void DS18B20_Rst(void)
{
CLR_DS18B20(); //拉低DQ
delay_us(750); //拉低750us
SET_DS18B20();; //DQ=1
delay_us(15); //15US
}


//等待DS18B20的回应
//返回1:未检测到ds18b20的存在
//返回0:存在
uint8_t DS18B20_Check(void)
{
uint8_t retry=0;

while (DS18B20_DQ_IN&&retry<200)
{
retry++;
delay_us(1);
};
if(retry>=200)return 1;
else retry=0;
while (!DS18B20_DQ_IN&&retry<240)
{
retry++;
delay_us(1);
};
if(retry>=240)return 1;
return 0;
}


//从DS18B20读取一个位
//返回值:1/0
uint8_t DS18B20_Read_Bit(void) // read one bit
{
uint8_t data;

CLR_DS18B20(); //拉低DQ
delay_us(2);
SET_DS18B20();; //DQ=1
delay_us(12);
if(DS18B20_DQ_IN)data=1;
else data=0;
delay_us(50);

return data;
}


//从ds18b20读取一个字节
//返回值:读取到的数据
uint8_t DS18B20_Read_Byte(void) // read one byte
{
uint8_t i,j,dat;
dat=0;

for (i=1;i<=8;i++)
{
j=DS18B20_Read_Bit();
dat=(j<<7)|(dat>>1);
}
return dat;
}

//*本程序由 www.stm32cube.com 提供
//写一个字节到DS18B20
//dat:要写入的字节
void DS18B20_Write_Byte(uint8_t dat)
{
uint8_t j;
uint8_t testb;

for (j=1;j<=8;j++)
{
testb=dat&0x01;
dat=dat>>1;
if (testb)
{
CLR_DS18B20(); //DS18B20_DQ_OUT=0;// Write 1
delay_us(2);
SET_DS18B20(); //DS18B20_DQ_OUT=1;
delay_us(60);
}
else
{
CLR_DS18B20(); //DS18B20_DQ_OUT=0;// Write 0
delay_us(60);
SET_DS18B20(); //DS18B20_DQ_OUT=1;
delay_us(2);
}
}
}


//开始温度转换
void DS18B20_Start(void)// ds1820 start convert
{
DS18B20_Rst();
DS18B20_Check();
DS18B20_Write_Byte(0xcc);// skip rom
DS18B20_Write_Byte(0x44);// convert
}


//初始化DS18B20的IO口DQ同时检查DS的存在
//返回1:不存在
//返回0:存在
uint8_t DS18B20_Init(void)
{
//配置PA2口
GPIO_InitTypeDef GPIO_InitStruct;

/[i] GPIO Ports Clock Enable [/i]/
__GPIOA_CLK_ENABLE();

/[i]Configure GPIO pin : PA2 [/i]/
GPIO_InitStruct.Pin = DS18B20_BIT;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FAST;
HAL_GPIO_Init(DS18B20_PORT, &GPIO_InitStruct);

SET_DS18B20(); //使PA2输出高电平

DS18B20_Rst();
return DS18B20_Check();
}


//从ds18b20得到温度值
//精度:0.1C
//返回值:温度值(-550~1250)
short DS18B20_Get_Temp(void)
{
uint8_t temp;
uint8_t TL,TH;
short tem;

DS18B20_Start (); // ds1820 start convert
DS18B20_Rst();
DS18B20_Check();
DS18B20_Write_Byte(0xcc);// skip rom
DS18B20_Write_Byte(0xbe);// convert
TL=DS18B20_Read_Byte(); // LSB
TH=DS18B20_Read_Byte(); // MSB

if(TH>7)
{
TH=~TH;
TL=~TL;
temp=0; //温度为负值
}else temp=1; //温度为正
tem=TH; //获得高8位
tem<<=8;
tem+=TL; //获得低8位
tem=(float)tem*0.625; //转换
if(temp)return tem; //返回温度值
else return -tem;
}



文件名: ds18b20.h


#ifndef __DS18B20_H
#define __DS18B20_H
#include "stm32f4xx_hal.h"


#define DS18B20_BIT GPIO_PIN_2
#define DS18B20_PORT GPIOA

#define CLR_DS18B20() HAL_GPIO_WritePin (DS18B20_PORT,DS18B20_BIT,GPIO_PIN_RESET )
#define SET_DS18B20() HAL_GPIO_WritePin (DS18B20_PORT,DS18B20_BIT,GPIO_PIN_SET )

#define DS18B20_DQ_IN HAL_GPIO_ReadPin(DS18B20_PORT, DS18B20_BIT)


uint8_t DS18B20_Init(void); //初始化DS18B20
short DS18B20_Get_Temp(void); //获取温度
void DS18B20_Start(void); //开始温度转换
void DS18B20_Write_Byte(uint8_t dat);//写入一个字节
uint8_t DS18B20_Read_Byte(void); //读出一个字节
uint8_t DS18B20_Read_Bit(void); //读出一个位
uint8_t DS18B20_Check(void); //检测是否存在DS18b20
void DS18B20_Rst(void); //复位DS18B20

#endif


文件名: delay.c


#include "delay.h"

/***************************************************************************
*函数名:delay_nus()
*参数u32 n 时钟延时的微妙数
*返回值:void
*功能:使用系统节拍时钟精准延时n个微妙函数
*本程序由 www.stm32cube.com 提供
*****************************************************************************/
void delay_us(uint32_t value)
{
uint32_t i;
i = value * 50;
while(i--);
}

文件名:delay.h


#ifndef __DELAY_H
#define __DELAY_H
#include "stm32f4xx_hal.h"
/***************************************************************************
*函数名:delay_nus()
*参数u32 n 时钟延时的微妙数
*返回值:void
*功能:使用系统节拍时钟精准延时n个微妙函数
*本程序由 www.stm32cube.com 提供
*****************************************************************************/
void delay_us(uint32_t value);

#endif



以上是ds18b20所要使用的驱动程序文件,将这两个c文件添加至工程中
在main.c文件中
添加ds18b20的驱动头文件和uart的printf函数栈定义


/[i] USER CODE BEGIN 0 [/i]/
#include "ds18b20.h"
#include "stdio.h"
#ifdef __GNUC__
/* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf
set to 'Yes') calls __io_putchar() */
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif /[i] __GNUC__ [/i]/

/**
* @brief Retargets the C library printf function to the USART.
* @param None
* @retval None
*/
PUTCHAR_PROTOTYPE
{
/[i] Place your implementation of fputc here [/i]/
/[i] e.g. write a character to the EVAL_COM1 and Loop until the end of transmission [/i]/
HAL_UART_Transmit(&huart1 , (uint8_t *)&ch, 1, 0xFFFF);
return ch;
}
/[i] USER CODE END 0 [/i]/


主函数mian()中是以下代码
int main(void)
{

/ USER CODE BEGIN 1 /
short temp;
/ USER CODE END 1 /

/ MCU Configuration----------------------------------------------------------/

/ Reset of all peripherals, Initializes the Flash interface and the Systick. /
HAL_Init();

/ Configure the system clock /
SystemClock_Config();

/ System interrupt init/
/ Sets the priority grouping field /
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_0);
HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);

/ Initialize all configured peripherals /
MX_GPIO_Init();
MX_USART1_UART_Init();

/ USER CODE BEGIN 2 /
printf ("start:\r\n");

while(DS18B20_Init()) //初始化并检测18B20
{
printf ("DS18B20 Check Failed!");
HAL_Delay (500);
printf ("Please Check!");
HAL_Delay (500);
}




/ USER CODE END 2 /

/ USER CODE BEGIN 3 /
/ Infinite loop /
while (1)
{
HAL_Delay (500);
HAL_GPIO_TogglePin (GPIOF ,GPIO_PIN_6 ); //闪烁led指示程序运行正常
temp=DS18B20_Get_Temp();//获取温度值
printf ("Temperate:%d \r\n",temp );//输出得到的温度值到终端
}
/ USER CODE END 3 /

}
编译,后运行,串口调试助手里面会显示测量的温度值........
注意啊,ds18b20.c文件里面
uint8_t DS18B20_Init(void)
{

GPIO_InitTypeDef GPIO_InitStruct;

/ GPIO Ports Clock Enable /
__GPIOA_CLK_ENABLE();

/Configure GPIO pin : PA2 /
GPIO_InitStruct.Pin = DS18B20_BIT;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FAST;
HAL_GPIO_Init(DS18B20_PORT, &GPIO_InitStruct);

SET_DS18B20(); //ʹGPIOAµÄPin_2Êä³ö¸ßµçƽ

DS18B20_Rst();
return DS18B20_Check();
}
这个代码,上面初始化的部分由于stm32cubemx生成的时候已经初始化了,可以删掉...额
我是直接把初始化的这个剪切到了这里
如果你要用以上的代码在其他端口,只需要修改ds18b20.h中的
#define DS18B20_BIT GPIO_PIN_2
#define DS18B20_PORT GPIOA
这个就可以了.
最简洁的办法是,不要用stm32cubemx定义你准备使用的连接到ds18b20的管脚,
到时候用的时候直接来这个h文件里面修改!
结束!

分享stm32cubemx软件和各芯片驱动包下载和手动安装驱动包的方法

admin 发表了文章 • 64 个评论 • 83369 次浏览 • 2014-11-17 12:59 • 来自相关话题

由于先前分享中同时转载有其他网盘文件,
遭到版权方投诉侵权!
导致分享文件均被强制撤回!

先前如有冒犯版权作者请见谅!

**本站专用百度网盘:
http://pan.baidu.com/s/1gdhcja7**

网盘里包含本站所有实验程序和相关软件,随时更新!
同时欢迎大家提供相关程序和好用的软件!
提交到邮箱: AD@Stm32cube.com


文件列表如下;
文件名 大小 修改日期
24c02_IGT已调试成功可连续写入.zip
5.3M 2014-12-10 22:10
AN2784 使用大容量STM32F10xxx的FSMC驱动外部的存储器.pdf
715KB 2015-01-06 22:25
ATxmega单片机自动分页写24c02代码.zip
2KB 2015-02-08 20:46
AVR_XMEGA_应用教程.pdf
1.5M 2015-03-23 15:50
Atxmega64A3单片机读写24C64.zip
2KB 2015-02-11 09:36
CAN_Loopback实验.zip
5M 2014-12-31 15:19
CANopen协议分析指南.zip
898KB 2015-01-03 13:07
CAN总线原理和应用系统设计.pdf
6.5M 2015-01-18 14:15
CH372-DRIVER示例.zip
38KB 2015-04-14 16:13
CoIDE-V2Beta-20141205(ARM编程软件需GCC编译器).exe
111.9M 2014-12-21 14:32
Cube关于usb驱动库介绍.pdf
1.2M 2015-02-13 15:42
C浮点数与字符转换工具.exe
28KB 2015-03-03 21:00
F103芯片fsmc操作nand官方中文.pdf
715KB 2014-12-31 10:17
F303-i2c-neu(来自中文论坛-【福清】Paderboy分享).rar
2.8M 2015-07-27 10:44
FSMC_NAND(无坏块管理).rar
831KB 2015-01-05 19:15
HAL驱动详解.pdf
4.5M 2014-11-22 19:55
ICCAVR+V6.31带注册机.rar
4.5M 2014-11-22 19:55
IIC模拟程序(驱动部分).zip
3KB 2015-02-06 15:57
KEIL MDK4.60crack破解文件.zip
16KB 2014-11-22 19:55
LCD时序图怎么读.doc
561KB 2015-03-10 21:11
LED(Systick(非中断方式)精确定时闪烁).zip
906KB 2015-03-23 16:59
MEMS_stm32f4_discovery参考程序.zip
45KB 2015-01-06 22:58
ModBusPol(本站freemodbus移植所用软件之一).rar
3.6M 2015-01-05 19:57
STM32Cube USB device library (2).pdf
1.4M 2014-12-14 13:21
STM32F303RET-TIM2-ADC2-ADC4-DMA-UART(来自中文论坛-[福清]Paderboy分享).rar
4.5M 2015-07-27 16:56
STM32F4xx中文参考手册.zip
12.3M 2015-05-20 11:37
STM32_PID.rar
484KB 2015-01-08 16:34
STM32串口环形队列.rar
1.2M 2015-01-18 20:07
STM32自学笔记.pdf
35.8M 2014-11-22 19:55
ST专用虚拟com口驱动工具stm32 virtual com.zip
2.2M 2014-12-05 15:07
UART.rar
3.1M 2015-01-06 13:59
UCOSIII_freemodbus.7z
428KB 2014-12-12 19:45
USB_MIDI协议.pdf
184KB 2014-12-14 13:21
USB芯片Ch372和Ch375调试助手.zip
8KB 2015-03-03 22:35
UsbHidDemonstrator.zip
4.8M 2015-01-12 17:21
VS2012_ULT_chs.iso
1.53G 2015-01-21 09:57
VS_VisualAssistX_2012破解版.zip
13.3M 2015-03-24 13:30
VisualGDB-4.2r4.rar
6.1M 2015-02-13 15:19
WPF编程宝典:使用C#2012和NET 4.5 第4版_13353713.pdf
89.7M 2015-03-07 22:03
YXD-1602G LCM.pdf
188KB 2015-03-08 18:42
ad_dma_duo多路DMA采集示例.zip
10.9M 2015-01-05 19:56
altium designer14.3.14.iso
2.97G 2015-03-23 16:03
bushound5.0使用.pdf
360KB 2015-01-12 11:47
bushound50.rar
594KB 2015-02-02 20:32
chromeinstall-7u60.exe
897KB 2014-11-22 19:55
cube输入捕获红外解码-芯片F103(坛友:整个夏天 提供).docx
333KB 2015-02-28 21:29
freemodbus-v1.5.0(原版官方文件).zip
4.2M 2015-01-05 19:58
freemodbus_stm32F407_stm32cubemx移植成功.zip
9.1M 2015-01-05 19:44
gcc-arm-win32编译器(辅助CoIDE编译器用).exe
81.9M 2014-12-21 14:31
lcd1602资料.pdf
621KB 2015-03-08 20:16
malloc.zip
2KB 2014-12-16 19:02
mdk474.exe
576.8M 2014-11-22 19:55
modbus协议解析.pdf
1.5M 2015-01-05 19:57
pcl6045b_四轴运动控制芯片_中文说明.pdf
14.1M 2015-01-08 15:20
st-link_v2_usbdriver.zip
9.9M 2014-11-22 19:55
stm32F405_407XX.pdf
5.7M 2015-05-15 15:10
stm32F407-四线方式操作lcd1602(型号YXD-1602G02).zip
8.9M 2015-04-15 16:48
stm32L0.pdf
10.1M 2014-11-22 19:55
stm32cube-crc校验例程.zip
9.1M 2015-04-21 10:20
stm32cube.com_RTOS文档.pdf
710KB 2014-12-31 16:09
stm32cube_tcp_ip操作.pdf
1000KB 2014-12-31 09:59
stm32cubemx软件和驱动库下载
[]2015-04-21 16:37[/]stm32cube使用教程1-流水灯怎样用软件设置和编写的.pdf
2.6M 2014-11-22 19:55
stm32f3-usb-vcom-echo.zip
525KB 2015-03-17 11:42
stm32f407_eval学习板原理图SCH和PCB图.zip
2.7M 2014-12-12 21:16
stm32f407_pwm_uart.zip
10.3M 2015-04-20 15:40
stm32f407使用DS18b20测试温度.zip
5M 2014-12-10 22:13
stm32f4discovery_sch.zip
300KB 2014-11-22 19:55
usb_cdc简单实验.rar
5.5M 2015-01-05 18:51
usb_hid测试代码F407discovery板(配合官方Demonstrator发送和接收).zip
7.4M 2015-01-18 17:56
usb虚拟串口缺失文件和驱动(32位系统x86专用).zip
5.7M 2014-12-16 21:07
usb虚拟串口缺失文件和驱动(X64位系统用).zip
5.7M 2014-12-16 21:04
《STM32自学笔记》随书资料.rar
22M 2014-11-22 19:55
【STM32神舟III号实验例程】——NAND FLASH访问实验(实验十四) - .pdf
12.2M 2015-01-04 11:25
一些cube实验程序.zip
65.6M 2014-11-28 09:09
你好,放大器.pdf
9M 2015-04-16 15:25
使用 STM32F40507xx 和 STM32F415417xx微控制器的浮点运算单元.pdf
282KB 2015-02-02 22:42
使用 U 盘更新 STM32F4DISCOVERY 板固件.pdf
463KB 2015-04-28 17:26
使用stm32F2XX和4XX微控器时,如何提供ADC精度.PDF
602KB 2015-03-26 19:45
关于stm32cube对SRAM的操作和设置.zip
5.3M 2015-01-22 11:39
周立功◆ARM嵌入式系统实验教程(一).pdf
2.9M 2015-07-02 13:59
周立功◆ARM嵌入式系统实验教程(三).pdf
2.9M 2015-07-02 14:02
国外写的usb虚拟串口程序STM32DiscoveryVCP-master.zip
209KB 2014-12-05 15:07
圈圈教你玩USB.pdf
25M 2015-06-04 14:07
基于STM32的 PMSM FOC软件库培训.zip
2.5M 2015-05-06 14:22
基于STM32的USB程序开发笔记(stm32cubemx.com中文网提供).pdf
2.4M 2014-12-05 15:34
基于stm32cubef4(HAL驱动,非固件库)的httpserver-socket(freertos lwip)在407上调试成功(RMII模式).7z
24.2M 2015-01-06 13:59
如何编写应用程序与USB_HID_设备通讯(读写USB_HID设备).pdf
1.1M 2015-03-26 11:56
安富莱STM32-V5开发板STemWin教程1-60期.pdf
15M 2015-05-27 09:35
实例讲解USB的枚举(配置)过程.pdf
1.1M 2015-03-26 11:53
教你使用1602液晶_详细的中文指导_兼容51、AVR、PIC单片机.pdf
973KB 2015-04-17 13:52
最新stm32f407zgt-sram-cubemx.zip
9.5M 2015-04-21 11:59
本站演示所用串口调试助手(推荐).zip
133KB 2015-01-05 19:55
模拟工程师速查参考.pdf
7.1M 2015-04-17 09:44
深入解析STM32_USB-FS-Device_Lib库.pdf
697KB 2014-12-05 15:30
用STM32CubeMX初始化SD卡终于好使了 STM32F407 .png
308KB 2015-01-06 22:22
电机控制中的MOSFET和IGBT基础知识.pdf
401KB 2015-04-17 09:27
虚拟串口工具.zip
4.7M 2015-01-27 12:50
西门子PLC上所使用的软件PID程序.zip
1.1M 2015-01-03 21:07
设计原理图.pdf
38KB 2015-04-14 15:12
12864_uc1701.zip
5.6M 2015-05-19 12:00
(中文)使用STM32F2xx 和STM32F4xx 微控制器时如何提高ADC 测量精度.PDF
602KB 2015-01-29 12:59
(感谢QQ群成员-一毛-提供)F4多通道ADC+DMA+UART采集数据.zip
8.5M 2015-07-27 16:39
(电机驱动库官方版4.0)STM32_FOC_SDK_4.0.0.zip
70.8M 2015-05-06 14:45


mx更新内容如下:
Added support of code generation, clock and power consumption calculation for the new part numbers of STM32F7 series.
Management of the dependency and configuration of external I/O, when required by a peripheral
STM32CubeMX can now be installed from a console.
STM32CubeMX supports now a command line mode.
F4更新如下:
Add support of System Workbench for STM32 (SW4STM32) toolchain
Maintenance release to fix known defects, in HAL and Projects

b更新STM32Cubemx软件到4.8.0版本[/b]
------------->文件名:stm32cubemx-4.8.0.zip
(2015.3.24)更新STM32cubeF4驱动库到1.6.0版本
--------------->文件名:stm32cubef4-1.6.0.zip


喜讯: Cube支持F1系列了!
请大家务必更新!

重新上传了!以前那个没法添加后续更新文件,晕死
最近有童鞋新入手stm32cubemx软件,但是不知道怎么安装和更新,尤其是软件自动更新慢如蜗牛,
惨不忍睹,导致很多人放弃了.
在此,分享下官方最新安装包和驱动包,
本帖也会长期更新驱动的更新和官方提供的中文PDF文档下载
希望对童鞋们节省翻墙的时间................
不废话了,上地址,百度网盘

另外,官方提供的示例代码在各芯片的驱动库里面,详情请看下面的帖子
http://www.stm32cube.com/question/17
我已经将下面所有介绍到的文件都共享到上面的地址里面了
大家下载的时候按照下面的介绍文件名选择下载

首先是stm32cubemx的安装程序,最新版本是4.4.0(于2014,11,17更新)
文件名: stm32cubemx-4.4.0.zip

安装mx之后必须按照你要用到的芯片型号选择驱动包下载,
文件名类似: stm32cubef4-1.3.0.zip





下面介绍下安装驱动包的步骤:
在C盘新建一个文件夹,必须英文,也可以不是c盘,随你便




将你需要安装的驱动包下载后,解压到这个文件夹里面,无需修改任何东西
返回到stm32cubemx软件,找到heip点击 updater setting,在里面选择刚才新建的文件夹















好了,已经安装好了
你可以点击help里面的install new library查看下






软件和驱动包都安装好了.
下面说下生成程序最好设置的一个地方





这样,生成程序的时候对应的外设会分别生成.c文件,便于管理,层次更清晰
推荐使用keil4.74版本,前面的下载里面有最新的mdk474下载,里面有个绿化工具
推荐大家购买正版.
keil4.70以上版本可以支持自动补全功能,非常方便,虽然没viral stdio好用,但是也很好了.呵呵
以后慢慢更新官方发布的中文使用文档 查看全部
由于先前分享中同时转载有其他网盘文件,
遭到版权方投诉侵权!
导致分享文件均被强制撤回!

先前如有冒犯版权作者请见谅!

**本站专用百度网盘:
http://pan.baidu.com/s/1gdhcja7**

网盘里包含本站所有实验程序和相关软件,随时更新!
同时欢迎大家提供相关程序和好用的软件!
提交到邮箱: AD@Stm32cube.com


文件列表如下;
文件名 大小 修改日期
24c02_IGT已调试成功可连续写入.zip
5.3M 2014-12-10 22:10
AN2784 使用大容量STM32F10xxx的FSMC驱动外部的存储器.pdf
715KB 2015-01-06 22:25
ATxmega单片机自动分页写24c02代码.zip
2KB 2015-02-08 20:46
AVR_XMEGA_应用教程.pdf
1.5M 2015-03-23 15:50
Atxmega64A3单片机读写24C64.zip
2KB 2015-02-11 09:36
CAN_Loopback实验.zip
5M 2014-12-31 15:19
CANopen协议分析指南.zip
898KB 2015-01-03 13:07
CAN总线原理和应用系统设计.pdf
6.5M 2015-01-18 14:15
CH372-DRIVER示例.zip
38KB 2015-04-14 16:13
CoIDE-V2Beta-20141205(ARM编程软件需GCC编译器).exe
111.9M 2014-12-21 14:32
Cube关于usb驱动库介绍.pdf
1.2M 2015-02-13 15:42
C浮点数与字符转换工具.exe
28KB 2015-03-03 21:00
F103芯片fsmc操作nand官方中文.pdf
715KB 2014-12-31 10:17
F303-i2c-neu(来自中文论坛-【福清】Paderboy分享).rar
2.8M 2015-07-27 10:44
FSMC_NAND(无坏块管理).rar
831KB 2015-01-05 19:15
HAL驱动详解.pdf
4.5M 2014-11-22 19:55
ICCAVR+V6.31带注册机.rar
4.5M 2014-11-22 19:55
IIC模拟程序(驱动部分).zip
3KB 2015-02-06 15:57
KEIL MDK4.60crack破解文件.zip
16KB 2014-11-22 19:55
LCD时序图怎么读.doc
561KB 2015-03-10 21:11
LED(Systick(非中断方式)精确定时闪烁).zip
906KB 2015-03-23 16:59
MEMS_stm32f4_discovery参考程序.zip
45KB 2015-01-06 22:58
ModBusPol(本站freemodbus移植所用软件之一).rar
3.6M 2015-01-05 19:57
STM32Cube USB device library (2).pdf
1.4M 2014-12-14 13:21
STM32F303RET-TIM2-ADC2-ADC4-DMA-UART(来自中文论坛-[福清]Paderboy分享).rar
4.5M 2015-07-27 16:56
STM32F4xx中文参考手册.zip
12.3M 2015-05-20 11:37
STM32_PID.rar
484KB 2015-01-08 16:34
STM32串口环形队列.rar
1.2M 2015-01-18 20:07
STM32自学笔记.pdf
35.8M 2014-11-22 19:55
ST专用虚拟com口驱动工具stm32 virtual com.zip
2.2M 2014-12-05 15:07
UART.rar
3.1M 2015-01-06 13:59
UCOSIII_freemodbus.7z
428KB 2014-12-12 19:45
USB_MIDI协议.pdf
184KB 2014-12-14 13:21
USB芯片Ch372和Ch375调试助手.zip
8KB 2015-03-03 22:35
UsbHidDemonstrator.zip
4.8M 2015-01-12 17:21
VS2012_ULT_chs.iso
1.53G 2015-01-21 09:57
VS_VisualAssistX_2012破解版.zip
13.3M 2015-03-24 13:30
VisualGDB-4.2r4.rar
6.1M 2015-02-13 15:19
WPF编程宝典:使用C#2012和NET 4.5 第4版_13353713.pdf
89.7M 2015-03-07 22:03
YXD-1602G LCM.pdf
188KB 2015-03-08 18:42
ad_dma_duo多路DMA采集示例.zip
10.9M 2015-01-05 19:56
altium designer14.3.14.iso
2.97G 2015-03-23 16:03
bushound5.0使用.pdf
360KB 2015-01-12 11:47
bushound50.rar
594KB 2015-02-02 20:32
chromeinstall-7u60.exe
897KB 2014-11-22 19:55
cube输入捕获红外解码-芯片F103(坛友:整个夏天 提供).docx
333KB 2015-02-28 21:29
freemodbus-v1.5.0(原版官方文件).zip
4.2M 2015-01-05 19:58
freemodbus_stm32F407_stm32cubemx移植成功.zip
9.1M 2015-01-05 19:44
gcc-arm-win32编译器(辅助CoIDE编译器用).exe
81.9M 2014-12-21 14:31
lcd1602资料.pdf
621KB 2015-03-08 20:16
malloc.zip
2KB 2014-12-16 19:02
mdk474.exe
576.8M 2014-11-22 19:55
modbus协议解析.pdf
1.5M 2015-01-05 19:57
pcl6045b_四轴运动控制芯片_中文说明.pdf
14.1M 2015-01-08 15:20
st-link_v2_usbdriver.zip
9.9M 2014-11-22 19:55
stm32F405_407XX.pdf
5.7M 2015-05-15 15:10
stm32F407-四线方式操作lcd1602(型号YXD-1602G02).zip
8.9M 2015-04-15 16:48
stm32L0.pdf
10.1M 2014-11-22 19:55
stm32cube-crc校验例程.zip
9.1M 2015-04-21 10:20
stm32cube.com_RTOS文档.pdf
710KB 2014-12-31 16:09
stm32cube_tcp_ip操作.pdf
1000KB 2014-12-31 09:59
stm32cubemx软件和驱动库下载
    []2015-04-21 16:37[/]
stm32cube使用教程1-流水灯怎样用软件设置和编写的.pdf
2.6M 2014-11-22 19:55
stm32f3-usb-vcom-echo.zip
525KB 2015-03-17 11:42
stm32f407_eval学习板原理图SCH和PCB图.zip
2.7M 2014-12-12 21:16
stm32f407_pwm_uart.zip
10.3M 2015-04-20 15:40
stm32f407使用DS18b20测试温度.zip
5M 2014-12-10 22:13
stm32f4discovery_sch.zip
300KB 2014-11-22 19:55
usb_cdc简单实验.rar
5.5M 2015-01-05 18:51
usb_hid测试代码F407discovery板(配合官方Demonstrator发送和接收).zip
7.4M 2015-01-18 17:56
usb虚拟串口缺失文件和驱动(32位系统x86专用).zip
5.7M 2014-12-16 21:07
usb虚拟串口缺失文件和驱动(X64位系统用).zip
5.7M 2014-12-16 21:04
《STM32自学笔记》随书资料.rar
22M 2014-11-22 19:55
【STM32神舟III号实验例程】——NAND FLASH访问实验(实验十四) - .pdf
12.2M 2015-01-04 11:25
一些cube实验程序.zip
65.6M 2014-11-28 09:09
你好,放大器.pdf
9M 2015-04-16 15:25
使用 STM32F40507xx 和 STM32F415417xx微控制器的浮点运算单元.pdf
282KB 2015-02-02 22:42
使用 U 盘更新 STM32F4DISCOVERY 板固件.pdf
463KB 2015-04-28 17:26
使用stm32F2XX和4XX微控器时,如何提供ADC精度.PDF
602KB 2015-03-26 19:45
关于stm32cube对SRAM的操作和设置.zip
5.3M 2015-01-22 11:39
周立功◆ARM嵌入式系统实验教程(一).pdf
2.9M 2015-07-02 13:59
周立功◆ARM嵌入式系统实验教程(三).pdf
2.9M 2015-07-02 14:02
国外写的usb虚拟串口程序STM32DiscoveryVCP-master.zip
209KB 2014-12-05 15:07
圈圈教你玩USB.pdf
25M 2015-06-04 14:07
基于STM32的 PMSM FOC软件库培训.zip
2.5M 2015-05-06 14:22
基于STM32的USB程序开发笔记(stm32cubemx.com中文网提供).pdf
2.4M 2014-12-05 15:34
基于stm32cubef4(HAL驱动,非固件库)的httpserver-socket(freertos lwip)在407上调试成功(RMII模式).7z
24.2M 2015-01-06 13:59
如何编写应用程序与USB_HID_设备通讯(读写USB_HID设备).pdf
1.1M 2015-03-26 11:56
安富莱STM32-V5开发板STemWin教程1-60期.pdf
15M 2015-05-27 09:35
实例讲解USB的枚举(配置)过程.pdf
1.1M 2015-03-26 11:53
教你使用1602液晶_详细的中文指导_兼容51、AVR、PIC单片机.pdf
973KB 2015-04-17 13:52
最新stm32f407zgt-sram-cubemx.zip
9.5M 2015-04-21 11:59
本站演示所用串口调试助手(推荐).zip
133KB 2015-01-05 19:55
模拟工程师速查参考.pdf
7.1M 2015-04-17 09:44
深入解析STM32_USB-FS-Device_Lib库.pdf
697KB 2014-12-05 15:30
用STM32CubeMX初始化SD卡终于好使了 STM32F407 .png
308KB 2015-01-06 22:22
电机控制中的MOSFET和IGBT基础知识.pdf
401KB 2015-04-17 09:27
虚拟串口工具.zip
4.7M 2015-01-27 12:50
西门子PLC上所使用的软件PID程序.zip
1.1M 2015-01-03 21:07
设计原理图.pdf
38KB 2015-04-14 15:12
12864_uc1701.zip
5.6M 2015-05-19 12:00
(中文)使用STM32F2xx 和STM32F4xx 微控制器时如何提高ADC 测量精度.PDF
602KB 2015-01-29 12:59
(感谢QQ群成员-一毛-提供)F4多通道ADC+DMA+UART采集数据.zip
8.5M 2015-07-27 16:39
(电机驱动库官方版4.0)STM32_FOC_SDK_4.0.0.zip
70.8M 2015-05-06 14:45


mx更新内容如下:
Added support of code generation, clock and power consumption calculation for the new part numbers of STM32F7 series.
Management of the dependency and configuration of external I/O, when required by a peripheral
STM32CubeMX can now be installed from a console.
STM32CubeMX supports now a command line mode.
F4更新如下:
Add support of System Workbench for STM32 (SW4STM32) toolchain
Maintenance release to fix known defects, in HAL and Projects

b更新STM32Cubemx软件到4.8.0版本[/b]
------------->文件名:stm32cubemx-4.8.0.zip
(2015.3.24)更新STM32cubeF4驱动库到1.6.0版本
--------------->文件名:stm32cubef4-1.6.0.zip


喜讯: Cube支持F1系列了!
请大家务必更新!

重新上传了!以前那个没法添加后续更新文件,晕死
最近有童鞋新入手stm32cubemx软件,但是不知道怎么安装和更新,尤其是软件自动更新慢如蜗牛,
惨不忍睹,导致很多人放弃了.
在此,分享下官方最新安装包和驱动包,
本帖也会长期更新驱动的更新和官方提供的中文PDF文档下载
希望对童鞋们节省翻墙的时间................
不废话了,上地址,百度网盘

另外,官方提供的示例代码在各芯片的驱动库里面,详情请看下面的帖子
http://www.stm32cube.com/question/17
我已经将下面所有介绍到的文件都共享到上面的地址里面了
大家下载的时候按照下面的介绍文件名选择下载

首先是stm32cubemx的安装程序,最新版本是4.4.0(于2014,11,17更新)
文件名: stm32cubemx-4.4.0.zip

安装mx之后必须按照你要用到的芯片型号选择驱动包下载,
文件名类似: stm32cubef4-1.3.0.zip

无标题.png

下面介绍下安装驱动包的步骤:
在C盘新建一个文件夹,必须英文,也可以不是c盘,随你便
无标题3.png

将你需要安装的驱动包下载后,解压到这个文件夹里面,无需修改任何东西
返回到stm32cubemx软件,找到heip点击 updater setting,在里面选择刚才新建的文件夹

无标题1.png


无标题2.png


无标题22.png

好了,已经安装好了
你可以点击help里面的install new library查看下

无标题4.png


软件和驱动包都安装好了.
下面说下生成程序最好设置的一个地方

无标题45.png

这样,生成程序的时候对应的外设会分别生成.c文件,便于管理,层次更清晰
推荐使用keil4.74版本,前面的下载里面有最新的mdk474下载,里面有个绿化工具
推荐大家购买正版.
keil4.70以上版本可以支持自动补全功能,非常方便,虽然没viral stdio好用,但是也很好了.呵呵
以后慢慢更新官方发布的中文使用文档

记录stm32cubemx中I2C的DMA板卡之间的传输设置

admin 发表了文章 • 3 个评论 • 6140 次浏览 • 2014-11-07 09:23 • 来自相关话题

I2c板卡之间连接示意图





先上图,后面解释..




















2楼注释 查看全部
I2c板卡之间连接示意图

5.png

先上图,后面解释..

1.png


2.png


3.png


4.png

2楼注释

stm32cubemx教程之ADC采集通过DMA传输,听说能省很多CPU时间做其他事

admin 发表了文章 • 25 个评论 • 38036 次浏览 • 2014-11-06 11:44 • 来自相关话题

再次写写stm32cubemx中AD采集的问题,这次不用while里面的查询,也不用中断采样了,直接用DMA
先说下用DMA的好处:无论是中断采样还是查询采样,都需要在主程序中占用好多时间出来,嗯,你可以这样理解
那种采样都需要调用HAL_ADC_GetValue()这个函数,,,就是要取得转换后的值,中断还好点,要是查询的话,有可能会丢失数据啊. 用dma就可以避免了
DMA用的事总线时间,无线cpu干预,额,这种说法貌似有点问题.管它呢
在AD转换结束的时候自动连接你准备存取的变量的地址,数据一步到位.额,省了多少事..
使用stm32cubemx对AD的配置





然后对她的DMA配置,并开启DMA的中断




然后生成代码吧
打开main.c文件,在这个地方添加代码

/[i] USER CODE BEGIN 0 [/i]/
__IO uint16_t uhADCxConvertedValue = 0;
/[i] USER CODE END 0 [/i]/

在main()函数里添加

/[i] USER CODE BEGIN 2 [/i]/
HAL_ADC_Start_DMA(&hadc1, (uint32_t*)&uhADCxConvertedValue, 1);

/[i] USER CODE END 2 [/i]/

意思是开启dma传输,传送一个字的数据到uhADCxConvertedValue这个变量里面
然后再文件的末尾处添加

/[i] USER CODE BEGIN 4 [/i]/
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* AdcHandle)
{
/[i] Turn LED1 on: Transfer process is correct [/i]/
// BSP_LED_On(LED1);
HAL_GPIO_WritePin (GPIOF,GPIO_PIN_6,GPIO_PIN_SET );
}
/[i] USER CODE END 4 [/i]/

意思是AD转换完成调用这个函数,哈数里使能led
也许,你会问,为毛是HAL_ADC_ConvCpltCallback()这个函数啊,这个函数不是当开启AD的中断的时候才调用的吗?
嗯,对,这个函数是这样的,但是你仔细去分析下开启AD的DMA中断函数里面,就会发现这个函数也在啊
如下图.进入HAL_ADC_Start_DMA函数里面,看到





在进入到图中的ADC_DMAConvCplt函数里面看到





OK,疑问解决,
以后用到AD就可以直接调用这个CALL了,不要纠结了. 查看全部
再次写写stm32cubemx中AD采集的问题,这次不用while里面的查询,也不用中断采样了,直接用DMA
先说下用DMA的好处:无论是中断采样还是查询采样,都需要在主程序中占用好多时间出来,嗯,你可以这样理解
那种采样都需要调用HAL_ADC_GetValue()这个函数,,,就是要取得转换后的值,中断还好点,要是查询的话,有可能会丢失数据啊. 用dma就可以避免了
DMA用的事总线时间,无线cpu干预,额,这种说法貌似有点问题.管它呢
在AD转换结束的时候自动连接你准备存取的变量的地址,数据一步到位.额,省了多少事..
使用stm32cubemx对AD的配置

5.png

然后对她的DMA配置,并开启DMA的中断
无标题.png

然后生成代码吧
打开main.c文件,在这个地方添加代码

/[i] USER CODE BEGIN 0 [/i]/
__IO uint16_t uhADCxConvertedValue = 0;
/[i] USER CODE END 0 [/i]/


在main()函数里添加

  /[i] USER CODE BEGIN 2 [/i]/
HAL_ADC_Start_DMA(&hadc1, (uint32_t*)&uhADCxConvertedValue, 1);

/[i] USER CODE END 2 [/i]/


意思是开启dma传输,传送一个字的数据到uhADCxConvertedValue这个变量里面
然后再文件的末尾处添加

/[i] USER CODE BEGIN 4 [/i]/
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* AdcHandle)
{
/[i] Turn LED1 on: Transfer process is correct [/i]/
// BSP_LED_On(LED1);
HAL_GPIO_WritePin (GPIOF,GPIO_PIN_6,GPIO_PIN_SET );
}
/[i] USER CODE END 4 [/i]/


意思是AD转换完成调用这个函数,哈数里使能led
也许,你会问,为毛是HAL_ADC_ConvCpltCallback()这个函数啊,这个函数不是当开启AD的中断的时候才调用的吗?
嗯,对,这个函数是这样的,但是你仔细去分析下开启AD的DMA中断函数里面,就会发现这个函数也在啊
如下图.进入HAL_ADC_Start_DMA函数里面,看到

2.png

在进入到图中的ADC_DMAConvCplt函数里面看到

3.png

OK,疑问解决,
以后用到AD就可以直接调用这个CALL了,不要纠结了.

stm32cubemx教程之简单测试片内FLASH的烧写

admin 发表了文章 • 8 个评论 • 22979 次浏览 • 2014-11-04 17:25 • 来自相关话题

基于官方的flash例子来做的
针对flash的擦除和写入软件stm32cubemx不需要设置任何外设,因为没用到,
额,我用了一个led作为擦除后写入在读取比较的指示
所以,软件商设置好RCC和GPIO口的led灯配置,生成代码
因为,stm32cube用的最新的库函数,里面已经包含了以前stm32f1系列针对flash的操作
根本不需要自己编写任何函数.嗯,方便了不少
falsh是按照SECTOR来擦除的,这方面有很多的资料
所以打开main.c后
在用户代码输入0处写入以下代码


/[i] USER CODE BEGIN 0 [/i]/
#define DATA_32 ((uint32_t)0x12345678)

uint32_t startAddress = 0, endAddress = 0;
uint32_t data32 = 0 , MemoryProgramStatus = 0;

static FLASH_EraseInitTypeDef EraseInitStruct;
/[i] USER CODE END 0 [/i]/


以上,定义了几个变量,分别是起始地址和终止地址,这两个是我准备写入的范围
接着是data32就是32位的数据变量,等会要用来存储读出的32位数据

static FLASH_EraseInitTypeDef EraseInitStruct;

// 这个意思是flash要擦除的块的一个结构体变量,额,这个库里面定义的,我们只需要修改值就行
在main函数中用户代码输入2处写入以下代码


/[i] USER CODE BEGIN 2 [/i]/
HAL_FLASH_Unlock(); //解锁,删除和写入必须先解锁,规定的
EraseInitStruct.TypeErase = TYPEERASE_SECTORS;
EraseInitStruct .VoltageRange =VOLTAGE_RANGE_3 ;
EraseInitStruct.Sector = FLASH_SECTOR_2 ;
EraseInitStruct.NbSectors = 2;
//以上,定义删除类型是SECTORS就是块,提供的电压是3.3v的所以选VOLTAGE_RANGE_3
//从FLASH_SECTOR_2业就是第二块开始删除,删除的数量是2个
HAL_FLASHEx_Erase(&EraseInitStruct, &SectorError);
//清除函数,如果出错则错误码存储到SectorError这个里面
startAddress = 0x08008000;
endAddress = 0x0800C000;
//设置了准备写入数据的起始地址和结束地址
while (startAddress < endAddress)
{
if (HAL_FLASH_Program(TYPEPROGRAM_WORD, startAddress, DATA_32) == HAL_OK)
{
startAddress = startAddress + 4;
}

}
//以上,如果起始地址开始累加写入,一直写入到endAddress这个地址结束,写入的是0x12345678这个数
HAL_FLASH_Lock();
//锁定,读取的话,无需解锁
startAddress = 0x08008000;
MemoryProgramStatus = 0x0;

while (startAddress < endAddress)
{
data32 = [url=__IO uint32_t[/i]]i[/url]startAddress;

if (data32 != DATA_32)
{
MemoryProgramStatus++;
}

startAddress = startAddress + 4;
}
//以上,逐个读取32位数据和前面写入的数据0x12345678对比,若不同则MemoryProgramStatus这个变量自加1
/[i]Check if there is an issue to program data[/i]/
if (MemoryProgramStatus == 0)
{
/[i] No error detected. Switch on LED4[/i]/
HAL_GPIO_WritePin (GPIOF,GPIO_PIN_6,GPIO_PIN_SET);
}
else
{
/[i] Error detected. Switch on LED5[/i]/
// Error_Handler();
}

//以上,若MemoryProgramStatus这个变量一直是0没加过,说明没有任何错误,数据写入正确,led点亮
/[i] USER CODE END 2 [/i]/

当然你也可以输入刚才写入的地址看看里面的数据是否是你要的.
以keil为例,在线调试状态下,在右下角的memery地址里面输入0x08008000,看看里面的数据,嗯,是对的 查看全部
基于官方的flash例子来做的
针对flash的擦除和写入软件stm32cubemx不需要设置任何外设,因为没用到,
额,我用了一个led作为擦除后写入在读取比较的指示
所以,软件商设置好RCC和GPIO口的led灯配置,生成代码
因为,stm32cube用的最新的库函数,里面已经包含了以前stm32f1系列针对flash的操作
根本不需要自己编写任何函数.嗯,方便了不少
falsh是按照SECTOR来擦除的,这方面有很多的资料
所以打开main.c后
在用户代码输入0处写入以下代码


/[i] USER CODE BEGIN 0 [/i]/
#define DATA_32 ((uint32_t)0x12345678)

uint32_t startAddress = 0, endAddress = 0;
uint32_t data32 = 0 , MemoryProgramStatus = 0;

static FLASH_EraseInitTypeDef EraseInitStruct;
/[i] USER CODE END 0 [/i]/


以上,定义了几个变量,分别是起始地址和终止地址,这两个是我准备写入的范围
接着是data32就是32位的数据变量,等会要用来存储读出的32位数据

static FLASH_EraseInitTypeDef EraseInitStruct; 


// 这个意思是flash要擦除的块的一个结构体变量,额,这个库里面定义的,我们只需要修改值就行
在main函数中用户代码输入2处写入以下代码


 /[i] USER CODE BEGIN 2 [/i]/
HAL_FLASH_Unlock(); //解锁,删除和写入必须先解锁,规定的
EraseInitStruct.TypeErase = TYPEERASE_SECTORS;
EraseInitStruct .VoltageRange =VOLTAGE_RANGE_3 ;
EraseInitStruct.Sector = FLASH_SECTOR_2 ;
EraseInitStruct.NbSectors = 2;
//以上,定义删除类型是SECTORS就是块,提供的电压是3.3v的所以选VOLTAGE_RANGE_3
//从FLASH_SECTOR_2业就是第二块开始删除,删除的数量是2个
HAL_FLASHEx_Erase(&EraseInitStruct, &SectorError);
//清除函数,如果出错则错误码存储到SectorError这个里面
startAddress = 0x08008000;
endAddress = 0x0800C000;
//设置了准备写入数据的起始地址和结束地址
while (startAddress < endAddress)
{
if (HAL_FLASH_Program(TYPEPROGRAM_WORD, startAddress, DATA_32) == HAL_OK)
{
startAddress = startAddress + 4;
}

}
//以上,如果起始地址开始累加写入,一直写入到endAddress这个地址结束,写入的是0x12345678这个数
HAL_FLASH_Lock();
//锁定,读取的话,无需解锁
startAddress = 0x08008000;
MemoryProgramStatus = 0x0;

while (startAddress < endAddress)
{
data32 = [url=__IO uint32_t[/i]]i[/url]startAddress;

if (data32 != DATA_32)
{
MemoryProgramStatus++;
}

startAddress = startAddress + 4;
}
//以上,逐个读取32位数据和前面写入的数据0x12345678对比,若不同则MemoryProgramStatus这个变量自加1
/[i]Check if there is an issue to program data[/i]/
if (MemoryProgramStatus == 0)
{
/[i] No error detected. Switch on LED4[/i]/
HAL_GPIO_WritePin (GPIOF,GPIO_PIN_6,GPIO_PIN_SET);
}
else
{
/[i] Error detected. Switch on LED5[/i]/
// Error_Handler();
}

//以上,若MemoryProgramStatus这个变量一直是0没加过,说明没有任何错误,数据写入正确,led点亮
/[i] USER CODE END 2 [/i]/


当然你也可以输入刚才写入的地址看看里面的数据是否是你要的.
以keil为例,在线调试状态下,在右下角的memery地址里面输入0x08008000,看看里面的数据,嗯,是对的

无标题.png


关于stm32cubemx生成的RTC程序的学习记录,用到RTC/usart/printf/sprintf,基于官方库例子

admin 发表了文章 • 28 个评论 • 17380 次浏览 • 2014-11-04 10:22 • 来自相关话题

先大略的看了下官方的RTC的例子,
于是准备利用usart的printf输出,启用了stm32cube中的RTC
首先初始化了uart的printf初始化了rtc,
然后随便uart输出一个东西,
发现此时上电后,usart输出好慢,不是立马输出
于是,注释掉MX_RTC_Init();
重新烧录,输出速度正常了......
说明stm32cubemx生成的RTC初始化代码初始RTC时间长啊....不是一般的长,我还没有开始初始定义的说.
好了,2楼继续

好吧,懒得仔细搞了,就大致按照官方的例子弄下算了
过程如下:
设置此时的时间为2:20:00,2014年1月18号
定时时间为:2:20:30秒零56,2014年1月18号,
定时时间到产生中断,使LED灯亮.
ok,就按照这个来做,
下面的图示是stm32cubemx软件的相关RTC设置




















还有GPIO的设置,推挽,上拉,ok
设置完毕后自动生成代码
打开RTc.c文件,更改下面的代码为:
void MX_RTC_Init(void)
{
RTC_TimeTypeDef sTime;
RTC_DateTypeDef sDate;
RTC_AlarmTypeDef sAlarm;

/**Initialize RTC and set the Time and Date
*/
hrtc.Instance = RTC;
hrtc.Init.HourFormat = RTC_HOURFORMAT_24;
hrtc.Init.AsynchPrediv = 127;
hrtc.Init.SynchPrediv = 255;
hrtc.Init.OutPut = RTC_OUTPUT_DISABLE;
hrtc.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
hrtc.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
HAL_RTC_Init(&hrtc);

sTime.Hours = 0x02;
sTime.Minutes = 0x20;
sTime.Seconds = 0;
sTime.SubSeconds = 0;
sTime.TimeFormat = RTC_HOURFORMAT12_AM;
sTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
sTime.StoreOperation = RTC_STOREOPERATION_RESET;
HAL_RTC_SetTime(&hrtc, &sTime, FORMAT_BCD);

sDate.WeekDay = RTC_WEEKDAY_MONDAY;
sDate.Month = RTC_MONTH_JANUARY;
sDate.Date = 0x18;
sDate.Year = 0x14;
HAL_RTC_SetDate(&hrtc, &sDate, FORMAT_BCD);

/**Enable the Alarm A
*/
sAlarm.AlarmTime.Hours = 0x02;
sAlarm.AlarmTime.Minutes = 0x20;
sAlarm.AlarmTime.Seconds = 0x30;
sAlarm.AlarmTime.SubSeconds = 0x56;
sAlarm.AlarmTime.TimeFormat = RTC_HOURFORMAT12_AM;
sAlarm.AlarmTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
sAlarm.AlarmTime.StoreOperation = RTC_STOREOPERATION_RESET;
sAlarm.AlarmMask = RTC_ALARMMASK_DATEWEEKDAY;
sAlarm.AlarmSubSecondMask = RTC_ALARMSUBSECONDMASK_None;
sAlarm.AlarmDateWeekDaySel = RTC_ALARMDATEWEEKDAYSEL_DATE;
sAlarm.AlarmDateWeekDay = RTC_WEEKDAY_MONDAY;
sAlarm.Alarm = RTC_ALARM_A;
HAL_RTC_SetAlarm_IT(&hrtc, &sAlarm, FORMAT_BCD);

}
这个就是刚才第一步时候提到的时间,对号入座....不解释了
返回到main.c文件
在用户代码4的地方写入:
/ USER CODE BEGIN 4 /
void HAL_RTC_AlarmAEventCallback(RTC_HandleTypeDef *hrtc)
{
/* NOTE : This function Should not be modified, when the callback is needed,
the HAL_RTC_AlarmAEventCallback could be implemented in the user file
*/
HAL_GPIO_WritePin (GPIOG,GPIO_PIN_6,GPIO_PIN_RESET );
}
这个是定时中断的返回调用,当中断的时候,使LED亮(我的板子是负驱动)...
ok,测试和官方实例效果一样......
30秒后led亮.....
当然这个事例子......你可以设定时间长一点,比如,好几天之后的某天..
修修补补就可以用了. 查看全部
先大略的看了下官方的RTC的例子,
于是准备利用usart的printf输出,启用了stm32cube中的RTC
首先初始化了uart的printf初始化了rtc,
然后随便uart输出一个东西,
发现此时上电后,usart输出好慢,不是立马输出
于是,注释掉MX_RTC_Init();
重新烧录,输出速度正常了......
说明stm32cubemx生成的RTC初始化代码初始RTC时间长啊....不是一般的长,我还没有开始初始定义的说.
好了,2楼继续

好吧,懒得仔细搞了,就大致按照官方的例子弄下算了
过程如下:
设置此时的时间为2:20:00,2014年1月18号
定时时间为:2:20:30秒零56,2014年1月18号,
定时时间到产生中断,使LED灯亮.
ok,就按照这个来做,
下面的图示是stm32cubemx软件的相关RTC设置

2.png


3.png


4.png


5.png

还有GPIO的设置,推挽,上拉,ok
设置完毕后自动生成代码
打开RTc.c文件,更改下面的代码为:
void MX_RTC_Init(void)
{
RTC_TimeTypeDef sTime;
RTC_DateTypeDef sDate;
RTC_AlarmTypeDef sAlarm;

/**Initialize RTC and set the Time and Date
*/
hrtc.Instance = RTC;
hrtc.Init.HourFormat = RTC_HOURFORMAT_24;
hrtc.Init.AsynchPrediv = 127;
hrtc.Init.SynchPrediv = 255;
hrtc.Init.OutPut = RTC_OUTPUT_DISABLE;
hrtc.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
hrtc.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
HAL_RTC_Init(&hrtc);

sTime.Hours = 0x02;
sTime.Minutes = 0x20;
sTime.Seconds = 0;
sTime.SubSeconds = 0;
sTime.TimeFormat = RTC_HOURFORMAT12_AM;
sTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
sTime.StoreOperation = RTC_STOREOPERATION_RESET;
HAL_RTC_SetTime(&hrtc, &sTime, FORMAT_BCD);

sDate.WeekDay = RTC_WEEKDAY_MONDAY;
sDate.Month = RTC_MONTH_JANUARY;
sDate.Date = 0x18;
sDate.Year = 0x14;
HAL_RTC_SetDate(&hrtc, &sDate, FORMAT_BCD);

/**Enable the Alarm A
*/
sAlarm.AlarmTime.Hours = 0x02;
sAlarm.AlarmTime.Minutes = 0x20;
sAlarm.AlarmTime.Seconds = 0x30;
sAlarm.AlarmTime.SubSeconds = 0x56;
sAlarm.AlarmTime.TimeFormat = RTC_HOURFORMAT12_AM;
sAlarm.AlarmTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
sAlarm.AlarmTime.StoreOperation = RTC_STOREOPERATION_RESET;
sAlarm.AlarmMask = RTC_ALARMMASK_DATEWEEKDAY;
sAlarm.AlarmSubSecondMask = RTC_ALARMSUBSECONDMASK_None;
sAlarm.AlarmDateWeekDaySel = RTC_ALARMDATEWEEKDAYSEL_DATE;
sAlarm.AlarmDateWeekDay = RTC_WEEKDAY_MONDAY;
sAlarm.Alarm = RTC_ALARM_A;
HAL_RTC_SetAlarm_IT(&hrtc, &sAlarm, FORMAT_BCD);

}
这个就是刚才第一步时候提到的时间,对号入座....不解释了
返回到main.c文件
在用户代码4的地方写入:
/ USER CODE BEGIN 4 /
void HAL_RTC_AlarmAEventCallback(RTC_HandleTypeDef *hrtc)
{
/* NOTE : This function Should not be modified, when the callback is needed,
the HAL_RTC_AlarmAEventCallback could be implemented in the user file
*/
HAL_GPIO_WritePin (GPIOG,GPIO_PIN_6,GPIO_PIN_RESET );
}
这个是定时中断的返回调用,当中断的时候,使LED亮(我的板子是负驱动)...
ok,测试和官方实例效果一样......
30秒后led亮.....
当然这个事例子......你可以设定时间长一点,比如,好几天之后的某天..
修修补补就可以用了.

usart的真正用法之一堆栈,push和pop处理uart得到的数据,不要再说stm32cube的新库函数不好用了

admin 发表了文章 • 17 个评论 • 7749 次浏览 • 2014-10-22 14:17 • 来自相关话题

b[/b]

如题:
刚开始用stm32cube的最新uart库函数的时候其实我也发牢骚了半天.
甚至不知道应该怎么去处理数据..........
汗,只怪自己就没怎么认真学过,还敢自称会用uart,汗颜
以前就是直接接收到数据,然后判断处理,这个其实就是小成用法.
下面列出研究了两天的稍微大成点的用法
将uart取得的数据,经过入栈存入到一个数据表中,然后用pop出栈进行数据处理
大体做法是:
要进行传输的数据必须格式化,例如设置数据头和数据尾来判断一帧完整的数据.
数据的头和尾之间是有效数据,可以包含数据的定义和数据本身
单片机接受到数据后,先存入到
HAL_UART_Receive_IT(&huart1, que._data, QUEUE_max_size);
这句话的que._data数据表中,这个数据表可以设置的长一点,不会溢出就行
然后写一个程序处理这个里面的数据,第一步就是查找判断这个数据是不是按照上面的数据格式
的数据,如果不是则舍弃,否则,按照你的数据规则取得这个有效的数据例如queue_find_cmd(cmd_buffer,30),其中cmd_buffer里面就是得到的数据.
然后可以依照规则将每位进行分解处理,例如cmd_buffer[1]=0x00表示这次传输的是数字,=0x01则表示传输的是字符串,然后cmd_buffer[2]+(cmd_buffer[3]<<8)+(cmd_buffer[4]<<16)+(cmd_buffer[5]<<24).
这样表示后面的是连续32位数据,呵呵
2楼继续. 查看全部
b[/b]

如题:
刚开始用stm32cube的最新uart库函数的时候其实我也发牢骚了半天.
甚至不知道应该怎么去处理数据..........
汗,只怪自己就没怎么认真学过,还敢自称会用uart,汗颜
以前就是直接接收到数据,然后判断处理,这个其实就是小成用法.
下面列出研究了两天的稍微大成点的用法
将uart取得的数据,经过入栈存入到一个数据表中,然后用pop出栈进行数据处理
大体做法是:
要进行传输的数据必须格式化,例如设置数据头和数据尾来判断一帧完整的数据.
数据的头和尾之间是有效数据,可以包含数据的定义和数据本身
单片机接受到数据后,先存入到
HAL_UART_Receive_IT(&huart1, que._data, QUEUE_max_size);
这句话的que._data数据表中,这个数据表可以设置的长一点,不会溢出就行
然后写一个程序处理这个里面的数据,第一步就是查找判断这个数据是不是按照上面的数据格式
的数据,如果不是则舍弃,否则,按照你的数据规则取得这个有效的数据例如queue_find_cmd(cmd_buffer,30),其中cmd_buffer里面就是得到的数据.
然后可以依照规则将每位进行分解处理,例如cmd_buffer[1]=0x00表示这次传输的是数字,=0x01则表示传输的是字符串,然后cmd_buffer[2]+(cmd_buffer[3]<<8)+(cmd_buffer[4]<<16)+(cmd_buffer[5]<<24).
这样表示后面的是连续32位数据,呵呵
2楼继续.

stm32cube中文教程:按键检测怎么设置,举例说明如下

admin 发表了文章 • 2 个评论 • 3878 次浏览 • 2014-10-14 00:23 • 来自相关话题

按键检测,就是按键作为输入,一般51的做法是IO口接上拉按键控制接地.
至于stm32cube中不需接上拉电阻,内置上啦就成了.
端口设置为GPIO_Input,上拉模式.
记得不是GPIO_OUTPUT模式啊,那个可不行
至于定时器设置为10ms定时就可以了,有人说设置为20ms最好,自己看了
我用定时器3,设置定时时间10ms
定时完成回调函数里面就定义一个标志,表示定时时间到
主程序中处理按键检测
我这里演示了3个按键的检测,用灯指示输出
随便写了个程序.


#include "stm32f4xx_hal.h"
#include "tim.h"
#include "gpio.h"

/[i] Private variables ---------------------------------------------------------[/i]/

/[i] USER CODE BEGIN 0 [/i]/
uint8_t update_flag = 0;
uint8_t key[2],c_time,key_v,key_s=0x07;
uint8_t get_value(void);
void key_scan(void);
/[i] USER CODE END 0 [/i]/

/[i] Private function prototypes -----------------------------------------------[/i]/
void SystemClock_Config(void);

int main(void)
{

/[i] USER CODE BEGIN 1 [/i]/

/[i] USER CODE END 1 [/i]/

/[i] MCU Configuration----------------------------------------------------------[/i]/

/[i] Reset of all peripherals, Initializes the Flash interface and the Systick. [/i]/
HAL_Init();

/[i] Configure the system clock [/i]/
SystemClock_Config();

/[i] System interrupt init[/i]/
/[i] Sets the priority grouping field [/i]/
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_0);
HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);

/[i] Initialize all configured peripherals [/i]/
MX_GPIO_Init();
MX_TIM3_Init();

/[i] USER CODE BEGIN 2 [/i]/
// uint8_t ReadData,Trg,Cont;
// uint8_t value;
// uint8_t value_pre = 0x07;
uint8_t key_flag;

HAL_TIM_Base_Start_IT (&htim3);
/[i] USER CODE END 2 [/i]/

/[i] USER CODE BEGIN 3 [/i]/
/[i] Infinite loop [/i]/
while (1)
{
// if(update_flag)
// {c_time++ ;update_flag=0;}
// if(c_time >=100) {HAL_GPIO_TogglePin( GPIOF, GPIO_PIN_6 );c_time= 0;}
//

if(update_flag)
{
key_scan ();
update_flag = 0;
}
if(key_v != key_s)
{ key_s = key_v; key_flag = 1; }
if(key_flag)
{
key_flag = 0;
// HAL_GPIO_TogglePin( GPIOF, GPIO_PIN_6 );
switch(key_s)
{
case 0x00 : HAL_GPIO_TogglePin( GPIOB, GPIO_PIN_11 ); HAL_GPIO_TogglePin( GPIOB, GPIO_PIN_12 );break;
case 0x01 : HAL_GPIO_TogglePin( GPIOB, GPIO_PIN_12 ); break;
case 0x03 : HAL_GPIO_TogglePin( GPIOB, GPIO_PIN_11 ); break;
case 0x07 : HAL_GPIO_TogglePin( GPIOF, GPIO_PIN_6 ); break;
default : break;
}
}
}
/[i] USER CODE END 3 [/i]/

}

/** System Clock Configuration
*/
void SystemClock_Config(void)
{

RCC_ClkInitTypeDef RCC_ClkInitStruct;
RCC_OscInitTypeDef RCC_OscInitStruct;

__PWR_CLK_ENABLE();

__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLM = 25;
RCC_OscInitStruct.PLL.PLLN = 336;
RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
RCC_OscInitStruct.PLL.PLLQ = 4;
HAL_RCC_OscConfig(&RCC_OscInitStruct);

RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_SYSCLK|RCC_CLOCKTYPE_PCLK1
|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5);

}

/[i] USER CODE BEGIN 4 [/i]/
void key_scan(void)
{
key[ c_time ] = get_value ();
c_time ++;
if(c_time <= 1) return ;
c_time = 0;
if(key[1]==key[0]) key_v = key[0];
}
uint8_t get_value(void)
{
uint8_t PIN_value;
PIN_value = (HAL_GPIO_ReadPin (GPIOB,GPIO_PIN_13)<<2) + (HAL_GPIO_ReadPin (GPIOB,GPIO_PIN_14)<<1) + HAL_GPIO_ReadPin (GPIOB,GPIO_PIN_15);
// PIN_value = HAL_GPIO_ReadPin (GPIOB,GPIO_PIN_13);
return PIN_value;
}
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
update_flag = 1;

}
/[i] USER CODE END 4 [/i]/ 查看全部
按键检测,就是按键作为输入,一般51的做法是IO口接上拉按键控制接地.
至于stm32cube中不需接上拉电阻,内置上啦就成了.
端口设置为GPIO_Input,上拉模式.
记得不是GPIO_OUTPUT模式啊,那个可不行
至于定时器设置为10ms定时就可以了,有人说设置为20ms最好,自己看了
我用定时器3,设置定时时间10ms
定时完成回调函数里面就定义一个标志,表示定时时间到
主程序中处理按键检测
我这里演示了3个按键的检测,用灯指示输出
随便写了个程序.


#include "stm32f4xx_hal.h"
#include "tim.h"
#include "gpio.h"

/[i] Private variables ---------------------------------------------------------[/i]/

/[i] USER CODE BEGIN 0 [/i]/
uint8_t update_flag = 0;
uint8_t key[2],c_time,key_v,key_s=0x07;
uint8_t get_value(void);
void key_scan(void);
/[i] USER CODE END 0 [/i]/

/[i] Private function prototypes -----------------------------------------------[/i]/
void SystemClock_Config(void);

int main(void)
{

/[i] USER CODE BEGIN 1 [/i]/

/[i] USER CODE END 1 [/i]/

/[i] MCU Configuration----------------------------------------------------------[/i]/

/[i] Reset of all peripherals, Initializes the Flash interface and the Systick. [/i]/
HAL_Init();

/[i] Configure the system clock [/i]/
SystemClock_Config();

/[i] System interrupt init[/i]/
/[i] Sets the priority grouping field [/i]/
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_0);
HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);

/[i] Initialize all configured peripherals [/i]/
MX_GPIO_Init();
MX_TIM3_Init();

/[i] USER CODE BEGIN 2 [/i]/
// uint8_t ReadData,Trg,Cont;
// uint8_t value;
// uint8_t value_pre = 0x07;
uint8_t key_flag;

HAL_TIM_Base_Start_IT (&htim3);
/[i] USER CODE END 2 [/i]/

/[i] USER CODE BEGIN 3 [/i]/
/[i] Infinite loop [/i]/
while (1)
{
// if(update_flag)
// {c_time++ ;update_flag=0;}
// if(c_time >=100) {HAL_GPIO_TogglePin( GPIOF, GPIO_PIN_6 );c_time= 0;}
//

if(update_flag)
{
key_scan ();
update_flag = 0;
}
if(key_v != key_s)
{ key_s = key_v; key_flag = 1; }
if(key_flag)
{
key_flag = 0;
// HAL_GPIO_TogglePin( GPIOF, GPIO_PIN_6 );
switch(key_s)
{
case 0x00 : HAL_GPIO_TogglePin( GPIOB, GPIO_PIN_11 ); HAL_GPIO_TogglePin( GPIOB, GPIO_PIN_12 );break;
case 0x01 : HAL_GPIO_TogglePin( GPIOB, GPIO_PIN_12 ); break;
case 0x03 : HAL_GPIO_TogglePin( GPIOB, GPIO_PIN_11 ); break;
case 0x07 : HAL_GPIO_TogglePin( GPIOF, GPIO_PIN_6 ); break;
default : break;
}
}
}
/[i] USER CODE END 3 [/i]/

}

/** System Clock Configuration
*/
void SystemClock_Config(void)
{

RCC_ClkInitTypeDef RCC_ClkInitStruct;
RCC_OscInitTypeDef RCC_OscInitStruct;

__PWR_CLK_ENABLE();

__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLM = 25;
RCC_OscInitStruct.PLL.PLLN = 336;
RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
RCC_OscInitStruct.PLL.PLLQ = 4;
HAL_RCC_OscConfig(&RCC_OscInitStruct);

RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_SYSCLK|RCC_CLOCKTYPE_PCLK1
|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5);

}

/[i] USER CODE BEGIN 4 [/i]/
void key_scan(void)
{
key[ c_time ] = get_value ();
c_time ++;
if(c_time <= 1) return ;
c_time = 0;
if(key[1]==key[0]) key_v = key[0];
}
uint8_t get_value(void)
{
uint8_t PIN_value;
PIN_value = (HAL_GPIO_ReadPin (GPIOB,GPIO_PIN_13)<<2) + (HAL_GPIO_ReadPin (GPIOB,GPIO_PIN_14)<<1) + HAL_GPIO_ReadPin (GPIOB,GPIO_PIN_15);
// PIN_value = HAL_GPIO_ReadPin (GPIOB,GPIO_PIN_13);
return PIN_value;
}
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
update_flag = 1;

}
/[i] USER CODE END 4 [/i]/

stm32cube中文教程:TIM3定时,TIM1双通道计数器的实现

admin 发表了文章 • 0 个评论 • 6590 次浏览 • 2014-10-14 00:16 • 来自相关话题

本次利用了,stm32cubemx生成代码,稍微在main中添加得到
打开cubemx,先设置pinout选项卡。
rcc选择crystal。外部时钟
TIM1中选择Channel1的Input Capture direct mode
TIM1中选择Channel2的Input Capture direct mode

TIM3中Clock Source选择Internal Clock
Usart1中MOde选择Asynchronous

其他所有的默认即可。
TIM1用于计数,两个通道同时计数。
TIM3用于定时,并且生成一个脉冲信号
usart用于输出计数结果

Clock configuration选项卡中
时钟我用的25M晶振,系统时钟设为168MHz
APB1 Prescaler 选4,APB2 Prescaler选2

Configuration选项卡中,
usart设置不再讲述,可以去看网站里面的帖子
NVIC按钮打开后,TIM1 Capture Compare interrupt 设为0,2
TIM3 gloable interrupt 设置 0,1
并且以上开启使能
TIM1设置页打开后 counter period (autoreload register-16bits value) 设为65535,up,其他不变,tim1的gpio都设为Pull-up,high
Tim3设置页 prescaler (psc-16 bits value) 为8399
紧接着up,继续9999
最后update event。

好了,设置结束,生成代码,
main.c中的代码:其他的文件没变啊,自己对比添加了哪些吧,懒得一个个写


/[i] Includes ------------------------------------------------------------------[/i]/
#include "stm32f4xx_hal.h"

/[i] Private variables ---------------------------------------------------------[/i]/
TIM_HandleTypeDef htim1;
TIM_HandleTypeDef htim3;

UART_HandleTypeDef huart1;

/[i] USER CODE BEGIN 0 [/i]/
#include "stdio.h"
#ifdef __GNUC__
/* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf
set to 'Yes') calls __io_putchar() */
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif /[i] __GNUC__ [/i]/

/**
* @brief Retargets the C library printf function to the USART.
* @param None
* @retval None
*/
PUTCHAR_PROTOTYPE
{
/[i] Place your implementation of fputc here [/i]/
/[i] e.g. write a character to the EVAL_COM1 and Loop until the end of transmission [/i]/
HAL_UART_Transmit(&huart1 , (uint8_t *)&ch, 1, 0xFFFF);
return ch;
}
uint32_t cont_value1 = 0;
uint32_t cont_value2 = 0;
uint32_t v_value1 = 0;
uint32_t v_value2 = 0;
static void Error_Handler(void);
/[i] USER CODE END 0 [/i]/

/[i] Private function prototypes -----------------------------------------------[/i]/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_TIM1_Init(void);
static void MX_TIM3_Init(void);
static void MX_USART1_UART_Init(void);

int main(void)
{

/[i] USER CODE BEGIN 1 [/i]/

/[i] USER CODE END 1 [/i]/

/[i] MCU Configuration----------------------------------------------------------[/i]/

/[i] Reset of all peripherals, Initializes the Flash interface and the Systick. [/i]/
HAL_Init();

/[i] Configure the system clock [/i]/
SystemClock_Config();

/[i] System interrupt init[/i]/
/[i] Sets the priority grouping field [/i]/
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_0);
HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);

/[i] Initialize all configured peripherals [/i]/
MX_GPIO_Init();
MX_TIM1_Init();
MX_TIM3_Init();
MX_USART1_UART_Init();

/[i] USER CODE BEGIN 2 [/i]/
HAL_TIM_Base_Start_IT (&htim3 );
if(HAL_TIM_IC_Start_IT(&htim1, TIM_CHANNEL_2) != HAL_OK)
{
/[i] Starting Error [/i]/
Error_Handler();
}
if(HAL_TIM_IC_Start_IT(&htim1, TIM_CHANNEL_1) != HAL_OK)
{
/[i] Starting Error [/i]/
Error_Handler();
}
/[i] USER CODE END 2 [/i]/

/[i] USER CODE BEGIN 3 [/i]/
/[i] Infinite loop [/i]/
while (1)
{
// HAL_Delay(1000);

// printf ("hello ,my world!");
HAL_Delay(1000);
printf ("%d , %d \r\n",v_value1, v_value2);
cont_value1= 0;cont_value2= 0;

}
/[i] USER CODE END 3 [/i]/

}

/** System Clock Configuration
*/
void SystemClock_Config(void)
{

RCC_ClkInitTypeDef RCC_ClkInitStruct;
RCC_OscInitTypeDef RCC_OscInitStruct;

__PWR_CLK_ENABLE();

__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLM = 25;
RCC_OscInitStruct.PLL.PLLN = 336;
RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
RCC_OscInitStruct.PLL.PLLQ = 4;
HAL_RCC_OscConfig(&RCC_OscInitStruct);

RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_SYSCLK|RCC_CLOCKTYPE_PCLK1
|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5);

}

/[i] TIM1 init function [/i]/
void MX_TIM1_Init(void)
{

TIM_IC_InitTypeDef sConfigIC;
TIM_MasterConfigTypeDef sMasterConfig;

htim1.Instance = TIM1;
htim1.Init.Prescaler = 0;
htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
htim1.Init.Period = 65535;
htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim1.Init.RepetitionCounter = 0;
HAL_TIM_IC_Init(&htim1);

sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_RISING;
sConfigIC.ICSelection = TIM_ICSELECTION_DIRECTTI;
sConfigIC.ICPrescaler = TIM_ICPSC_DIV1;
sConfigIC.ICFilter = 0;
HAL_TIM_IC_ConfigChannel(&htim1, &sConfigIC, TIM_CHANNEL_1);

HAL_TIM_IC_ConfigChannel(&htim1, &sConfigIC, TIM_CHANNEL_2);

sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig);

}

/[i] TIM3 init function [/i]/
void MX_TIM3_Init(void)
{

TIM_ClockConfigTypeDef sClockSourceConfig;
TIM_MasterConfigTypeDef sMasterConfig;

htim3.Instance = TIM3;
htim3.Init.Prescaler = 8399;
htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
htim3.Init.Period = 99;
htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
HAL_TIM_Base_Init(&htim3);

sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig);

sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig);

}

/[i] USART1 init function [/i]/
void MX_USART1_UART_Init(void)
{

huart1.Instance = USART1;
huart1.Init.BaudRate = 115200;
huart1.Init.WordLength = UART_WORDLENGTH_8B;
huart1.Init.StopBits = UART_STOPBITS_1;
huart1.Init.Parity = UART_PARITY_NONE;
huart1.Init.Mode = UART_MODE_TX_RX;
huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart1.Init.OverSampling = UART_OVERSAMPLING_16;
HAL_UART_Init(&huart1);

}

/** Configure pins as
* Analog
* Input
* Output
* EVENT_OUT
* EXTI
*/
void MX_GPIO_Init(void)
{

GPIO_InitTypeDef GPIO_InitStruct;

/[i] GPIO Ports Clock Enable [/i]/
__GPIOF_CLK_ENABLE();
__GPIOH_CLK_ENABLE();
__GPIOE_CLK_ENABLE();
__GPIOB_CLK_ENABLE();

/[i]Configure GPIO pin : PF6 [/i]/
GPIO_InitStruct.Pin = GPIO_PIN_6;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FAST;
HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);

}

/[i] USER CODE BEGIN 4 [/i]/
static void Error_Handler(void)
{
/[i] Turn LED3 on [/i]/
HAL_GPIO_WritePin (GPIOF,GPIO_PIN_6,GPIO_PIN_SET );
while(1)
{
}
}
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
/* NOTE : This function Should not be modified, when the callback is needed,
the __HAL_TIM_PeriodElapsedCallback could be implemented in the user file
*/
v_value1 = cont_value1;v_value2 = cont_value2;
// cont_value = 0;
HAL_GPIO_TogglePin (GPIOF,GPIO_PIN_6);

}
/**
* @brief Conversion complete callback in non blocking mode
* @param htim : hadc handle
* @retval None
*/
void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_1)
{

/[i] Get the 1st Input Capture value [/i]/
cont_value1 ++;

}
if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_2)
{

/[i] Get the 1st Input Capture value [/i]/
cont_value2 ++;

}
}
/[i] USER CODE END 4 [/i]/

#ifdef USE_FULL_ASSERT

/**
* @brief Reports the name of the source file and the source line number
* where the assert_param error has occurred.
* @param file: pointer to the source file name
* @param line: assert_param error line source number
* @retval None
*/
void assert_failed(uint8_t* file, uint32_t line)
{
/[i] USER CODE BEGIN 6 [/i]/
/* User can add his own implementation to report the file name and line number,
ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
/[i] USER CODE END 6 [/i]/

}

#endif 查看全部
本次利用了,stm32cubemx生成代码,稍微在main中添加得到
打开cubemx,先设置pinout选项卡。
rcc选择crystal。外部时钟
TIM1中选择Channel1的Input Capture direct mode
TIM1中选择Channel2的Input Capture direct mode

TIM3中Clock Source选择Internal Clock
Usart1中MOde选择Asynchronous

其他所有的默认即可。
TIM1用于计数,两个通道同时计数。
TIM3用于定时,并且生成一个脉冲信号
usart用于输出计数结果

Clock configuration选项卡中
时钟我用的25M晶振,系统时钟设为168MHz
APB1 Prescaler 选4,APB2 Prescaler选2

Configuration选项卡中,
usart设置不再讲述,可以去看网站里面的帖子
NVIC按钮打开后,TIM1 Capture Compare interrupt 设为0,2
TIM3 gloable interrupt 设置 0,1
并且以上开启使能
TIM1设置页打开后 counter period (autoreload register-16bits value) 设为65535,up,其他不变,tim1的gpio都设为Pull-up,high
Tim3设置页 prescaler (psc-16 bits value) 为8399
紧接着up,继续9999
最后update event。

好了,设置结束,生成代码,
main.c中的代码:其他的文件没变啊,自己对比添加了哪些吧,懒得一个个写


/[i] Includes ------------------------------------------------------------------[/i]/
#include "stm32f4xx_hal.h"

/[i] Private variables ---------------------------------------------------------[/i]/
TIM_HandleTypeDef htim1;
TIM_HandleTypeDef htim3;

UART_HandleTypeDef huart1;

/[i] USER CODE BEGIN 0 [/i]/
#include "stdio.h"
#ifdef __GNUC__
/* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf
set to 'Yes') calls __io_putchar() */
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif /[i] __GNUC__ [/i]/

/**
* @brief Retargets the C library printf function to the USART.
* @param None
* @retval None
*/
PUTCHAR_PROTOTYPE
{
/[i] Place your implementation of fputc here [/i]/
/[i] e.g. write a character to the EVAL_COM1 and Loop until the end of transmission [/i]/
HAL_UART_Transmit(&huart1 , (uint8_t *)&ch, 1, 0xFFFF);
return ch;
}
uint32_t cont_value1 = 0;
uint32_t cont_value2 = 0;
uint32_t v_value1 = 0;
uint32_t v_value2 = 0;
static void Error_Handler(void);
/[i] USER CODE END 0 [/i]/

/[i] Private function prototypes -----------------------------------------------[/i]/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_TIM1_Init(void);
static void MX_TIM3_Init(void);
static void MX_USART1_UART_Init(void);

int main(void)
{

/[i] USER CODE BEGIN 1 [/i]/

/[i] USER CODE END 1 [/i]/

/[i] MCU Configuration----------------------------------------------------------[/i]/

/[i] Reset of all peripherals, Initializes the Flash interface and the Systick. [/i]/
HAL_Init();

/[i] Configure the system clock [/i]/
SystemClock_Config();

/[i] System interrupt init[/i]/
/[i] Sets the priority grouping field [/i]/
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_0);
HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);

/[i] Initialize all configured peripherals [/i]/
MX_GPIO_Init();
MX_TIM1_Init();
MX_TIM3_Init();
MX_USART1_UART_Init();

/[i] USER CODE BEGIN 2 [/i]/
HAL_TIM_Base_Start_IT (&htim3 );
if(HAL_TIM_IC_Start_IT(&htim1, TIM_CHANNEL_2) != HAL_OK)
{
/[i] Starting Error [/i]/
Error_Handler();
}
if(HAL_TIM_IC_Start_IT(&htim1, TIM_CHANNEL_1) != HAL_OK)
{
/[i] Starting Error [/i]/
Error_Handler();
}
/[i] USER CODE END 2 [/i]/

/[i] USER CODE BEGIN 3 [/i]/
/[i] Infinite loop [/i]/
while (1)
{
// HAL_Delay(1000);

// printf ("hello ,my world!");
HAL_Delay(1000);
printf ("%d , %d \r\n",v_value1, v_value2);
cont_value1= 0;cont_value2= 0;

}
/[i] USER CODE END 3 [/i]/

}

/** System Clock Configuration
*/
void SystemClock_Config(void)
{

RCC_ClkInitTypeDef RCC_ClkInitStruct;
RCC_OscInitTypeDef RCC_OscInitStruct;

__PWR_CLK_ENABLE();

__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLM = 25;
RCC_OscInitStruct.PLL.PLLN = 336;
RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
RCC_OscInitStruct.PLL.PLLQ = 4;
HAL_RCC_OscConfig(&RCC_OscInitStruct);

RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_SYSCLK|RCC_CLOCKTYPE_PCLK1
|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5);

}

/[i] TIM1 init function [/i]/
void MX_TIM1_Init(void)
{

TIM_IC_InitTypeDef sConfigIC;
TIM_MasterConfigTypeDef sMasterConfig;

htim1.Instance = TIM1;
htim1.Init.Prescaler = 0;
htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
htim1.Init.Period = 65535;
htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim1.Init.RepetitionCounter = 0;
HAL_TIM_IC_Init(&htim1);

sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_RISING;
sConfigIC.ICSelection = TIM_ICSELECTION_DIRECTTI;
sConfigIC.ICPrescaler = TIM_ICPSC_DIV1;
sConfigIC.ICFilter = 0;
HAL_TIM_IC_ConfigChannel(&htim1, &sConfigIC, TIM_CHANNEL_1);

HAL_TIM_IC_ConfigChannel(&htim1, &sConfigIC, TIM_CHANNEL_2);

sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig);

}

/[i] TIM3 init function [/i]/
void MX_TIM3_Init(void)
{

TIM_ClockConfigTypeDef sClockSourceConfig;
TIM_MasterConfigTypeDef sMasterConfig;

htim3.Instance = TIM3;
htim3.Init.Prescaler = 8399;
htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
htim3.Init.Period = 99;
htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
HAL_TIM_Base_Init(&htim3);

sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig);

sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig);

}

/[i] USART1 init function [/i]/
void MX_USART1_UART_Init(void)
{

huart1.Instance = USART1;
huart1.Init.BaudRate = 115200;
huart1.Init.WordLength = UART_WORDLENGTH_8B;
huart1.Init.StopBits = UART_STOPBITS_1;
huart1.Init.Parity = UART_PARITY_NONE;
huart1.Init.Mode = UART_MODE_TX_RX;
huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart1.Init.OverSampling = UART_OVERSAMPLING_16;
HAL_UART_Init(&huart1);

}

/** Configure pins as
* Analog
* Input
* Output
* EVENT_OUT
* EXTI
*/
void MX_GPIO_Init(void)
{

GPIO_InitTypeDef GPIO_InitStruct;

/[i] GPIO Ports Clock Enable [/i]/
__GPIOF_CLK_ENABLE();
__GPIOH_CLK_ENABLE();
__GPIOE_CLK_ENABLE();
__GPIOB_CLK_ENABLE();

/[i]Configure GPIO pin : PF6 [/i]/
GPIO_InitStruct.Pin = GPIO_PIN_6;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FAST;
HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);

}

/[i] USER CODE BEGIN 4 [/i]/
static void Error_Handler(void)
{
/[i] Turn LED3 on [/i]/
HAL_GPIO_WritePin (GPIOF,GPIO_PIN_6,GPIO_PIN_SET );
while(1)
{
}
}
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
/* NOTE : This function Should not be modified, when the callback is needed,
the __HAL_TIM_PeriodElapsedCallback could be implemented in the user file
*/
v_value1 = cont_value1;v_value2 = cont_value2;
// cont_value = 0;
HAL_GPIO_TogglePin (GPIOF,GPIO_PIN_6);

}
/**
* @brief Conversion complete callback in non blocking mode
* @param htim : hadc handle
* @retval None
*/
void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_1)
{

/[i] Get the 1st Input Capture value [/i]/
cont_value1 ++;

}
if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_2)
{

/[i] Get the 1st Input Capture value [/i]/
cont_value2 ++;

}
}
/[i] USER CODE END 4 [/i]/

#ifdef USE_FULL_ASSERT

/**
* @brief Reports the name of the source file and the source line number
* where the assert_param error has occurred.
* @param file: pointer to the source file name
* @param line: assert_param error line source number
* @retval None
*/
void assert_failed(uint8_t* file, uint32_t line)
{
/[i] USER CODE BEGIN 6 [/i]/
/* User can add his own implementation to report the file name and line number,
ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
/[i] USER CODE END 6 [/i]/

}

#endif

stm32cube中文教程:运行中修改TIM定时时间的例子将1s定时运行中改成200ms定时

admin 发表了文章 • 0 个评论 • 4359 次浏览 • 2014-10-14 00:14 • 来自相关话题

本实验用stm32cubemx生成定时器4的1s定时,然后准备在运行过程中更改定时时间
考虑程序中初始化后定时修改时再次init初始化,应该就可以了。
关于用stm32cube生成定时的方法,请找本论坛文章。
本程序只在原来定时中断中增加了再次初始化代码。
运行正常,测试通过。
代码如下:

其他代码不给出了,只贴出修改了的代码:
在main文件中的定时中断函数中增加:


void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
/* NOTE : This function Should not be modified, when the callback is needed,
the __HAL_TIM_PeriodElapsedCallback could be implemented in the user file
*/
flag++;
HAL_GPIO_TogglePin (GPIOD,GPIO_PIN_14);
if(flag==20)
{
htim4.Init.Period = 1999;
HAL_TIM_Base_Init(&htim4);
}
}

其中flag是计数标示,用来记进入了几次中断,程序中断20次后,修改Period ,然后固化,
之后程序开始以200ms开始闪烁。灯是PD14. 查看全部
本实验用stm32cubemx生成定时器4的1s定时,然后准备在运行过程中更改定时时间
考虑程序中初始化后定时修改时再次init初始化,应该就可以了。
关于用stm32cube生成定时的方法,请找本论坛文章。
本程序只在原来定时中断中增加了再次初始化代码。
运行正常,测试通过。
代码如下:

其他代码不给出了,只贴出修改了的代码:
在main文件中的定时中断函数中增加:


void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
/* NOTE : This function Should not be modified, when the callback is needed,
the __HAL_TIM_PeriodElapsedCallback could be implemented in the user file
*/
flag++;
HAL_GPIO_TogglePin (GPIOD,GPIO_PIN_14);
if(flag==20)
{
htim4.Init.Period = 1999;
HAL_TIM_Base_Init(&htim4);
}
}

其中flag是计数标示,用来记进入了几次中断,程序中断20次后,修改Period ,然后固化,
之后程序开始以200ms开始闪烁。灯是PD14.

stm32cube中文教程:DAC输出模拟电压,用12位精度DA最大3.3v,学习笔记

admin 发表了文章 • 0 个评论 • 7487 次浏览 • 2014-10-14 00:11 • 来自相关话题

用stm32cubemx生成DA输出真对stm32f407的模拟输出电压,很简单
首先,配置时钟,168M,我用的stm32f407discovery板。
这些配置操作我以前提到过,不懂的可以在这个论坛里找找,有图文注释的。
直接点取DAC的通道1,然后去configariton里面配置DAC,其实无需配置,不用改任何东西
生成代码。
打开main文件,找到main函数中初始化后添加:
这个是我自己的例子,你可以适当修改


/[i][size=16]-4- Enable DAC Channel1 [/size]#########################[size=16]#[size=16]#[size=16]#[size=16]#[size=16]#[size=16]#[size=16]#[/i]/ [/size][/size][/size][/size][/size][/size][/size]
if(HAL_DAC_Start(&hdac, DAC_CHANNEL_1) != HAL_OK)
{
/[i] Start Error [/i]/
Error_Handler();
}

/[i] USER CODE END 2 [/i]/

/[i] USER CODE BEGIN 3 [/i]/
/[i] Infinite loop [/i]/
while (1)
{


HAL_Delay (1);
HAL_GPIO_TogglePin (GPIOF,GPIO_PIN_6 );
HAL_DAC_SetValue(&hdac, DAC_CHANNEL_1, DAC_ALIGN_12B_R, value );
if(!flag)
{ value ++; if(value==0xfff){ flag=1; }} else { value--;if(!value) flag=0; }
}

代码注释:第一个意思是开启dac的通道1.
while中的意思是:设置DA的值,我用的12位精度,右对齐,值是value,通道DAC_CHANNEL_1
值value从0增加到4095即0xfff,然后从0xfff减小到0,无限循环,哦,上面还有个指示灯,不过
这么高的频率是指示不出来的。是i我调试其他的时候加的,可以无视它。

用示波器 测量PA4管脚(这个就是DA的输出口1),会看到波形类似三角波,电压是从0升到3.3然后再降到0v,ok,结束实验 查看全部
用stm32cubemx生成DA输出真对stm32f407的模拟输出电压,很简单
首先,配置时钟,168M,我用的stm32f407discovery板。
这些配置操作我以前提到过,不懂的可以在这个论坛里找找,有图文注释的。
直接点取DAC的通道1,然后去configariton里面配置DAC,其实无需配置,不用改任何东西
生成代码。
打开main文件,找到main函数中初始化后添加:
这个是我自己的例子,你可以适当修改


/[i][size=16]-4- Enable DAC Channel1 [/size]#########################[size=16]#[size=16]#[size=16]#[size=16]#[size=16]#[size=16]#[size=16]#[/i]/ [/size][/size][/size][/size][/size][/size][/size]
if(HAL_DAC_Start(&hdac, DAC_CHANNEL_1) != HAL_OK)
{
/[i] Start Error [/i]/
Error_Handler();
}

/[i] USER CODE END 2 [/i]/

/[i] USER CODE BEGIN 3 [/i]/
/[i] Infinite loop [/i]/
while (1)
{


HAL_Delay (1);
HAL_GPIO_TogglePin (GPIOF,GPIO_PIN_6 );
HAL_DAC_SetValue(&hdac, DAC_CHANNEL_1, DAC_ALIGN_12B_R, value );
if(!flag)
{ value ++; if(value==0xfff){ flag=1; }} else { value--;if(!value) flag=0; }
}

代码注释:第一个意思是开启dac的通道1.
while中的意思是:设置DA的值,我用的12位精度,右对齐,值是value,通道DAC_CHANNEL_1
值value从0增加到4095即0xfff,然后从0xfff减小到0,无限循环,哦,上面还有个指示灯,不过
这么高的频率是指示不出来的。是i我调试其他的时候加的,可以无视它。

用示波器 测量PA4管脚(这个就是DA的输出口1),会看到波形类似三角波,电压是从0升到3.3然后再降到0v,ok,结束实验

stm32cube中文教程:操作24c02程序,调用I2C可直接写数据,完整代码

admin 发表了文章 • 33 个评论 • 8617 次浏览 • 2014-10-14 00:10 • 来自相关话题

以前用stm32cubemx生成的代码写I2C的24c02很麻烦,因为自动生成的代码时对分页操作的
分页操作又没有弄对数据地址自动分页的代码,于是,手动分页写数据,安排数据地址。
坑死了。
研究了下,自己写了几个函数省去以上的麻烦。
方法很简单,前面的帖子里面我也提到了代码。
将要写的数据按照一个字节一个字节的方法写入就绝对不存在分页问题,而且读取操作页不存在分页问题,好了,完整代码如下:
文件:24C02.C内容


/[i] Includes ------------------------------------------------------------------[/i]/
#include "24C02.h"
#include "stdio.h"
__IO uint32_t I2CTimeout = I2C_Open_LONG_TIMEOUT;

static void I2C_delay(uint16_t cnt);

/*******************************************************************************
* Function Name : I2C_delay
* Description :
* Input : None
* Output : None
* Return : None
* Attention : None
*******************************************************************************/
static void I2C_delay(uint16_t cnt)
{
while(cnt--);
}
/*******************************************************************************
* Function Name : I2C_Read
* Description :
* Input :
* Output :
* Return :
* Attention : None
*******************************************************************************/
uint8_t I2C_Read(I2C_HandleTypeDef [i]I2Cx,uint8_t I2C_Addr,uint8_t addr,uint8_t [/i]buf,uint16_t num)
{
uint8_t err=0;
while(HAL_I2C_Mem_Read (I2Cx ,I2C_Addr,addr,I2C_MEMADD_SIZE_8BIT,buf,num,I2CTimeout) != HAL_OK ){};

//err = HAL_I2C_Mem_Read(I2Cx, I2C_Addr, addr, I2C_MEMADD_SIZE_8BIT, buf, num, I2CTimeout);
if(err)
return err;
else
return 0;
}

/*******************************************************************************
* Function Name : I2C_WriteOneByte
* Description :
* Input :
* Output : None
* Return :
* Attention : None
*******************************************************************************/
uint8_t I2C_WriteOneByte(I2C_HandleTypeDef *I2Cx,uint8_t I2C_Addr,uint8_t addr,uint8_t value)
{
// uint8_t err=0;

while( HAL_I2C_Mem_Write(I2Cx, I2C_Addr, addr, I2C_MEMADD_SIZE_8BIT, &value, 0x01, I2CTimeout) != HAL_OK ){};
//I2C_delay(50000);
// if(err)
// return 1;
// else
// return 0;
}

学习 stm32cubemx软件编程,来STM32CUBE.COM ,随时更新!
/*******************************************************************************
* Function Name : I2C_Write
* Description :
* Input :
* Output : None
* Return :
* Attention : None
*******************************************************************************/
uint8_t I2C_Write(I2C_HandleTypeDef [i]I2Cx,uint8_t I2C_Addr,uint8_t addr,uint8_t [/i]buf,uint16_t num)
{
uint8_t err=0;

while(num--)
{
I2C_WriteOneByte(I2Cx, I2C_Addr,addr++,*buf++);
// if(I2C_WriteOneByte(I2Cx, I2C_Addr,addr++,*buf++))
// {
// err++;
// }
}
// if(err)
// return 1;
// else
// return 0;
}

/*********************************************************************************************************
END FILE
*********************************************************************************************************/

文件24C02.H内容:


#ifndef __24C02_H
#define __24C02_H

/[i] Includes ------------------------------------------------------------------[/i]/
#include "stm32f4xx_hal.h"

/[i] Private define ------------------------------------------------------------[/i]/
#define AT24C01A
//#define AT24C01

#define ADDR_24LC02 0xA0
#define I2C_PAGESIZE 4


/* Maximum Timeout values for flags and events waiting loops. These timeouts are
not based on accurate values, they just guarantee that the application will
not remain stuck if the I2C communication is corrupted.
You may modify these timeout values depending on CPU frequency and application
conditions (interrupts routines ...). */
#define I2C_Open_FLAG_TIMEOUT ((uint32_t)0x1000)
#define I2C_Open_LONG_TIMEOUT ((uint32_t)0xffff)

/[i] Private function prototypes -----------------------------------------------[/i]/
uint8_t I2C_Read(I2C_HandleTypeDef [i]I2Cx,uint8_t I2C_Addr,uint8_t addr,uint8_t [/i]buf,uint16_t num);
uint8_t I2C_Write(I2C_HandleTypeDef [i]I2Cx,uint8_t I2C_Addr,uint8_t addr,uint8_t [/i]buf,uint16_t num);

#endif

/*********************************************************************************************************
END FILE
*********************************************************************************************************/


代码就那么多。
下面介绍下用法:
首先main文件肯定要调用


#include "24c02.h"
#include "stdio.h"
#include "string.h"


到了该写数据的地方,直接调用上面的函数,如下:


I2C_Write(&hi2c2,ADDR_24LC02,0x05,(uint8_t *)WriteBuffer,sizeof(WriteBuffer) );


我用的是stm32cube中的I2C2口,而ADDR_24LC02前面的函数H文件中已经有了,从地质0x05
开始写入,写入的是WriteBuffer这个结构表数据,里面包含了sizeof(WriteBuffer) 这么多个数据,读取的时候用


I2C_Read(&hi2c2,ADDR_24LC02,0x05,(uint8_t *)ReadBuffer,sizeof(WriteBuffer) )


同上,读取数据到ReadBuffer这个结构表中。嗯,以上结束。
有问题可以留言。
原创转载请注明。
所有本站实验过的程序都可以到【资源下载】网盘里找到........... 查看全部
以前用stm32cubemx生成的代码写I2C的24c02很麻烦,因为自动生成的代码时对分页操作的
分页操作又没有弄对数据地址自动分页的代码,于是,手动分页写数据,安排数据地址。
坑死了。
研究了下,自己写了几个函数省去以上的麻烦。
方法很简单,前面的帖子里面我也提到了代码。
将要写的数据按照一个字节一个字节的方法写入就绝对不存在分页问题,而且读取操作页不存在分页问题,好了,完整代码如下:
文件:24C02.C内容


/[i] Includes ------------------------------------------------------------------[/i]/
#include "24C02.h"
#include "stdio.h"
__IO uint32_t I2CTimeout = I2C_Open_LONG_TIMEOUT;

static void I2C_delay(uint16_t cnt);

/*******************************************************************************
* Function Name : I2C_delay
* Description :
* Input : None
* Output : None
* Return : None
* Attention : None
*******************************************************************************/
static void I2C_delay(uint16_t cnt)
{
while(cnt--);
}
/*******************************************************************************
* Function Name : I2C_Read
* Description :
* Input :
* Output :
* Return :
* Attention : None
*******************************************************************************/
uint8_t I2C_Read(I2C_HandleTypeDef [i]I2Cx,uint8_t I2C_Addr,uint8_t addr,uint8_t [/i]buf,uint16_t num)
{
uint8_t err=0;
while(HAL_I2C_Mem_Read (I2Cx ,I2C_Addr,addr,I2C_MEMADD_SIZE_8BIT,buf,num,I2CTimeout) != HAL_OK ){};

//err = HAL_I2C_Mem_Read(I2Cx, I2C_Addr, addr, I2C_MEMADD_SIZE_8BIT, buf, num, I2CTimeout);
if(err)
return err;
else
return 0;
}

/*******************************************************************************
* Function Name : I2C_WriteOneByte
* Description :
* Input :
* Output : None
* Return :
* Attention : None
*******************************************************************************/
uint8_t I2C_WriteOneByte(I2C_HandleTypeDef *I2Cx,uint8_t I2C_Addr,uint8_t addr,uint8_t value)
{
// uint8_t err=0;

while( HAL_I2C_Mem_Write(I2Cx, I2C_Addr, addr, I2C_MEMADD_SIZE_8BIT, &value, 0x01, I2CTimeout) != HAL_OK ){};
//I2C_delay(50000);
// if(err)
// return 1;
// else
// return 0;
}

学习 stm32cubemx软件编程,来STM32CUBE.COM ,随时更新!
/*******************************************************************************
* Function Name : I2C_Write
* Description :
* Input :
* Output : None
* Return :
* Attention : None
*******************************************************************************/
uint8_t I2C_Write(I2C_HandleTypeDef [i]I2Cx,uint8_t I2C_Addr,uint8_t addr,uint8_t [/i]buf,uint16_t num)
{
uint8_t err=0;

while(num--)
{
I2C_WriteOneByte(I2Cx, I2C_Addr,addr++,*buf++);
// if(I2C_WriteOneByte(I2Cx, I2C_Addr,addr++,*buf++))
// {
// err++;
// }
}
// if(err)
// return 1;
// else
// return 0;
}

/*********************************************************************************************************
END FILE
*********************************************************************************************************/

文件24C02.H内容:


#ifndef __24C02_H
#define __24C02_H

/[i] Includes ------------------------------------------------------------------[/i]/
#include "stm32f4xx_hal.h"

/[i] Private define ------------------------------------------------------------[/i]/
#define AT24C01A
//#define AT24C01

#define ADDR_24LC02 0xA0
#define I2C_PAGESIZE 4


/* Maximum Timeout values for flags and events waiting loops. These timeouts are
not based on accurate values, they just guarantee that the application will
not remain stuck if the I2C communication is corrupted.
You may modify these timeout values depending on CPU frequency and application
conditions (interrupts routines ...). */
#define I2C_Open_FLAG_TIMEOUT ((uint32_t)0x1000)
#define I2C_Open_LONG_TIMEOUT ((uint32_t)0xffff)

/[i] Private function prototypes -----------------------------------------------[/i]/
uint8_t I2C_Read(I2C_HandleTypeDef [i]I2Cx,uint8_t I2C_Addr,uint8_t addr,uint8_t [/i]buf,uint16_t num);
uint8_t I2C_Write(I2C_HandleTypeDef [i]I2Cx,uint8_t I2C_Addr,uint8_t addr,uint8_t [/i]buf,uint16_t num);

#endif

/*********************************************************************************************************
END FILE
*********************************************************************************************************/


代码就那么多。
下面介绍下用法:
首先main文件肯定要调用


#include "24c02.h"
#include "stdio.h"
#include "string.h"


到了该写数据的地方,直接调用上面的函数,如下:


I2C_Write(&hi2c2,ADDR_24LC02,0x05,(uint8_t *)WriteBuffer,sizeof(WriteBuffer) );


我用的是stm32cube中的I2C2口,而ADDR_24LC02前面的函数H文件中已经有了,从地质0x05
开始写入,写入的是WriteBuffer这个结构表数据,里面包含了sizeof(WriteBuffer) 这么多个数据,读取的时候用


I2C_Read(&hi2c2,ADDR_24LC02,0x05,(uint8_t *)ReadBuffer,sizeof(WriteBuffer) )


同上,读取数据到ReadBuffer这个结构表中。嗯,以上结束。
有问题可以留言。
原创转载请注明。
所有本站实验过的程序都可以到【资源下载】网盘里找到...........

stm32cube中文教程:TIM3定时1S完整代码分析与实现

admin 发表了文章 • 15 个评论 • 15847 次浏览 • 2014-10-14 00:03 • 来自相关话题

纯粹用的stm32cubemx软件自动生成,特此记录,为以后理解做准备。
要修改的我写在下面了,其他不提及的都是默认的不变即可
1,打开stm32cubemx,点PINout选项卡里面的RCC里面选项high speed clock选crystal。
同时,PINOUT选项卡里的tim3里面的clock source 选择internal clock,右边管脚画面里面选择PD12和13为输出。
额,我例子里面包含了PA0作为外部中断0口,这个你可以不用选。
好了。
2,stm32cubemx的clock选项里面设置外部8M,系统时钟168M,APB1为84M。
3,点stm32cubemx的configuration选项卡,gpio设置为推挽输出,上啦,nvic中断优先级
中断分组0,system tic timer为0,0
exti line0 interrupt 为0,1------------------这个如果上面没用到外部中断0的话就不选
Tim3 gloabal interrupt 为0,2
3,点TIM3的按钮,设置TIM3参数,Prescaler 为8399,
counter mode 为UP
counter Period为9999
master/slave mode 为 disable 不使能主从
Triggerevent selection为Update event 触发事件选事件更新
原因如下:
我这个实验是要设置PD13口的led每1S点亮和熄灭,然后循环,用定时器做,不用滴答时钟做。
即1s转换一次,即1HZ,TIM3的时钟是84Mhz。
+ Period = 10000-1 这个是定时器计数周期,即循环这么多次后产生中断
+ Prescaler = (84M/10000) - 1 这个是定时器重载数,即每次循环加载的值
要产生1s,就是10000*0.0001s,即10000次10kHZ,
所以 + Period = 10000 - 1 减1是因为从0开始计数嘛
+ Prescaler = ((SystemCoreClock/2)/10000) - 1
4,自动生成代码。
keil打开生成的代码,main中添加
HAL_TIM_Base_Start_IT (&htim3 );
文件尾部添加
(sorry,原来写错了,写成了外部中断里面的那个函数,汗,改回来了)
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
/* NOTE : This function Should not be modified, when the callback is needed,
the __HAL_TIM_PeriodElapsedCallback could be implemented in the user file
*/
HAL_GPIO_TogglePin (GPIOD ,GPIO_PIN_13);
}

完整main代码如下:


/[i] Includes ------------------------------------------------------------------[/i]/
#include "stm32f4xx_hal.h"

/[i] Private variables ---------------------------------------------------------[/i]/
TIM_HandleTypeDef htim3;

/[i] USER CODE BEGIN 0 [/i]/

/[i] USER CODE END 0 [/i]/

/[i] Private function prototypes -----------------------------------------------[/i]/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_TIM3_Init(void);

int main(void)
{

/[i] USER CODE BEGIN 1 [/i]/

/[i] USER CODE END 1 [/i]/

/[i] MCU Configuration----------------------------------------------------------[/i]/

/[i] Reset of all peripherals, Initializes the Flash interface and the Systick. [/i]/
HAL_Init();

/[i] Configure the system clock [/i]/
SystemClock_Config();

/[i] System interrupt init[/i]/
/[i] Sets the priority grouping field [/i]/
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_0);
HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);

/[i] Initialize all configured peripherals [/i]/
MX_GPIO_Init();
MX_TIM3_Init();

/[i] USER CODE BEGIN 2 [/i]/
HAL_TIM_Base_Start_IT (&htim3 );
/[i] USER CODE END 2 [/i]/

/[i] USER CODE BEGIN 3 [/i]/
/[i] Infinite loop [/i]/
while (1)
{
HAL_GPIO_TogglePin (GPIOD,GPIO_PIN_12);
HAL_Delay (1000);
}
/[i] USER CODE END 3 [/i]/

}

/** System Clock Configuration
*/
void SystemClock_Config(void)
{

RCC_ClkInitTypeDef RCC_ClkInitStruct;
RCC_OscInitTypeDef RCC_OscInitStruct;

__PWR_CLK_ENABLE();

__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLM = 8;
RCC_OscInitStruct.PLL.PLLN = 336;
RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
RCC_OscInitStruct.PLL.PLLQ = 4;
HAL_RCC_OscConfig(&RCC_OscInitStruct);

RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_SYSCLK|RCC_CLOCKTYPE_PCLK1
|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5);

}

/[i] TIM3 init function [/i]/
void MX_TIM3_Init(void)
{

TIM_ClockConfigTypeDef sClockSourceConfig;
TIM_MasterConfigTypeDef sMasterConfig;

htim3.Instance = TIM3;
htim3.Init.Prescaler = 8399;
htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
htim3.Init.Period = 9999;
htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
HAL_TIM_Base_Init(&htim3);

sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig);

sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig);

}

/** Configure pins as
* Analog
* Input
* Output
* EVENT_OUT
* EXTI
*/
void MX_GPIO_Init(void)
{

GPIO_InitTypeDef GPIO_InitStruct;

/[i] GPIO Ports Clock Enable [/i]/
__GPIOH_CLK_ENABLE();
__GPIOA_CLK_ENABLE();
__GPIOD_CLK_ENABLE();

/[i]Configure GPIO pin : PA0 [/i]/
GPIO_InitStruct.Pin = GPIO_PIN_0;
GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

/[i]Configure GPIO pins : PD12 PD13 [/i]/
GPIO_InitStruct.Pin = GPIO_PIN_12|GPIO_PIN_13;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FAST;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);

/[i] EXTI interrupt init[/i]/
/[i] Sets the priority grouping field [/i]/
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_0);
HAL_NVIC_SetPriority(EXTI0_IRQn, 0, 1);
HAL_NVIC_EnableIRQ(EXTI0_IRQn);

}

/[i] USER CODE BEGIN 4 [/i]/
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
/* NOTE : This function Should not be modified, when the callback is needed,
the __HAL_TIM_PeriodElapsedCallback could be implemented in the user file
*/
HAL_GPIO_TogglePin (GPIOD ,GPIO_PIN_13);
}
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
/* NOTE: This function Should not be modified, when the callback is needed,
the HAL_GPIO_EXTI_Callback could be implemented in the user file
*/
HAL_GPIO_TogglePin (GPIOD,GPIO_PIN_13);
}

/[i] USER CODE END 4 [/i]/ 查看全部
纯粹用的stm32cubemx软件自动生成,特此记录,为以后理解做准备。
要修改的我写在下面了,其他不提及的都是默认的不变即可
1,打开stm32cubemx,点PINout选项卡里面的RCC里面选项high speed clock选crystal。
同时,PINOUT选项卡里的tim3里面的clock source 选择internal clock,右边管脚画面里面选择PD12和13为输出。
额,我例子里面包含了PA0作为外部中断0口,这个你可以不用选。
好了。
2,stm32cubemx的clock选项里面设置外部8M,系统时钟168M,APB1为84M。
3,点stm32cubemx的configuration选项卡,gpio设置为推挽输出,上啦,nvic中断优先级
中断分组0,system tic timer为0,0
exti line0 interrupt 为0,1------------------这个如果上面没用到外部中断0的话就不选
Tim3 gloabal interrupt 为0,2
3,点TIM3的按钮,设置TIM3参数,Prescaler 为8399,
counter mode 为UP
counter Period为9999
master/slave mode 为 disable 不使能主从
Triggerevent selection为Update event 触发事件选事件更新
原因如下:
我这个实验是要设置PD13口的led每1S点亮和熄灭,然后循环,用定时器做,不用滴答时钟做。
即1s转换一次,即1HZ,TIM3的时钟是84Mhz。
+ Period = 10000-1 这个是定时器计数周期,即循环这么多次后产生中断
+ Prescaler = (84M/10000) - 1 这个是定时器重载数,即每次循环加载的值
要产生1s,就是10000*0.0001s,即10000次10kHZ,
所以 + Period = 10000 - 1 减1是因为从0开始计数嘛
+ Prescaler = ((SystemCoreClock/2)/10000) - 1
4,自动生成代码。
keil打开生成的代码,main中添加
HAL_TIM_Base_Start_IT (&htim3 );
文件尾部添加
(sorry,原来写错了,写成了外部中断里面的那个函数,汗,改回来了)
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
/* NOTE : This function Should not be modified, when the callback is needed,
the __HAL_TIM_PeriodElapsedCallback could be implemented in the user file
*/
HAL_GPIO_TogglePin (GPIOD ,GPIO_PIN_13);
}

完整main代码如下:


/[i] Includes ------------------------------------------------------------------[/i]/
#include "stm32f4xx_hal.h"

/[i] Private variables ---------------------------------------------------------[/i]/
TIM_HandleTypeDef htim3;

/[i] USER CODE BEGIN 0 [/i]/

/[i] USER CODE END 0 [/i]/

/[i] Private function prototypes -----------------------------------------------[/i]/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_TIM3_Init(void);

int main(void)
{

/[i] USER CODE BEGIN 1 [/i]/

/[i] USER CODE END 1 [/i]/

/[i] MCU Configuration----------------------------------------------------------[/i]/

/[i] Reset of all peripherals, Initializes the Flash interface and the Systick. [/i]/
HAL_Init();

/[i] Configure the system clock [/i]/
SystemClock_Config();

/[i] System interrupt init[/i]/
/[i] Sets the priority grouping field [/i]/
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_0);
HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);

/[i] Initialize all configured peripherals [/i]/
MX_GPIO_Init();
MX_TIM3_Init();

/[i] USER CODE BEGIN 2 [/i]/
HAL_TIM_Base_Start_IT (&htim3 );
/[i] USER CODE END 2 [/i]/

/[i] USER CODE BEGIN 3 [/i]/
/[i] Infinite loop [/i]/
while (1)
{
HAL_GPIO_TogglePin (GPIOD,GPIO_PIN_12);
HAL_Delay (1000);
}
/[i] USER CODE END 3 [/i]/

}

/** System Clock Configuration
*/
void SystemClock_Config(void)
{

RCC_ClkInitTypeDef RCC_ClkInitStruct;
RCC_OscInitTypeDef RCC_OscInitStruct;

__PWR_CLK_ENABLE();

__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLM = 8;
RCC_OscInitStruct.PLL.PLLN = 336;
RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
RCC_OscInitStruct.PLL.PLLQ = 4;
HAL_RCC_OscConfig(&RCC_OscInitStruct);

RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_SYSCLK|RCC_CLOCKTYPE_PCLK1
|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5);

}

/[i] TIM3 init function [/i]/
void MX_TIM3_Init(void)
{

TIM_ClockConfigTypeDef sClockSourceConfig;
TIM_MasterConfigTypeDef sMasterConfig;

htim3.Instance = TIM3;
htim3.Init.Prescaler = 8399;
htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
htim3.Init.Period = 9999;
htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
HAL_TIM_Base_Init(&htim3);

sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig);

sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig);

}

/** Configure pins as
* Analog
* Input
* Output
* EVENT_OUT
* EXTI
*/
void MX_GPIO_Init(void)
{

GPIO_InitTypeDef GPIO_InitStruct;

/[i] GPIO Ports Clock Enable [/i]/
__GPIOH_CLK_ENABLE();
__GPIOA_CLK_ENABLE();
__GPIOD_CLK_ENABLE();

/[i]Configure GPIO pin : PA0 [/i]/
GPIO_InitStruct.Pin = GPIO_PIN_0;
GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

/[i]Configure GPIO pins : PD12 PD13 [/i]/
GPIO_InitStruct.Pin = GPIO_PIN_12|GPIO_PIN_13;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FAST;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);

/[i] EXTI interrupt init[/i]/
/[i] Sets the priority grouping field [/i]/
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_0);
HAL_NVIC_SetPriority(EXTI0_IRQn, 0, 1);
HAL_NVIC_EnableIRQ(EXTI0_IRQn);

}

/[i] USER CODE BEGIN 4 [/i]/
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
/* NOTE : This function Should not be modified, when the callback is needed,
the __HAL_TIM_PeriodElapsedCallback could be implemented in the user file
*/
HAL_GPIO_TogglePin (GPIOD ,GPIO_PIN_13);
}
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
/* NOTE: This function Should not be modified, when the callback is needed,
the HAL_GPIO_EXTI_Callback could be implemented in the user file
*/
HAL_GPIO_TogglePin (GPIOD,GPIO_PIN_13);
}

/[i] USER CODE END 4 [/i]/

stm32cube中文教程:AD用TIM8定时采集,uart3输出

admin 发表了文章 • 16 个评论 • 6136 次浏览 • 2014-10-13 23:45 • 来自相关话题

stm32cube中文教程:AD用TIM8定时采集,uart3输出
arm片子stm32f407ZGT,用ADC1,TIM8,UART3,。
ad脚PB0,uart脚PB10和11,PF6输出led灯。
晶振25M,时钟168M。
stm32cubemx软件设置:
uart9600,8,0,1,不使能uart中断,TX:PULL_up,fast。RX:NO PULL_UP,fast
DMA不使能。
ADC设置:修改了continuous conversion mode:enable;end of conversion selection :Eoc flag signle channel

External Trigger conversion Edge : Trigger detection on the rising edge
External Trigger Conversion Source : Time 8 Trigger Out event
其余的默认即可。
ADC中断不使能。
TIme8定时设置:
Prescaler(psc - 16 bits value) : 0
counter mode : UP
counter Period(autoreload register - 16 bits value) : 60
internal clock division (CDK) : NO Division
Repetition counter(RCR - 8bits value) : 0
slave mode controller : trigger mode
master/slave mode : Disable
trigger event selection : Update enent
不使能任何TIM中断,DMA不使能。
----------------------------------------------------------
以上软件配置结束,自动生成代码即可。
main文件中添加:


#include "stdio.h"
#ifdef __GNUC__
/* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf
set to 'Yes') calls __io_putchar() */
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif /[i] __GNUC__ [/i]/

/**
* @brief Retargets the C library printf function to the USART.
* @param None
* @retval None
*/
PUTCHAR_PROTOTYPE
{
/[i] Place your implementation of fputc here [/i]/
/[i] e.g. write a character to the EVAL_COM1 and Loop until the end of transmission [/i]/
HAL_UART_Transmit(&huart3 , (uint8_t *)&ch, 1, 0xFFFF);
return ch;
}

---------------------------------------为了能使用printf。
main()函数中添加:


/[i] USER CODE BEGIN 2 [/i]/
/[i][size=16]-3- Start the conversion process and enable interrupt [/size]#[size=16]#[size=16]#[size=16]#[size=16]#[size=16]#[/i]/ [/size][/size][/size][/size][/size]
if(HAL_ADC_Start_IT(&hadc1) != HAL_OK)
{
/[i] Start Conversation Error [/i]/
// Error_Handler();
HAL_GPIO_WritePin (GPIOF,GPIO_PIN_6,GPIO_PIN_SET );
HAL_Delay (5000);
}
if(HAL_TIM_Base_Start(&htim8) != HAL_OK)
{
/[i] Counter Enable Error [/i]/
//Error_Handler();
HAL_GPIO_WritePin (GPIOF,GPIO_PIN_6,GPIO_PIN_SET );
HAL_Delay (5000);
}

/[i] USER CODE END 2 [/i]/

/[i] USER CODE BEGIN 3 [/i]/
/[i] Infinite loop [/i]/
while (1)
{

HAL_Delay (1000);
HAL_GPIO_TogglePin (GPIOF,GPIO_PIN_6);
printf ("%d",s_value);
// HAL_ADC_Start_IT(&hadc1);
}
/[i] USER CODE END 3 [/i]/

-------------------------------------------------开启AD和TIM
底部添加:


/[i] USER CODE BEGIN 4 [/i]/
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* AdcHandle)
{
/[i] Get the converted value of regular channel [/i]/
uhADCxConvertedValue = HAL_ADC_GetValue(AdcHandle);
v_value += uhADCxConvertedValue;
count++;
if(count>=500) { s_value = v_value/500; v_value = 0; count=0; }
}

/[i] USER CODE END 4 [/i]/

---------------------------------------AD采集完成数据处理调用

其他文件不要变动。

下面是完整的main文件代码:


/[i] Includes ------------------------------------------------------------------[/i]/
#include "stm32f4xx_hal.h"

/[i] Private variables ---------------------------------------------------------[/i]/
ADC_HandleTypeDef hadc1;

TIM_HandleTypeDef htim8;

UART_HandleTypeDef huart3;

/[i] USER CODE BEGIN 0 [/i]/
#include "stdio.h"
#ifdef __GNUC__
/* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf
set to 'Yes') calls __io_putchar() */
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif /[i] __GNUC__ [/i]/

/**
* @brief Retargets the C library printf function to the USART.
* @param None
* @retval None
*/
PUTCHAR_PROTOTYPE
{
/[i] Place your implementation of fputc here [/i]/
/[i] e.g. write a character to the EVAL_COM1 and Loop until the end of transmission [/i]/
HAL_UART_Transmit(&huart3 , (uint8_t *)&ch, 1, 0xFFFF);
return ch;
}
/[i] Variable used to get converted value [/i]/
__IO uint16_t uhADCxConvertedValue = 0;
int32_t v_value;
int32_t s_value;
uint16_t count=0;
/[i] USER CODE END 0 [/i]/

/[i] Private function prototypes -----------------------------------------------[/i]/
static void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_ADC1_Init(void);
static void MX_TIM8_Init(void);
static void MX_USART3_UART_Init(void);

int main(void)
{

/[i] USER CODE BEGIN 1 [/i]/

/[i] USER CODE END 1 [/i]/

/[i] MCU Configuration----------------------------------------------------------[/i]/

/[i] Reset of all peripherals, Initializes the Flash interface and the Systick. [/i]/
HAL_Init();

/[i] Configure the system clock [/i]/
SystemClock_Config();

/[i] Initialize all configured peripherals [/i]/
MX_GPIO_Init();
MX_ADC1_Init();
MX_TIM8_Init();
MX_USART3_UART_Init();

/[i] USER CODE BEGIN 2 [/i]/
/[i][size=16]-3- Start the conversion process and enable interrupt [/size]#[size=16]#[size=16]#[size=16]#[size=16]#[size=16]#[/i]/ [/size][/size][/size][/size][/size]
if(HAL_ADC_Start_IT(&hadc1) != HAL_OK)
{
/[i] Start Conversation Error [/i]/
// Error_Handler();
HAL_GPIO_WritePin (GPIOF,GPIO_PIN_6,GPIO_PIN_SET );
HAL_Delay (5000);
}
if(HAL_TIM_Base_Start(&htim8) != HAL_OK)
{
/[i] Counter Enable Error [/i]/
//Error_Handler();
HAL_GPIO_WritePin (GPIOF,GPIO_PIN_6,GPIO_PIN_SET );
HAL_Delay (5000);
}

/[i] USER CODE END 2 [/i]/

/[i] USER CODE BEGIN 3 [/i]/
/[i] Infinite loop [/i]/
while (1)
{

HAL_Delay (1000);
HAL_GPIO_TogglePin (GPIOF,GPIO_PIN_6);
printf ("%d",s_value);
// HAL_ADC_Start_IT(&hadc1);
}
/[i] USER CODE END 3 [/i]/

}
/** System Clock Configuration
*/
static void SystemClock_Config(void)
{

RCC_ClkInitTypeDef RCC_ClkInitStruct;
RCC_OscInitTypeDef RCC_OscInitStruct;

__PWR_CLK_ENABLE();

__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLM = 25;
RCC_OscInitStruct.PLL.PLLN = 336;
RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
RCC_OscInitStruct.PLL.PLLQ = 4;
HAL_RCC_OscConfig(&RCC_OscInitStruct);

RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_SYSCLK|RCC_CLOCKTYPE_PCLK1
|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5);

}

/[i] ADC1 init function [/i]/
void MX_ADC1_Init(void)
{

ADC_ChannelConfTypeDef sConfig;
ADC_MultiModeTypeDef multimode;

/**Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion)
*/
hadc1.Instance = ADC1;
hadc1.Init.ClockPrescaler = ADC_CLOCKPRESCALER_PCLK_DIV2;
hadc1.Init.Resolution = ADC_RESOLUTION12b;
hadc1.Init.ScanConvMode = DISABLE;
hadc1.Init.ContinuousConvMode = ENABLE;
hadc1.Init.DiscontinuousConvMode = DISABLE;
hadc1.Init.NbrOfDiscConversion = 1;
hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_RISING;
hadc1.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T8_TRGO;
hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
hadc1.Init.NbrOfConversion = 1;
hadc1.Init.DMAContinuousRequests = DISABLE;
hadc1.Init.EOCSelection = EOC_SINGLE_CONV;
HAL_ADC_Init(&hadc1);

/**Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.
*/
sConfig.Channel = ADC_CHANNEL_8;
sConfig.Rank = 1;
sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES;
HAL_ADC_ConfigChannel(&hadc1, &sConfig);

/**Configure the ADC multi-mode
*/
multimode.Mode = ADC_MODE_INDEPENDENT;
multimode.TwoSamplingDelay = ADC_TWOSAMPLINGDELAY_5CYCLES;
HAL_ADCEx_MultiModeConfigChannel(&hadc1, &multimode);

}

/[i] TIM8 init function [/i]/
void MX_TIM8_Init(void)
{

TIM_SlaveConfigTypeDef sSlaveConfig;
TIM_MasterConfigTypeDef sMasterConfig;

htim8.Instance = TIM8;
htim8.Init.Prescaler = 0;
htim8.Init.CounterMode = TIM_COUNTERMODE_UP;
htim8.Init.Period = 60;
htim8.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim8.Init.RepetitionCounter = 0;
HAL_TIM_Base_Init(&htim8);

sSlaveConfig.SlaveMode = TIM_SLAVEMODE_TRIGGER;
sSlaveConfig.InputTrigger = TIM_TS_ITR0;
HAL_TIM_SlaveConfigSynchronization(&htim8, &sSlaveConfig);

sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
HAL_TIMEx_MasterConfigSynchronization(&htim8, &sMasterConfig);

}

/[i] USART3 init function [/i]/
void MX_USART3_UART_Init(void)
{

huart3.Instance = USART3;
huart3.Init.BaudRate = 9600;
huart3.Init.WordLength = UART_WORDLENGTH_8B;
huart3.Init.StopBits = UART_STOPBITS_1;
huart3.Init.Parity = UART_PARITY_NONE;
huart3.Init.Mode = UART_MODE_TX_RX;
huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart3.Init.OverSampling = UART_OVERSAMPLING_16;
HAL_UART_Init(&huart3);

}

/** Configure pins as
* Analog
* Input
* Output
* EVENT_OUT
* EXTI
*/
void MX_GPIO_Init(void)
{

GPIO_InitTypeDef GPIO_InitStruct;

/[i] GPIO Ports Clock Enable [/i]/
__GPIOF_CLK_ENABLE();
__GPIOH_CLK_ENABLE();
__GPIOB_CLK_ENABLE();

/[i]Configure GPIO pin : PF6 [/i]/
GPIO_InitStruct.Pin = GPIO_PIN_6;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FAST;
HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);

}

/[i] USER CODE BEGIN 4 [/i]/
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* AdcHandle)
{
/[i] Get the converted value of regular channel [/i]/
uhADCxConvertedValue = HAL_ADC_GetValue(AdcHandle);
v_value += uhADCxConvertedValue;
count++;
if(count>=500) { s_value = v_value/500; v_value = 0; count=0; }
}

/[i] USER CODE END 4 [/i]/ 查看全部
stm32cube中文教程:AD用TIM8定时采集,uart3输出
arm片子stm32f407ZGT,用ADC1,TIM8,UART3,。
ad脚PB0,uart脚PB10和11,PF6输出led灯。
晶振25M,时钟168M。
stm32cubemx软件设置:
uart9600,8,0,1,不使能uart中断,TX:PULL_up,fast。RX:NO PULL_UP,fast
DMA不使能。
ADC设置:修改了continuous conversion mode:enable;end of conversion selection :Eoc flag signle channel

External Trigger conversion Edge : Trigger detection on the rising edge
External Trigger Conversion Source : Time 8 Trigger Out event
其余的默认即可。
ADC中断不使能。
TIme8定时设置:
Prescaler(psc - 16 bits value) : 0
counter mode : UP
counter Period(autoreload register - 16 bits value) : 60
internal clock division (CDK) : NO Division
Repetition counter(RCR - 8bits value) : 0
slave mode controller : trigger mode
master/slave mode : Disable
trigger event selection : Update enent
不使能任何TIM中断,DMA不使能。
----------------------------------------------------------
以上软件配置结束,自动生成代码即可。
main文件中添加:


#include "stdio.h"
#ifdef __GNUC__
/* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf
set to 'Yes') calls __io_putchar() */
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif /[i] __GNUC__ [/i]/

/**
* @brief Retargets the C library printf function to the USART.
* @param None
* @retval None
*/
PUTCHAR_PROTOTYPE
{
/[i] Place your implementation of fputc here [/i]/
/[i] e.g. write a character to the EVAL_COM1 and Loop until the end of transmission [/i]/
HAL_UART_Transmit(&huart3 , (uint8_t *)&ch, 1, 0xFFFF);
return ch;
}

---------------------------------------为了能使用printf。
main()函数中添加:


/[i] USER CODE BEGIN 2 [/i]/
/[i][size=16]-3- Start the conversion process and enable interrupt [/size]#[size=16]#[size=16]#[size=16]#[size=16]#[size=16]#[/i]/ [/size][/size][/size][/size][/size]
if(HAL_ADC_Start_IT(&hadc1) != HAL_OK)
{
/[i] Start Conversation Error [/i]/
// Error_Handler();
HAL_GPIO_WritePin (GPIOF,GPIO_PIN_6,GPIO_PIN_SET );
HAL_Delay (5000);
}
if(HAL_TIM_Base_Start(&htim8) != HAL_OK)
{
/[i] Counter Enable Error [/i]/
//Error_Handler();
HAL_GPIO_WritePin (GPIOF,GPIO_PIN_6,GPIO_PIN_SET );
HAL_Delay (5000);
}

/[i] USER CODE END 2 [/i]/

/[i] USER CODE BEGIN 3 [/i]/
/[i] Infinite loop [/i]/
while (1)
{

HAL_Delay (1000);
HAL_GPIO_TogglePin (GPIOF,GPIO_PIN_6);
printf ("%d",s_value);
// HAL_ADC_Start_IT(&hadc1);
}
/[i] USER CODE END 3 [/i]/

-------------------------------------------------开启AD和TIM
底部添加:


/[i] USER CODE BEGIN 4 [/i]/
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* AdcHandle)
{
/[i] Get the converted value of regular channel [/i]/
uhADCxConvertedValue = HAL_ADC_GetValue(AdcHandle);
v_value += uhADCxConvertedValue;
count++;
if(count>=500) { s_value = v_value/500; v_value = 0; count=0; }
}

/[i] USER CODE END 4 [/i]/

---------------------------------------AD采集完成数据处理调用

其他文件不要变动。

下面是完整的main文件代码:


/[i] Includes ------------------------------------------------------------------[/i]/
#include "stm32f4xx_hal.h"

/[i] Private variables ---------------------------------------------------------[/i]/
ADC_HandleTypeDef hadc1;

TIM_HandleTypeDef htim8;

UART_HandleTypeDef huart3;

/[i] USER CODE BEGIN 0 [/i]/
#include "stdio.h"
#ifdef __GNUC__
/* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf
set to 'Yes') calls __io_putchar() */
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif /[i] __GNUC__ [/i]/

/**
* @brief Retargets the C library printf function to the USART.
* @param None
* @retval None
*/
PUTCHAR_PROTOTYPE
{
/[i] Place your implementation of fputc here [/i]/
/[i] e.g. write a character to the EVAL_COM1 and Loop until the end of transmission [/i]/
HAL_UART_Transmit(&huart3 , (uint8_t *)&ch, 1, 0xFFFF);
return ch;
}
/[i] Variable used to get converted value [/i]/
__IO uint16_t uhADCxConvertedValue = 0;
int32_t v_value;
int32_t s_value;
uint16_t count=0;
/[i] USER CODE END 0 [/i]/

/[i] Private function prototypes -----------------------------------------------[/i]/
static void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_ADC1_Init(void);
static void MX_TIM8_Init(void);
static void MX_USART3_UART_Init(void);

int main(void)
{

/[i] USER CODE BEGIN 1 [/i]/

/[i] USER CODE END 1 [/i]/

/[i] MCU Configuration----------------------------------------------------------[/i]/

/[i] Reset of all peripherals, Initializes the Flash interface and the Systick. [/i]/
HAL_Init();

/[i] Configure the system clock [/i]/
SystemClock_Config();

/[i] Initialize all configured peripherals [/i]/
MX_GPIO_Init();
MX_ADC1_Init();
MX_TIM8_Init();
MX_USART3_UART_Init();

/[i] USER CODE BEGIN 2 [/i]/
/[i][size=16]-3- Start the conversion process and enable interrupt [/size]#[size=16]#[size=16]#[size=16]#[size=16]#[size=16]#[/i]/ [/size][/size][/size][/size][/size]
if(HAL_ADC_Start_IT(&hadc1) != HAL_OK)
{
/[i] Start Conversation Error [/i]/
// Error_Handler();
HAL_GPIO_WritePin (GPIOF,GPIO_PIN_6,GPIO_PIN_SET );
HAL_Delay (5000);
}
if(HAL_TIM_Base_Start(&htim8) != HAL_OK)
{
/[i] Counter Enable Error [/i]/
//Error_Handler();
HAL_GPIO_WritePin (GPIOF,GPIO_PIN_6,GPIO_PIN_SET );
HAL_Delay (5000);
}

/[i] USER CODE END 2 [/i]/

/[i] USER CODE BEGIN 3 [/i]/
/[i] Infinite loop [/i]/
while (1)
{

HAL_Delay (1000);
HAL_GPIO_TogglePin (GPIOF,GPIO_PIN_6);
printf ("%d",s_value);
// HAL_ADC_Start_IT(&hadc1);
}
/[i] USER CODE END 3 [/i]/

}
/** System Clock Configuration
*/
static void SystemClock_Config(void)
{

RCC_ClkInitTypeDef RCC_ClkInitStruct;
RCC_OscInitTypeDef RCC_OscInitStruct;

__PWR_CLK_ENABLE();

__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLM = 25;
RCC_OscInitStruct.PLL.PLLN = 336;
RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
RCC_OscInitStruct.PLL.PLLQ = 4;
HAL_RCC_OscConfig(&RCC_OscInitStruct);

RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_SYSCLK|RCC_CLOCKTYPE_PCLK1
|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5);

}

/[i] ADC1 init function [/i]/
void MX_ADC1_Init(void)
{

ADC_ChannelConfTypeDef sConfig;
ADC_MultiModeTypeDef multimode;

/**Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion)
*/
hadc1.Instance = ADC1;
hadc1.Init.ClockPrescaler = ADC_CLOCKPRESCALER_PCLK_DIV2;
hadc1.Init.Resolution = ADC_RESOLUTION12b;
hadc1.Init.ScanConvMode = DISABLE;
hadc1.Init.ContinuousConvMode = ENABLE;
hadc1.Init.DiscontinuousConvMode = DISABLE;
hadc1.Init.NbrOfDiscConversion = 1;
hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_RISING;
hadc1.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T8_TRGO;
hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
hadc1.Init.NbrOfConversion = 1;
hadc1.Init.DMAContinuousRequests = DISABLE;
hadc1.Init.EOCSelection = EOC_SINGLE_CONV;
HAL_ADC_Init(&hadc1);

/**Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.
*/
sConfig.Channel = ADC_CHANNEL_8;
sConfig.Rank = 1;
sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES;
HAL_ADC_ConfigChannel(&hadc1, &sConfig);

/**Configure the ADC multi-mode
*/
multimode.Mode = ADC_MODE_INDEPENDENT;
multimode.TwoSamplingDelay = ADC_TWOSAMPLINGDELAY_5CYCLES;
HAL_ADCEx_MultiModeConfigChannel(&hadc1, &multimode);

}

/[i] TIM8 init function [/i]/
void MX_TIM8_Init(void)
{

TIM_SlaveConfigTypeDef sSlaveConfig;
TIM_MasterConfigTypeDef sMasterConfig;

htim8.Instance = TIM8;
htim8.Init.Prescaler = 0;
htim8.Init.CounterMode = TIM_COUNTERMODE_UP;
htim8.Init.Period = 60;
htim8.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim8.Init.RepetitionCounter = 0;
HAL_TIM_Base_Init(&htim8);

sSlaveConfig.SlaveMode = TIM_SLAVEMODE_TRIGGER;
sSlaveConfig.InputTrigger = TIM_TS_ITR0;
HAL_TIM_SlaveConfigSynchronization(&htim8, &sSlaveConfig);

sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
HAL_TIMEx_MasterConfigSynchronization(&htim8, &sMasterConfig);

}

/[i] USART3 init function [/i]/
void MX_USART3_UART_Init(void)
{

huart3.Instance = USART3;
huart3.Init.BaudRate = 9600;
huart3.Init.WordLength = UART_WORDLENGTH_8B;
huart3.Init.StopBits = UART_STOPBITS_1;
huart3.Init.Parity = UART_PARITY_NONE;
huart3.Init.Mode = UART_MODE_TX_RX;
huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart3.Init.OverSampling = UART_OVERSAMPLING_16;
HAL_UART_Init(&huart3);

}

/** Configure pins as
* Analog
* Input
* Output
* EVENT_OUT
* EXTI
*/
void MX_GPIO_Init(void)
{

GPIO_InitTypeDef GPIO_InitStruct;

/[i] GPIO Ports Clock Enable [/i]/
__GPIOF_CLK_ENABLE();
__GPIOH_CLK_ENABLE();
__GPIOB_CLK_ENABLE();

/[i]Configure GPIO pin : PF6 [/i]/
GPIO_InitStruct.Pin = GPIO_PIN_6;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FAST;
HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);

}

/[i] USER CODE BEGIN 4 [/i]/
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* AdcHandle)
{
/[i] Get the converted value of regular channel [/i]/
uhADCxConvertedValue = HAL_ADC_GetValue(AdcHandle);
v_value += uhADCxConvertedValue;
count++;
if(count>=500) { s_value = v_value/500; v_value = 0; count=0; }
}

/[i] USER CODE END 4 [/i]/

stm32cube中文教程:stm32cube中使用DMA配置方法和例子

admin 发表了文章 • 1 个评论 • 5713 次浏览 • 2014-10-13 23:38 • 来自相关话题

本实验只是独立测试DMA的运作,没有实现其他功能,DMA可以添加到UART,I2C等接口的驱动中使用。
程序代码由软件stm32cubemx点击设置自动完成,除了main中添加了数据表,调用了反馈函数,
其他都未曾改动,初步测试DMA可使用。
下面是软件操作:
第一步,配置了高速时钟管脚,点击了PIN的相应脚。
第二步,配置时钟,配置P,M,Q,系统为168M频率。
第三步,点击DMA的配置按钮,选择了DMA2,0通道,M2M模式,高速,data宽度为word
其他未变,选择默认。
第四步,配置NVIC,选择优先级分组3,设置DMA的中断优先级为1,0
滴答时钟的优先级不变。
然后导出了代码,用keil打开。
main文件中,在main()中的 MX_DMA_Init();下面直接添加了代码:
hdma_memtomem_dma2_stream0.XferCpltCallback = TransferCompletecc;
hdma_memtomem_dma2_stream0.XferErrorCallback = TransferErrorcc;
意思是,正常传输的话调用名字为TransferCompletecc的函数,错误传输的话调用TransferErrorcc的函数。
然后继续添加:
if(HAL_DMA_Start_IT(&hdma_memtomem_dma2_stream0, (uint32_t)&aSRC_Const_Buffer, (uint32_t)&aDST_Buffer, BUFFER_SIZE) != HAL_OK)
{
/ Transfer Error /
HAL_GPIO_WritePin (GPIOF,GPIO_PIN_6,GPIO_PIN_SET );
while(1);
}
意思是:开启DMA的全部中断,顺便传输数据,aSRC_Const_Buffer和aDST_Buffer是前面定义的数据表。
注意:外围添加TransferCompletecc的函数和TransferErrorcc的函数
,然后直接编译,烧录,测试通过,观察aSRC_Const_Buffer和aDST_Buffer的数据是否一样,
相同的话说明DMA传输正确。
ok,下面上完整的main文件代码。其他文件自动生成后不需改动。
#include "stm32f4xx_hal.h"

/ Private variables ---------------------------------------------------------/
DMA_HandleTypeDef hdma_memtomem_dma2_stream0;

/ USER CODE BEGIN 0 /
#define BUFFER_SIZE 32

static const uint32_t aSRC_Const_Buffer[BUFFER_SIZE]= {
0x01020304,0x05060708,0x090A0B0C,0x0D0E0F10,
0x11121314,0x15161718,0x191A1B1C,0x1D1E1F20,
0x21222324,0x25262728,0x292A2B2C,0x2D2E2F30,
0x31323334,0x35363738,0x393A3B3C,0x3D3E3F40,
0x41424344,0x45464748,0x494A4B4C,0x4D4E4F50,
0x51525354,0x55565758,0x595A5B5C,0x5D5E5F60,
0x61626364,0x65666768,0x696A6B6C,0x6D6E6F70,
0x71727374,0x75767778,0x797A7B7C,0x7D7E7F80};

static uint32_t aDST_Buffer[BUFFER_SIZE];

static void TransferCompletecc(DMA_HandleTypeDef *DmaHandle);
static void TransferErrorcc(DMA_HandleTypeDef *DmaHandle);
/ USER CODE END 0 /

/ Private function prototypes -----------------------------------------------/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_DMA_Init(void);

int main(void)
{

/ USER CODE BEGIN 1 /

/ USER CODE END 1 /

/ MCU Configuration----------------------------------------------------------/

/ Reset of all peripherals, Initializes the Flash interface and the Systick. /
HAL_Init();

/ Configure the system clock /
SystemClock_Config();

/ System interrupt init/
/ Sets the priority grouping field /
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_1);
HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);

/ Initialize all configured peripherals /
MX_GPIO_Init();
MX_DMA_Init();

/ USER CODE BEGIN 2 /
hdma_memtomem_dma2_stream0.XferCpltCallback = TransferCompletecc;
hdma_memtomem_dma2_stream0.XferErrorCallback = TransferErrorcc;
//if(HAL_DMA_GetState != HAL_OK )
//{ HAL_GPIO_WritePin (GPIOF,GPIO_PIN_6,GPIO_PIN_SET ); while(1); }
if(HAL_DMA_Start_IT(&hdma_memtomem_dma2_stream0, (uint32_t)&aSRC_Const_Buffer, (uint32_t)&aDST_Buffer, BUFFER_SIZE) != HAL_OK)
{
/ Transfer Error /
HAL_GPIO_WritePin (GPIOF,GPIO_PIN_6,GPIO_PIN_SET );
while(1);
}

/ USER CODE END 2 /

/ USER CODE BEGIN 3 /
/ Infinite loop /
while (1)
{
// HAL_GPIO_TogglePin (GPIOF,GPIO_PIN_6 );
// HAL_Delay (1000);
}
/ USER CODE END 3 /

}

/** System Clock Configuration
*/
void SystemClock_Config(void)
{

RCC_ClkInitTypeDef RCC_ClkInitStruct;
RCC_OscInitTypeDef RCC_OscInitStruct;

__PWR_CLK_ENABLE();

__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLM = 25;
RCC_OscInitStruct.PLL.PLLN = 336;
RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
RCC_OscInitStruct.PLL.PLLQ = 4;
HAL_RCC_OscConfig(&RCC_OscInitStruct);

RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_SYSCLK|RCC_CLOCKTYPE_PCLK1
|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5);

}

/**
* Enable DMA controller clock
* Configure DMA for memory to memory transfers
* hdma_memtomem_dma2_stream0
*/
void MX_DMA_Init(void)
{
/ DMA controller clock enable /
__DMA2_CLK_ENABLE();

/ Configure DMA request hdma_memtomem_dma2_stream0 on DMA2_Stream0 /
hdma_memtomem_dma2_stream0.Instance = DMA2_Stream0;
hdma_memtomem_dma2_stream0.Init.Channel = DMA_CHANNEL_0;
hdma_memtomem_dma2_stream0.Init.Direction = DMA_MEMORY_TO_MEMORY;
hdma_memtomem_dma2_stream0.Init.PeriphInc = DMA_PINC_ENABLE;
hdma_memtomem_dma2_stream0.Init.MemInc = DMA_MINC_ENABLE;
hdma_memtomem_dma2_stream0.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
hdma_memtomem_dma2_stream0.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
hdma_memtomem_dma2_stream0.Init.Mode = DMA_NORMAL;
hdma_memtomem_dma2_stream0.Init.Priority = DMA_PRIORITY_HIGH;
hdma_memtomem_dma2_stream0.Init.FIFOMode = DMA_FIFOMODE_ENABLE;
hdma_memtomem_dma2_stream0.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
hdma_memtomem_dma2_stream0.Init.MemBurst = DMA_MBURST_SINGLE;
hdma_memtomem_dma2_stream0.Init.PeriphBurst = DMA_PBURST_SINGLE;



HAL_DMA_Init(&hdma_memtomem_dma2_stream0);

/ DMA interrupt init /
/ Sets the priority grouping field /
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_1);
HAL_NVIC_SetPriority(DMA2_Stream0_IRQn, 1, 0);
HAL_NVIC_EnableIRQ(DMA2_Stream0_IRQn);

}

/** Configure pins as
* Analog
* Input
* Output
* EVENT_OUT
* EXTI
*/
void MX_GPIO_Init(void)
{

GPIO_InitTypeDef GPIO_InitStruct;

/ GPIO Ports Clock Enable /
__GPIOF_CLK_ENABLE();
__GPIOH_CLK_ENABLE();

/Configure GPIO pin : PF6 /
GPIO_InitStruct.Pin = GPIO_PIN_6;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FAST;
HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);

}

/ USER CODE BEGIN 4 /
static void TransferCompletecc(DMA_HandleTypeDef *DmaHandle)
{
/ Turn LED1 on: Transfer correct /
while(1){
HAL_GPIO_TogglePin (GPIOF,GPIO_PIN_6 );
HAL_Delay (3000);
}
}

/**
* @brief DMA conversion error callback
* @note This function is executed when the transfer error interrupt
* is generated during DMA transfer
* @retval None
*/
static void TransferErrorcc(DMA_HandleTypeDef *DmaHandle)
{
/ Turn LED2 on: Transfer Error /
while(1){
HAL_GPIO_TogglePin (GPIOF,GPIO_PIN_6 );
HAL_Delay (100);
}
}
/ USER CODE END 4 / 查看全部
本实验只是独立测试DMA的运作,没有实现其他功能,DMA可以添加到UART,I2C等接口的驱动中使用。
程序代码由软件stm32cubemx点击设置自动完成,除了main中添加了数据表,调用了反馈函数,
其他都未曾改动,初步测试DMA可使用。
下面是软件操作:
第一步,配置了高速时钟管脚,点击了PIN的相应脚。
第二步,配置时钟,配置P,M,Q,系统为168M频率。
第三步,点击DMA的配置按钮,选择了DMA2,0通道,M2M模式,高速,data宽度为word
其他未变,选择默认。
第四步,配置NVIC,选择优先级分组3,设置DMA的中断优先级为1,0
滴答时钟的优先级不变。
然后导出了代码,用keil打开。
main文件中,在main()中的 MX_DMA_Init();下面直接添加了代码:
hdma_memtomem_dma2_stream0.XferCpltCallback = TransferCompletecc;
hdma_memtomem_dma2_stream0.XferErrorCallback = TransferErrorcc;
意思是,正常传输的话调用名字为TransferCompletecc的函数,错误传输的话调用TransferErrorcc的函数。
然后继续添加:
if(HAL_DMA_Start_IT(&hdma_memtomem_dma2_stream0, (uint32_t)&aSRC_Const_Buffer, (uint32_t)&aDST_Buffer, BUFFER_SIZE) != HAL_OK)
{
/ Transfer Error /
HAL_GPIO_WritePin (GPIOF,GPIO_PIN_6,GPIO_PIN_SET );
while(1);
}
意思是:开启DMA的全部中断,顺便传输数据,aSRC_Const_Buffer和aDST_Buffer是前面定义的数据表。
注意:外围添加TransferCompletecc的函数和TransferErrorcc的函数
,然后直接编译,烧录,测试通过,观察aSRC_Const_Buffer和aDST_Buffer的数据是否一样,
相同的话说明DMA传输正确。
ok,下面上完整的main文件代码。其他文件自动生成后不需改动。
#include "stm32f4xx_hal.h"

/ Private variables ---------------------------------------------------------/
DMA_HandleTypeDef hdma_memtomem_dma2_stream0;

/ USER CODE BEGIN 0 /
#define BUFFER_SIZE 32

static const uint32_t aSRC_Const_Buffer[BUFFER_SIZE]= {
0x01020304,0x05060708,0x090A0B0C,0x0D0E0F10,
0x11121314,0x15161718,0x191A1B1C,0x1D1E1F20,
0x21222324,0x25262728,0x292A2B2C,0x2D2E2F30,
0x31323334,0x35363738,0x393A3B3C,0x3D3E3F40,
0x41424344,0x45464748,0x494A4B4C,0x4D4E4F50,
0x51525354,0x55565758,0x595A5B5C,0x5D5E5F60,
0x61626364,0x65666768,0x696A6B6C,0x6D6E6F70,
0x71727374,0x75767778,0x797A7B7C,0x7D7E7F80};

static uint32_t aDST_Buffer[BUFFER_SIZE];

static void TransferCompletecc(DMA_HandleTypeDef *DmaHandle);
static void TransferErrorcc(DMA_HandleTypeDef *DmaHandle);
/ USER CODE END 0 /

/ Private function prototypes -----------------------------------------------/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_DMA_Init(void);

int main(void)
{

/ USER CODE BEGIN 1 /

/ USER CODE END 1 /

/ MCU Configuration----------------------------------------------------------/

/ Reset of all peripherals, Initializes the Flash interface and the Systick. /
HAL_Init();

/ Configure the system clock /
SystemClock_Config();

/ System interrupt init/
/ Sets the priority grouping field /
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_1);
HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);

/ Initialize all configured peripherals /
MX_GPIO_Init();
MX_DMA_Init();

/ USER CODE BEGIN 2 /
hdma_memtomem_dma2_stream0.XferCpltCallback = TransferCompletecc;
hdma_memtomem_dma2_stream0.XferErrorCallback = TransferErrorcc;
//if(HAL_DMA_GetState != HAL_OK )
//{ HAL_GPIO_WritePin (GPIOF,GPIO_PIN_6,GPIO_PIN_SET ); while(1); }
if(HAL_DMA_Start_IT(&hdma_memtomem_dma2_stream0, (uint32_t)&aSRC_Const_Buffer, (uint32_t)&aDST_Buffer, BUFFER_SIZE) != HAL_OK)
{
/ Transfer Error /
HAL_GPIO_WritePin (GPIOF,GPIO_PIN_6,GPIO_PIN_SET );
while(1);
}

/ USER CODE END 2 /

/ USER CODE BEGIN 3 /
/ Infinite loop /
while (1)
{
// HAL_GPIO_TogglePin (GPIOF,GPIO_PIN_6 );
// HAL_Delay (1000);
}
/ USER CODE END 3 /

}

/** System Clock Configuration
*/
void SystemClock_Config(void)
{

RCC_ClkInitTypeDef RCC_ClkInitStruct;
RCC_OscInitTypeDef RCC_OscInitStruct;

__PWR_CLK_ENABLE();

__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLM = 25;
RCC_OscInitStruct.PLL.PLLN = 336;
RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
RCC_OscInitStruct.PLL.PLLQ = 4;
HAL_RCC_OscConfig(&RCC_OscInitStruct);

RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_SYSCLK|RCC_CLOCKTYPE_PCLK1
|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5);

}

/**
* Enable DMA controller clock
* Configure DMA for memory to memory transfers
* hdma_memtomem_dma2_stream0
*/
void MX_DMA_Init(void)
{
/ DMA controller clock enable /
__DMA2_CLK_ENABLE();

/ Configure DMA request hdma_memtomem_dma2_stream0 on DMA2_Stream0 /
hdma_memtomem_dma2_stream0.Instance = DMA2_Stream0;
hdma_memtomem_dma2_stream0.Init.Channel = DMA_CHANNEL_0;
hdma_memtomem_dma2_stream0.Init.Direction = DMA_MEMORY_TO_MEMORY;
hdma_memtomem_dma2_stream0.Init.PeriphInc = DMA_PINC_ENABLE;
hdma_memtomem_dma2_stream0.Init.MemInc = DMA_MINC_ENABLE;
hdma_memtomem_dma2_stream0.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
hdma_memtomem_dma2_stream0.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
hdma_memtomem_dma2_stream0.Init.Mode = DMA_NORMAL;
hdma_memtomem_dma2_stream0.Init.Priority = DMA_PRIORITY_HIGH;
hdma_memtomem_dma2_stream0.Init.FIFOMode = DMA_FIFOMODE_ENABLE;
hdma_memtomem_dma2_stream0.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
hdma_memtomem_dma2_stream0.Init.MemBurst = DMA_MBURST_SINGLE;
hdma_memtomem_dma2_stream0.Init.PeriphBurst = DMA_PBURST_SINGLE;



HAL_DMA_Init(&hdma_memtomem_dma2_stream0);

/ DMA interrupt init /
/ Sets the priority grouping field /
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_1);
HAL_NVIC_SetPriority(DMA2_Stream0_IRQn, 1, 0);
HAL_NVIC_EnableIRQ(DMA2_Stream0_IRQn);

}

/** Configure pins as
* Analog
* Input
* Output
* EVENT_OUT
* EXTI
*/
void MX_GPIO_Init(void)
{

GPIO_InitTypeDef GPIO_InitStruct;

/ GPIO Ports Clock Enable /
__GPIOF_CLK_ENABLE();
__GPIOH_CLK_ENABLE();

/Configure GPIO pin : PF6 /
GPIO_InitStruct.Pin = GPIO_PIN_6;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FAST;
HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);

}

/ USER CODE BEGIN 4 /
static void TransferCompletecc(DMA_HandleTypeDef *DmaHandle)
{
/ Turn LED1 on: Transfer correct /
while(1){
HAL_GPIO_TogglePin (GPIOF,GPIO_PIN_6 );
HAL_Delay (3000);
}
}

/**
* @brief DMA conversion error callback
* @note This function is executed when the transfer error interrupt
* is generated during DMA transfer
* @retval None
*/
static void TransferErrorcc(DMA_HandleTypeDef *DmaHandle)
{
/ Turn LED2 on: Transfer Error /
while(1){
HAL_GPIO_TogglePin (GPIOF,GPIO_PIN_6 );
HAL_Delay (100);
}
}
/ USER CODE END 4 /