单片机裸机实用组件--软件定时器、时间戳

最新推荐文章于 2024-03-06 17:47:32 发布
最新推荐文章于 2024-03-06 17:47:32 发布
阅读量9.2k 收藏 6
点赞数 2
分类专栏： 嵌入式 文章标签： 单片机 stm32 嵌入式 物联网 定时器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42378319/article/details/121890545
版权

单片机裸机实用组件–软件定时器、时间戳

之前写过一篇关于单片机定时器延时计时功能的博客 ，刚工作的时候搞得现在看来还是比较糙的，是时候整一个新的了。

base_timer

单片机裸机适用的定时器小组件,通过一个定时器记录系统运行时长，为用户提供一个时间戳信息，当然也有软件定时器功能。

移植教程

  1. 将 base_timer.c base_timer.h base_timer_port.c 添加到工程中
  2. 打开 base_timer_port.c 文件，自行实现里面的函数, 其中最重要的是 btimer_port_init(uint32_t clock, uint16_t ticks)函数和 uint32_t btimer_port_get_ticks(void)函数
/*!
  * @brief    初始化定时器
  *
  * @param    clock:  定时器时钟
  * @param    ticks:  定时器每s中断ticks次
  *
  * @return   无
  *
  * @note     移植时需要根据使用的定时器实现该函数
  *
  * @see      btimer_port_init(72000000, 1000);  
  *
  * @date     2019/07/15
  */
void btimer_port_init(uint32_t clock, uint16_t ticks)
{

}

/*!
  * @brief    获取定时器的tick值
  *
  * @param    无
  *
  * @return   ticks
  *
  * @note     移植时需要根据使用的定时器实现该函数
  *
  * @see      
  *
  * @date     2019/07/15
  */
uint32_t btimer_port_get_ticks(void)
{
    return ;
}
  1. 将 btimer_ticks();函数添加到定时器中断服务函数中，周期性的执行。

使用说明

  1. 初始化定时器
void btimer_init(uint32_t clock, uint16_t ticks);
  1. 定时器初始化后，系统内就存在了一个时基，可以获取系统从定时器初始化到现在的运行 ticks，通过这个时间戳信息，就可以实现各种各样的功能了。
    需要注意的是，us和ms相关的函数都是在调用 uint64_t btimer_get_ticks(void); 函数的基础上使用除法实现的，但是没有double FPU的单片机对 uint64_t 的除法运算比较耗时，实测STM32F103 72MHz时， 一次uint64_t 需要50us左右
uint64_t btimer_get_ticks(void);
uint32_t btimer_get_us(void);
uint32_t btimer_get_ms(void);
void btimer_delay_ticks(uint32_t ticks);
void btimer_delay_us(uint32_t us);
void btimer_delay_ms(uint32_t ms);
  1. 组件内同样也有实现软件定时器，在 base_timer.h 中使能
/*! 是否使能软件定时器 */
#define SOFT_TIMER_ENABLE  1
  • 调用软件定时器初始化函数初始化一个软件定时器
void stimer_init(Stimer_t * stimer, uint16_t ticks, uint8_t count, stimerCallback_t cb);
  • 开启关闭定时器
void stimer_start(Stimer_t * stimer);
void stimer_stop(Stimer_t * stimer);

使用例子

/* 定时器超时回调函数 */
void stimerLed1Callback(void)
{
  //do something
}

void stimerLed2Callback(void)
{
  //do something
}

void stimerLed3Callback(void)
{
  //do something
}

Stimer_t g_stimerLed1, g_stimerLed2, g_stimerLed3;

int main(void)
{

  /* 初始化定时器 定时器时钟 72MHz 每秒中断1000次 */
  btimer_init(72000000, 1000);
  
  /* 获取时间戳 */
  uint64_t ticks1 = btimer_get_ticks();
  
  /* 延时 10000us */
  btimer_delay_us(10000);
  
  /* 获取时间戳 通过 ticks2 - ticks1 可以获得 btimer_delay_us(10000); 运行时长 */
  uint64_t ticks2 = btimer_get_ticks();
  
  /* 延时 10ms */
  btimer_delay_ms(10);
  
  stimer_init(&g_stimerLed1, 100,  COUNTER_MAX, stimerLed1Callback);
  stimer_init(&g_stimerLed2, 1000, 1,           stimerLed2Callback);
  stimer_init(&g_stimerLed3, 1000, COUNTER_MAX, stimerLed3Callback);
  
  stimer_start(&g_stimerLed1);
  stimer_start(&g_stimerLed2);
  stimer_start(&g_stimerLed3);

  while (1)
  {
    if(stimer_is_timeout(&g_stimerLed2))
    {
      stimer_init(&g_stimerLed2, 1000, 1,           stimerLed2Callback);
      stimer_start(&g_stimerLed2);
    }
  }
}

base_timer.c

/*!
  * @file     base_timer.c
  *
  * @brief    系统计时器
  *
  * @company   
  *
  * @author   不咸不要钱
  *
  * @note     
  *
  * @version  V1.2
  *
  * @Software  
  *
  * @par URL  
  *           
  *
  * @date     2019/07/15
  */ 
#include "base_timer.h"

/** 
  * @brief 一个时间结构体
  * @note  内部调用
  */
typedef struct{
    uint32_t ulTickPerMicrosecond;                  /*!<每us tick计数值         */
    uint32_t ulTickPerMillisecond;                  /*!<每ms tick计数值         */
    uint32_t ulTickPerHandler;                      /*!<每？ticks 定时器中断一次*/
    volatile uint64_t ullTicks;                     /*!<当前ticks               */
    uint32_t ulDelayOffSet;                         /*!<函数零偏                */
}BaseTimerParame_t;

/** 保存定时器参数 */
static BaseTimerParame_t s_tTimer;

#if defined(SOFT_TIMER_ENABLE) && (SOFT_TIMER_ENABLE == 1)
static void stimer_ticks(void);
#endif

/*!
  * @brief    定时器tick自增
  *
  * @param    无
  *
  * @return   无
  *
  * @note     需要在定时器中断服务函数中调用 btimer_ticks(); 
  *
  * @see      无
  *
  * @date     2019/07/15
  */
void btimer_ticks(void)
{
    s_tTimer.ullTicks     += s_tTimer.ulTickPerHandler;
    
    #if defined(SOFT_TIMER_ENABLE) && (SOFT_TIMER_ENABLE == 1)
        stimer_ticks();    
    #endif
}

/*!
  * @brief    初始化定时器
  *
  * @param    clock:  定时器时钟 clock要大于等于 1M
  * @param    ticks:  定时器每s中断ticks次 
  *
  * @return   无
  *
  * @note     
  *
  * @see      btimer_init(72000000, 1000);  
  *
  * @date     2019/07/15
  */
void btimer_init(uint32_t clock, uint16_t ticks)
{
    
    if(clock < 1000000ul)
    {
        /* 定时器频率 小于1MHz  每us tick计数值 固定为1 
           注意：定时器频率过低，使用us相关函数时会不准确 */
        s_tTimer.ulTickPerMicrosecond = 1;
    }
    else
    {
        s_tTimer.ulTickPerMicrosecond = clock / 1000000ul;
    }
    
    if(clock < 1000)
    {
        /* 定时器频率 小于1KHz  
           注意：定时器频率过低 */
        while(1);
    }
    else
    {
        s_tTimer.ulTickPerMillisecond = clock / 1000;
    }
    
    s_tTimer.ullTicks = 0;
    s_tTimer.ulTickPerHandler = clock / ticks;
    s_tTimer.ulDelayOffSet = 0;
    
    btimer_port_init(clock, ticks);
    
    /* 去零偏 */
    uint32_t currentTicks1 = 0, currentTicks2 = 0;
    for(int i = 0; i < 1000; i++)
    {
        currentTicks1 = btimer_get_ticks();
        btimer_delay_us(1);
        currentTicks2 = btimer_get_ticks();
        s_tTimer.ulDelayOffSet += (currentTicks2 - currentTicks1 - s_tTimer.ulTickPerMicrosecond);
    }
    s_tTimer.ulDelayOffSet = (s_tTimer.ulDelayOffSet + 500)/1000;
}


/*!
  * @brief    关闭定时器
  *
  * @param    无
  *
  * @return   无
  *
  * @note     
  *
  * @see      BaseTimerDeInit();  
  *
  * @date     2019/07/15
  */
void btimer_deinit(void)
{
    btimer_port_deinit();
}

/*!
  * @brief    获取当前tick值
  *
  * @param    无
  *
  * @return   从定时器初始化到当前的ticks
  *
  * @note     
  *
  * @see      
  *
  * @date     2019/07/15
  */
uint64_t btimer_get_ticks(void)
{
    uint64_t ticks = 0;
    uint32_t timerValue = 0;
    do
    {
        ticks = s_tTimer.ullTicks;
        timerValue = btimer_port_get_ticks();
        
    }while(ticks != s_tTimer.ullTicks);
    return ticks + timerValue;
}

/*!
  * @brief    获取当前us值
  *
  * @param    无
  *
  * @return   从定时器初始化到当前的us
  *
  * @note     uint64 除法非常耗时  stm32F1xx 做一次 uint64除法大概需要50us
  *
  * @see      
  *
  * @date     2019/07/15
  */
uint32_t btimer_get_us(void)
{
    return btimer_get_ticks()/s_tTimer.ulTickPerMicrosecond;
}



/*!
  * @brief    获取当前ms值
  *
  * @param    无
  *
  * @return   从定时器初始化到当前的ms
  *
  * @note     uint64 除法非常耗时  stm32F1xx 做一次 uint64除法大概需要50us
  *
  * @see      
  *
  * @date     2019/07/15
  */
uint32_t btimer_get_ms(void)
{
    return btimer_get_ticks()/s_tTimer.ulTickPerMillisecond;
}



/*!
  * @brief    延时
  *
  * @param    ticks ： 要延时的ticks
  *
  * @return   无
  *
  * @note     
  *
  * @see      
  *
  * @date     2019/07/15
  */
void btimer_delay_ticks(uint32_t ticks)
{
    uint64_t end = btimer_get_ticks() + ticks - s_tTimer.ulDelayOffSet;
    
    while(btimer_get_ticks() <= end);
}

/*!
  * @brief    延时
  *
  * @param    us ： 要延时的us
  *
  * @return   无
  *
  * @note     
  *
  * @see      
  *
  * @date     2019/07/15
  */
void btimer_delay_us(uint32_t us)
{
    uint64_t end = btimer_get_ticks() + us * s_tTimer.ulTickPerMicrosecond - s_tTimer.ulDelayOffSet;
    
    while(btimer_get_ticks() <= end);
}

/*!
  * @brief    延时
  *
  * @param    ms ： 要延时的ms
  *
  * @return   无
  *
  * @note     
  *
  * @see      
  *
  * @date     2019/07/15
  */
void btimer_delay_ms(uint32_t ms)
{
    uint64_t end = btimer_get_ticks() + ms * s_tTimer.ulTickPerMillisecond - s_tTimer.ulDelayOffSet;
    
    while(btimer_get_ticks() <= end);
}


#if defined(SOFT_TIMER_ENABLE) && (SOFT_TIMER_ENABLE == 1)

/** 指向软件定时器驱动链表头节点 */
static Stimer_t * s_stimer_head = 0;

/*!
  * @brief    软件定时器节拍处理
  *
  * @param    无
  *
  * @return   无
  *
  * @note     需要周期性调用该函数  软件定时器ticks均以该周期为单位 
  *
  * @see      
  *
  * @date     2019/07/15
  */
static void stimer_ticks(void)
{
    Stimer_t * node = s_stimer_head;
    
    while(node)
    {
        if(node->ucCounter > 0)
        {  
            if(-- node->ulTicks == 0)
            {
                if(node->ucCounter != COUNTER_MAX)
                {
                    node->ucCounter--;
                }

                node->ulTicks = node->ulPerLoad;
                node->ucFlag  = 1;
                
                if(node->stimerCallback != 0)
                {
                    node->stimerCallback((void *)node);
                }
                
                if(node->ucCounter == 0)
                {
                    stimer_stop(node);
                }
            }
        }
        else
        {
            stimer_stop(node);
        } 
        
        node = node->ptNextTimer;
    }
}    

/*!
  * @brief    软件定时器初始化
  *
  * @param    stimer：软件定时器
  * @param    ticks ：软件定时器定时时间
  * @param    count ：软件定时器定时次数  如果为0xFF 则为永久
  * @param    cb    ：软件定时器溢出回调函数
  *
  * @return   无
  *
  * @note     cb 回调函数会在 btimer_ticks() 中执行，而 btimer_ticks() 一般在中断服务函数中，因此定时器溢出回调函数尽量快进快出
  *
  * @see      
  *
  * @date     2019/07/15
  */
void stimer_init(Stimer_t * stimer, uint16_t ticks, uint8_t count, stimerCallback_t cb)
{
    stimer_port_lock();
    
    stimer->ulTicks   = ticks;
    stimer->ulPerLoad = ticks;
    stimer->ucCounter = count;
    stimer->ucFlag    = 0;
    stimer->stimerCallback = cb;
    
    stimer_port_unlock();
}

/*!
  * @brief    开启软件定时器
  *
  * @param    stimer：软件定时器
  *
  * @return   无
  *
  * @note     将软件定时器添加到链表上
  *
  * @see      
  *
  * @date     2019/07/15
  */
void stimer_start(Stimer_t * stimer)
{
    stimer_port_lock();
  
    /* 防止重复 */
    Stimer_t * node = s_stimer_head;

    while(node)
    {
        if(node == stimer)
        {
            stimer_port_unlock();
            return;
        }
        else
        {
            node = node->ptNextTimer;
        }   
    }

    stimer->ptNextTimer  = s_stimer_head;
    s_stimer_head        = stimer;
    
    stimer_port_unlock();
}

/*!
  * @brief    停止软件定时器
  *
  * @param    stimer：软件定时器
  *
  * @return   无
  *
  * @note     将软件定时器从定时器链表上移除
  *
  * @see      
  *
  * @date     2019/07/15
  */
void stimer_stop(Stimer_t * stimer)
{
    Stimer_t** curr;
	  for(curr = &s_stimer_head; *curr; ) 
    {
        Stimer_t* entry = *curr;
        if (entry == stimer) 
        {
            stimer_port_lock();
                
            *curr = entry->ptNextTimer;
                
            stimer_port_unlock();
            return;
        } 
        else
        {
            curr = &entry->ptNextTimer;
        }   	
	  }
}

/*!
  * @brief    停止软件定时器超时
  *
  * @param    stimer：软件定时器
  *
  * @return   无
  *
  * @note     调用后会自动清除超时标志位
  *
  * @see      
  *
  * @date     2019/07/15
  */
uint8_t stimer_is_timeout(Stimer_t * stimer)
{
    uint8_t flag = stimer->ucFlag;
    
    stimer_port_lock();
    
    stimer->ucFlag = 0;
    
    stimer_port_unlock();
    
    return flag;
}
#endif

base_timer.h

/*!
  * @file     base_timer.h
  *
  * @brief    系统计时器
  *
  * @company   
  *
  * @author   不咸不要钱
  *
  * @note     
  *
  * @version  V1.2
  *
  * @Software C99
  *
  * @par URL  
  *           
  *
  * @date     2019/07/15
  */ 
#ifndef __BASE_TIMER_H
#define __BASE_TIMER_H

#ifdef __cplusplus
extern "C" {
#endif

#include <stdint.h>

/* 用户函数 */
void btimer_init(uint32_t clock, uint16_t ticks);
void btimer_deinit(void);
uint64_t btimer_get_ticks(void);
uint32_t btimer_get_us(void);
uint32_t btimer_get_ms(void);
void btimer_delay_ticks(uint32_t ticks);
void btimer_delay_us(uint32_t us);
void btimer_delay_ms(uint32_t ms);
void btimer_ticks(void);


/*! 是否使能软件定时器 */
#define SOFT_TIMER_ENABLE  1

#if defined(SOFT_TIMER_ENABLE) && (SOFT_TIMER_ENABLE == 1)


/*! 定时器重复最大次数 */
#define COUNTER_MAX  (0xFF)

/*! 函数指针 指向软件定时器超时回调函数 */
typedef void (*stimerCallback_t)(void *);

/** 
  * @brief stimer 软件定时器结构体
  * @note  无
  */
typedef struct Stimer
{
    volatile uint8_t  ucCounter;
    volatile uint8_t  ucFlag;
    volatile uint32_t ulTicks;
             uint32_t ulPerLoad;
    stimerCallback_t  stimerCallback;
    struct Stimer * ptNextTimer;
}Stimer_t;

void stimer_init(Stimer_t * stimer, uint16_t ticks, uint8_t count, stimerCallback_t cb);
void stimer_start(Stimer_t * stimer);
void stimer_stop(Stimer_t * stimer);
uint8_t stimer_is_timeout(Stimer_t * stimer);

void stimer_port_lock(void);
void stimer_port_unlock(void);
#endif




/* 移植时需用户实现 */
void btimer_port_init(uint32_t clock, uint16_t ticks);
void btimer_port_deinit(void);
uint32_t btimer_port_get_ticks(void);





#ifdef __cplusplus
}
#endif

#endif

base_timer_port.c

/*!
  * @file     base_timer_port.c
  *
  * @brief    系统计时器用户接口
  *
  * @company   
  *
  * @author   不咸不要钱
  *
  * @note     
  *
  * @version  V1.2
  *
  * @Software C99
  *
  * @par URL  
  *           
  *
  * @date     2019/07/15
  */ 
#include "base_timer.h"


/*!
  * @brief    初始化定时器
  *
  * @param    clock:  定时器时钟
  * @param    ticks:  定时器每s中断ticks次
  *
  * @return   无
  *
  * @note     移植时需要根据使用的定时器实现该函数
  *
  * @see      btimer_port_init(72000000, 1000);  
  *
  * @date     2019/07/15
  */
void btimer_port_init(uint32_t clock, uint16_t ticks)
{

}

/*!
  * @brief    关闭定时器
  *
  * @param    无
  *
  * @return   无
  *
  * @note     
  *
  * @see      btimer_port_deinit();  
  *
  * @date     2019/07/15
  */
void btimer_port_deinit(void)
{

}

/*!
  * @brief    获取定时器的tick值
  *
  * @param    无
  *
  * @return   ticks
  *
  * @note     移植时需要根据使用的定时器实现该函数
  *
  * @see      
  *
  * @date     2019/07/15
  */
uint32_t btimer_port_get_ticks(void)
{
    return ;
}


#if defined(SOFT_TIMER_ENABLE) && (SOFT_TIMER_ENABLE == 1)
/*!
  * @brief    加锁
  *
  * @param    
  *
  * @return   无
  *
  * @note     
  *
  * @see      
  */
void stimer_port_lock(void)
{

}

/*!
  * @brief    开锁
  *
  * @param    无
  *
  * @return   无
  *
  * @note     
  *
  * @see      
  */
void stimer_port_unlock(void)
{

}

#endif
不咸不要钱
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
API和微服务-项目-时间戳-微服务
02-13
在我们的测试中，我们将使用符合ISO-8601的日期字符串（例如"2016-11-20" ），因为这将确保UTC时间戳。 如果日期字符串为空，则它应等效于触发new Date() ，即服务使用当前时间戳。 如果日期字符串有效，则api返回...
linux 时间戳 单片机,C语言练习项目-UNIX时间戳4字节转时间可移植函数单片机嵌入式...
weixin_33654339的博客
05-04 266
4字节unix时间戳和正常年月日互相转换，很多协议用的到，c语言，有可以优化的地方欢迎讨论，根据网上案例总结优化后自己写的。评论免费拿走！！！1 #include"stdio.h"2 #include "stdint.h"3 #include 45 #define TIME_ZONE 8 //北京时间67 uint8_t Common_month_day[12]={ 31, 28, 31, 30,...
单片机时间戳转换
u013369325的博客
02-23 1100
看了网上的例程，大多繁琐，直接利用time.h里的库函数进行转换即可。
STM32标准库——（18）Unix时间戳、BKP备份寄存器、RTC实时时钟
2301_78772787的博客
03-06 994
32位有符号数所能表示的最大数字是2^32/2-1这个数是21亿多，这其实是有溢出风险的，因为目前到2023年时间戳已经计到16亿了，32位有符号数的时间戳会在2038年的1月19号溢出，64位的时间戳能存储的时间范围非常非常的大，看下手册STM32它核心的计时部分，是一个32位的可编程计数器，这说明我们这款stm32 ，它的时间戳是32位的数据类型，这表示我们这个stm32也会在2038年出现bug吗，实际上并不会啊，因为根据我的研究，这个时间戳在stm32程序中定义的其实是无符号。
keil编译时生成时间戳_ARM编译器那些事
weixin_39773817的博客
11-12 571
基于ARM内核的芯片在我们的世界中无处不在，从简单的MCU到高端的应用处理器，各行各业中都有它们的身影。如今ARM生态系统非常繁荣，在这繁荣的背后编译器的作用功不可没。ARM编译器按照内核类型可分为两大类，其一是适用于Cortex-M/R内核的编译器，其二是适用于Cortex-A内核的编译器。编译器（套件）通常也称作（编译）工具链，下文可能会混用，但是是一个意思，请知悉。适用于Cortex-M/R...
毫秒时间戳与时间转换C源码
qq_36257571的博客
08-11 1027
毫秒时间戳与时间转换C源码。
C语言编写 秒数转换成时间戳 UTC时间 函数实现
小小黑猫警长的博客
12-24 8881
单片机中需要转换时间戳，没有现成的函数可以用，为了提高单片机的效率，写了一个，参考如下： const int Days[12]={31,28,31,30,31,30,31,31,30,31,30,31}; void MainWindow::Calc_Time(unsigned long Second_data) { unsigned long Year = 1970; ...
利用单片机定时器做Unix时间戳保持及时间转换
u011852186的博客
08-23 1408
单片机Unix时间戳保持及时间转换引言流程图1、定时器相关代码片段2、时间戳转换3、字符串转换函数 引言 单片机平台上进行网络应用开发时，总会遇到Unix时间戳与本地时间转换的问题。对于使用低端MCU+WIFI模块的硬件方案，策略是使用MCU的一个定时器，配置定时器1S产生一次中断，中断处理函数中对uint32_t的变量做累加,用于表示本机时间。当MCU通过WIFI模块获取到网络时间后，计算网络时间与本机时间的差值，并保存此差值。 此后MCU端需要使用Unix时间戳是，就无需通过WIFI模块获取网络事件，而
【C语言】计算实时太阳角度（高度角、方位角），以及使用stm32单片机实时获取时间戳
weixin_70042862的博客
11-22 1025
在编写该代码的过程中寻找了多篇博文和论文，综合所有文章且按网上的以0时的方位角的0°，且随时间累加累加至360度。我修改了博文和论文的一些角度的计算方法。得到一下代码。
STM32学习笔记（十二）丨RTC实时时钟
电子德彪西的博客
07-16 3393
Bilibili 江协科技 STM32个人学习笔记（持续更新完善中……）
STM32单片机示例：64位全局时间戳发生器
Naisu的各种笔记
08-30 620
STM32H743 / H750 系列的芯片有一个64位的全局时间戳发生器（ Global timestamp generator ），这篇文章将对它的使用做个记录。
获取时间戳方法总结
追梦
01-04 302
通过valueOf（）和 getTime（）方法获取 var date = new Date() console.log(date.valueOf()) console.log(date.getTime()) 通过+new Date() 方法获取 var date1 = +new Date() console.log(date1) 通过Date.now()方法获取 （H5新增，部分浏览器不支持...
GMT 0033-2014 时间戳接口规范.PDF
05-18
GMT 0033-2014 时间戳接口规范.PDF
UCOSIII-4-时间戳
最新发布
03-07
移步文章 https://blog.csdn.net/qq_36769966/article/details/136509497
Unity-C#-时间戳解析.txt
08-04
完成时间戳向各种时间格式的快速转换
js时间戳转yyyy-MM-dd HH-mm-ss工具类详解
10-17
主要介绍了js时间戳转yyyy-MM-dd HH-mm-ss工具类，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
STM32单片机bootloader扫盲
热门推荐
不咸不要钱
10-21 4万+
STM32单片机BootLoader扫盲 BootLoader和APP之间的关系 APP就是平时写的单片机上的应用程序，而BootLoader本质上和APP一样，也是平时写的应用程序。BootLoader只不过是拥有从外部接收数据，更新Flash（也就是APP），跳转至APP功能的特殊APP罢了。 以STM32F103为例，如果没有BootLoader，flash分布就如下图左半部分。如果有BootLoader，就如下图右半部分，将flash分为两部分（这里举例用0x800 4000做分界线），存储了两个应
STM32 单片机启动流程
不咸不要钱
10-19 1万+
STM32 单片机启动流程 刚接触ARM的cortex-m系列单片机时，被告知一切都从main() 函数开始，要将程序写在main()函数中。而仿真时也貌似是从main() 函数开始的，以STM32F103为例。 后来了解到全局变量是在main()函数之前初始化的。MDK默认情况下勾选下面选项，跳过了启动的汇编部分代码，直接进入了main() 函数. 实际起始位置 在cortex-m系列中，中断向量表存放在 Flash 开始部分，Flash中第一个字存放栈顶指针，第二个字存放复位中断服务函数入口地址，
基于单片机的简单的任务调度器
不咸不要钱
05-15 9721
近来工作之余，研究了一下APM的源码。 APM源码连接https://pan.baidu.com/s/17Dg1oEJT_fj12DM1BmZWxA 发现源码中有一个简单的任务调度器，不太重要的任务都在Scheduler中完成。为什么需要Scheduler呢？？ 飞行器姿态信息需要角速度积分，位置信息也需要光流的积分，也就是需要获取精确的时间间隔，对时间敏感。 Scheduler的主要作用是保证主函数运行的时间相同，什么原理呢？ 假设我们主循环中有6个任务， 每个任务执行时间为1ms，而我们的控制周期要求
java 时间戳 - 3小时
05-30
可以使用以下代码获取当前时间戳并减去3小时的时间戳： ``` long currentTimeStamp = System.currentTimeMillis(); long adjustedTimeStamp = currentTimeStamp - 3 * 60 * 60 * 1000; ``` 其中，`currentTimeStamp`表示当前时间戳，单位为毫秒，`adjustedTimeStamp`表示调整后的时间戳。需要注意的是，这里减去的3小时需要转换为毫秒数，即3 * 60 * 60 * 1000。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值