单片机学习经历和模板

最新推荐文章于 2026-06-22 13:30:39 发布
原创 最新推荐文章于 2026-06-22 13:30:39 发布 · 233 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#单片机 #学习 #嵌入式硬件
引言
  • 按键状态机在单片机开发中的重要性
  • 传统按键检测方法的局限性（如延时消抖）
  • 状态机方法的优势（实时性、可扩展性）

话不多说

1.添加自己的按键读取函数和触发回调函数

2.注册状态机

3.状态机轮询(ms)

4.源代码，可选择需要的功能(双击、长按)，以节省内存

#include "key.h"

/* ---------------------------状态机结构体--------------------------- */
struct KEY_StateMachine
{
    KeyState current_state;             // 当前按键状态
    uint32_t current_time;              // 当前扫描时刻
    uint32_t last_time;                 // 状态变化时刻
#if ENABLE_LONG_CLICK
    uint8_t long_pressed;               // 标记是否已经长按过
#endif
#if ENABLE_DOUBLE_CLICK
    uint8_t click_count;                // 单击计数（用于双击判断）
#else
    uint8_t reserved;
#endif
    Trigger_Action click_action;        // 单击触发函数
#if ENABLE_DOUBLE_CLICK
    Trigger_Action double_click_action; // 双击触发函数
#endif
    Trigger_Action long_click_action;   // 长按触发函数
    Read_Key_Pin read_key;              // 读取引脚电平函数
};
// 按键状态机实例（每个按键一个）
static KEY_StateMachine key_sms[KEY_NUM] =
{
  KEY_SMS_INIT
};
#define KEYSMS_TABLE_SIZE (sizeof(key_sms)/sizeof(key_sms[0]))
/* ----------------------------------------------------------------- */

/* --------------------------辅助函数和工具-------------------------- */
// 时间差计算
inline static uint32_t time_diff(KEY_StateMachine* key_sm)
{
    uint32_t curr = key_sm->current_time;
    uint32_t last = key_sm->last_time;
    if (curr < last)
        return (0xFFFFFFFF - last) + curr + 1;
    else
        return curr - last;
}
/* ----------------------------------------------------------------- */

/* -----------------------------动作函数----------------------------- */
// 空事件，不做处理
static void action_none(KEY_StateMachine* key_sm)
{
    /* --- */
}
// 按键开始按下，记录开始按下时间
static void action_press_start(KEY_StateMachine* key_sm)
{
    key_sm->last_time = key_sm->current_time;
#if ENABLE_LONG_CLICK
    key_sm->long_pressed = 0;    // 新一次按下时清除长按标志
#endif
}
static void action_click(KEY_StateMachine* key_sm)
{
#if ENABLE_DOUBLE_CLICK
#if ENABLE_LONG_CLICK
    // 只在双击超时后才触发单击
    if (key_sm->click_action && key_sm->click_count == 1 && !key_sm->long_pressed)
    {
        key_sm->click_action();
        key_sm->click_count = 0;
    }
#else
    // 只在双击超时后才触发单击
    if (key_sm->click_action && key_sm->click_count == 1)
    {
        key_sm->click_action();
        key_sm->click_count = 0;
    }
#endif
#else
#if ENABLE_LONG_CLICK
    // 直接触发单击
    if (key_sm->click_action && !key_sm->long_pressed)
    {
        key_sm->click_action();
    }
#else
    // 直接触发单击
    if (key_sm->click_action)
    {
        key_sm->click_action();
    }
#endif
#endif
}
#if ENABLE_DOUBLE_CLICK
// 双击触发
static void action_double_click(KEY_StateMachine* key_sm)
{
#if ENABLE_LONG_CLICK
    if (key_sm->double_click_action && key_sm->click_count == 2 && !key_sm->long_pressed)
    {
        key_sm->double_click_action();
        key_sm->click_count = 0; // 重置单击计数
    }
#else
    if (key_sm->double_click_action && key_sm->click_count == 2)
    {
        key_sm->double_click_action();
        key_sm->click_count = 0; // 重置单击计数
    }
#endif
}
#endif

#if ENABLE_LONG_CLICK
// 长按触发
static void action_long_press(KEY_StateMachine* key_sm)
{
    if (key_sm->long_click_action && !key_sm->long_pressed) // 只触发一次长按
    {
        key_sm->long_click_action();
        key_sm->long_pressed = 1;
#if ENABLE_DOUBLE_CLICK
        key_sm->click_count = 0; // 长按时重置单击计数，防止误触发单击
#endif
    }
}
#endif
// 按键开始松开，记录开始松开时间
static void action_release_start(KEY_StateMachine* key_sm)
{
    key_sm->last_time = key_sm->current_time;
}
#if ENABLE_DOUBLE_CLICK
// 第一次松开，等待双击
static void action_first_release(KEY_StateMachine* key_sm)
{
    key_sm->last_time = key_sm->current_time;
    key_sm->click_count = 1; // 标记为第一次按下
}
// 第二次按下，准备双击
static void action_second_press(KEY_StateMachine* key_sm)
{
    key_sm->last_time = key_sm->current_time;
    key_sm->click_count = 2; // 标记为第二次按下
}
#endif
#if ENABLE_LONG_CLICK
// 长按后松开，直接返回空闲状态
static void action_long_press_release(KEY_StateMachine* key_sm)
{
#if ENABLE_DOUBLE_CLICK
    key_sm->click_count = 0; // 重置单击计数
#endif
    key_sm->long_pressed = 0; // 重置长按标志
}
#endif
/* ----------------------------------------------------------------- */

/* ----------------------------状态转移表---------------------------- */
typedef struct
{
    KeyState current_state;      // 按键当前状态
    KeyEvent event;              // 事件
    KeyState next_state;         // 按键下一个状态
    ActionFunc action;           // 动作函数
}
StateTransition;

#if ENABLE_DOUBLE_CLICK
static const StateTransition state_table[] =
{
    { KEY_IDLE,                     EVENT_PRESS,                KEY_PRESS_DEBOUNCE,           action_press_start },
    { KEY_PRESS_DEBOUNCE,           EVENT_PRESS,                KEY_PRESSED,                  action_none },
    { KEY_PRESS_DEBOUNCE,           EVENT_NONE,                 KEY_PRESS_DEBOUNCE,           action_none },
    { KEY_PRESS_DEBOUNCE,           EVENT_TIMEOUT,              KEY_IDLE,                     action_none },
    { KEY_PRESSED,                  EVENT_RELEASE,              KEY_RELEASE_DEBOUNCE,         action_first_release },
    #if ENABLE_LONG_CLICK                   
    { KEY_PRESSED,                  EVENT_LONG_PRESS,           KEY_PRESSED,                  action_long_press },
    #endif                  
    { KEY_RELEASE_DEBOUNCE,         EVENT_RELEASE,              KEY_WAIT_DOUBLE_CLICK,        action_none },
    { KEY_RELEASE_DEBOUNCE,         EVENT_NONE,                 KEY_RELEASE_DEBOUNCE,         action_none },
    { KEY_RELEASE_DEBOUNCE,         EVENT_TIMEOUT,              KEY_PRESSED,                  action_none },
    { KEY_WAIT_DOUBLE_CLICK,        EVENT_PRESS,                KEY_SECOND_PRESS_DEBOUNCE,    action_second_press },
    { KEY_WAIT_DOUBLE_CLICK,        EVENT_TIMEOUT,              KEY_IDLE,                     action_click },
    { KEY_WAIT_DOUBLE_CLICK,        EVENT_NONE,                 KEY_WAIT_DOUBLE_CLICK,        action_none },
    { KEY_SECOND_PRESS_DEBOUNCE,    EVENT_PRESS,                KEY_SECOND_PRESSED,           action_none },
    { KEY_SECOND_PRESS_DEBOUNCE,    EVENT_NONE,                 KEY_SECOND_PRESS_DEBOUNCE,    action_none },
    { KEY_SECOND_PRESS_DEBOUNCE,    EVENT_TIMEOUT,              KEY_WAIT_DOUBLE_CLICK,        action_none },
    { KEY_SECOND_PRESSED,           EVENT_RELEASE,              KEY_SECOND_RELEASE_DEBOUNCE,  action_release_start },
    #if ENABLE_LONG_CLICK       
    { KEY_SECOND_PRESSED,           EVENT_LONG_PRESS,           KEY_IDLE,                     action_long_press },
    #endif
    { KEY_SECOND_RELEASE_DEBOUNCE,  EVENT_RELEASE,              KEY_IDLE,                     action_double_click },
    { KEY_SECOND_RELEASE_DEBOUNCE,  EVENT_NONE,                 KEY_SECOND_RELEASE_DEBOUNCE,  action_none },
    { KEY_SECOND_RELEASE_DEBOUNCE,  EVENT_TIMEOUT,              KEY_SECOND_PRESSED,           action_none },
    #if ENABLE_LONG_CLICK
    { KEY_PRESSED,                  EVENT_RELEASE_AFTER_LONG,   KEY_IDLE,                     action_long_press_release },
    #endif
};
#else
static const StateTransition state_table[] =
{
    { KEY_IDLE,                     EVENT_PRESS,                KEY_PRESS_DEBOUNCE,           action_press_start },
    { KEY_PRESS_DEBOUNCE,           EVENT_PRESS,                KEY_PRESSED,                  action_none },
    { KEY_PRESS_DEBOUNCE,           EVENT_NONE,                 KEY_PRESS_DEBOUNCE,           action_none },
    { KEY_PRESS_DEBOUNCE,           EVENT_TIMEOUT,              KEY_IDLE,                     action_none },
    { KEY_PRESSED,                  EVENT_RELEASE,              KEY_RELEASE_DEBOUNCE,         action_release_start },
#if ENABLE_LONG_CLICK           
    { KEY_PRESSED,                  EVENT_LONG_PRESS,           KEY_PRESSED,                  action_long_press },
#endif          
    { KEY_RELEASE_DEBOUNCE,         EVENT_RELEASE,              KEY_IDLE,                     action_click },
    { KEY_RELEASE_DEBOUNCE,         EVENT_NONE,                 KEY_RELEASE_DEBOUNCE,         action_none },
    { KEY_RELEASE_DEBOUNCE,         EVENT_TIMEOUT,              KEY_PRESSED,                  action_none },
#if ENABLE_LONG_CLICK           
    { KEY_PRESSED,                  EVENT_RELEASE_AFTER_LONG,   KEY_IDLE,                     action_long_press_release },
#endif
};
#endif

#define STATE_TABLE_SIZE (sizeof(state_table)/sizeof(state_table[0]))
/* ----------------------------------------------------------------- */

/* ------------------------按键状态机实现函数------------------------- */
// 初始化接口
#if ENABLE_DOUBLE_CLICK && ENABLE_LONG_CLICK
KEY_StateMachine* key_init(
    KeyID key_id,
    Read_Key_Pin read_key,
    Trigger_Action click_action,
    Trigger_Action double_action,
    Trigger_Action long_action
)
#elif ENABLE_DOUBLE_CLICK
KEY_StateMachine* key_init(
    KeyID key_id,
    Read_Key_Pin read_key,
    Trigger_Action click_action,
    Trigger_Action double_action  // 启用双击时，传入单击和双击动作
)
#elif ENABLE_LONG_CLICK
KEY_StateMachine* key_init(
    KeyID key_id,
    Read_Key_Pin read_key,
    Trigger_Action click_action,
    Trigger_Action long_action  // 启用长按时，传入单击和长按动作
)
#else
KEY_StateMachine* key_init(
    KeyID key_id,
    Read_Key_Pin read_key,
    Trigger_Action click_action  // 只有单击时，传入单击动作
)
#endif
{
    if (key_id < KEY_NUM)
    {
        key_sms[key_id].click_action = click_action;
#if ENABLE_DOUBLE_CLICK
        key_sms[key_id].double_click_action = double_action;
#endif
#if ENABLE_LONG_CLICK
        key_sms[key_id].long_click_action = long_action;
#endif
        key_sms[key_id].read_key = read_key;
#if ENABLE_LONG_CLICK
        key_sms[key_id].long_pressed = 0;
#endif
#if ENABLE_DOUBLE_CLICK
        key_sms[key_id].click_count = 0;
#endif
        return &key_sms[key_id];
    }
    return NULL;
}

// 获取当前按键事件函数，根据按键当前状态和硬件输入进行判断
KeyEvent get_current_event(KEY_StateMachine* key_sm)
{
    KeyState state = key_sm->current_state;
    uint32_t diff = time_diff(key_sm);

    switch (state)
    {
    case KEY_PRESS_DEBOUNCE:
    case KEY_RELEASE_DEBOUNCE:
#if ENABLE_DOUBLE_CLICK
    case KEY_SECOND_PRESS_DEBOUNCE:
    case KEY_SECOND_RELEASE_DEBOUNCE:
#endif
        // 消抖状态检查
        if (diff >= DEBOUNCE_DELAY)
        {
            switch (state)
            {
            case KEY_PRESS_DEBOUNCE:
                return key_sm->read_key() ? EVENT_PRESS : EVENT_TIMEOUT;
            case KEY_RELEASE_DEBOUNCE:
                return !key_sm->read_key() ? EVENT_RELEASE : EVENT_TIMEOUT;
#if ENABLE_DOUBLE_CLICK
            case KEY_SECOND_PRESS_DEBOUNCE:
                return key_sm->read_key() ? EVENT_PRESS : EVENT_TIMEOUT;
            case KEY_SECOND_RELEASE_DEBOUNCE:
                return !key_sm->read_key() ? EVENT_RELEASE : EVENT_TIMEOUT;
#endif
            default:
                break;
            }
        }
        return EVENT_NONE;

#if ENABLE_DOUBLE_CLICK
    case KEY_WAIT_DOUBLE_CLICK:
        // 等待双击状态超时检查
        if (diff >= DOUBLE_CLICK_DELAY)
        {
            return EVENT_TIMEOUT;
        }
        // 等待双击状态的按下检测
        if (key_sm->read_key())
        {
            return EVENT_PRESS;
        }
        return EVENT_NONE;

    case KEY_PRESSED:
#if ENABLE_LONG_CLICK
        // 第一次按下状态
        if (!key_sm->long_pressed)
        {
            // 长按检查
            if (diff >= LONG_PRESS_DELAY)
            {
                return EVENT_LONG_PRESS;
            }
            // 松开检测（非长按情况）
            if (!key_sm->read_key())
            {
                return EVENT_RELEASE;
            }
        }
        else
        {
            // 长按状态下的松开检测
            if (!key_sm->read_key())
            {
                return EVENT_RELEASE_AFTER_LONG;
            }
        }
        return EVENT_NONE;
#else
        // 松开检测（非长按情况）
        if (!key_sm->read_key())
        {
            return EVENT_RELEASE;
        }
        return EVENT_NONE;
#endif

    case KEY_SECOND_PRESSED:
#if ENABLE_LONG_CLICK
        // 第二次按下状态
        if (!key_sm->long_pressed)
        {
            // 长按检查
            if (diff >= LONG_PRESS_DELAY)
            {
                return EVENT_LONG_PRESS;
            }
            // 松开检测
            if (!key_sm->read_key())
            {
                return EVENT_RELEASE;
            }
        }
#else
        // 松开检测
        if (!key_sm->read_key())
        {
            return EVENT_RELEASE;
        }
#endif
        return EVENT_NONE;
#else
    case KEY_PRESSED:
#if ENABLE_LONG_CLICK
        if (!key_sm->long_pressed)
        {
            if (diff >= LONG_PRESS_DELAY)
            {
                return EVENT_LONG_PRESS;
            }
            if (!key_sm->read_key())
            {
                return EVENT_RELEASE;
            }
        }
        else
        {
            if (!key_sm->read_key())
            {
                return EVENT_RELEASE_AFTER_LONG;
            }
        }
        return EVENT_NONE;
#else
        // 直接判断按键是否释放
        if (!key_sm->read_key()) // 按键松开
        {
            return EVENT_RELEASE;
        }
        return EVENT_NONE;
#endif
#endif
    case KEY_IDLE:
        // 空闲状态的按下检测
        return key_sm->read_key() ? EVENT_PRESS : EVENT_NONE;

    default:
        // 其他状态（理论上不会执行到这里）
        return EVENT_NONE;
    }
}

// 主扫描函数
void key_scan(KEY_StateMachine* key_sm, uint32_t current_tick)
{
    // 更新当前时间
    key_sm->current_time = current_tick;

    // 获取当前的按键事件
    KeyEvent event = get_current_event(key_sm);
    // 初始化动作为无操作
    ActionFunc Action = action_none;
    // 默认下一个状态与当前状态相同
    KeyState next_state = key_sm->current_state;

    // 查找状态转移表，寻找对应的当前状态和事件
    for (int i = 0; i < STATE_TABLE_SIZE; ++i)
    {
        if ((state_table[i].current_state == key_sm->current_state) && (state_table[i].event == event))
        {
            // 找到匹配，设置下一个状态和响应动作
            next_state = state_table[i].next_state;
            Action = state_table[i].action;
            break;
        }
    }
    // 执行动作函数
    Action(key_sm);
    // 更新按键状态
    key_sm->current_state = next_state;
}
/* ----------------------------------------------------------------- */
单片kun
关注
蓝桥杯单片机组_学习路线
Tensorrrrrr的博客
01-10 6416
前段时间整理硬盘发现了当时大二参加蓝桥杯时的一些记录，现在回想当时踩过的坑和备赛经历，现结合其写下这篇经验贴，供大家学习、高效备赛总的来说，蓝桥杯很适合作为一个入门类比赛，它可以帮你打好基础，锻炼自学能力，对后面的专业课的学习也起到预习的作用，祝大家玩的愉快！
蓝桥杯单片机总结
热门推荐
FILWY_M
02-02 2万+
第十一届蓝桥杯单片机总结 一些废话，可以不看，直接看后面的步入正题和如何备赛 现在已经2021/2/2下午8:37:31了，距离蓝桥杯单片机的比赛的日期已经过去了很久，之前一直没有总结一下，刚好现在在准备第十二届的蓝桥杯嵌入式，趁着这个机会，把之前的蓝桥杯单片机的比赛也总结一下吧，同时也是借着这个机会，也对自己过去的一年做一个总结。 上一年，说来就是去年寒假的时候了，那是候还是大二上刚结束，现在就已经是大三的老学长了，突然感叹一下，时间匆匆。大一进校，那时候什么目标都没有，每天都是正常的上课，没有什么追求，
单片机的工程建立模板
weixin_44759501的博客
11-10 945
1.打开程序、 这里我用的是“Keil 5” 本次主要建立一个工程模板，这个模板仅包含一个main函数，作为空白模板以后再写项目时可以直接复制一份，以避免每次建立新工程都经历繁杂的最初步骤。 1.打开程序、 这里我用的是“Keil 5” 2.选择单片机类型 第一步： 第二步： 新建一个文件夹，给项目命名并存入 第三步： 选择你所用的单片机的型号，我用的是AT89C52，所以我以此为例 注意： 这个我们选择否就可以 2. 建立main函数 鼠标点击Source，然后点击左上角，新建项目 点击 .
51单片机通用开发模板指南
weixin_32098457的博客
06-25 1060
51单片机，也称为8051微控制器，是基于Intel 8051架构的微控制器家族中的一个成员。它广泛应用于工业控制、家用电器、嵌入式系统等领域，因其简单、稳定和易于编程而受到许多开发者的青睐。在软件开发过程中，模板是一种用于快速生成代码的预制结构，其核心目的是为了复用代码、减少重复劳动，以及确保代码风格和质量的统一性。模板通常包括项目的基础架构代码、通用功能实现代码以及配置信息等。其设计的初衷是使得开发者能够专注于业务逻辑的实现，而不是基础框架的搭建。
RS485自动收发芯片-MS2548
weixin_41226265的博客
06-20 328
RS485自动收发芯片MS2548深度解析 摘要：本文深入分析了RS485自动收发芯片MS2548的关键特性与优化应用。MS2548凭借自动换向功能（无需DE控制信号）、20Mbps高速传输、128节点支持和热插拔保护等优势，成为工业通信的理想选择。文章对比了MS2548与TI的THVD1400芯片，指出MS2548在成本与节点数上的优势。针对RS485自动收发的常见问题（如信号干扰、切换延迟等），提供了终端电阻配置、PCB布局优化等解决方案。通过典型应用电路和工业场景案例，展示了MS2548如何简化系统设
面向 MCU 与 RTOS 的 Newlib、Newlib-nano、`--specs=nano.specs` 与 `_REENT_SMALL` 说明
wdfk-prog.space
06-17 422
Newlib 在 MCU/RTOS 开发中的使用指南 摘要 本文介绍了 newlib 和 newlib-nano 在 MCU/RTOS 嵌入式开发中的应用。主要内容包括： 核心概念： newlib 是面向嵌入式系统的 C 标准库实现 newlib-nano 是优化体积和内存占用的变体 --specs=nano.specs 用于启用 newlib-nano _REENT_SMALL 宏用于优化线程局部存储结构 工程建议： MCU 项目通常应使用 newlib-nano 需要提供底层适配函数（如 _write、
【51单片机用CD4094和单片机链接扩展io口，控制一个8个LED灯一次性发光】2024-6-21
浤济的专栏
06-17 346
摘要：该问答展示了如何用51单片机和CD4094扩展IO口控制8个LED灯，通过C语言编写程序实现循环点亮效果。电路连接使用P1口控制CD4094的串行数据输入、时钟和锁存信号。程序定义QD4094函数实现8位数据串行移位输出，主函数通过变量递增和位操作实现LED灯的循环点亮模式（1→2→4→8...）。代码利用了51单片机的端口位操作功能，通过串行转并行方式扩展输出端口，实现了简单的LED控制功能。
新版本JLINK 手动添加自定义芯片支持国产32 单片机
刻[苦] 的 blog
06-20 321
如何手动为J-Link添加国产Cortex-M芯片支持（如Puya PY32、GD32等） 准备材料： 从芯片DFP包中提取.FLM烧录算法文件 获取芯片型号、内核、Flash/RAM地址和大小信息 操作方法： 在%APPDATA%\SEGGER\JLinkDevices\下创建厂商文件夹 编写XML描述文件，包含芯片信息和Flash算法路径 正确配置<ChipInfo>和<FlashBankInfo>等关键参数 优势： 无需管理员权限 J-Link升级不会覆盖自定义配置 配置对所有J-Link安装生效 验
继电器项目
2403_83711988的博客
06-20 72
配置完之后在main.c文件添加#include "jidianqi.h"但是这个jidianqi.h文件，去添加头文件路径(魔术棒c/c++include paths里添加jidianqi文件夹)在之前的项目文件中添加jidianqi.c和jidianqi.h文件，然后加入到项目工程文件的USER文件夹里。最后点亮灯光，把继电器PA3电频拉低打开开关，在gpio.h文件找到resetbits函数。1.代码控制开关口，单片机-继电器-模块（是否打开）2.告诉单片机把灯点亮。3.继电器控制灯的开关。
基于单片机的大货车防偷油系统设计
xuezhang666666的博客
06-21 343
本文介绍了一种基于51单片机的智能交通灯控制系统设计。系统采用模块化架构，以单片机为核心控制器，通过LED点阵屏模拟交通信号灯的红黄绿灯状态，配合LCD1602液晶屏实时显示倒计时信息。系统支持用户按键调整各信号灯持续时间，实现灵活配置。硬件设计包括单片机最小系统、点阵显示、LCD显示、按键输入和定时器等模块；软件采用模块化编程，包含初始化、状态控制、显示驱动等程序。该系统具有参数可调、显示直观、运行稳定等特点，适用于交通控制教学、嵌入式开发等场景，并具备良好的扩展性。
单片机FOChall驱动
weixin_69179903的博客
06-17 104
单片机 ：STM32F407。开发板：DMF407电机开发板。平台：keil V5.31。
STM32：定时器从模式
yyyzc_的博客
06-12 529
本文介绍了STM32定时器的三种从模式工作方式：复位模式、门模式和触发模式。复位模式通过外部信号复位计数器并触发更新中断；门模式通过电平信号控制计数启停；触发模式通过边沿信号启动计数，常配合单脉冲模式使用。文章详细说明了各模式的配置方法，包括CubeMX设置和代码实现要点，并解释了如何通过中断标志位区分不同触发源。特别指出触发模式初始化时需手动清除更新中断标志位，避免误触发。这三种模式为定时器提供了灵活的外部控制方式，适用于不同应用场景。
基于单片机的家庭防盗防火智能门窗报警系统设计
点灯小铭的博客
06-21 196
本文设计了一种基于单片机的PID控制PWM温度加热系统，采用闭环控制策略实现精准温控。系统通过温度传感器采集数据，经PID算法计算后输出PWM信号调节加热功率，默认设定50℃目标温度并支持参数调整。硬件包含单片机、温度采集、PWM驱动、按键和显示模块；软件采用模块化设计，实现温度采集、PID运算、PWM输出等功能。该系统具有响应快、精度高、可调性强等特点，适用于恒温控制、实验设备等应用场景。仿真验证表明，该方案能有效实现温度稳定控制。
按键控制 LED
jdjkdidjdj的博客
06-15 463
Rust + ESP32-S3 按键控制 LED 项目摘要 本教程演示如何使用 Rust 语言在 ESP32-S3 开发板上实现按键控制 LED 的基础嵌入式项目。项目通过 39 行代码实现按键状态检测和 LED 状态切换功能，涵盖： 硬件配置：使用板载 BOOT 按键(GPIO0)和 RGB LED(GPIO48) 核心知识点： GPIO 输入/输出配置 上拉电阻(Pull::Up)应用 按键消抖处理(120ms延时) 嵌入式主循环(loop)结构 开发环境：基于 Rust 的 esp-hal 硬件抽象层
vscode 上开发 MCU 嵌入式项目
mapleay的博客
06-21 305
替换 Keil 那套嵌入式 MCU 单片机开发流程。 转而使用 VScode IDE 加上 ARM 官方插件服务作为嵌入式ARM单片机的开发平台。 这里详细介绍 VScode 上利用 ARM 官方插件服务开发ARM单片机的平台搭建。
半桥 IGBT/MOS 驱动自举电路原理与设计计算
qq_38326420的博客
06-16 424
讲解了自举电路中关键器件参数的设计和计算
微机原理 8259A 可编程中断控制器
DrLuffy的博客
06-15 250
lIntel 8259中断控制器是集合中断源识别、中断屏蔽、中断优先权排队、中断类型号提供等功能的，专用于微机系统INTR类中断管理的大规模集成电路芯片。
stm32f103芯片驱动mcp41010的模拟spi驱动代码
最新发布
玛卡巴卡
06-22 125
本文介绍了基于STM32F103ZET6标准库的MCP41010数字电位器软件模拟SPI驱动实现方法。通过GPIO模拟SPI时序，解决了硬件SPI引脚冲突问题，并详细说明了JTAG引脚释放、SPI模式0时序控制等关键技术点。驱动代码包含初始化配置、字节发送函数和阻值设置功能，采用上升沿采样数据，提供1μs延时确保信号稳定。测试时需注意主频匹配和信号测量，给出了典型应用示例和故障排查建议。该方法具有灵活性强、移植方便的特点，适用于需要精确控制数字电位器的应用场景。
1A,1MHz,30VIN,XZ4115,降压恒流LED驱动芯片
koce13544100678的博客
06-16 259
这是一款连续电感电流导通模式的降压恒流源，用于驱动一颗或多颗串联 LED。芯片输入电压范围从 6V 到 30V，输出电流可调，最大可达 1A。根据不同的输入电压和外部器件， 可以驱动高达数十瓦的 LED。芯片内置功率开关，采用高端电流采样设置负载 LED 平均电流，通过 DIM引脚可以接受模拟调光和很宽范围的PWM 调光。当 DIM 的电压低于 0.3V时，功率开关关断， 芯片进入极低工作电流的待机状态。●工作电压范围：6V-30V。●产品封装：SOT89-5。●PWM调光，模拟调光。
单片机软件延时的一种容易出现错误
weixin_43794311的博客
06-16 276
一次程序编写的过程中，发现延时不能按照正确的时间。下面是通过stc软件生成的延时，其中黑色部分是定义任何ms的函数，区别在于把函数参数作为一个可以控制的值。但出现了问题，一个很容易忽略的问题，循环后的再次赋值，这里。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值