STM32F10x读取DS1302的时间，通过USART显示在串口调试助手上

最新推荐文章于 2024-05-01 00:54:15 发布
最新推荐文章于 2024-05-01 00:54:15 发布
阅读量2.7k 收藏 28
点赞数 7
分类专栏： 语言编程 串口 C STM32 DS1302 文章标签： STM32 DS1302 时间 USART 串口
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lnniyunlong99/article/details/89763411
版权
STM32 同时被 3 个专栏收录
27 篇文章 9 订阅
订阅专栏
语言编程
18 篇文章 2 订阅
订阅专栏
C
13 篇文章 0 订阅
订阅专栏

STM32的开发板上有个DS1302芯片，STM32从DS1302上读取时间，并通过串口通讯显示在PC的串口调试助手上。

STM32和DS1302的接线如下：

代码如下：

#include "stm32f10x.h"
#include <stdio.h>
#include <string.h>

#define AHB_INPUT 72

#define DS1302_PORT           GPIOB
#define DS1302_SCK_PIN        GPIO_Pin_5
#define DS1302_IO_PIN         GPIO_Pin_6
#define DS1302_CE_PIN         GPIO_Pin_7

u8 WRITE_RTC_ADDR[7] = {0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8c};
u8 TIME[7] = {0, 0x30, 0x17, 0x02, 0x05, 0x01, 0x19};

void delay_us(uint32_t time_us)
{
	SysTick->LOAD = AHB_INPUT * time_us;
	SysTick->VAL = 0x00;
	SysTick->CTRL = 0x00000005;
	for(;!(SysTick->CTRL & 0x00010000););
	SysTick->CTRL = 0x00000004;
}

void delay_ms(uint32_t time_ms)
{
	for(;time_ms-- > 0;)
	{
		delay_us(1000);
	}
}

void usart1_init(uint32_t bound)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
	
	RCC_APB2PeriphClockCmd(RCC_APB1Periph_USART2 | RCC_APB2Periph_GPIOA, ENABLE);
	
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);
	
	USART_InitStructure.USART_BaudRate = bound;
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
	USART_InitStructure.USART_StopBits = USART_StopBits_1;
	USART_InitStructure.USART_Parity = USART_Parity_No;
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
	USART_Init(USART2, &USART_InitStructure);
	USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
	USART_Cmd(USART2, ENABLE);
	
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	GPIO_ResetBits(GPIOA, GPIO_Pin_1);
}

void RCC_Configuration(void)
{
	RCC_DeInit();
	RCC_HSEConfig(RCC_HSE_ON);
	while(RCC_GetFlagStatus(RCC_FLAG_HSERDY) == RESET);
	
	FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);	//Enable Prefetch Buffer
	FLASH_SetLatency(FLASH_Latency_2);		//Flash 2 wait state
	
	RCC_HCLKConfig(RCC_SYSCLK_Div1);		//HCLK = SYSCLK
	RCC_PCLK2Config(RCC_HCLK_Div1);			//PCLK2 =  HCLK
	RCC_PCLK1Config(RCC_HCLK_Div2);			//PCLK1 = HCLK/2
	RCC_PLLConfig(RCC_PLLSource_HSE_Div1,RCC_PLLMul_9);	//PLLCLK = 8MHZ * 9 =72MHZ
	RCC_PLLCmd(ENABLE);			//Enable PLLCLK
	
	while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET){};
	
  RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);	//Select PLL as system clock
	while(RCC_GetSYSCLKSource()!=0x08);		//Wait till PLL is used as system clock source
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE); 
}

void RS485_Config(u32 bound)
{
    GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;
    NVIC_InitTypeDef NVIC_InitStructure;
    
    /* config USART1 clock */
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2 , ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA  , ENABLE);
    
    /* USART1 GPIO config */
    /* Configure USART1 Tx (PA.02) as alternate function push-pull *///TX
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
    /* Configure USART1 Rx (PA.03) as input floating *///RX
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
    
    
    USART_InitStructure.USART_BaudRate = bound;
    USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    USART_InitStructure.USART_StopBits = USART_StopBits_1;
    USART_InitStructure.USART_Parity = USART_Parity_No ;
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    USART_Init(USART2, &USART_InitStructure);
    
    
    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
    
    USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
    USART_Cmd(USART2, ENABLE);
    
    //USART_ClearFlag(USART1, USART_FLAG_TC);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1; 
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 
    GPIO_Init(GPIOA, &GPIO_InitStructure);
    GPIO_SetBits(GPIOA, GPIO_Pin_1);
    
}

void func_ds1302_configuration()
{
	GPIO_InitTypeDef GPIO_InitStruct; 
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
	
	GPIO_InitStruct.GPIO_Pin = DS1302_SCK_PIN | DS1302_CE_PIN ;  
	GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(DS1302_PORT, &GPIO_InitStruct);  

}

void func_config_ds1302_io_pin(u8 in_out)
{
	GPIO_InitTypeDef GPIO_InitStruct;
	if(in_out == 1)
	{
		GPIO_InitStruct.GPIO_Pin = DS1302_IO_PIN;
		GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;
		GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
		GPIO_Init(DS1302_PORT, &GPIO_InitStruct);
	}
	else
	{
		GPIO_InitStruct.GPIO_Pin = DS1302_IO_PIN;
		GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IPU;
		GPIO_Init(DS1302_PORT, &GPIO_InitStruct);
	}
}

void nop(u8 nop_cnt)
{
	for(;nop_cnt-- > 0;)
	{
		__NOP();
	}
}


void func_write_ds1302_a_byte(u8 addr, u8 dat)
{
	u8 n;
	
	GPIO_ResetBits(DS1302_PORT, DS1302_CE_PIN);
	nop(2);
	GPIO_ResetBits(DS1302_PORT, DS1302_SCK_PIN);
	nop(2);
	GPIO_SetBits(DS1302_PORT, DS1302_CE_PIN);
	nop(2);
	func_config_ds1302_io_pin(1);
	nop(2);
	
	for (n=0; n<8; n++)
	{
		GPIO_WriteBit(DS1302_PORT, DS1302_IO_PIN, (BitAction)(0x01 & addr));
		addr >>= 1;
		GPIO_SetBits(DS1302_PORT, DS1302_SCK_PIN);
		nop(2);
		GPIO_ResetBits(DS1302_PORT, DS1302_SCK_PIN);
		nop(2);
	}
	for (n=0; n<8; n++)
	{
		GPIO_WriteBit(DS1302_PORT, DS1302_IO_PIN, (BitAction)(0x01 & dat));
		dat >>= 1;
		GPIO_SetBits(DS1302_PORT, DS1302_SCK_PIN);
		nop(2);
		GPIO_ResetBits(DS1302_PORT, DS1302_SCK_PIN);
		nop(2);   
	}   
			 
	GPIO_ResetBits(DS1302_PORT, DS1302_CE_PIN);
	nop(2); 
}

/**
* CLOCK - SEC : 0x81
* CLOCK - MIN : 0x83
* CLOCK - HR : 0x85
* CLOCK - DATE : 0x87
* CLOCK - MONTH : 0x89
* CLOCK - DAY : 0x8B
* CLOCK - YEAR : 0x8D
*/
u8 func_read_ds1302_a_byte(u8 cmd)
{
	u8 tmp;
	u8 i;
	u8 ret;
	
	if(cmd < 0x81 || cmd > 0x8F)
	{
		return 255;
	}
	
	GPIO_ResetBits(DS1302_PORT, DS1302_CE_PIN);
	GPIO_ResetBits(DS1302_PORT, DS1302_SCK_PIN);
	func_config_ds1302_io_pin(1);
	nop(5);
	GPIO_SetBits(DS1302_PORT, DS1302_CE_PIN);
	for(i = 0; i < 8; i++)
	{
		tmp = cmd;
		tmp= tmp >> i;
		GPIO_WriteBit(DS1302_PORT, DS1302_IO_PIN, (BitAction)(0x01 & tmp));
		nop(2);
		GPIO_SetBits(DS1302_PORT, DS1302_SCK_PIN);
		nop(2);
		GPIO_ResetBits(DS1302_PORT, DS1302_SCK_PIN);
		nop(2);
	}
	
	func_config_ds1302_io_pin(0);
	nop(2);
	for(i = 0; i < 8; i++)
	{
		tmp = GPIO_ReadInputDataBit(DS1302_PORT, DS1302_IO_PIN);
		ret = ret | (tmp << i);
		GPIO_SetBits(DS1302_PORT, DS1302_SCK_PIN);
		nop(2);
		GPIO_ResetBits(DS1302_PORT, DS1302_SCK_PIN);
		nop(2);
	}
	GPIO_ResetBits(DS1302_PORT, DS1302_CE_PIN);
	nop(2);
	func_config_ds1302_io_pin(1);
	nop(2);
	GPIO_SetBits(DS1302_PORT, DS1302_SCK_PIN);
	nop(2);
	GPIO_ResetBits(DS1302_PORT, DS1302_IO_PIN);
	nop(2);
	GPIO_SetBits(DS1302_PORT, DS1302_IO_PIN);
	nop(2);
	return ret;
}

u8 func_read_ds1302_time(char *ret_time)
{
	u8 ret;
	u8 tmp_t[14];
	
	//YEAR
	ret = func_read_ds1302_a_byte(0x8D);
	if(ret == 255)
	{
		return 255;
	}
	tmp_t[1] = ret & 0x0f;
	tmp_t[0] = ret >> 4;
	
	//MONTH
	ret = func_read_ds1302_a_byte(0x89);
	if(ret == 255)
	{
		return 255;
	}
	tmp_t[3] = ret & 0x0f;
	tmp_t[2] = ret >> 4;
	
	//DATE
	ret = func_read_ds1302_a_byte(0x87);
	if(ret == 255)
	{
		return 255;
	}
	tmp_t[5] = ret & 0x0f;
	tmp_t[4] = ret >> 4;
	
	//HR
	ret = func_read_ds1302_a_byte(0x85);
	if(ret == 255)
	{
		return 255;
	}
	tmp_t[7] = ret & 0x0f;
	tmp_t[6] = ret >> 4;
	
	//MIN
	ret = func_read_ds1302_a_byte(0x83);
	if(ret == 255)
	{
		return 255;
	}
	tmp_t[9] = ret & 0x0f;
	tmp_t[8] = ret >> 4;
	
	//SEC
	ret = func_read_ds1302_a_byte(0x81);
	if(ret == 255)
	{
		return 255;
	}
	tmp_t[11] = ret & 0x0f;
	tmp_t[10] = ret >> 4;	
	
	sprintf(ret_time, "20%d%d-%d%d-%d%d %d%d:%d%d:%d%d ", tmp_t[0], tmp_t[1], tmp_t[2], tmp_t[3], tmp_t[4], tmp_t[5], tmp_t[6], tmp_t[7], tmp_t[8], tmp_t[9], tmp_t[10], tmp_t[11]);
	return 0;
}


void Ds1302Init()
{
	
	u8 n;
	func_write_ds1302_a_byte(0x8E, 0X00);
	for (n=0; n<7; n++)
	{
		 func_write_ds1302_a_byte(WRITE_RTC_ADDR[n], TIME[n]); 
	}
	
	func_write_ds1302_a_byte(0x8E,0x80);
}

int main()
{	
	
	u8 i = 0;
	u8 suc;
	char ch_t[24];
	
	RS485_Config(9600);
	
	func_ds1302_configuration();
	
	Ds1302Init();
	
	while (1)
	{
		suc = func_read_ds1302_time(ch_t);
		if(suc == 0)
		{
			for(i = 0; i < 20; i++)
			{
				USART_SendData(USART2, ch_t[i]);
				while(USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET);
			}
		}
		
		delay_ms(1000);
	}
}

读取时间的效果如下：

测试代码，可以实现读取数据，仅供参考。

Mr_Johhny
关注
  • 7
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
ds1302显示时间（通过串口调试助手）
08-09
ds1302显示时间（通过串口调试助手）内容讲解的很详细，如果有疑问或是发现错误，希望可以告诉我，谢谢
Keil4用STM32中实现RTC时间显示
08-03
在Keil4用STM32中实现RTC时间显示，基础程序，用于初学者参考，可从解压后的MDK中用Keil4打开程序，主函数在SRE中，若打开后运行不起，得把路径不符的文件重新在Libraries中引入，在LCD屏上显示
关于STM32驱动DS1302实时时钟的一点思考
weixin_30594001的博客
12-28 890
之前用51驱动过DS1302，没用多久就输出了正确的时间。当时以为这块芯片其实没啥，很简单。但是现在用STM32做项目，用到同样的芯片，以为这有何难，只要把那个程序拿过来复制黏贴改一下IO设置不就行了？但是事情远没有想想的那么简单。 经过3天的挣扎，现在才知道当时自己是多么天真。 关于DS1302的基本操作可以看这里：http://www.cnblogs...
STM32控制DS1302时钟模块获取实时时间
最新发布
KINO32的博客
05-01 1009
时间记录：2024/4/30。
STM32 利用定时器来计程序运行时间
banzhuan133的博客
04-05 8277
在单片机的调试过程中，我们经常需要知道某个过程跑一遍的时长，以便更好地对时序进行控制。事实上，利用单片机自带的定时器就能很方便地实现这一功能。 void TIM4_Int_Init(void) { TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure; NVIC_InitTypeDef NVIC_InitStructure;
单片机：DS1302时钟
acktomas的博客
02-14 6174
indexDS1302时钟数据输入输出(I/O) DS1302时钟 一．DS1302的主要性能指标 （1）DS1302实时时钟具有能计算2100年之前的秒、分、时、日、日期、星期、月、年的能力，还有闰年调整的能力。 （2）内部含有31个字节静态RAM，可提供用户访问。 （3）采用串行数据传送方式，使得管脚数量最少，简单SPI 3线接口。 （4）工作电压范围宽：2.0～5.5V。 （5）工作电流：2...
stm32f103vet6采集dht11温湿度数据通过usart1在串口助手中显示
02-02
在Keil5中编写完程序后，需要编译、下载到开发板，并使用串口助手软件（如RealTerm或PuTTY）连接到STM32的USART1接口，即可实时查看温湿度数据。 总之，这个项目涵盖了STM32微控制器的GPIO控制、USART通信以及...
stm32F103串口的调试，串口2发送数据串口1接收并在串口调试助手上显示keil工程源码.zip
03-10
通过串口助手，我们可以发送命令到STM32或者接收STM32发送的数据，进行实时交互和调试。 总结来说，这个项目涵盖了STM32F103的串口配置、数据传输、中断处理以及与串口调试助手的配合使用。通过这样的实践，开发者...
STM32F10X-USART.rar_USART__examples_stm32f10x_stm32f10x uart_stm
09-19
STM32F10X-USART.rar 是一个与STM32F10X微控制器相关的压缩包，包含了一些关于UART（通用异步收发传输器）应用的示例代码。STM32F10X系列是基于ARM Cortex-M3内核的微控制器，广泛应用于嵌入式系统设计中，因其高...
stm32f10x_tim.rar_STM32USART_stm32f10x_tim
09-19
在STM32系列中，STM32F10x是其中一个产品线，它包含了丰富的外设集，包括通用异步收发传输器（USART）和定时器（TIM）。本文将详细探讨STM32F10x中的USART和TIM模块。 **STM32F10x USART** USART是一种串行通信...
1STM32F10X_串口USART1_串口_uart_STM32F103_
10-03
STM32F10X系列是意法半导体（STMicroelectronics）推出的基于ARM Cortex-M3内核的微控制器，广泛应用于各种嵌入式系统设计。在这个项目中，我们专注于使用STM32F103单片机实现串行通信接口（UART），特别是使用USART...
STM32+RTC（DS1302）实时时钟设计，整个工程（库函数）
12-25
STM32+RTC实时时钟设计，整个工程已测试，现在正在项目上用。
串口时钟显示代码
07-12
单片机 串口 时钟 代码 编译 arduino开发必用
STM32定时器中断显示时间
qq_44703307的博客
01-07 6069
前言 利用STM32的定时器中断，实现时间的显示。我们知道利用定时器中断只能进行tick的计算，然而用来显示时间我们应该怎么办呢？经过项目的实际运用，我发现利用定时器中断配合串口通讯也能实现时间显示。 这种方法应用的前提是，我们的板件不能装电池无法保存时钟，我们的板件会与其他可以保存时钟的板件通讯。 原理介绍 （1）硬件资源：有通讯功能的STM32板件、可以保存时钟且能通讯的其他任意板件 （2）软...
stm32怎么基于ds1302实现闹钟功能，不使用定时器
weixin_35756892的博客
02-14 552
在STM32上实现基于DS1302的闹钟功能需要使用I2C总线进行通信。 步骤如下： 配置STM32的I2C接口，并初始化DS1302。 读取DS1302上的时钟数据，并将其存储到STM32的内存中。 利用STM32的循环程序，每隔一段时间检查一次DS1302上的时钟数据是否与设定的闹钟时间相同，如果相同，则可以触发闹钟事件。 在这个过程中，不需要使用STM32的定时器，只需要循环程序来...
STM32F103VCT6单片机实现秒表功能
SiLenceJiong的博客
02-27 1612
STM32F103VCT6单片机实现秒表功能
一个完整的DS1302时钟在STM32上的应用实例
魏波
05-23 6372
一个完整的DS1302时钟在STM32上的应用(代码位置有点乱）. 整理后的完整代码https://blog.csdn.net/weibo1230123/article/details/80372790 一个完整的DS1302时钟在STM32上的应用 /*DS1302时钟芯片*/ uint8_t read[] = {0x81,0x83,0x85,0x87,0x89,0x8b,0x8d};/...
基于STM32的DS1302时钟芯片驱动
魏波
05-09 1957
基于STM32的DS1302时钟芯片驱动/************************************************************************************************************************* * 函数 : DS1302.H * 功能 : DS1302头文件 * 参数 : 无 * 返回 : 无 * 依...
STM32F103和DS1302时钟
qq_45488746的博客
05-04 5543
STM32F103和DS1302时钟
基于stm32单片机和1602液晶显示的DS1820的程序编写的
05-25
在上述程序中，我们通过USART串口将温度数据输出到PC端，也可以通过LCD1602显示模块将温度数据显示在液晶屏幕上。需要注意的是，不同型号的STM32单片机引脚布局可能会有所不同，需要根据具体型号进行调整。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值