定时器系列1-红黑树

最新推荐文章于 2023-09-05 23:06:16 发布
最新推荐文章于 2023-09-05 23:06:16 发布
阅读量250 收藏
点赞数
分类专栏： 定时器 C/C++ 文章标签： nginx
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/u014183456/article/details/120277324
版权

对于服务端来说，驱动服务端逻辑的事件主要有两个，⼀个是⽹络事件，另⼀个是时间事件；
在不同框架中，这两种事件有不同的实现⽅式；
第⼀种，⽹络事件和时间事件在⼀个线程当中配合使⽤；例如nginx、 redis；

// 第⼀种
while (!quit) {
int now = get_now_time();// 单位： ms
int timeout = get_nearest_timer() - now;
if (timeout < 0) timeout = 0;
int nevent = epoll_wait(epfd, ev, nev, timeout);
for (int i=0; i<nevent; i++) {
//... ⽹络事件处理
}
update_timer(); // 时间事件处理
}

第⼆种，⽹络事件和时间事件在不同线程当中处理；例如skynet；

// 第⼆种 在其他线程添加定时任务
void* thread_timer(void * thread_param) {
init_timer();
while (!quit) {
update_timer(); // 更新检测定时器，并把定时事件发送到消息队列中
sleep(t); // 这⾥的 t 要⼩于 时间精度
}
clear_timer();
return NULL;
}
pthread_create(&pid, NULL, thread_timer, &thread_param);

对于定时器的数据结构选择，主要有红黑树， 最小堆，跳表，时间轮这几种。这个系列主要对这几种定时器做一个理解。

红黑树

对于增删查，时间复杂度为 O ( l o g 2 n ) O(log_2n) O(log2​n)；对于红⿊树最⼩节点为最左侧节点，时间复杂度为 O ( l o g 2 n ) O(log_2n) O(log2​n)。

nginx中的定时器的实现主要也是红黑树，我们可以直接拿nginx中的学习。
对于红黑树的系列可以看：红黑树的系列文章

r b t r e e . c rbtree.c rbtree.c


/*
 * Copyright (C) Igor Sysoev
 * Copyright (C) Nginx, Inc.
 */


#include "rbtree.h"


/*
 * The red-black tree code is based on the algorithm described in
 * the "Introduction to Algorithms" by Cormen, Leiserson and Rivest.
 */


static inline void ngx_rbtree_left_rotate(ngx_rbtree_node_t **root,
    ngx_rbtree_node_t *sentinel, ngx_rbtree_node_t *node);
static inline void ngx_rbtree_right_rotate(ngx_rbtree_node_t **root,
    ngx_rbtree_node_t *sentinel, ngx_rbtree_node_t *node);


void
ngx_rbtree_insert(ngx_rbtree_t *tree, ngx_rbtree_node_t *node)
{
    ngx_rbtree_node_t  **root, *temp, *sentinel;

    /* a binary tree insert */

    root = &tree->root;
    sentinel = tree->sentinel;

    if (*root == sentinel) {
        node->parent = NULL;
        node->left = sentinel;
        node->right = sentinel;
        ngx_rbt_black(node);
        *root = node;

        return;
    }

    tree->insert(*root, node, sentinel);

    /* re-balance tree */

    while (node != *root && ngx_rbt_is_red(node->parent)) {

        if (node->parent == node->parent->parent->left) {
            temp = node->parent->parent->right;

            if (ngx_rbt_is_red(temp)) {
                ngx_rbt_black(node->parent);
                ngx_rbt_black(temp);
                ngx_rbt_red(node->parent->parent);
                node = node->parent->parent;

            } else {
                if (node == node->parent->right) {
                    node = node->parent;
                    ngx_rbtree_left_rotate(root, sentinel, node);
                }

                ngx_rbt_black(node->parent);
                ngx_rbt_red(node->parent->parent);
                ngx_rbtree_right_rotate(root, sentinel, node->parent->parent);
            }

        } else {
            temp = node->parent->parent->left;

            if (ngx_rbt_is_red(temp)) {
                ngx_rbt_black(node->parent);
                ngx_rbt_black(temp);
                ngx_rbt_red(node->parent->parent);
                node = node->parent->parent;

            } else {
                if (node == node->parent->left) {
                    node = node->parent;
                    ngx_rbtree_right_rotate(root, sentinel, node);
                }

                ngx_rbt_black(node->parent);
                ngx_rbt_red(node->parent->parent);
                ngx_rbtree_left_rotate(root, sentinel, node->parent->parent);
            }
        }
    }

    ngx_rbt_black(*root);
}


void
ngx_rbtree_insert_value(ngx_rbtree_node_t *temp, ngx_rbtree_node_t *node,
    ngx_rbtree_node_t *sentinel)
{
    ngx_rbtree_node_t  **p;

    for ( ;; ) {

        p = (node->key < temp->key) ? &temp->left : &temp->right;

        if (*p == sentinel) {
            break;
        }

        temp = *p;
    }

    *p = node;
    node->parent = temp;
    node->left = sentinel;
    node->right = sentinel;
    ngx_rbt_red(node);
}


void
ngx_rbtree_insert_timer_value(ngx_rbtree_node_t *temp, ngx_rbtree_node_t *node,
    ngx_rbtree_node_t *sentinel)
{
    ngx_rbtree_node_t  **p;

    for ( ;; ) {

        /*
         * Timer values
         * 1) are spread in small range, usually several minutes,
         * 2) and overflow each 49 days, if milliseconds are stored in 32 bits.
         * The comparison takes into account that overflow.
         */

        /*  node->key < temp->key */
        p = ((ngx_rbtree_key_int_t) (node->key - temp->key) < 0)
            ? &temp->left : &temp->right;

        if (*p == sentinel) {
            break;
        }

        temp = *p;
    }

    *p = node;
    node->parent = temp;
    node->left = sentinel;
    node->right = sentinel;
    ngx_rbt_red(node);
}


void
ngx_rbtree_delete(ngx_rbtree_t *tree, ngx_rbtree_node_t *node)
{
    ngx_uint_t           red;
    ngx_rbtree_node_t  **root, *sentinel, *subst, *temp, *w;

    /* a binary tree delete */

    root = &tree->root;
    sentinel = tree->sentinel;

    if (node->left == sentinel) {
        temp = node->right;
        subst = node;

    } else if (node->right == sentinel) {
        temp = node->left;
        subst = node;

    } else {
        subst = ngx_rbtree_min(node->right, sentinel);

        if (subst->left != sentinel) {
            temp = subst->left;
        } else {
            temp = subst->right;
        }
    }

    if (subst == *root) {
        *root = temp;
        ngx_rbt_black(temp);

        /* DEBUG stuff */
        node->left = NULL;
        node->right = NULL;
        node->parent = NULL;
        node->key = 0;

        return;
    }

    red = ngx_rbt_is_red(subst);

    if (subst == subst->parent->left) {
        subst->parent->left = temp;

    } else {
        subst->parent->right = temp;
    }

    if (subst == node) {

        temp->parent = subst->parent;

    } else {

        if (subst->parent == node) {
            temp->parent = subst;

        } else {
            temp->parent = subst->parent;
        }

        subst->left = node->left;
        subst->right = node->right;
        subst->parent = node->parent;
        ngx_rbt_copy_color(subst, node);

        if (node == *root) {
            *root = subst;

        } else {
            if (node == node->parent->left) {
                node->parent->left = subst;
            } else {
                node->parent->right = subst;
            }
        }

        if (subst->left != sentinel) {
            subst->left->parent = subst;
        }

        if (subst->right != sentinel) {
            subst->right->parent = subst;
        }
    }

    /* DEBUG stuff */
    node->left = NULL;
    node->right = NULL;
    node->parent = NULL;
    node->key = 0;

    if (red) {
        return;
    }

    /* a delete fixup */

    while (temp != *root && ngx_rbt_is_black(temp)) {

        if (temp == temp->parent->left) {
            w = temp->parent->right;

            if (ngx_rbt_is_red(w)) {
                ngx_rbt_black(w);
                ngx_rbt_red(temp->parent);
                ngx_rbtree_left_rotate(root, sentinel, temp->parent);
                w = temp->parent->right;
            }

            if (ngx_rbt_is_black(w->left) && ngx_rbt_is_black(w->right)) {
                ngx_rbt_red(w);
                temp = temp->parent;

            } else {
                if (ngx_rbt_is_black(w->right)) {
                    ngx_rbt_black(w->left);
                    ngx_rbt_red(w);
                    ngx_rbtree_right_rotate(root, sentinel, w);
                    w = temp->parent->right;
                }

                ngx_rbt_copy_color(w, temp->parent);
                ngx_rbt_black(temp->parent);
                ngx_rbt_black(w->right);
                ngx_rbtree_left_rotate(root, sentinel, temp->parent);
                temp = *root;
            }

        } else {
            w = temp->parent->left;

            if (ngx_rbt_is_red(w)) {
                ngx_rbt_black(w);
                ngx_rbt_red(temp->parent);
                ngx_rbtree_right_rotate(root, sentinel, temp->parent);
                w = temp->parent->left;
            }

            if (ngx_rbt_is_black(w->left) && ngx_rbt_is_black(w->right)) {
                ngx_rbt_red(w);
                temp = temp->parent;

            } else {
                if (ngx_rbt_is_black(w->left)) {
                    ngx_rbt_black(w->right);
                    ngx_rbt_red(w);
                    ngx_rbtree_left_rotate(root, sentinel, w);
                    w = temp->parent->left;
                }

                ngx_rbt_copy_color(w, temp->parent);
                ngx_rbt_black(temp->parent);
                ngx_rbt_black(w->left);
                ngx_rbtree_right_rotate(root, sentinel, temp->parent);
                temp = *root;
            }
        }
    }

    ngx_rbt_black(temp);
}


static inline void
ngx_rbtree_left_rotate(ngx_rbtree_node_t **root, ngx_rbtree_node_t *sentinel,
    ngx_rbtree_node_t *node)
{
    ngx_rbtree_node_t  *temp;

    temp = node->right;
    node->right = temp->left;

    if (temp->left != sentinel) {
        temp->left->parent = node;
    }

    temp->parent = node->parent;

    if (node == *root) {
        *root = temp;

    } else if (node == node->parent->left) {
        node->parent->left = temp;

    } else {
        node->parent->right = temp;
    }

    temp->left = node;
    node->parent = temp;
}


static inline void
ngx_rbtree_right_rotate(ngx_rbtree_node_t **root, ngx_rbtree_node_t *sentinel,
    ngx_rbtree_node_t *node)
{
    ngx_rbtree_node_t  *temp;

    temp = node->left;
    node->left = temp->right;

    if (temp->right != sentinel) {
        temp->right->parent = node;
    }

    temp->parent = node->parent;

    if (node == *root) {
        *root = temp;

    } else if (node == node->parent->right) {
        node->parent->right = temp;

    } else {
        node->parent->left = temp;
    }

    temp->right = node;
    node->parent = temp;
}


ngx_rbtree_node_t *
ngx_rbtree_next(ngx_rbtree_t *tree, ngx_rbtree_node_t *node)
{
    ngx_rbtree_node_t  *root, *sentinel, *parent;

    sentinel = tree->sentinel;

    if (node->right != sentinel) {
        return ngx_rbtree_min(node->right, sentinel);
    }

    root = tree->root;

    for ( ;; ) {
        parent = node->parent;

        if (node == root) {
            return NULL;
        }

        if (node == parent->left) {
            return parent;
        }

        node = parent;
    }
}

r b t r e e . h rbtree.h rbtree.h


/*
 * Copyright (C) Igor Sysoev
 * Copyright (C) Nginx, Inc.
 */

#ifndef _NGX_RBTREE_H_INCLUDED_
#define _NGX_RBTREE_H_INCLUDED_

typedef unsigned int  ngx_rbtree_key_t;
typedef unsigned int  ngx_uint_t;
typedef int   ngx_rbtree_key_int_t;
typedef unsigned char u_char;
#ifndef NULL
    #define NULL ((void*)0)
#endif

typedef struct ngx_rbtree_node_s  ngx_rbtree_node_t;

struct ngx_rbtree_node_s {
    ngx_rbtree_key_t       key;
    ngx_rbtree_node_t     *left;
    ngx_rbtree_node_t     *right;
    ngx_rbtree_node_t     *parent;
    u_char                 color;
    u_char                 data;
};

typedef struct ngx_rbtree_s  ngx_rbtree_t;

typedef void (*ngx_rbtree_insert_pt) (ngx_rbtree_node_t *root,
    ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel);

struct ngx_rbtree_s {
    ngx_rbtree_node_t     *root;
    ngx_rbtree_node_t     *sentinel;
    ngx_rbtree_insert_pt   insert;
};

#define ngx_rbtree_init(tree, s, i)                                           \
    ngx_rbtree_sentinel_init(s);                                              \
    (tree)->root = s;                                                         \
    (tree)->sentinel = s;                                                     \
    (tree)->insert = i

void 
ngx_rbtree_insert(ngx_rbtree_t *tree, ngx_rbtree_node_t *node);

void
ngx_rbtree_delete(ngx_rbtree_t *tree, ngx_rbtree_node_t *node);

void
ngx_rbtree_insert_value(ngx_rbtree_node_t *root, ngx_rbtree_node_t *node,
    ngx_rbtree_node_t *sentinel);
    
void
ngx_rbtree_insert_timer_value(ngx_rbtree_node_t *root,
    ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel);

ngx_rbtree_node_t *
ngx_rbtree_next(ngx_rbtree_t *tree,
    ngx_rbtree_node_t *node);

#define ngx_rbt_red(node)               ((node)->color = 1)
#define ngx_rbt_black(node)             ((node)->color = 0)
#define ngx_rbt_is_red(node)            ((node)->color)
#define ngx_rbt_is_black(node)          (!ngx_rbt_is_red(node))
#define ngx_rbt_copy_color(n1, n2)      (n1->color = n2->color)

/* a sentinel must be black */

#define ngx_rbtree_sentinel_init(node)  ngx_rbt_black(node)

static ngx_rbtree_node_t *
ngx_rbtree_min(ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel)
{
    while (node->left != sentinel) {
        node = node->left;
    }

    return node;
}

#endif /* _NGX_RBTREE_H_INCLUDED_ */

r b − t i m e r . h rb-timer.h rb−timer.h

#ifndef _MARK_RBT_
#define _MARK_RBT_

#include <stdio.h>
#include <stdint.h>
#include <unistd.h>
#include <stdlib.h>
#include <stddef.h>

#if defined(__APPLE__)
#include <AvailabilityMacros.h>
#include <sys/time.h>
#include <mach/task.h>
#include <mach/mach.h>
#else
#include <time.h>
#endif

#include "rbtree.h"

ngx_rbtree_t              timer;
static ngx_rbtree_node_t  sentinel;

typedef struct timer_entry_s timer_entry_t;
typedef void (*timer_handler_pt)(timer_entry_t *ev);

struct timer_entry_s {
    ngx_rbtree_node_t timer;
    timer_handler_pt handler;
};

static uint32_t
current_time() {
	uint32_t t;
#if !defined(__APPLE__) || defined(AVAILABLE_MAC_OS_X_VERSION_10_12_AND_LATER)
	struct timespec ti;
	clock_gettime(CLOCK_MONOTONIC, &ti);
	t = (uint32_t)ti.tv_sec * 1000;
	t += ti.tv_nsec / 1000000;
#else
	struct timeval tv;
	gettimeofday(&tv, NULL);
	t = (uint32_t)tv.tv_sec * 1000;
	t += tv.tv_usec / 1000;
#endif
	return t;
}

int init_timer() {
    ngx_rbtree_init(&timer, &sentinel, ngx_rbtree_insert_timer_value);
    return 0;
}

void add_timer(timer_entry_t *te, uint32_t msec) {
    msec += current_time();
    printf("add_timer expire at msec = %u\n", msec);
    te->timer.key = msec;
    ngx_rbtree_insert(&timer, &te->timer);
}

void del_timer(timer_entry_t *te) {
    ngx_rbtree_delete(&timer, &te->timer);
}

void expire_timer() {
    timer_entry_t *te;
    ngx_rbtree_node_t *sentinel, *root, *node;
    sentinel = timer.sentinel;
    uint32_t now = current_time();
    for (;;) {
        root = timer.root;
        if (root == sentinel) break;
        node = ngx_rbtree_min(root, sentinel);
        if (node->key > now) break;
        printf("touch timer expire time=%u, now = %u\n", node->key, now);
        te = (timer_entry_t *) ((char *) node - offsetof(timer_entry_t, timer));
        te->handler(te);
        ngx_rbtree_delete(&timer, &te->timer);
        free(te);
    }
}

#endif

r b − t i m e r . c rb-timer.c rb−timer.c

#include <stdio.h>
#include <string.h>
#include "rbt-timer.h"

void print_hello(timer_entry_t *te) {
    printf("hello world time = %u\n", te->timer.key);
}

int main()
{
    init_timer();
    timer_entry_t *te = malloc(sizeof(timer_entry_t));
    memset(te, 0, sizeof(timer_entry_t));
    te->handler = print_hello;
    add_timer(te, 3000);
    for (;;) {
        expire_timer();
        usleep(10000);
    }
    return 0;
}
birate_小小人生
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
4.5 小时钟-定时器 --------
04-19
4.5 小时钟-定时器 --------
二叉树总结
入门搬砖Figaro
02-25 279
二叉树总结 前序遍历 递归法（很简单，效率低） class Solution { List<Integer> result = new ArrayList<>(); public List<Integer> preorderTraversal(TreeNode root) { if (root == null) return result; result.add(root.val);
数据结构【java进阶笔记七】
yuyu的博客
01-15 276
目录 数据存储方式 时间复杂度 空间复杂度 树结构 二叉排序树 平衡二叉树（AVL） 右旋： 左旋： 双旋转 高度计算： 插入的同时维护平衡 Demo 红黑树 B树 B+树 数据存储方式 数据存储方式有几种？ 就两种：① 数组（顺序存储）、② 链表（链式存储） 数组：连续存储，随机访问、需要一次性分配好、扩容的时间复杂度为 O(N) 链表：不存在扩容问题、删除的时间复杂度为 O(1)、有较大的存储空间 常见数据结构 存储形式 其他（队列、栈、跳表..） .
红黑树实现定时器
向往天空的鱼
11-16 971
借助nginx中红黑树源码实现一个简单定时器demo
定时器方案之红黑树、最小堆、时间轮
最新发布
qq_29750559的博客
09-05 136
⼼跳检测技能冷却武器冷却倒计时CSDN文章的定时发布其它需要使⽤定时机制的功能int i,j;for (i=0;i
定时器设计--红黑树
kakaka666的博客
09-07 964
定时器设计--红黑树
C51单片机-定时器可调时钟-程序1
08-08
C51单片机-定时器可调时钟-程序1
linux 用户任务定时器配置 crontab -e 编辑的文本
05-14
linux 配置定时任务， crontab -e 编辑的文本，用户任务定时器配置，目录位置在 /var/spool/cron中的root文件中
555定时器.rar-综合文档
05-23
555定时器.rar电子技术资料大合集
STM32F103定时器1-5实验
07-16
STM32F103定时器1-5实验
linux下定时器实现
01-29
以最小堆、红黑树、时间轮三种方式实现定时器，时间轮效率最高，非常具有参考价值！
定时器方案 红黑树 时间轮 最小堆1
08-03
背景参照时钟表盘的运转规律，可以将定时任务根据触发的紧急程度，分布到不同层级的时间轮中；假设时间精度为 10ms ；在第 1 层级每 10ms 移动格；每移动格
（转载）数据结构与算法整理总结---红黑树
jim_007的博客
11-17 333
什么是 “平衡⼆叉查找树”？ 平衡⼆叉树的严格定义是这样的：⼆叉树中任意⼀个节点的左右⼦树的⾼度相差不能⼤于 1。从这个定义来看，完全⼆叉树、满⼆叉树其实都是平衡⼆叉树，但是⾮完全⼆叉树也有可能是平衡⼆叉树。 平衡⼆叉查找树不仅满⾜上⾯平衡⼆叉树的定义，还满⾜⼆叉查找树的特点。最先被发明的平衡⼆叉查找树是 AVL 树，它严格符合我刚讲到的平衡⼆叉查找树的定义，即任何节点的左右⼦树⾼度相差不超过 1，是⼀种⾼度平衡的⼆叉查找树。 但是很多平衡⼆叉查找树其实并没有严格符合上⾯的定义（树中任意⼀个节点的左右⼦
泛型容器-红黑树源码分析附带详细图解
weixin_38496592的博客
12-10 956
红黑树介绍 1.2-3树 红⿊树是⼀种⾃平衡的⼆叉树，它可以避免⼆分搜索树在极端的情况下蜕化成链表的情况。那么什么是红⿊树呢？要想便于了解红⿊树，我们先了解⼀下跟它息息相关的2-3树。 2-3树是⼀种绝对平衡的多叉树，在这棵树中，任意⼀个节点，它的左右⼦树的⾼度是相同的。如下所示： 正如上⾯介绍过的，2-3树是⼀个多叉树。那为什么叫做2-3树呢？ 因为规则定义，2-3树分为两种节点，分别为：2-节点和3-节点。其中，2-节点表示节点中保存⼀个元素，3-节点则表示节点中保存两个元素。 演示⼀下如
HashMap源码解析【java进阶笔记二】
yuyu的博客
12-06 832
目录 知识储备 个人理解 源码解析：从构造函数入手 1> 创建table数组 2> 向table数组中赋值 1） 没有发⽣哈希冲突 2） 发生了哈希冲突 3> 如超过阈值，则进行扩容 知识储备 ① HashMap 1.8前：数组+链表 ​ 1.8后：数组+链表+红黑树 ② 红⿊树 是⼀种⾃平衡的⼆叉树，它可以避免⼆分搜索树在极端的情况下蜕化成链表的情况。 ​ ● 条件⼀：每个节点要么是红⾊，要么是⿊⾊。...
JDK8中的HashMap什么时候将链表转化为红⿊树
GG.com
02-20 916
这个题很容易答错，⼤部分答案就是：当链表中的元素个数⼤于8时就会把链表转化为红⿊树。 但是其实还有另外⼀个限制：当发现链表中的元素个数⼤于8之后，还会判断⼀下当前数组的⻓度，如果数组⻓度⼩于64时，此时并不会转化为红⿊树，⽽是进⾏扩容。 只有当链表中的元素个数⼤于8，并且数组的⻓度⼤于等于64时才会将链表转为红⿊树。 上⾯扩容的原因是，如果数组⻓度还⽐较⼩，就先利⽤扩容来缩⼩链表的⻓度 ...
【Java经典面试题系列】3.13道数据结构与算法面试题
平凡的树叶，记录我程序生涯的成长
06-13 270
AVL红⿊树 是 1972 年发明的，称为对称⼆叉 B 树，1978 年正式命名红⿊树。主要特征是在每个节点上增加⼀个属性表示节点颜⾊，可以红⾊或⿊⾊。红⿊树和 AVL 树 类似，都是在进⾏插⼊和删除时通过旋转保持⾃身平衡，从⽽获得较⾼的查找性能。与 AVL 树 相⽐，红⿊树不追求所有递归⼦树的⾼度差不超过 1，保证从根节点到叶尾的最⻓路径不超过最短路径的 2 倍，所以最差时间复杂度是 O(logn)。红⿊树通过重新着⾊和左右旋转，更加⾼效地完成了插⼊和删除之后的⾃平衡调整。
定时器方案 红黑树、时间轮学习笔记
jue_1xin的专栏
09-10 458
定时器属于基础组件，不管是用户空间的程序开发，还是内核空间的程序开发，很多时候都需要有定时器作为基础组件的支持。
JAVA常见数据结构
JUN__TAO的博客
07-30 633
常见的的数据结构 数据存储的常⽤结构有：栈、队列、数组、链表和红⿊树。 栈 栈：stack，⼜称堆栈，它是运算受限的线性表，其限制是仅允许在标的⼀端进⾏插⼊和删除操作，不允许在其他任何位置进⾏添加、查找、删除等操作。 简单的说：采⽤该结构的集合，对元素的存取有如下的特点 1.先进后出（即，存进去的元素，要在后它后⾯的元素依次取出后，才能取出该元素）。例如，⼦弹压进弹夹，先压进去的⼦弹在下⾯，后压进去的⼦弹在上⾯，当开枪时，先弹出上⾯的⼦弹，然后才能弹出下⾯的⼦弹。 2.栈的⼊⼝、出⼝的都是栈的顶端位置。
高级定时器专属--MOE主输出使能
07-14
1. 首先，您需要了解MOE（Master Output Enable）的功能。MOE是一个控制信号，用于使能或禁用高级定时器的主输出。 2. 在使用高级定时器之前，您需要初始化定时器并配置相关参数。这包括选择定时器的工作模式、预...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值