如何快速操作RTC模块

最新推荐文章于 2024-05-03 20:32:26 发布
最新推荐文章于 2024-05-03 20:32:26 发布
阅读量913 收藏
点赞数
分类专栏： TOUCH-KING
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42381351/article/details/102753621
版权

   看到工程已经有rtc.c--MX打钩的
    我需要做的是BSPRTC 
    拷贝文件夹 Gbsp_rtc
    怎么使用？三元组
    初始化--没有必要了 因为有  MX_RTC_Init();即可
    没有后台--因为rtc_alarm_callback 没有写
    也就是直接用就可以！！test_rtc直接看看效果
    注意：里面内部调用的函数需要放到内部的rtc.c模块中

修改rtc。c  是增加 它只有init

我喂猫2个函数【前面的可以不看了】

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/


#include "gunit.h"
//http://www.waveshare.net/study/article-652-1.html
///rtc.c   GKOSON ADD

//static uint8_t rtc_alarm_flag = 0;

void GRTC_GET(uint8_t* showtime)
{
    RTC_DateTypeDef sdatestructureget;
    RTC_TimeTypeDef stimestructureget;

    /* Get the RTC current Time */
    HAL_RTC_GetTime(&hrtc, &stimestructureget, RTC_FORMAT_BIN);
    /* Get the RTC current Date */
    HAL_RTC_GetDate(&hrtc, &sdatestructureget, RTC_FORMAT_BIN);
    /* Display time Format : hh:mm:ss */
   
  //sprintf((char*)showtime,"%02d:%02d:%02d",stimestructureget.Hours, stimestructureget.Minutes, stimestructureget.Seconds);
     printf("%02d:%02d:%02d\r\n",stimestructureget.Hours, stimestructureget.Minutes, stimestructureget.Seconds);
     printf("%02d:%02d:%02d\r\n",sdatestructureget.Year, sdatestructureget.Month, sdatestructureget.Date);
     printf("--%02d--\r\n",sdatestructureget.WeekDay);
}

//__weak void HAL_RTC_AlarmAEventCallback(RTC_HandleTypeDef *hrtc)
//void HAL_RTC_AlarmAEventCallback(RTC_HandleTypeDef *hrtc)
//{
//    rtc_alarm_flag++;   
//	  printf("\r\n\r\n\r\n%s %d\r\n\r\n\r\n",__FUNCTION__,rtc_alarm_flag);	
//}

//uint8_t RTC_TimeAlarm(void)
//{
//   return rtc_alarm_flag;
//}


//дRTC
//GRTC_SET(19,4,23,11,12,13,RTC_WEEKDAY_TUESDAY)
void GRTC_SET(uint8_t year , uint8_t mon , uint8_t day ,
             uint8_t hour , uint8_t min , uint8_t sec , uint8_t week)
{
	RTC_DateTypeDef sdatestructureget;
	RTC_TimeTypeDef stimestructureget;

	sdatestructureget.WeekDay=week;//RTC_WEEKDAY_TUESDAY;                         
	sdatestructureget.Month=mon;//RTC_MONTH_APRIL;                         
	sdatestructureget.Date=day;//23;                        
	sdatestructureget.Year=year;//19;   

	stimestructureget.Hours=hour;//11;          
	stimestructureget.Minutes=min;//12;        
	stimestructureget.Seconds=sec;//13;         
								

	if (HAL_RTC_SetDate(&hrtc, &sdatestructureget, RTC_FORMAT_BIN) != HAL_OK)
	{
		Error_Handler();
	}
	if (HAL_RTC_SetTime(&hrtc, &stimestructureget, RTC_FORMAT_BIN) != HAL_OK)
	{
		Error_Handler();
	}

}






//类似 GRTC_GET
void hal_rtc_read(uint8_t *time)
{
	  RTC_DateTypeDef sTimeStampDateget;
    RTC_TimeTypeDef sTimeStampget;
    
    /* Get the RTC current Time */
    HAL_RTC_GetTime(&hrtc, &sTimeStampget, RTC_FORMAT_BIN);
    /* Get the RTC current Date */
    HAL_RTC_GetDate(&hrtc, &sTimeStampDateget, RTC_FORMAT_BIN);

		time[0]=sTimeStampDateget.Year;
		time[1]=sTimeStampDateget.Month;
		time[2]=sTimeStampDateget.Date;
		time[3]=sTimeStampget.Hours;
		time[4]=sTimeStampget.Minutes;
		time[5]=sTimeStampget.Seconds;
		time[6]=sTimeStampDateget.WeekDay;
    
}



void hal_rtc_set(uint8_t year , uint8_t mon , uint8_t day ,
                   uint8_t hour , uint8_t min , uint8_t sec , uint8_t week)
{
    RTC_DateTypeDef sDate;
    RTC_TimeTypeDef sTime;

    sTime.Hours = hour;
    sTime.Minutes = min;
    sTime.Seconds = sec;
    sTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
    sTime.StoreOperation = RTC_STOREOPERATION_RESET;
    if (HAL_RTC_SetTime(&hrtc, &sTime, RTC_FORMAT_BIN) != HAL_OK)
    {
        Error_Handler();
    }

    sDate.WeekDay = week;
    sDate.Month = mon;
    sDate.Date = day;
    sDate.Year = year;

    if (HAL_RTC_SetDate(&hrtc, &sDate, RTC_FORMAT_BIN) != HAL_OK)
    {
        Error_Handler();
    }
  
}

#ifndef __rtc_H
#define __rtc_H
#ifdef __cplusplus
 extern "C" {
#endif

/* Includes ------------------------------------------------------------------*/
#include "main.h"

/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

extern RTC_HandleTypeDef hrtc;

/* USER CODE BEGIN Private defines */

/* USER CODE END Private defines */

void MX_RTC_Init(void);

/* USER CODE BEGIN Prototypes */

void hal_rtc_read(uint8_t *time);

void hal_rtc_set(uint8_t year , uint8_t mon , uint8_t day ,uint8_t hour , uint8_t min , uint8_t sec , uint8_t week);

/* USER CODE END Prototypes */

#ifdef __cplusplus
}
#endif
#endif /*__ rtc_H */

/**
  * @}
  */

/**
  * @}
  */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

 

 

 

#include "gbsp_rtc.h"
#include "rtc.h"

#include "gunit.h"



//1480494176
//时间戳 每年的起始值
const uint32_t gdwUnixTimeStampYear[100]=
{ 946656000, 978278400,1009814400,1041350400,1072886400,1104508800,1136044800,1167580800,1199116800,1230739200,//00-1-1 0:0:0 09-1-1 0:0:0
1262275200,1293811200,1325347200,1356969600,1388505600,1420041600,1451577600,1483200000,1514736000,1546272000,//10-1-1 0:0:0
1577808000,1609430400,1640966400,1672502400,1704038400,1735660800,1767196800,1798732800,1830268800,1861891200,//20-1-1 0:0:0
1893427200,1924963200,1956499200,1988121600,2019657600,2051193600,2082729600,2114352000,2145888000,2177424000,//30-1-1 0:0:0
2208960000,2240582400,2272118400,2303654400,2335190400,2366812800,2398348800,2429884800,2461420800,2493043200,//40-1-1 0:0:0
2524579200,2556115200,2587651200,2619273600,2650809600,2682345600,2713881600,2745504000,2777040000,2808576000,//50-1-1 0:0:0
2840112000,2871734400,2903270400,2934806400,2966342400,2997964800,3029500800,3061036800,3092572800,3124195200,//60-1-1 0:0:0
3155731200,3187267200,3218803200,3250425600,3281961600,3313497600,3345033600,3376656000,3408192000,3439728000,//70-1-1 0:0:0
3471264000,3502886400,3534422400,3565958400,3597494400,3629116800,3660652800,3692188800,3723724800,3755347200,//80-1-1 0:0:0
3786883200,3818419200,3849955200,3881577600,3913113600,3944649600,3976185600,4007808000,4039344000,4070880000//90-1-1 0:0:0
};
//100年最大时间戳
const uint32_t gdwUnixTimeMax=4102415990;//2099/12/31 23:59:50     4102415999;//2099/12/31 23:59:59
//每月的1日的 总天数
const uint16_t      gwUnixTimeStampMonth[12]={0, 31,59,90,120,151,181,212,243,273,304,334};
const static uint8_t no_leap_year[12]={6,2,2,5,0,3,5,1,4,6,2,4};//非闰年
const static uint8_t leap_year[12]={5,1,2,5,0,3,5,1,4,6,2,4};//闰年  
const static uint8_t no_leap_year_month_day[12]={31,28,31,30,31,30,31,31,30,31,30,31};//非闰年
const static uint8_t leap_year_month_day[12]={31,29,31,30,31,30,31,31,30,31,30,31};//闰年  

unsigned char is_leap_year(unsigned char year)
{    
    if((year%4==0)&&(year!=0)) 
        return 1;  
    else 
        return 0; 
}

unsigned char RTC_Get_Day(unsigned char year,unsigned char month)
{
    return is_leap_year(year)?leap_year_month_day[month-1]:no_leap_year_month_day[month-1]; 
}

unsigned char get_week(unsigned char year,unsigned char month,unsigned char day)
{
    uint8_t temp;
    
    temp=is_leap_year(year)?leap_year[month-1]:no_leap_year[month-1]; 
    
    return ((day+temp+((year/4+year)%7))%7); 
}

void time_to_stamp(uint32_t *stamp,uint8_t *dt)//由日期时间 转成 时间戳
{
    if((*(dt+1)>0)&&(*(dt+1)<3))
    {
        *stamp = (((gwUnixTimeStampMonth[*(dt+1)-1] + 
                    (*(dt+2)-1))*24 + *(dt+3)) * 60 + 
                    *(dt+4)) * 60 + *(dt+5);
    }
    else
    {
        *stamp = (((gwUnixTimeStampMonth[*(dt+1)-1] + 
                    (*(dt+2)-1) + ((is_leap_year(*(dt+0)))?1:0))*24 + 
                   *(dt+3)) * 60 + *(dt+4)) * 60 + *(dt+5);
    }
    
    *stamp +=gdwUnixTimeStampYear[*(dt+0)];
}


void stamp_to_time(uint32_t *dwStamp,uint8_t *dt)//由 时间戳 转成 日期时间
{
    uint8_t i,j;
    uint16_t wUnixTimeStampMonth[12];
    uint32_t dwD;

    if(*dwStamp>gdwUnixTimeMax)//大于 2099/12/31 23：59：50
    {
        *(dt+0)=99;*(dt+1)=12;*(dt+2)=31;
        *(dt+3)=23;*(dt+4)=59;*(dt+5)=50;
    }
    else
    {
        for(i=0;i<100;i++)
        {
            if(gdwUnixTimeStampYear[i]>*dwStamp)
                break;
        }
        if(i==0)
        {
            for(j=0;j<6;j++)*(dt+i)=0;
                return;
        }
        else
        {
            *(dt+0)=i-1;

            if(is_leap_year(*(dt+0))==1)
            {
                for(j = 0 ; j < 2; j++)
                {
                    wUnixTimeStampMonth[j]=gwUnixTimeStampMonth[j];
                }
                for(j = 2; j < 12; j++)
                {
                    wUnixTimeStampMonth[j]=gwUnixTimeStampMonth[j]+1;
                }
            }
            else
            {
                for(j = 0; j < 12; j++)
                {
                    wUnixTimeStampMonth[j]=gwUnixTimeStampMonth[j];
                }
            }
            //printf("年：%d\r\n",*(dt+0));
            dwD=*dwStamp-gdwUnixTimeStampYear[i-1];
            //printf("dwD Zs=%d\r\n",dwD);
            *(dt+5)=dwD%60;
            //printf("dwD 秒=%d\r\n",*(dt+5));
            dwD=dwD/60;
            *(dt+4)=dwD%60;
            //printf("dwD 分钟=%d\r\n",*(dt+4));
            dwD=dwD/60;
            *(dt+3)=dwD%24;
            //printf("dwD 小时=%d\r\n",*(dt+3));
            dwD=dwD/24;
            //printf("dwD 天数=%d\r\n",dwD);
            for(i=0;i<12;i++)
            {
                if(wUnixTimeStampMonth[i]>dwD)
                    break;
            }
            *(dt+1)=i;
            *(dt+2)=(dwD-wUnixTimeStampMonth[i-1])+1;
        }
    }
}


void rtc_set_time( rtcTimeType *time)
{
    hal_rtc_set(time->year,time->mon,time->day,time->hour,time->min,time->sec ,time->week);
}


uint32_t rtc_read_stamp( void )
{
	uint32_t unix_stamp = 0;

	uint8_t dataTime[7];

	hal_rtc_read(dataTime);

	time_to_stamp(&unix_stamp , dataTime);

	return unix_stamp;
}

void rtc_read_time(rtcTimeType *time)
{
    uint8_t dataTime[7];
    
    hal_rtc_read(dataTime);
    
    time->year = dataTime[0];
    time->mon  = dataTime[1];
    time->day = dataTime[2];
    time->hour = dataTime[3];
    time->min = dataTime[4];
    time->sec = dataTime[5];
    time->week = dataTime[6];
   
}

uint32_t rtc_time_to_stamp(rtcTimeType *time)
{
    uint32_t unix_stamp = 0;
    uint8_t dataTime[7];
    
		dataTime[0] = time->year;
		dataTime[1] = time->mon;
		dataTime[2] = time->day;
		dataTime[3] = time->hour;
		dataTime[4] = time->min;
		dataTime[5] = time->sec;
		dataTime[5] = time->week;
    
    time_to_stamp(&unix_stamp , dataTime);

    printf("Input = 20%d-%02d-%02d %02d:%02d:%02d, output stamp =%ld\n" ,
                dataTime[0],dataTime[1],dataTime[2] ,dataTime[3],dataTime[4],dataTime[5] ,unix_stamp);    
    
    
    return unix_stamp;
}

void rtc_stamp_to_time(rtcTimeType *time ,uint32_t unix_stamp)
{
    uint8_t dataTime[7];


    stamp_to_time(&unix_stamp ,dataTime );
                 
    time->year = dataTime[0];
    time->mon = dataTime[1];
    time->day = dataTime[2];
    time->hour = dataTime[3];
    time->min = dataTime[4];
    time->sec = dataTime[5];

    time->week = get_week(time->year , time->mon , time->day);
    
    printf("Input stamp:%d ,out time:20%d-%02d-%02d %02d:%02d:%02d\n" ,unix_stamp,time->year,time->mon,time->day,
                                                     time->hour,time->min,time->sec);    
        
}


void HAL_RTC_AlarmAEventCallback(RTC_HandleTypeDef *hrtc)
{
		log_err("Rtc alarm\r\n");
		log_err("Rtc alarm\r\n");
		while(1);
}

void rtc_alarm_callback( void)
{

}

void rtc_set_time_form_stamp( uint32_t unix_stamp)
{
    rtcTimeType time;
    
    rtc_stamp_to_time(&time , unix_stamp);
    
    hal_rtc_set(time.year,time.mon,time.day,time.hour,time.min,time.sec,time.week);
}


rtcType    rtc=
{
    .set_time               = rtc_set_time,
    .set_time_form_stamp    = rtc_set_time_form_stamp,
    .read_stamp             = rtc_read_stamp,
    .read_time              = rtc_read_time,
    .time_to_stamp          = rtc_time_to_stamp,
    .stamp_to_time          = rtc_stamp_to_time,
};


void test_rtc(void)
{
	for(char i=0;i<2;i++)
	{
			//1--获得时间错
		    static uint32_t stamp=0;
			stamp = rtc.read_stamp();
			printf("stamp = rtc.read_stamp()=%08X\r\n",stamp);

            //2--获得时间结构体
			rtcTimeType time;
			rtc.read_time(&time);
			log_err("Time  =  20%02d-%02d-%02d %02d:%02d:%02d ,week:%d\r\n" ,
						time.year,time.mon,time.day,
						time.hour,time.min,time.sec,
						time.week);
				
			//3自己转化玩儿	
			stamp = 1559208020	;
			rtc.stamp_to_time(&time ,stamp );

				
            //4设置时间
			rtc.set_time_form_stamp(stamp);	
	}
}

#ifndef _GBSP_RTC_H_
#define _GBSP_RTC_H_

#include <stdint.h>


typedef struct
{
    uint8_t year;
    uint8_t mon;
    uint8_t day;
    uint8_t hour;
    uint8_t min;
    uint8_t sec;
    uint8_t week;
}rtcTimeType;

typedef struct
{
    void        (*set_time)                 (rtcTimeType *time);
    void        (*set_time_form_stamp)      (uint32_t unix_stamp);
	uint32_t    (*read_stamp)	            ( void );
	void        (*read_time)                (rtcTimeType *time);
    uint32_t    (*time_to_stamp)            (rtcTimeType *time);
    void        (*stamp_to_time)            (rtcTimeType *time ,uint32_t unix_stamp);
}rtcType;

extern void rtc_alarm_callback( void);

extern rtcType  rtc;

void test_rtc(void);

#endif

 

GKoSon
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
海思3559A 内置RTC模块调试
jzwjzw19900922的博客
06-12 1358
前言 由于内置有RTC模块，无须再外挂RTC 查看SDK是否默认开启RTC 1. 查看设备节点 ls dev 说明默认SDK已经开启了RTC功能 2. 查看驱动 使用的linux标准rtc驱动 设置RTC时间 查看硬件时钟用命令： hwclock --show 或者 hwclock -r 重置硬件时钟用： #date 060910252020.00 //设置系统时钟 2020 年 06 月 09 日 星期四 10:25:00 CST #hwclo...
STM32的RTC模块
GKoSon的博客
08-08 1420
写在前面： 其实并不困难，RTC已经整合在STM32芯片内部，你可以理解为一个比如AT24C02在芯片里面。 比如你现在要做一个时钟，你需要什么？ A一个一秒钟增加1的一个数 B一个把这个数转化成年月日的算法。 写在这个数u32我们放到全局中，每1S就增加一个，我们用32.768K的晶振， 因为越高越安全，其实我们会分频的，就是1s动一下。 准备空米快 typedef st...
STM32F407+RTC实时时钟
最新发布
m0_61973119的博客
05-03 611
实时时钟。RTC模块拥有一个连续计数的计数器，在相应的软件配置下，可以提供时钟日历的功能。修改计数器的值可以重新设置当前时间和日期 RTC还包含用于管理低功耗模式的自动唤醒单元。RTC实物图如下。无论器件状态如何（运行模式、低功耗模式或处于复位状态），只要电源电压保持在工作范围内，RTC使不会停止工作。
rtc使用
qq_54215896的博客
11-09 1004
rtc
RTC module design
naumy的博客
03-19 796
RTC单元提供实时时钟和日历功能，包括自动闰年调整、闹钟和周期性中断支持。无论在何种工作模式下，RTC都不会关闭，即使在低功耗模式下也能正常运行。此外，RTC的输出寄存器和时钟校正寄存器不会被复位，以确保时钟的准确性。RTC模块的时钟源可选择Fosc时钟（默认）或Flrc时钟。而且，RTC模块的工作电压可以降至最低1V。
QuickActionView, 视图，显示长按时间的快速操作，由rtc启动.zip
10-10
QuickActionView, 视图，显示长按时间的快速操作，由rtc启动 QuickActionView视图，显示长按时间的快速操作，由rtc启动 Gradle依赖项将这里文件添加到 root build.gradle 文件( 你的模块 build.gradle 文件不包括 ) ...
boardy:响应式，易于定制，针对Web浏览器上的rtc绘图工具进行了优化
05-02
快速实时通信：我们考虑到实时通信的开始开发了此模块。 因此，boardy可让您以最小的有效负载在互联网上共享黑板笔迹。 （不是协议有效负载，仅是绘画有效负载）工作方式交叉浏览last 2 version > 1% IE 10
船用发电机组自动准同步并车装置的开发.pdf
09-06
该文章详细介绍了基于S3C2440A微处理器和嵌入式Linux实时操作系统平台的船用发电机组自动准同步并车装置的开发过程。这种装置是现代船舶电站自动化的重要组成部分，能够实现发电机组的高效、稳定并网运行。 **系统...
ARCall（支持一对一，一对多，音视频呼叫，可应用于在线会议，视频通话、在线医疗等场景）
04-11
ArCall支持一对一呼叫，代码可拓展多人呼叫邀请，可运用自采集模块，加载第三方美颜库，实现美颜贴图功能,项目可对接第三方推送实现推送功能。 通过调用接口的双引擎达到数据高速传输的目的，可独立运行，也可接入...
solaris内存检测方法
10-13
Solaris 操作系统提供了多种内存检测方法，其中之一是使用 dbx 工具中的 Runtime Checking（RTC）模块。RTC 模块不仅可以检测内存泄漏，还可以检测内存访问和使用问题。 RTC 模块的使用需要满足一些前提条件，例如...
通用模块（5）——RTC模块
横山郡守的博客
03-24 728
参考链接： https://blog.csdn.net/bb807777/article/details/80447747 https://blog.csdn.net/u011290127/article/details/95401602 rtc架构 kernel-3.4.39/include/linux/rtc.h struct rtc_class_ops { int (*open)(struct device *); void (*release)(struct d
【蓝桥杯嵌入式组】十一、RTC模块
悟已往之不谏 知来者之可追
02-18 863
工程可见Github&amp;amp;amp;amp;amp;lt;传送门&amp;amp;amp;amp;amp;gt; 一、主要代码 main.c /******************************************************************************* * 文件名：main.c * 描 述： * 作 者：CLAY * 版本号：v1.0.0 * 日 期: 2019年2月18日 * 备 注：修改后的LCD例程 ...
RTC模块驱动开发总结
Jkf40622的专栏
11-17 1502
一、RTC模块驱动开发 1、RTC模块的设备驱动模型 RTC应用层API (/dev/rtc)   2、I2C模块的驱动模型                                        
STM32基于固件库学习笔记(11)RTC实时时钟
weixin_43993734的博客
10-07 3221
使用RTC实时时钟的秒中断打印当前时间。（相当于使用简单的定时器每一秒中断打印时间）
学习使用 8051 和 DS1307 RTC 模块构建实时时钟
华维单片机编程
02-20 912
将 RTC 模块 (DS1307) 与 8051 微控制器连接 我们来了解如何将 RTC（实时时钟）模块连接到 8051 微控制器。市场上有不同种类的 RTC 模块。我们使用 DS1307 IC、LCD 模块和 AT89S52附带的最常见的 RTC 模块。AT89S52 是 Atmel 制造的典8051 微控制器。将 RTC 模块连接到 8051 微控制器非常简单。只需要在 RTC 模块和 8051 之间建立 2 个连接。 实时时钟模块基本上是一个时间跟踪设备，它提供当前时间和日期。DS323.
RK3568平台（时间篇）RTC时间框架
weixin_49303682的博客
02-27 1900
RTC（）是一种用于计时的模块，可以是再soc内部，也可以是外部模块。对于soc内部的RTC，只需要读取寄存器即可，对于外部模块的RTC，一般需要使用到I2C接口进行读取。至于如何供电，都是可以在主电源断开后使用纽扣电源辅助供电，达到设备断电仍然可以计时的效果。对于soc内部的RTC，需要额外的晶振，而外部模块的RTC不需要。在linux内核里，rtc是一个字符设备，内核实现了一个通用的字符设备层，提供给应用层系统调用，给底下的RTC硬件驱动层提供注册接口。
嵌入式--RTC实时时钟原理及相关库函数功能
wenbo5的博客
10-23 3483
嵌入式--RTC实时时钟原理及相关库函数功能
TM4C Hibernate RTC实现
qq_15242011的博客
02-20 693
项目有个地方需要RTC，我研究了TM4C Hibernate RTC的Demo，发现了一些问题。 TM4C Hibernate实现RTC有个主意的地方就是不能用官方给的demo，我的平台是TM4C1294KCPDT，用官方的demo，调试发现卡在HibernateEnableExpClk(SysCtlClockGet())里，不能用，研究库源码发现这个函数仅仅是置位HIBCTL寄存器的CLK32...
stmdaf103按键调整rtc
02-02
stmdaf103按键可以用来调整RTC（Real Time Clock）模块的时间。...总的来说，stmdaf103按键调整RTC模块的时间是一种简单而有效的方法，可以快速准确地完成时间调整操作，确保RTC模块的准确性和可靠性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值