一盏LED能玩出多少花样

已于 2024-10-28 21:17:53 修改
阅读量337 收藏 6
点赞数 5
分类专栏： 单片机 文章标签： 单片机 嵌入式硬件 c语言
于 2024-10-27 17:31:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_56750103/article/details/143271432
版权

介绍

在单片机中，LED是最常见的电元件，通常的控制方式就是通过GPIO的推挽输出来控制LED的亮灭，对于LED而言，本身只有亮灭两种状态，但是利用单片机和人类视觉暂离的效果，LED可以实现亮灭、闪烁、PWM呼吸灯输出。然后再结合现实的一些场景需求，来看看LED的代码到底能写成什么样。

点亮LED

我使用的是STM32F103C8T6这款单片机来作为代码演示的设备，首先，使用GPIO来点亮一个LED

这是我的LED的控制原理图，可以看到PC13输出低电平，LED灯亮，PC13输出高电平，LED灯灭。

下面这段代码写了一个很简单的LED的闪烁的代码，通过延时函数，实现LED每500ms的亮灭

int main(void)
{
    /*NVIC中断分组*/
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//配置NVIC为分组2
    
    timer_systime_init();
    gpio_led_init();
    
    while (1)
    {
        led_set_status(LED_ON);
        mcu_time_delay_ms(500);
        led_set_status(LED_OFF);
        mcu_time_delay_ms(500);
    }
}

需求：通过不同的闪烁时间来表示不同的信息，且不影响程序运行

现在想做一个能够随着事件触发来同时改变LED的闪烁时长，从而表现不同的信息。那么就需要一个通用的闪烁函数来对LED进行设置和一个函数来获取LED的当前的状态进行状态改变。

需求分析：

  1. 不同的闪烁时间，亮灭的时间也可能不一致
  2. 不影响程序运行，不能使用延时来等待时间，不能一直轮询的去查看LED是否到时间该变化了

程序设计：

  1. 设计一个符合此需求的LED的类
  2. 根据需求实现对于的LED的功能，看来是需要定时器中断来搭配实现了

首先设置LED的类设计

#include <stdint.h>
#include <stdio.h>

typedef void (*led_set_status_fun) (uint8_t);

#define LED_ON Bit_RESET
#define LED_OFF Bit_SET

typedef enum
{
    LED_GREEN = 0,
    LED_RED,

    LED_ID_MAX//在这之前添加
}LED_ID;

typedef enum 
{
    LED_MODE_OFF = 0,
    LED_MODE_ON ,
    LED_MODE_FLICKER_BY_SAME,
    LED_MODE_FLICKER_BY_DIFF,
    
    LED_MODE_MAX
}LED_MODE;

typedef struct
{
    LED_ID led_id :8;           //设备号 
    LED_MODE mode :8;           //模式  
    uint8_t status;             //状态 LED_OFF:关闭 LED_ON:打开        内部使用外部无需初始化
    uint8_t reserve;            //保留
    union flicker
    {
        struct diff_time
        {
            uint16_t on_time;
            uint16_t off_time;
        }diff_time;
        uint32_t same_time;
    } flicker;                                            //根据模式决定初始化
    uint32_t change_status_time;//改变状态的时间            内部使用外部无需初始化
    led_set_status_fun set_status_fun;//led控制回调函数
} LED;

LED的核心函数 mcu_time_get_time函数是一个获取系统运行的时间戳的函数，由定时器实现1ms的中断累加。

static LED kernel_led[LED_ID_MAX] = {0};//内核LED对象组
/**
* @description: 设置LED的状态函数
* @time: 2024-10-27 15:10:51
* @param: 参数
* @return: 返回值
*/
void green_led_set_status(uint8_t status)
{
    GPIO_WriteBit(GPIOC, GPIO_Pin_13, (BitAction)(status));
}

/**
*  @brief : 设置LED对象
*  @param : 
*  @note  : 
*  @return: 0 成功 1失败
*/
uint8_t led_set(LED *led)
{
    //1. 判断LED对象是否为空
    if(led == NULL)
        return 1;
    //2. 设置LED对象
    kernel_led[led->led_id].mode = led->mode;
    kernel_led[led->led_id].set_status_fun = led->set_status_fun;
    if(led->mode == LED_MODE_ON || led->mode == LED_MODE_OFF)
    {
        kernel_led[led->led_id].set_status_fun(led->status);
    }
    else if(kernel_led[led->led_id].mode == LED_MODE_FLICKER_BY_SAME)
    {
        kernel_led[led->led_id].flicker.same_time = led->flicker.same_time;
        kernel_led[led->led_id].change_status_time = mcu_time_get_time();
    }
    else if(kernel_led[led->led_id].mode == LED_MODE_FLICKER_BY_DIFF)
    {
        kernel_led[led->led_id].flicker.diff_time.on_time = led->flicker.diff_time.on_time;
        kernel_led[led->led_id].flicker.diff_time.off_time = led->flicker.diff_time.off_time;
        kernel_led[led->led_id].change_status_time = mcu_time_get_time();
    }
    else
    {
        return 1;
    }
    return 0;
}

/**
*  @brief : 关闭一个LED对象
*  @param : 设备号 对应枚举LED_ID
*  @note  : 
*  @return: 
*/
void led_reset(uint8_t led_id)
{
    //1.关闭此LED
    kernel_led[led_id].set_status_fun(LED_OFF);
    //2.重置LED对象信息
    kernel_led[led_id].mode = LED_MODE_OFF;
    kernel_led[led_id].flicker.same_time = 0;
    kernel_led[led_id].status = LED_OFF;
    kernel_led[led_id].change_status_time = 0;
}

void led_task(void *obj)
{
    //1.遍历所有LED对象，找到需要改变状态的LED
    for(uint8_t i = 0; i < LED_ID_MAX; i++)
    {
        //2.判断此LED是否需要改变状态
        if(kernel_led[i].change_status_time != 0 && kernel_led[i].change_status_time <= mcu_time_get_time())
        {
            //3.根据LED模式设置LED状态
            switch (kernel_led[i].mode)
            {
            case LED_MODE_FLICKER_BY_SAME:
                kernel_led[i].set_status_fun(!kernel_led[i].status);
                kernel_led[i].change_status_time = mcu_time_get_time() + kernel_led[i].flicker.same_time;
                kernel_led[i].status = !kernel_led[i].status;
                break;
            
            case LED_MODE_FLICKER_BY_DIFF:
                if(kernel_led[i].status == LED_ON)
                {
                    kernel_led[i].set_status_fun(!kernel_led[i].status);
                    kernel_led[i].change_status_time = mcu_time_get_time() + kernel_led[i].flicker.diff_time.off_time;
                }
                else
                {
                    kernel_led[i].set_status_fun(!kernel_led[i].status);
                    kernel_led[i].change_status_time = mcu_time_get_time() + kernel_led[i].flicker.diff_time.on_time;
                }
                kernel_led[i].status = !kernel_led[i].status;
                break;
            }
        }
    }

}

简单的功能示例

void test_01(void)
{
    uint8_t static step = 0;   
    switch (step)
    {
    case 0:
        {
            LED led_green;
            led_green.set_status_fun = green_led_set_status;
            led_green.led_id = LED_GREEN;
            led_green.mode = LED_MODE_FLICKER_BY_DIFF;
            led_green.flicker.diff_time.on_time = 1000;
            led_green.flicker.diff_time.off_time = 2000;
            led_set(&led_green);
            g_mcu_timer[DELAY_TIMER] = 5000;
            step++;
        }
        break;
    case 1:
        if(g_mcu_timer[DELAY_TIMER] == 0)
        {
            step++;
        }
        break;
    case 2:
            led_reset(LED_GREEN);
            LED led_green;
            led_green.set_status_fun = green_led_set_status;
            led_green.led_id = LED_GREEN;
            led_green.mode = LED_MODE_FLICKER_BY_SAME;
            led_green.flicker.same_time = 1000;
            led_set(&led_green);
            step++;
        break;
    case 3:
        if(mcu_time_get_time() == 300*1000)
        {
            step = 0;
        }
    default:
        break;
    }
}

int main(void)
{
    /*NVIC中断分组*/
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//配置NVIC为分组2

    //GPIO初始化   
    timer_systime_init();
    gpio_led_init();
    
    //设备初始化
    mcu_time_delay_ms(1);

    //程序初始化

    
    
    while (1)
    {
        test_01();
        led_task(NULL);
    }
    
}

这样，可以在不同时间去设置LED的属性，然后实现LED的复杂功能。但是也可以看到设置LED的部分代码就比较繁琐复杂，想要LED实现复杂的亮灭逻辑需要大量的代码去实现，比如一个LED先是亮200ms在灭300ms在亮400ms最后在灭500ms。这样的一个周期轮回，就不太适合用了。所有可以利用状态机的方式去表示一个LED的周期的状态，从而实现方便快捷的设置。

需求：实现多样变化的LED闪烁功能

其实想一想，发现对于LED而言，其实就只有开关两个状态，变化的只是这两个状态的持续时间，所以为什么不写一个数组来传递给LED去自动读取下一步该做的事呢？

举个简单的例子，一个LED先是亮200ms在灭300ms在亮400ms最后在灭500ms，转换成一个数组就是[{ON,200}, {OFF,300}, {ON,400},{OFF,500}]。如果说需要LED周期性的这样去做，那么我们可以加一个属性loop用来表示循环次数。

loop表示循环的次数 0 表示一直循环 1-N 表示限定次数。 我们对上面的代码进行修改，让每个LED一开始都初始化一次。后续只要修改每个LED的状态数组就可以实现LED的多样变化，需要注意的是，LED的数组使用的是同一个就要考虑加锁，防止LED的数组在修改的时候也在读取。

#ifndef _LED_H_
#define _LED_H_
#ifdef __cplusplus
extern "C" {
#endif
#include <stdint.h>
#include <string.h>
#include <stdio.h>

typedef void (*led_set_status_fun) (uint8_t); //LED的状态控制函数指针

#define LED_ACTION_MAX_NUM    10

#define LED_ON 1
#define LED_OFF 0

#define LED_LOCK    1
#define LED_UNLOCK  0

#define LED_WORK 1
#define LED_STOP 0

typedef enum
{
    LED_GREEN = 0,
    LED_RED,

    LED_ID_MAX//在这之前添加
}LED_ID;

typedef enum 
{
    LED_MODE_OFF = 0,
    LED_MODE_ON ,
}LED_MODE;

typedef struct
{
    uint8_t status;    //亮灭
    uint32_t time;    //时长
}LED_ACTION;

typedef struct
{
    uint8_t queue_schedule;                             //队列的进度
    uint8_t led_status;                                 //led的状态 0 停止 1工作
    uint8_t led_lock;                                   //操作的锁
    uint16_t loop;                                      //循环次数 0表示死循环
    uint16_t led_action_length;                         //执行的状态队列的长度
    uint32_t timepiece;                                 //计时器
    led_set_status_fun set_status_fun;                  //led控制回调函数
    LED_ACTION led_action_queue[LED_ACTION_MAX_NUM];    //led的状态队列
} LED;


void led_set_callback_fun(uint8_t led_id, led_set_status_fun fun);
uint8_t led_set_run_queue(LED_ID led_id, LED_ACTION * led_action_queue, uint16_t led_action_length, uint16_t loop);
void led_task(void);



#ifdef __cplusplus
}
#endif
#endif
#include "led.h"



static LED kernel_led[LED_ID_MAX] = {0};//内核LED对象组

//初始化LED的控制回调函数
void led_set_callback_fun(uint8_t led_id, led_set_status_fun fun)
{
    kernel_led[led_id].set_status_fun = fun;
}

uint8_t led_set_run_queue(LED_ID led_id, LED_ACTION *led_action_queue, uint16_t led_action_length, uint16_t loop)
{
    //1.数据校验
    if(led_id >= LED_ID_MAX || led_action_queue == NULL || led_action_length >= LED_ACTION_MAX_NUM)
    {
        return 1;    
    }
    while(kernel_led[led_id].led_lock == LED_LOCK)
    {
    }
    kernel_led[led_id].led_lock = LED_LOCK;//设备加锁
    //2.数据写入
    for(uint16_t i = 0; i < led_action_length; i++)
    {
        kernel_led[led_id].led_action_queue[i].time = led_action_queue[i].time;
        kernel_led[led_id].led_action_queue[i].status = led_action_queue[i].status;
    }
    kernel_led[led_id].led_status = LED_WORK;
    kernel_led[led_id].led_action_length = led_action_length;
    kernel_led[led_id].loop = loop;
    kernel_led[led_id].timepiece = 0;
    kernel_led[led_id].queue_schedule = 0;
    kernel_led[led_id].led_lock = LED_UNLOCK;//设备解锁
    return 0;    
}


void led_task(void)
{
    //1.遍历所有LED对象，找到需要改变状态的LED
    for(uint8_t i = 0; i < LED_ID_MAX; i++)
    {
        
        //2.查看LED是否在工作
        if(kernel_led[i].led_status == LED_WORK && kernel_led[i].led_lock == LED_UNLOCK)
        {
            kernel_led[i].led_lock = LED_LOCK;
            if(kernel_led[i].timepiece == 0)
            {
                kernel_led[i].set_status_fun(kernel_led[i].led_action_queue[kernel_led[i].queue_schedule].status);
                kernel_led[i].timepiece = kernel_led[i].led_action_queue[kernel_led[i].queue_schedule].time;
                if(kernel_led[i].queue_schedule == kernel_led[i].led_action_length - 1)
                {
                    if(kernel_led[i].loop != 0)
                    {
                        kernel_led[i].loop--;
                        if(kernel_led[i].loop == 0)
                        {
                            kernel_led[i].led_status = LED_STOP;
                        }
                    }
                    kernel_led[i].queue_schedule = 0;
                }
                else
                {
                    kernel_led[i].queue_schedule++;    
                }
                             
            }
            else
            {
                kernel_led[i].timepiece -= 1;//这里减去的数位此函数调用的间隔时间，要保证调用的间隔内这个函数一定要跑完，可以设置为10ms以上，如果数量在10个以上
            }
            kernel_led[i].led_lock = LED_UNLOCK;
            
        }
        
    }

}

#include "led.h"


#include <windows.h>

void redled_set_status(uint8_t status)
{
    if(status == LED_ON)
    {
        printf("LED NOW IS ON ! \r\n");
    }
    else
    {
        printf("LED NOW IS OFF ! \r\n");
    }
}


int main()
{

    led_set_callback_fun(LED_RED, redled_set_status);

    LED_ACTION red_led_queue[4] = {{LED_ON,5},{LED_OFF,10},{LED_ON,10},{LED_OFF,5}};
    led_set_run_queue(LED_RED, red_led_queue, 4, 10);
    
    
    while(1)
    {
        led_task();
        Sleep(100);//休眠100ms
    }
    
}

这样的话，只要两行代码就能设置LED，同时只要一个定时器中断的周期任务调用或者一个线程任务的调用就可以实现一个LED的多样复杂的动态显示。当然还有呼吸灯的效果也可以加进来，只是代码更复杂一些。

对于LED的结构体的内存，可以根据实际需求进行修改。

多个LED组合，实现花式表演

这个需要考虑LED之间的同步互斥，代码的实时性要求很高，一般都是在RTOS系统上跑，可以以OLED屏为例，在基础的驱动程序上，搭配双缓冲机制刷屏，有些代码都能实现30fps的动画效果。

对于多个LED，常见的就是红绿灯表示设备状态了，这个只需要简单的逻辑判断就行。复杂的LED的效果可能就需要对LED进行分组、分类，要考虑很多。

花样led灯c语言程序,单片机控制花样流水灯原理图及程序
weixin_39724009的博客
05-17 3460
描述AT89C51单片机流水灯c语言程序1、首先先在proteus画出仿真图，方便仿真程序2、下面来编写程序，先来写入头函数3、根据自己在proteus画的图，定义一下管脚根据你的原理图进行编写sbit p0=P1^0;sbit p1=P1^1;sbit p2=P1^2;sbit p3=P1^3;sbit p4=P1^4;sbit p5=P1^5;sbit p6=P1^6;sbit p7=P1^7...
java led_LED学习及一个花样流水灯的实现
weixin_39838302的博客
02-20 985
在STC89C52RC中，负责显示的有8个LED灯，8位数码管，并且支持1602和12864两种液晶显示屏；本篇总结的是8位红光LED灯模块。主要处理的是点亮和熄灭灯的操作。0是点亮，1是熄灭。其中点亮一位LED灯，有两种方法：一个是定义一个可以位寻址的变量；一个是利用总线方式直接为P0口赋值。方法1例子：/*********************************************...
花样led灯c语言程序,《心形LED灯花样闪烁(内含程序)》.doc
weixin_32896083的博客
05-17 1066
《心形LED灯花样闪烁(内含程序)》.doc心形花样LED流水灯(带程序)使用89C52做的，原理图如下：总共有32个LED灯，4个I/O全部用上了。我在这里不加有LED保护电阻，用200的也可以晶振用12M的或11.0592M也行，C1,C2用30PF。PCB图如下：作品效果录像：/programs/view/z0bjKg_3Cd4/程序是用C语言写的;如下：#include#include #...
51单片机LED花样流水灯实验
chunOS的博客
07-20 5019
#include <reg52.h> typedef unsigned char u8; typedef unsigned int u16; void delay(u16 t) //延时函数 { u16 x,y; for(x=t;x>0;x--) for(y=110;y>0;y--);//延时1ms } void main() //主函数 { u8 temp,i; while(1) { temp=0x01;//8盏灯单个亮向右移 for...
带中断控制的LED花样灯
Bonnie-Yang的博客
03-20 1762
一、目标 P0端口作为输出口，外接8只LED，P3.2外接按键K。编写程序，当K未按下时，8位LED进行默认显示，其显示规律为左移流水->右移流水->隔灯闪烁三次花样显示；如果按下K键后，8只LED暂停默认显示，而进行闪烁显示，当显示5次后，继续按默认规律显示。 二、proteus连线 三、代码实现 1、首先我们来实现默认的花样流水灯显示 void Multi_Display() { uint i=0; uint p0=0x00; //left_LED左移流水 p0=0x7F;
32种花样流水灯c语言程序,32LED单片机心形花样流水灯程序+视频
weixin_42097914的博客
05-18 2600
include#include #define uint unsigned int#define uchar unsigned charuchar code zou[]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};//单个从0到7uchar code you[]={0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x01};//单个从7...
【51单片机】在51单片机上用C语言实现循环点亮8盏LED灯
qq_36237096的博客
06-27 9034
#include //sbit LED = P2^0; void LEDMoveLeft(); void LEDMoveRight();unsigned char temp ;void main() { unsigned int i; while(1) { for(temp=0;temp
按键控制led灯亮灭c语言实验报告,通过按键控制LED灯的实验
weixin_33695092的博客
05-18 4878
通过查看开发板的核心电路原理图,加上查阅SUMSANG2440的datasheed得知四个按键K1，K2，K3，K4对应GPF中的GPF1,GPF4,GPF2,GPF0。将这四个引脚配置为输入模式,这样通过GPFDAT寄存器中的相应为来得知哪个键被按下,当某个键被按下时,相应连接引脚接地,为低电平,在GPFDAT中相应的为表现为逻辑0。否则为1。设置C语言环境的汇编文件和循环点亮LED灯的实验中的...
5种花样模式流水灯设计Verilog代码VIVADO仿真
xiakunpei123的博客
06-20 1361
本设计使用的流水灯为16个灯，分为5种变化花样，每种自动切换，切换到第5种模式后返回第一种。实验原理为使用状态机控制led的模式切换，一个设计了6种状态，分别是空闲状态、模式1、模式2、模式3、模式4、模式5，每个模式持续16个时钟周期。系统初始状态为空闲状态，然后切换到模式1状态，当模式1状态时钟周期到16时，切换到模式2状态，当模式2状态时钟周期到16时切换到模式3状态，如此循环往复。 当处于模式1状态时，将led灯依次向右点亮，16个周期刚好全部点亮一遍，当处于模式2时，将led灯依次向左点亮，16
通过51单片机使用外部中断去控制8盏led灯实现3种流水灯花样
05-15
通过外部中断控制8盏LED灯实现3种流水灯花样，可以按照以下步骤进行： 1. 确定外部中断引脚和LED灯的控制引脚，这里以P3口为例，P3.0~P3.7为控制LED灯的引脚，P3.2为外部中断引脚。 2. 初始化外部中断，使能中断并...
单片机简介
Cao123456789321的博客
05-26 754
从4位机到AIoT，单片机用50年时间重塑了人类与机器的交互方式。无论是点亮第一颗LED，还是构建复杂的物联网系统，这片"硅基大脑"始终是工程师手中最强大的魔法芯片。文末福利：关注+转发，私信获取《单片机项目实战宝典》！
PCB设计教程【入门篇】——电路分析基础-基本元件（二极管三极管场效应管）
2501_91732643的博客
05-20 1770
本教程基于B站Expert电子实验室的PCB设计教学的整理，为个人学习记录，旨在帮助PCB设计新手入门。所有内容仅作学习交流使用，无任何商业目的。若涉及侵权，请随时联系，将会立即处理、目录前言1.二极管1.发光二极管（LED）2.普通二极管3.其他二极管4.电压与电流的关系图1.电压轴的正半轴向负半轴看去2.向电压轴的负半轴看去5.正负极的区别方法1.实物2.PCB板上2.三极管1.NPN型2.PNP型3.内部结构4.输出特性曲线图5.不同封装的三极管3.场效应管1.场效应管和三极管对比图。
UDP编程
m0_57685225的博客
05-29 426
udp是无连接的，没有listen 与 accept。
ST MCU CAN模块--TTCAN模式浅析
aiot_bigbear的专栏,关注我获取最新技术文章信息与海量资源~
05-29 714
本文总结了STM32微控制器中CAN模块的使用要点。首先介绍了CAN协议的特点，包括多主控制、消息仲裁和错误检测机制，以及CAN-FD协议的改进。重点分析了CAN总线电平传输特性，强调显性电平优先级高于隐性电平。文章详细解读了CAN的数据格式，包括数据帧与遥控帧的区别，并指出遥控帧在实际应用中的局限性。此外，还介绍了时间触发的TT-CAN机制及其标准化情况。最后阐述了在STM32中如何通过配置寄存器开启TT-CAN模式，并给出了相关固件库函数接口。这些内容为STM32开发者在汽车电子等实时性要求高的应用中正
嵌入式STM32学习—— 定时器中断（应用-利用定时器中断实现LED亮一秒灭一秒）
Sfy314的博客
05-25 242
本文介绍了使用STM32定时器中断实现LED每秒闪烁的方法。通过配置TIM2定时器（周期7200，预分频10000）产生1秒中断，在中断服务程序中翻转GPIOA1引脚电平。系统包含定时器初始化、LED驱动和主程序三部分：定时器模块设置时钟和中断，LED模块初始化GPIOA1为推挽输出，主程序启动各模块后进入循环。中断处理函数TIM2_IRQHandler检测更新事件并执行LED状态切换，实现精确的1秒亮灭周期控制。
什么是单片机?
最新发布
Deng945201314的博客
05-29 928
一台功能完备的计算机主要由若干核心组件构成，这些组件包括中央处理器（CPU），作为计算机的运算核心，负责执行各类指令和数据处理；然而，仅将这些硬件组件组装起来尚不足以使计算机正常运作，必须为其配置操作系统，通常是Windows操作系统，以赋予计算机完整的运行环境和用户界面，从而实现多样化功能和应用。通过运用先进的超大规模集成电路技术，巧妙地将具备强大数据处理能力的中央处理器（CPU）、各类存储器、输入输出（IO）端口、定时器以及其他多种功能模块，全部紧凑地集成在单一的硅片之上。
直流电机 pwm 调速
道亦无名
05-25 607
PWM（脉冲宽度调制）调速是直流电机调速中常用的一种方法。
硬件学习笔记--62 MCU的ECC功能简介
Rousson的博客
05-29 257
ECC（Error Correction Code，错误校正码）是MCU（微控制器）中用于检测和纠正存储器数据错误的硬件功能，主要应用于Flash、RAM、Cache等存储单元，确保数据在传输或存储过程中的可靠性。：识别存储/传输过程中的单比特（Single-bit）或多比特（Multi-bit）错误。：自动修复单比特错误（部分高级MCU支持多比特错误纠正）。：防止因宇宙射线、电磁干扰、老化等因素导致的数据损坏。可检测，纠正每32位数据需6位校验位（开销约16%）支持多比特错误纠正（需更高计算资源）
中断和信号详解
An15294874732的博客
05-25 1084
中断分为三种：硬件中断、异常中断、软中断。
8LED花样流水灯电路设计与控制原理详解
花样流水灯硬件电路原理图是一个针对实际应用场景的LED广告牌照明项目，旨在通过单片机控制LED灯实现循环闪烁，以吸引顾客注意力、美化环境和增加商业氛围。该项目的核心内容包括以下几个方面： 1. **项目需求**： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值