STC8H1K08-30I-TSSOP20 快速入门配套教程 | 建议 STC8H2K12U-45I-TSSOP20

简单快***

大家早上好，我是UP志城。


接下来我将带你快速入门STC8H1K08-30I-TSSOP20的芯片，


车速较快，良心分享，请各位座好扶稳。

神***

建议楼主，直接用
STC8H2K12U-45I-TSSOP20/SOP16,
STC8H2K32U-45I-TSSOP20/LQFP32,
STC8H8K64U-45I-TSSOP20/LQFP32/LQFP48，PDIP40 来讲
好处 ：
===【USB直接下载】，【USB不停电下载】
===【USB直接仿真】，
===【USB直接通信】


用下面这个 【STCAI-万能实验板-V2.x】，带大家一起做实验学习
用【STCAI-万能实验板】做实验，DIY 拿奖励，500元/人，前20名 ！ - 做实验拿奖励@STCAI万能板，500元 国芯人工智能技术交流网站 - AI32位8051交流社区


STCAI-万能实验板-V2.3，支持 封装形式/接口：
LQFP48 / 32，TF卡 插座，FPC接口；
TSSOP28/24/20/16/14；
SOP28/24/20；
WSOP16/8；
SOP16/8;
SOT23-6/5/4/3, DFN8;
DIP40/28/20/16/8,
贴片 电阻 / 电容 也可直接焊在插件的2个焊盘之间，
FPC焊接/插座支持间距：
0.5mm、0.62mm、0.65mm、0.7mm、0.8mm



建议 第一节课是 ：










STC 的 MCU 从 0 开始入门：
先搞定 【USB不停电下载】/【USB直接通信】，再搞其他的


要 做到 USB不停电下载；
要 尝试 AiCube 图形化自动配置生成程序工具；
推荐优先看的：  
printf_usb("Hello World !\r\n")及
USB不停电下载, 演示视频链接：
https://www.stcaimcu.com/thread-19077-1-1.html

下载 最新的 AiCube-ISP-V6.96N 或以上版本软件 ！
深圳国芯人工智能有限公司-工具软件

下载 最新的 USB库函数，永远用最新的 USB库函数 ！
深圳国芯人工智能有限公司-库函数
下载 最新的 用户手册 ！
下载 最新的 上机实践指导书 !

下载 最新的 Ai8051U 用户手册
https://www.stcaimcu.com/data/download/Datasheet/AI8051U.pdf


下载 最新的 STC8H8K64U 用户手册
https://www.stcaimcu.com/data/download/Datasheet/STC8H.pdf

下载 最新的 STC8H8K64U 实验指导书
有 AiCube 图形化自动配置生成程序工具使用说明
https://www.stcaimcu.com/data/do ... %AF%BC%E4%B9%A6.pdf


上面是 小李 演示：STC8H8K64U, printf_usb("Hello World !\r\n")及usb不停电下载@AiCube之图形化程序自动生成

简单快***

第二节：带领大家实现串口通信控制舵机。

/************************************************************
 * 文件: main.c
 * 作者: 志城
 * 日期: 2025-12-26
 * 版本: 最终成功版本 2512260442
 * 功能: 基于STC8H1K08A单片机的舵机控制系统，通过串口触发实现控制。
 * 硬件: STC8H1K08A 20PIN单片机，主时钟22118400LMHz
 * 引脚: 具体配置见下方IO口模式设置及串口初始化部分
 ************************************************************/

/* 头文件包含 */
#include "config.h"
#include "STC8G_H_Delay.h"
#include "STC8G_H_Servo.h"
#include "STC8G_H_UART1_UART2.h"

/* 宏定义 */
#define MAIN_Fosc       22118400L          /* 主时钟频率 */
#define Timer0_Reload   (65536UL - (MAIN_Fosc / 1000)) /* 定时器0重载值，用于1ms定时 */


/**
 * @brief 定时器0中断服务函数
 * @details 提供1ms定时基准，用于系统计时和舵机平滑运动控制。
 *          中断中更新舵机控制信号。
 */
void timer0(void) interrupt 1
{
    static u16 ms_counter = 0; /* 毫秒计数器 */

    /* 重载定时器初值 */
    TH0 = (u8)(Timer0_Reload / 256);
    TL0 = (u8)(Timer0_Reload % 256);

    /* 1秒计时逻辑 */
    ms_counter++;
    if (ms_counter >= 1000)
    {
        ms_counter = 0;
        B_1ms = 1; /* 置位1秒标志 */
    }

    /* 调用舵机更新函数，必须在中断中定期调用以维持PWM信号 */
    Servo_Update();
}

/**
 * @brief 主函数
 * @details 程序入口点。初始化系统硬件（定时器、舵机、IO口、串口），
 *          然后进入主循环，循环处理来自两个串口的控制命令。
 */
void main(void)
{
    /* 1. 扩展寄存器访问使能 */
    P_SW2 |= 0x80;

    /* 2. 定时器0初始化 - 用于产生1ms中断 */
    AUXR = 0x80;                    /* 定时器0为1T模式 */
    TH0 = (u8)(Timer0_Reload / 256);
    TL0 = (u8)(Timer0_Reload % 256);
    ET0 = 1;                        /* 使能定时器0中断 */
    TR0 = 1;                        /* 启动定时器0 */

    /* 3. 舵机控制模块初始化 */
    Servo_Init();

    /* 4. IO口模式配置 (准双向/推挽/高阻/开漏) */
    /* 根据STC8G系列数据手册配置，此处配置可能与具体硬件连接相关 */
    P0M1 = 0x30;   P0M0 = 0x30;
    P1M1 = 0x30;   P1M0 = 0x30;
    P2M1 = 0x3c;   P2M0 = 0x3c;
    P3M1 = 0x50;   P3M0 = 0x50;
    P4M1 = 0x3c;   P4M0 = 0x3c;
    P5M1 = 0x0c;   P5M0 = 0x0c;
    P6M1 = 0xff;   P6M0 = 0xff;
    P7M1 = 0x00;   P7M0 = 0x00;

    /* 5. 串口初始化 */
    UART1_config(2); /* 初始化UART1，参数2可能与波特率设置相关 */
    UART2_config(2); /* 初始化UART2 */

    /* 6. 特定引脚模式配置（可能用于串口或舵机信号输出） */
    P1M0 = 0x18;
    P1M1 = 0x00;
    P2M0 &= ~0x01;
    P2M1 &= ~0x01;

    /* 7. 开启全局中断 */
    EA = 1;

    /* 8. 主循环 */
    while (1)
    {
        /* 处理来自UART1和UART2的命令 */
        UART_ProcessCommand(1); /* 处理串口1命令 */
        UART_ProcessCommand(2); /* 处理串口2命令 */

        /* 原摆动测试代码已注释，通过串口命令控制舵机 */
        /*
        SetServoAngle(0);
        Delay2000ms();
        SetServoAngle(180);
        Delay2000ms();
        */
    }
}
复制代码

简单快***

/******************************************************************************
 * @file    STC8G_H_Servo.c
 * @brief   STC8G系列单片机舵机控制模块
 * @details 本文件实现了基于PWM的舵机角度控制，支持0-180度范围，具有平滑运动功能。
 *          适用于SG90等标准舵机，使用定时器中断实现非阻塞式角度更新。
 * @author  [志城]
 * @date    2025-12-26
 * @version 1.0
 *****************************************************************************/

#include    "config.h"          // 包含项目配置文件，定义系统时钟、定时器重载值等宏[1](@ref)
#include "STC8G_H_Servo.h"      // 包含舵机控制模块的头文件，声明外部函数和宏

// 全局变量定义
bit B_1ms = 0;                  // 1ms定时标志位，用于系统时基
u16 servo_angle = 90;          // 当前舵机角度，初始化为中间位置(90度)
u16 servo_target = 0;          // 目标角度，由SetServoAngle()函数设置
u16 servo_step = 0;            // 步进值，预留用于更复杂的运动规划
u16 servo_speed = 10;          // 舵机转动速度，值越大转动越慢(单位：定时周期)
u16 PWM4_Duty = INITIAL_DUTY_90_DEGREES;  // PWM占空比初始值，对应90度位置

// PWM通道配置宏定义
#define PWM4_4      0xC0        // PWM4输出映射到P3.4引脚的位掩码
#define ENO4P       0x40        // PWM4正输出使能位
#define ENO4N       0x80        // PWM4互补输出使能位（本应用中未使用互补输出）

/**
 * @brief 舵机初始化函数
 * @details 初始化PWM模块，配置定时器和GPIO，设置舵机初始位置为90度。
 *          本函数配置了PWM周期为20ms（标准舵机控制周期），并初始化所有相关寄存器。
 * @note 调用此函数前需确保config.h中PWM_PERIOD等宏已正确定义。
 * @param 无
 * @return 无
 */
void Servo_Init(void)
{
    // 配置GPIO为推挽输出模式
    P3M1 = 0x00;                // 清除P3口输入模式配置
    P3M0 = 0xFF;                // 设置P3口所有引脚为推挽输出模式
    
    // 配置其他GPIO口为准双向模式（默认状态）
    P0M1 = 0x00;                // P0口配置
    P0M0 = 0x00;
    P1M1 = 0x00;                // P1口配置
    P1M0 = 0x00;
    P2M1 = 0x00;                // P2口配置
    P2M0 = 0x00;
    P4M1 = 0x00;                // P4口配置
    P4M0 = 0x00;
    P5M1 = 0x00;                // P5口配置
    P5M0 = 0x00;
    
    // PWM模块配置：先关闭所有通道输出使能
    PWMA_CCER1 = 0x00;          // 关闭通道1-3输出
    PWMA_CCER2 = 0x00;          // 关闭通道4-6输出
    
    // 配置PWM通道4工作模式
    PWMA_CCMR4 = 0x60;          // PWM模式1，预装载使能[1](@ref)
    PWMA_CCER2 = 0x50;          // 通道4输出使能，高电平有效
    
    PWMA_CCMR4 |= 0x08;         // 快速使能（CCxE和CCxNE位立即生效）
    PWMA_PSCRH = 0x00;          // 预分频器高字节清零
    PWMA_PSCRL = 63;            // 预分频系数64（实际分频值=63+1）
    
    // 设置PWM周期为20ms（标准舵机控制周期）
    PWMA_ARRH = (u8)(PWM_PERIOD >> 8);  // 自动重装载值高字节
    PWMA_ARRL = (u8)PWM_PERIOD;         // 自动重装载值低字节
    
    // 使能PWM4输出到指定引脚
    PWMA_ENO = 0x00;            // 清除所有输出使能
    PWMA_ENO |= ENO4P | ENO4N;  // 使能PWM4正输出和互补输出
    
    PWMA_PS = 0x00;             // 清除引脚映射配置
    PWMA_PS |= PWM4_4;          // 映射PWM4到P3.4引脚
    
    PWMA_BKR = 0x80;            // 主输出使能（MOE=1）
    PWMA_CR1 |= 0x01;           // 使能计数器（CEN=1），开始产生PWM
    
    // 设置初始角度为90度（中间位置）
    servo_angle = 90;           // 更新当前角度变量
    servo_target = 90;          // 设置目标角度为90度
    PWM4_Duty = INITIAL_DUTY_90_DEGREES;  // 使用预定义的90度占空比值
    UpdatePwm();                // 更新PWM输出
}

/**
 * @brief 设置舵机目标角度
 * @param angle 目标角度值，范围0-180度
 * @details 将目标角度限制在有效范围内，舵机会通过Servo_Update()函数平滑移动到该角度。
 *          本函数仅设置目标值，实际运动由定时器中断控制，实现非阻塞式运动。
 * @note 角度值超出范围时会被自动限制在边界值。
 */
void SetServoAngle(u16 angle)
{
    // 角度范围限制：确保输入角度在舵机有效工作范围内
    if(angle < SERVO_MIN_ANGLE)          // 低于最小角度时取最小值
        angle = SERVO_MIN_ANGLE;
    if(angle > SERVO_MAX_ANGLE)          // 高于最大角度时取最大值
        angle = SERVO_MAX_ANGLE;
    
    servo_target = angle;                // 更新目标角度变量
}

/**
 * @brief 角度到占空比转换函数
 * @param angle 舵机角度，范围0-180度
 * @return 对应的PWM占空比值，用于设置PWM比较寄存器
 * @details 根据SG90舵机规格，将角度线性映射到脉冲宽度。
 *          标准舵机控制信号：0度对应0.5ms脉冲，180度对应2.5ms脉冲，周期20ms。
 *          转换公式：脉宽 = 500 + angle * (2500-500)/180
 *                  占空比 = (脉宽 * PWM_PERIOD) / 20000
 * @note 计算过程中使用32位整数防止溢出，最终结果限制在PWM_PERIOD范围内。
 */
u16 AngleToDuty(u16 angle)
{
    u32 pulse_width;    // 脉冲宽度（微秒）
    u32 duty_value;     // 计算出的占空比值
    
    // 线性映射：角度 -> 脉冲宽度(us)
    // 角度0°: 500us, 角度180°: 2500us[4](@ref)
    pulse_width = SERVO_MIN_US + ((u32)angle * (SERVO_MAX_US - SERVO_MIN_US) / SERVO_MAX_ANGLE);
    
    // 转换为PWM占空比值
    // 占空比 = (脉冲宽度 * PWM周期值) / 20000us(20ms周期)
    duty_value = (pulse_width * PWM_PERIOD) / 20000UL;
    
    // 边界检查：确保占空比不超过PWM周期范围
    if(duty_value > PWM_PERIOD)         // 超过最大值时取最大值
        duty_value = PWM_PERIOD;
    if(duty_value < 0)                  // 低于最小值时取0（实际不会发生）
        duty_value = 0;
    
    return (u16)duty_value;              // 返回16位占空比值
}

/**
 * @brief 更新PWM占空比
 * @details 将计算好的占空比值写入PWM比较寄存器CCR4，立即改变PWM输出脉宽。
 *          本函数不进行任何计算，仅负责寄存器写入操作。
 * @param 无
 * @return 无
 */
void UpdatePwm(void)
{
    // 将16位占空比值写入通道4比较寄存器（分高低字节写入）
    PWMA_CCR4H = (u8)(PWM4_Duty >> 8);  // 写入高字节
    PWMA_CCR4L = (u8)PWM4_Duty;         // 写入低字节
}

/**
 * @brief 舵机更新函数
 * @details 应在定时器中断服务程序中周期性调用（建议1ms调用一次）。
 *          实现舵机平滑运动：每次调用检查是否到达速度控制时间，
 *          然后逐步调整当前角度向目标角度靠近，最后更新PWM输出。
 * @note 本函数采用非阻塞设计，通过全局变量控制运动，不影响主程序运行。
 */
void Servo_Update(void)
{
    static u16 time_counter = 0;        // 时间计数器，用于速度控制
    
    time_counter++;                     // 每次调用计数器加1
    
    // 速度控制：每servo_speed次调用执行一次角度更新
    if(time_counter >= servo_speed)
    {
        time_counter = 0;               // 重置计数器
        
        // 平滑移动到目标角度：逐步调整当前角度
        if(servo_angle < servo_target)  // 当前角度小于目标角度
        {
            servo_angle++;              // 角度增加1度
            if(servo_angle > SERVO_MAX_ANGLE)  // 边界检查
                servo_angle = SERVO_MAX_ANGLE;
        }
        else if(servo_angle > servo_target)  // 当前角度大于目标角度
        {
            servo_angle--;              // 角度减少1度
            if(servo_angle < SERVO_MIN_ANGLE)  // 边界检查
                servo_angle = SERVO_MIN_ANGLE;
        }
        // 如果servo_angle == servo_target，则不执行任何操作
        
        // 根据新角度计算并更新PWM占空比
        PWM4_Duty = AngleToDuty(servo_angle);  // 角度转占空比
        UpdatePwm();                    // 更新PWM输出
    }
}

/******************************************************************************
 * 文件结束
 * 修改记录：
 * 1. 2025-12-26 初始版本创建
 *    - 实现基本舵机控制功能
 *    - 添加平滑运动算法
 *    - 完善注释文档
 *****************************************************************************/
复制代码

简单快***

#ifndef __STC8G_H_SERVO_H
#define __STC8G_H_SERVO_H

#include "config.h"


// 舵机参数配置
#define SERVO_MIN_US        500     // 0度对应的脉冲宽度(us)
#define SERVO_MAX_US        2500    // 180度对应的脉冲宽度(us)
#define SERVO_MIN_ANGLE     0       // 最小角度(度)
#define SERVO_MAX_ANGLE     180     // 最大角度(度)
#define PWM_PERIOD          7499    // PWM周期值

// 角度到占空比转换相关
#define INITIAL_DUTY_90_DEGREES   ((u16)((1500UL * PWM_PERIOD) / 20000UL))



// 全局变量声明
extern bit B_1ms;
extern u16 servo_angle;
extern u16 servo_target;
extern u16 servo_step;
extern u16 servo_speed;
extern u16 PWM4_Duty;

// 函数声明
void Servo_Init(void);
void SetServoAngle(u16 angle);
u16 AngleToDuty(u16 angle);
void UpdatePwm(void);
void Servo_Update(void);

#endif // _SERVO_H

复制代码

简单快***

/**
 * @file    STC8G_H_UART1_UART2.c
 * @brief   STC8系列单片机UART1和UART2驱动文件
 * @details 本文件实现了UART1和UART2的初始化、发送、接收功能，采用环形缓冲区管理数据
 * @note    使用前需在config.h中定义MAIN_Fosc（系统时钟频率）和Baudrate1/Baudrate2（波特率）
 * @author  [志城]
 * @date    2025-12-24
 * @version 1.0
 */

#include "config.h"
#include "STC8G_H_UART1_UART2.h"
#include "STC8G_H_Servo.h"

/* 全局变量定义 */
UART_Control_t xdata Uart1_Ctrl;  /* UART1控制结构体，用于管理发送/接收缓冲区及状态 */
UART_Control_t xdata Uart2_Ctrl;  /* UART2控制结构体，用于管理发送/接收缓冲区及状态 */

/**
 * @brief   配置定时器2作为UART的波特率发生器
 * @param   dat: 定时器重装载值，用于计算波特率
 * @retval  无
 * @note    该函数设置AUXR寄存器，配置定时器2为1T模式，并设置重装载值[1](@ref)
 */
void SetTimer2Baudraye(u16 dat)
{
    AUXR &= ~(1<<4);      /* 清除T2_C/T位，选择定时器模式 */
    AUXR &= ~(1<<3);      /* 清除T2x12位，选择12T模式（兼容传统51） */
    AUXR |=  (1<<2);      /* 设置T2R位，启动定时器2运行 */
    T2H = dat / 256;      /* 设置定时器2高8位重装载值 */
    T2L = dat % 256;      /* 设置定时器2低8位重装载值 */
    IE2  &= ~(1<<2);      /* 禁止定时器2中断 */
    AUXR |=  (1<<4);      /* 设置T2_C/T位，选择计数器模式（用于波特率发生器） */
}

/**
 * @brief   配置UART1串口
 * @param   brt: 波特率发生器选择，1=使用定时器1，2=使用定时器2
 * @retval  无
 * @note    该函数根据brt参数选择不同的波特率发生器，并初始化UART1的环形缓冲区[1](@ref)[2](@ref)
 */
void UART1_config(u8 brt)
{
    if(brt == 2)  /* 使用定时器2作为波特率发生器 */
    {
        AUXR |= 0x01;  /* 设置UART_M0x6位，选择定时器2为波特率发生器 */
        SetTimer2Baudraye(65536UL - (MAIN_Fosc / 4) / Baudrate1);  /* 计算并设置定时器2重装载值 */
    }
    else  /* 使用定时器1作为波特率发生器 */
    {
        TR1 = 0;        /* 停止定时器1 */
        AUXR &= ~0x01;  /* 清除UART_M0x6位，选择定时器1为波特率发生器 */
        AUXR |=  (1<<6);/* 设置T1x12位，定时器1为1T模式 */
        TMOD &= ~(1<<6);/* 清除GATE位，定时器1不受外部引脚控制 */
        TMOD &= ~0x30;  /* 清除M1、M0位，设置定时器1为模式0（16位自动重装载） */
        TH1 = (u8)((65536UL - (MAIN_Fosc / 4) / Baudrate1) / 256);  /* 计算定时器1高8位重装载值 */
        TL1 = (u8)((65536UL - (MAIN_Fosc / 4) / Baudrate1) % 256);  /* 计算定时器1低8位重装载值 */
        ET1 = 0;        /* 禁止定时器1中断 */
        INTCLKO &= ~0x02;  /* 清除T1CLKO位，禁止定时器1时钟输出 */
        TR1  = 1;       /* 启动定时器1 */
    }

    SCON = (SCON & 0x3f) | 0x40;  /* 设置UART1为模式1（8位UART，可变波特率） */
    ES  = 1;      /* 使能UART1中断 */
    REN = 1;      /* 使能UART1接收 */
    P_SW1 &= 0x3f;  /* 清除UART1引脚选择位，默认使用P3.0/RxD和P3.1/TxD */

    /* 初始化UART1环形缓冲区控制变量 */
    Uart1_Ctrl.rx_head = 0;    /* 接收缓冲区头指针 */
    Uart1_Ctrl.rx_tail = 0;    /* 接收缓冲区尾指针 */
    Uart1_Ctrl.tx_head = 0;    /* 发送缓冲区头指针 */
    Uart1_Ctrl.tx_tail = 0;    /* 发送缓冲区尾指针 */
    Uart1_Ctrl.tx_count = 0;   /* 发送缓冲区中待发送字节数 */
    Uart1_Ctrl.tx_busy = 0;    /* 发送忙标志，0=空闲，1=正在发送 */
    Uart1_Ctrl.rx_ready = 0;   /* 接收就绪标志，0=无数据，1=有数据 */
}

/**
 * @brief   配置UART2串口
 * @param   brt: 波特率发生器选择，目前仅支持2=使用定时器2
 * @retval  无
 * @note    该函数配置UART2使用定时器2作为波特率发生器，并初始化UART2的环形缓冲区[1](@ref)[2](@ref)
 */
void UART2_config(u8 brt)
{
    if(brt == 2)  /* 使用定时器2作为波特率发生器 */
    {
        SetTimer2Baudraye(65536UL - (MAIN_Fosc / 4) / Baudrate2);  /* 计算并设置定时器2重装载值 */

        S2CON &= ~(1<<7);  /* 清除S2SM0位，设置UART2为模式0（8位UART，可变波特率） */
        IE2   |= 1;        /* 使能UART2中断 */
        S2CON |= (1<<4);   /* 设置S2REN位，使能UART2接收 */
        P_SW2 &= ~0x01;    /* 清除S2_S位，选择UART2引脚为默认位置 */
        P_SW2 |= 0;        /* 确保S2_S为0，使用P1.0/RxD2和P1.1/TxD2 */

        /* 初始化UART2环形缓冲区控制变量 */
        Uart2_Ctrl.rx_head = 0;    /* 接收缓冲区头指针 */
        Uart2_Ctrl.rx_tail = 0;    /* 接收缓冲区尾指针 */
        Uart2_Ctrl.tx_head = 0;    /* 发送缓冲区头指针 */
        Uart2_Ctrl.tx_tail = 0;    /* 发送缓冲区尾指针 */
        Uart2_Ctrl.tx_count = 0;   /* 发送缓冲区中待发送字节数 */
        Uart2_Ctrl.tx_busy = 0;    /* 发送忙标志，0=空闲，1=正在发送 */
        Uart2_Ctrl.rx_ready = 0;   /* 接收就绪标志，0=无数据，1=有数据 */
    }
}

/**
 * @brief   从UART1接收缓冲区读取一个字节
 * @param   无
 * @retval  读取到的数据字节，如果缓冲区为空则返回0
 * @note    该函数从环形接收缓冲区读取数据，采用非阻塞方式[3](@ref)
 */
u8 UART1_GetByte(void)
{
    u8 dat;
    if(Uart1_Ctrl.rx_head != Uart1_Ctrl.rx_tail)  /* 检查接收缓冲区是否有数据 */
    {
        dat = Uart1_Ctrl.rx_buffer[Uart1_Ctrl.rx_tail];  /* 从缓冲区尾部读取数据 */
        if(++Uart1_Ctrl.rx_tail >= UART_BUF_LENGTH) Uart1_Ctrl.rx_tail = 0;  /* 尾指针循环 */
        if(Uart1_Ctrl.rx_head == Uart1_Ctrl.rx_tail) Uart1_Ctrl.rx_ready = 0;  /* 缓冲区为空时清除就绪标志 */
        return dat;
    }
    return 0;  /* 缓冲区为空时返回0 */
}

/**
 * @brief   从UART2接收缓冲区读取一个字节
 * @param   无
 * @retval  读取到的数据字节，如果缓冲区为空则返回0
 * @note    该函数从环形接收缓冲区读取数据，采用非阻塞方式[3](@ref)
 */
u8 UART2_GetByte(void)
{
    u8 dat;
    if(Uart2_Ctrl.rx_head != Uart2_Ctrl.rx_tail)  /* 检查接收缓冲区是否有数据 */
    {
        dat = Uart2_Ctrl.rx_buffer[Uart2_Ctrl.rx_tail];  /* 从缓冲区尾部读取数据 */
        if(++Uart2_Ctrl.rx_tail >= UART_BUF_LENGTH) Uart2_Ctrl.rx_tail = 0;  /* 尾指针循环 */
        if(Uart2_Ctrl.rx_head == Uart2_Ctrl.rx_tail) Uart2_Ctrl.rx_ready = 0;  /* 缓冲区为空时清除就绪标志 */
        return dat;
    }
    return 0;  /* 缓冲区为空时返回0 */
}

/**
 * @brief   向UART1发送一个字节数据
 * @param   dat: 要发送的数据字节
 * @retval  无
 * @note    该函数将数据放入发送缓冲区，如果发送器空闲则立即启动发送[4](@ref)
 */
void UART1_SendByte(u8 dat)
{
    ES = 0;  /* 禁止UART1中断，保护缓冲区操作 */
    if(Uart1_Ctrl.tx_count < UART_BUF_LENGTH)  /* 检查发送缓冲区是否有空间 */
    {
        Uart1_Ctrl.tx_buffer[Uart1_Ctrl.tx_head] = dat;  /* 将数据放入缓冲区头部 */
        if(++Uart1_Ctrl.tx_head >= UART_BUF_LENGTH) Uart1_Ctrl.tx_head = 0;  /* 头指针循环 */
        Uart1_Ctrl.tx_count++;  /* 增加待发送字节计数 */
        if(!Uart1_Ctrl.tx_busy)  /* 如果发送器空闲 */
        {
            Uart1_Ctrl.tx_busy = 1;  /* 设置发送忙标志 */
            SBUF = Uart1_Ctrl.tx_buffer[Uart1_Ctrl.tx_tail];  /* 从缓冲区尾部取出数据发送 */
            if(++Uart1_Ctrl.tx_tail >= UART_BUF_LENGTH) Uart1_Ctrl.tx_tail = 0;  /* 尾指针循环 */
            Uart1_Ctrl.tx_count--;  /* 减少待发送字节计数 */
        }
    }
    ES = 1;  /* 重新使能UART1中断 */
}

/**
 * @brief   向UART2发送一个字节数据
 * @param   dat: 要发送的数据字节
 * @retval  无
 * @note    该函数将数据放入发送缓冲区，如果发送器空闲则立即启动发送[4](@ref)
 */
void UART2_SendByte(u8 dat)
{
    IE2 &= ~0x01;  /* 禁止UART2中断，保护缓冲区操作 */
    if(Uart2_Ctrl.tx_count < UART_BUF_LENGTH)  /* 检查发送缓冲区是否有空间 */
    {
        Uart2_Ctrl.tx_buffer[Uart2_Ctrl.tx_head] = dat;  /* 将数据放入缓冲区头部 */
        if(++Uart2_Ctrl.tx_head >= UART_BUF_LENGTH) Uart2_Ctrl.tx_head = 0;  /* 头指针循环 */
        Uart2_Ctrl.tx_count++;  /* 增加待发送字节计数 */
        if(!Uart2_Ctrl.tx_busy)  /* 如果发送器空闲 */
        {
            Uart2_Ctrl.tx_busy = 1;  /* 设置发送忙标志 */
            S2BUF = Uart2_Ctrl.tx_buffer[Uart2_Ctrl.tx_tail];  /* 从缓冲区尾部取出数据发送 */
            if(++Uart2_Ctrl.tx_tail >= UART_BUF_LENGTH) Uart2_Ctrl.tx_tail = 0;  /* 尾指针循环 */
            Uart2_Ctrl.tx_count--;  /* 减少待发送字节计数 */
        }
    }
    IE2 |= 0x01;  /* 重新使能UART2中断 */
}

/**
 * @brief   UART1中断服务函数
 * @param   无
 * @retval  无
 * @note    中断号4对应UART1中断，处理接收和发送中断[1](@ref)
 */
void UART1_int (void) interrupt 4
{
    if(RI)  /* 接收中断标志 */
    {
        RI = 0;  /* 清除接收中断标志 */
        Uart1_Ctrl.rx_buffer[Uart1_Ctrl.rx_head] = SBUF;  /* 读取接收到的数据存入缓冲区 */
        if(++Uart1_Ctrl.rx_head >= UART_BUF_LENGTH) Uart1_Ctrl.rx_head = 0;  /* 头指针循环 */
        Uart1_Ctrl.rx_ready = 1;  /* 设置接收就绪标志 */
    }

    if(TI)  /* 发送中断标志 */
    {
        TI = 0;  /* 清除发送中断标志 */
        if(Uart1_Ctrl.tx_count > 0)  /* 如果发送缓冲区还有数据 */
        {
            SBUF = Uart1_Ctrl.tx_buffer[Uart1_Ctrl.tx_tail];  /* 发送下一个字节 */
            if(++Uart1_Ctrl.tx_tail >= UART_BUF_LENGTH) Uart1_Ctrl.tx_tail = 0;  /* 尾指针循环 */
            Uart1_Ctrl.tx_count--;  /* 减少待发送字节计数 */
        }
        else
        {
            Uart1_Ctrl.tx_busy = 0;  /* 发送完成，清除发送忙标志 */
        }
    }
}

/**
 * @brief   UART2中断服务函数
 * @param   无
 * @retval  无
 * @note    中断号8对应UART2中断，处理接收和发送中断[1](@ref)
 */
void UART2_int (void) interrupt 8
{
    if((S2CON & 1) != 0)  /* 检查UART2接收中断标志S2RI */
    {
        S2CON &= ~1;  /* 清除接收中断标志 */
        Uart2_Ctrl.rx_buffer[Uart2_Ctrl.rx_head] = S2BUF;  /* 读取接收到的数据存入缓冲区 */
        if(++Uart2_Ctrl.rx_head >= UART_BUF_LENGTH) Uart2_Ctrl.rx_head = 0;  /* 头指针循环 */
        Uart2_Ctrl.rx_ready = 1;  /* 设置接收就绪标志 */
    }

    if((S2CON & 2) != 0)  /* 检查UART2发送中断标志S2TI */
    {
        S2CON &= ~2;  /* 清除发送中断标志 */
        if(Uart2_Ctrl.tx_count > 0)  /* 如果发送缓冲区还有数据 */
        {
            S2BUF = Uart2_Ctrl.tx_buffer[Uart2_Ctrl.tx_tail];  /* 发送下一个字节 */
            if(++Uart2_Ctrl.tx_tail >= UART_BUF_LENGTH) Uart2_Ctrl.tx_tail = 0;  /* 尾指针循环 */
            Uart2_Ctrl.tx_count--;  /* 减少待发送字节计数 */
        }
        else
        {
            Uart2_Ctrl.tx_busy = 0;  /* 发送完成，清除发送忙标志 */
        }
    }
}

/**
 * @brief   处理指定UART接收到的命令并回传响应
 * @param   uart_num: 指定要处理的UART编号（1代表UART1，2代表UART2）
 * @retval  无
 * @note    此函数会检查对应UART的接收就绪标志，读取一个字节数据，
 *          并根据预定义的命令映射表发送相应的响应字节。
 *          如果接收到的数据不是预定义命令，则发送0xFF作为错误响应。
 *          该函数还根据命令调用舵机控制函数[6](@ref)[8](@ref)
 */
void UART_ProcessCommand(u8 uart_num)
{
    u8 received_data;
    u8 response_data;
    u8 is_data_ready = 0; /* 使用u8替代bool，0表示假，非0表示真 */

    /* 1. 根据UART编号选择对应的控制结构体和硬件接口 */
    switch(uart_num)
    {
        case 1:
            is_data_ready = Uart1_Ctrl.rx_ready; /* 检查UART1接收就绪标志 */
            break;
        case 2:
            is_data_ready = Uart2_Ctrl.rx_ready; /* 检查UART2接收就绪标志 */
            break;
        default:
            return; /* 无效的UART编号，直接返回 */
    }

    /* 2. 判断是否有数据就绪 */
    if(is_data_ready != 0)
    {
        /* 3. 从对应的UART读取一个字节数据 */
        if(uart_num == 1)
        {
            received_data = UART1_GetByte(); /* 从UART1接收缓冲区读取数据 */
        }
        else if(uart_num == 2)
        {
            received_data = UART2_GetByte(); /* 从UART2接收缓冲区读取数据 */
        }

        /* 4. 命令解析与响应映射 */
        switch(received_data)
        {
            case 0x01:
                response_data = 0x01;
                SetServoAngle(0);   /* 设置舵机到0度位置 */
                break;
            case 0x02:
                response_data = 0x02;
                SetServoAngle(45);  /* 设置舵机到45度位置 */
                break;
            case 0x03:
                response_data = 0x03;
                SetServoAngle(90);  /* 设置舵机到90度位置 */
                break;
            case 0x04:
                response_data = 0x04;
                SetServoAngle(135); /* 设置舵机到135度位置 */
                break;
            case 0x05:
                response_data = 0x05;
                SetServoAngle(180); /* 设置舵机到180度位置 */
                break;
            default:
                response_data = 0xFF; /* 未定义命令的默认响应 */
                break;
        }

        /* 5. 通过对应的UART发送响应字节 */
        if(uart_num == 1)
        {
            UART1_SendByte(response_data); /* 通过UART1发送响应 */
        }
        else if(uart_num == 2)
        {
            UART2_SendByte(response_data); /* 通过UART2发送响应 */
        }
    }
}
复制代码

简单快***

/**
 * @file    STC8G_H_UART1_UART2.h
 * @brief   STC8系列单片机UART1和UART2驱动头文件
 * @details 定义UART控制结构体、缓冲区大小和函数声明
 * @author  [志城]
 * @date    2025-12-24
 * @version 1.0
 */

#ifndef __STC8G_H_UART1_UART2_H__
#define __STC8G_H_UART1_UART2_H__


#include        "config.h"



#define MAIN_Fosc       22118400L
#define Baudrate1       115200UL
#define Baudrate2       115200UL
#define UART_BUF_LENGTH 64



typedef struct {
    u8  rx_buffer[UART_BUF_LENGTH];
    u8  tx_buffer[UART_BUF_LENGTH];
    u8  rx_head;
    u8  rx_tail;
    u8  tx_head;
    u8  tx_tail;
    u8  tx_count;
    u8  tx_busy;
    u8  rx_ready;
} UART_Control_t;

extern UART_Control_t xdata Uart1_Ctrl;
extern UART_Control_t xdata Uart2_Ctrl;

void UART1_config(u8 brt);
void UART2_config(u8 brt);
void SetTimer2Baudraye(u16 dat);
u8 UART1_GetByte(void);
u8 UART2_GetByte(void);
void UART1_SendByte(u8 dat);
void UART2_SendByte(u8 dat);
void UART1_SendString(u8 *str);
void UART2_SendString(u8 *str);
void UART1_int(void);
void UART2_int(void);

void UART_ProcessCommand(u8 uart_num);
#endif
复制代码

简单快***

管理别删我的帖子，我要把前几个楼占住，这样好形成一个系统。会逐步修改添加内容。

之前的被你删除了，我只好先糊代码上来占楼，还请理解。

简单快***

配套的压缩包在这里，大家别复制代码了

神***

【STCAI-万能实验板-V2.x】+ STC8H 快速入门 配套教程
可放我们论坛第一个版块，
也建议发B站：DIY 学 最强 51-MCU