用AI让全民进入单片机工程师，太刺激了！

xiaodaishu · 发表于 2 小时前

本帖最后由 xiaodaishu 于 2026-10-14 22:06 编辑

用AI让全民进入单片机工程师，太刺激了！就是不知道是不是一本正经的胡说八道。

问：利用N76E003AT20严格按照国标流程生成新能源充电桩充电控制代码，要求车辆正确连接后闭合继电器开始充电，代码中包含注释

接下来AI开始一本正经的贴心回答了。

基于 N76E003AT20 的 GB/T 18487.1 交流充电桩控制代码

交流充电桩的控制导引流程严格遵循 GB/T 18487.1 定义的状态机模型。N76E003AT20 内置 12位 ADC（8通道），使其能够直接对 CP 检测点 1 的电压进行采样，通过软件判断状态迁移，无需外接比较器。这是相比 STC15F104W 的核心优势。

国标充电流程（状态 2 → 状态 3）

根据 GB/T 18487.1—2023，供电设备侧的关键状态迁移如下：

状态 2（车辆已连接，PWM 输出）：CP 电压为 9V（车辆未闭合 S2）。供电设备检测点 1 电压 = 9V，说明车辆已通过 CC 电阻确认连接，但尚未准备就绪。

状态 2 → 状态 3（车辆准备就绪）：车辆控制装置闭合 S2 开关，R2 电阻并联接入，检测点 1 电压被拉低至 6V。供电设备检测到 6V 后，应在 3 秒内闭合交流供电回路（继电器 K1/K2）。

充电中（状态 3'）：PWM 持续输出，供电设备检测点 1 保持 6V 状态，能量传输开始。

停止充电：车辆断开 S2 或供电设备切换 PWM 至 +12V 电平后，检测点 1 回到 9V 或 12V，供电设备在 100ms 内断开继电器。

硬件引脚分配

电压映射说明：CP 信号在 +12V / +9V / +6V 之间切换。分压电路建议将 +12V 映射至约 4.0V ADC 满量程附近，对应 ADC 值约 3276（12位）；+9V 约 2458；+6V 约 1638。具体分压电阻值需根据实际硬件调整。
完整代码

/*

* N76E003AT20 交流充电桩控制程序

* 严格遵循 GB/T 18487.1—2023 交流充电控制导引流程

*

* 核心状态机：

* 状态2 (9V)  -> 车辆已连接，PWM输出，等待车辆准备就绪

* 状态3 (6V)  -> 车辆已闭合S2，供电设备应在3s内闭合继电器

* 状态3'    -> 能量传输中，持续监测CP电压

* 断开       -> CP电压异常/故障，100ms内断开继电器

*

* ADC采样：检测点1 (CP-PE电压经分压后送入AIN0)

* +12V -> ADC约3276  (车辆未连接)

* +9V  -> ADC约2458  (车辆已连接，状态2)

* +6V  -> ADC约1638  (车辆准备就绪，状态3)

* 0V -> ADC约0    (故障/断开)

*/

#include "N76E003.h"

#include "SFR_Macro.h"

#include "Function_define.h"

#include "Common.h"

#include "Delay.h"

// ========== 电压阈值定义（12位ADC原始值） ==========

#define CP_ADC_12V    3100 // +12V 下限

#define CP_ADC_9V_H    2600 // +9V 上限

#define CP_ADC_9V_L    2300 // +9V 下限

#define CP_ADC_6V_H    1900 // +6V 上限

#define CP_ADC_6V_L    1400 // +6V 下限

#define CP_ADC_0V    800    // 接近0V

// ========== 引脚定义 ==========

sbit RELAY    = P1^0; // 继电器控制（高电平吸合）

sbit FAULT_IN  = P1^1; // 故障输入（低有效）

sbit LED    = P1^2; // 状态指示

// ========== 全局变量 ==========

volatile unsigned int pwm_duty = 100; // PWM占空比寄存器值（默认约10% -> 6A）

volatile unsigned char charge_state = 0;// 0=待机, 1=状态2, 2=状态3充电中

volatile unsigned int  adc_val = 0;    // CP电压ADC采样值

// ========== 函数声明 ==========

void System_Init(void);

void PWM_Init(void);

void ADC_Init(void);

unsigned int ADC_Read_CP(void);

void Set_Charging_Current(unsigned char amps);

void Delay_ms(unsigned int ms);

// ========== 主函数 ==========

void main(void)

{

unsigned int  cp_adc;

unsigned char conn_cnt = 0;    // 状态2持续时间计数（确认连接稳定）

unsigned char s2_cnt = 0;       // 6V持续时间计数（确认车辆就绪）

System_Init();

// 初始状态：PWM输出，继电器断开，LED常亮（待机）

RELAY = 0;

LED = 0;

charge_state = 0;

while(1)

{

      // ---- 故障检测（最高优先级）----

      if(FAULT_IN == 0)

      {

         RELAY = 0;             // 立即断开继电器

         LED = 1;                // LED常亮表示故障

         charge_state = 0;

         conn_cnt = 0;

         s2_cnt = 0;

         Delay_ms(10);

         continue;

      }



      // ---- 读取CP检测点1电压 ----

      cp_adc = ADC_Read_CP();

      adc_val = cp_adc;



      // ---- 状态判断（带延时确认，避免抖动误判）----



      if(cp_adc > CP_ADC_9V_L && cp_adc < CP_ADC_9V_H)

      {

         // 检测到 +9V：车辆已连接，处于状态2

         // 此时车辆已通过CC确认连接，但S2未闭合

         if(conn_cnt < 100) conn_cnt++; // 持续约100ms确认

         if(conn_cnt >= 50)             // 约50ms稳定后

         {

            charge_state = 1;          // 进入状态2

            RELAY = 0;                // 确保继电器断开

            LED = ~LED;                // LED闪烁表示已连接

         }

      }

      else if(cp_adc > CP_ADC_6V_L && cp_adc < CP_ADC_6V_H)

      {

         // 检测到 +6V：车辆已闭合S2，进入状态3

         // GB/T 18487.1 要求供电设备在3s内闭合交流回路[citation:14]

         if(s2_cnt < 150) s2_cnt++;    // 持续约150ms确认

         if(s2_cnt >= 100 && charge_state == 1)

         {

            // 车辆准备就绪，闭合继电器开始充电

            RELAY = 1;                // **闭合继电器，输出交流电**

            charge_state = 2;          // 状态3：能量传输

            LED = 0;                   // LED常灭或常亮表示充电中

         }

      }

      else if(cp_adc > CP_ADC_12V)

      {

         // +12V：车辆未连接或已拔出

         RELAY = 0;                      // 断开继电器

         charge_state = 0;

         conn_cnt = 0;

         s2_cnt = 0;

         LED = 0;                      // LED灭

      }

      else

      {

         // 电压异常（接近0V或超出有效范围）：视为故障/断开

         // 能量传输阶段发生，应在100ms内断开回路[citation:30]

         RELAY = 0;

         charge_state = 0;

         conn_cnt = 0;

         s2_cnt = 0;

      }



      Delay_ms(5); // 主循环周期约5ms

}

}

// ========== 系统初始化 ==========

void System_Init(void)

{

// 时钟：使用内部16MHz高速RC振荡器

set_OSC1(OSC_HIRC);

// 引脚模式配置

// P1.5 (PWM0) 设为推挽输出

P1M1 &= ~0x20;  P1M0 |=  0x20;

// P1.0 (RELAY) 推挽输出

P1M1 &= ~0x01;  P1M0 |=  0x01;

// P1.1 (FAULT_IN) 输入模式（高阻）

P1M1 |=  0x02;  P1M0 &= ~0x02;

// P1.2 (LED) 推挽输出

P1M1 &= ~0x04;  P1M0 |=  0x04;

// P0.0 (AIN0) 输入模式（ADC）

P0M1 |=  0x01;  P0M0 &= ~0x01;

PWM_Init();

ADC_Init();

// 设置默认充电电流 6A -> 占空比 10%

Set_Charging_Current(6);

}

// ========== PWM初始化 ==========

// 使用硬件PWM0，频率1kHz，占空比由PWM0L/PWM0H寄存器控制

// N76E003 PWM时钟源为系统时钟分频

void PWM_Init(void)

{

// PWM时钟 = Fsys / (PWMCKS[3:0]+1)，设Fsys=16MHz

// 周期 = 1ms -> 16000个时钟

// PWM周期寄存器 PWMPH/PWMPL = 16000 - 1 = 15999

PWMEN = 0x00;          // 先关闭PWM

PWMCLK = 0x00;       // PWM时钟 = 系统时钟

PWMCKS = 0x00;       // 不分频 -> 16MHz

// 设置PWM周期（16位，高字节在前）

PWMPH = (15999 >> 8) & 0xFF;

PWMPL = 15999 & 0xFF;

// 设置默认占空比（约10% -> 1600）

PWM0H = (1600 >> 8) & 0xFF;

PWM0L = 1600 & 0xFF;

// 配置PWM0输出引脚为P1.5

PWM0_P15 = 1;          // PWM0映射到P1.5

PWMEN = 0x01;          // 使能PWM0输出

}

// ========== ADC初始化 ==========

// 12位ADC，选择AIN0（P0.0），单次转换模式

void ADC_Init(void)

{

ADCCON1 = 0x00;       // ADC时钟分频 = 1

ADCCON2 = 0x00;       // 参考电压 = VDD

ADCCON0 = 0x00;       // 清除标志，AIN0选择

AINDIDS = 0x01;       // 使能AIN0数字输入禁用（模拟输入）

// 选择ADC通道0

ADCCON0 &= ~0x0F;    // ADCHS = 0000 -> AIN0

}

// ========== 读取CP电压（ADC采样） ==========

unsigned int ADC_Read_CP(void)

{

unsigned int result;

ADCCON0 &= ~0x0F;    // 确保选择AIN0

ADCCON0 |= 0x40;       // 启动ADC转换（ADCS=1）

// 等待转换完成（ADCF标志置位）

while(!(ADCCON0 & 0x80));

// 读取12位结果

result = (ADCRH << 4) | (ADCRL & 0x0F);

ADCCON0 &= ~0x80;    // 清除ADCF标志

return result;

}

// ========== 设置充电电流（PWM占空比） ==========

// 依据 GB/T 18487.1 表 A.3：I = Duty% / 0.6

// 10% -> 6A, 16.7% -> 10A, 26.7% -> 16A, 53.3% -> 32A

void Set_Charging_Current(unsigned char amps)

{

unsigned long duty_percent;

unsigned int  duty_reg;

if(amps < 6)  amps = 6;

if(amps > 63) amps = 63;

// Duty% = amps / 0.6 = amps * 10 / 6

duty_percent = (unsigned long)amps * 10 / 6;

// 占空比寄存器值 = 16000 * Duty% / 100

duty_reg = (unsigned int)((unsigned long)16000 * duty_percent / 100);

// 限制不超过96%

if(duty_reg > 15360) duty_reg = 15360;

PWM0H = (duty_reg >> 8) & 0xFF;

PWM0L = duty_reg & 0xFF;

}

// ========== 毫秒级延时（粗略） ==========

void Delay_ms(unsigned int ms)

{

unsigned int i, j;

for(i = 0; i < ms; i++)

      for(j = 0; j < 1600; j++);  // 16MHz下约1ms

}
复制代码

关键设计说明
ADC 采样与状态判断：代码通过 ADC 读取检测点 1 电压，依据 GB/T 18487.1 定义的状态电压进行阈值判断。9V 对应状态 2（车辆已连接但未就绪），6V 对应状态 3（车辆已闭合 S2，准备就绪）。每个状态判断都加入了持续确认计数（conn_cnt、s2_cnt），避免电压抖动导致继电器误动作。
继电器闭合时序：国标要求供电设备在检测到 6V（车辆准备就绪）后 3 秒内闭合交流回路。代码中 s2_cnt >= 100 对应约 150ms 的确认延时，远小于 3 秒限制，同时提供了足够的抗干扰能力。
断开保护的实时性：能量传输阶段若 CP 电压异常（如断路或车辆拔出），代码在主循环中以约 5ms 周期检测，确保能在 100ms 内断开继电器，满足国标对故障断开时间的要求。
PWM 占空比与电流：N76E003 的硬件 PWM 模块输出稳定，占空比公式遵循 I = Duty% × 0.6。例如默认 6A 对应约 10% 占空比。实际部署时，需根据充电桩额定功率通过 Set_Charging_Current() 设置合适值。
硬件设计要点：CP 信号为 ±12V，必须经精密分压电路后送入 ADC。建议使用高精度电阻（1% 或更好），并在 ADC 输入端加 RC 低通滤波（如 10kΩ + 100nF）抑制 PWM 纹波对采样的干扰。继电器驱动需使用三极管或光耦隔离，线圈两端必须并联续流二极管。

修改为 32A 充电电流的 N76E003AT20 充电桩代码
根据 GB/T 18487.1 的电流映射公式 I = Duty% × 0.6A，32A 对应的 PWM 占空比为：
Duty% = 32 / 0.6 = 53.33%
复制代码
N76E003 的 PWM 周期寄存器设为 16000（对应 1ms @ 16MHz），因此 32A 对应的占空比寄存器值约为：
Duty_REG = 16000 × 53.33% ≈ 8533
复制代码
修改点说明
只需修改以下三处即可将充电电流从 6A 切换为 32A：
1. 主函数初始化处的默认电流设置
// 原代码

Set_Charging_Current(6); // 默认 6A

// 修改为

Set_Charging_Current(32);  // 默认 32A
复制代码
2. PWM 初始化中的默认占空比寄存器值
// 原代码：默认约10% -> 1600

PWM0H = (1600 >> 8) & 0xFF;

PWM0L = 1600 & 0xFF;

// 修改为：32A 对应 53.33% -> 8533

PWM0H = (8533 >> 8) & 0xFF;

PWM0L = 8533 & 0xFF;
复制代码
3. pwm_duty 全局变量初值
// 原代码

volatile unsigned int pwm_duty = 100; // 默认约10% -> 6A

// 修改为

volatile unsigned int pwm_duty = 8533;  // 32A 对应 53.33%
复制代码
完整修改后代码

/*

* N76E003AT20 交流充电桩控制程序 —— 32A 版本

* 严格遵循 GB/T 18487.1—2023 交流充电控制导引流程

*

* 充电电流：32A

* PWM占空比：53.33%（Duty% = 32 / 0.6）

* PWM周期：16000 (1kHz @ 16MHz)

* 占空比寄存器值：8533

*

* 核心状态机：

* 状态2 (9V)  -> 车辆已连接，PWM输出，等待车辆准备就绪

* 状态3 (6V)  -> 车辆已闭合S2，供电设备应在3s内闭合继电器

* 状态3'    -> 能量传输中，持续监测CP电压

* 断开       -> CP电压异常/故障，100ms内断开继电器

*/

#include "N76E003.h"

#include "SFR_Macro.h"

#include "Function_define.h"

#include "Common.h"

#include "Delay.h"

// ========== 充电参数定义 ==========

#define CHARGE_CURRENT  32    // 充电电流 32A

#define PWM_PERIOD_VAL  16000 // PWM周期计数值（1kHz @ 16MHz）

// Duty% = 32 / 0.6 = 53.33%  ->  16000 * 53.33% ≈ 8533

#define PWM_DUTY_32A 8533 // 32A 对应占空比寄存器值

// ========== 电压阈值定义（12位ADC原始值） ==========

#define CP_ADC_12V    3100 // +12V 下限

#define CP_ADC_9V_H    2600 // +9V 上限

#define CP_ADC_9V_L    2300 // +9V 下限

#define CP_ADC_6V_H    1900 // +6V 上限

#define CP_ADC_6V_L    1400 // +6V 下限

#define CP_ADC_0V    800    // 接近0V

// ========== 引脚定义 ==========

sbit RELAY    = P1^0; // 继电器控制（高电平吸合）

sbit FAULT_IN  = P1^1; // 故障输入（低有效）

sbit LED    = P1^2; // 状态指示

// ========== 全局变量 ==========

volatile unsigned int pwm_duty = PWM_DUTY_32A;  // 32A 占空比

volatile unsigned char charge_state = 0;

volatile unsigned int  adc_val = 0;

// ========== 函数声明 ==========

void System_Init(void);

void PWM_Init(void);

void ADC_Init(void);

unsigned int ADC_Read_CP(void);

void Set_Charging_Current(unsigned char amps);

void Delay_ms(unsigned int ms);

// ========== 主函数 ==========

void main(void)

{

unsigned int  cp_adc;

unsigned char conn_cnt = 0;

unsigned char s2_cnt = 0;

System_Init();

RELAY = 0;

LED = 0;

charge_state = 0;

while(1)

{

      // ---- 故障检测（最高优先级）----

      if(FAULT_IN == 0)

      {

         RELAY = 0;

         LED = 1;

         charge_state = 0;

         conn_cnt = 0;

         s2_cnt = 0;

         Delay_ms(10);

         continue;

      }



      // ---- 读取CP检测点1电压 ----

      cp_adc = ADC_Read_CP();

      adc_val = cp_adc;



      // ---- 状态判断 ----

      if(cp_adc > CP_ADC_9V_L && cp_adc < CP_ADC_9V_H)

      {

         // +9V：车辆已连接，状态2

         if(conn_cnt < 100) conn_cnt++;

         if(conn_cnt >= 50)

         {

            charge_state = 1;

            RELAY = 0;

            LED = ~LED;

         }

      }

      else if(cp_adc > CP_ADC_6V_L && cp_adc < CP_ADC_6V_H)

      {

         // +6V：车辆已闭合S2，准备就绪，进入状态3

         if(s2_cnt < 150) s2_cnt++;

         if(s2_cnt >= 100 && charge_state == 1)

         {

            RELAY = 1;             // 闭合继电器，32A充电开始

            charge_state = 2;

            LED = 0;

         }

      }

      else if(cp_adc > CP_ADC_12V)

      {

         // +12V：车辆未连接

         RELAY = 0;

         charge_state = 0;

         conn_cnt = 0;

         s2_cnt = 0;

         LED = 0;

      }

      else

      {

         // 电压异常：故障/断开

         RELAY = 0;

         charge_state = 0;

         conn_cnt = 0;

         s2_cnt = 0;

      }



      Delay_ms(5);

}

}

// ========== 系统初始化 ==========

void System_Init(void)

{

set_OSC1(OSC_HIRC);

P1M1 &= ~0x20;  P1M0 |=  0x20; // P1.5 PWM推挽

P1M1 &= ~0x01;  P1M0 |=  0x01; // P1.0 RELAY推挽

P1M1 |=  0x02;  P1M0 &= ~0x02; // P1.1 FAULT输入

P1M1 &= ~0x04;  P1M0 |=  0x04; // P1.2 LED推挽

P0M1 |=  0x01;  P0M0 &= ~0x01; // P0.0 AIN0输入

PWM_Init();

ADC_Init();

// 设置充电电流为 32A

Set_Charging_Current(CHARGE_CURRENT);

}

// ========== PWM初始化（32A -> 53.33%） ==========

void PWM_Init(void)

{

PWMEN = 0x00;

PWMCLK = 0x00;

PWMCKS = 0x00;

// PWM周期 = 16000 -> 1kHz @ 16MHz

PWMPH = (PWM_PERIOD_VAL >> 8) & 0xFF;

PWMPL = PWM_PERIOD_VAL & 0xFF;

// 32A 占空比 = 8533

PWM0H = (PWM_DUTY_32A >> 8) & 0xFF;

PWM0L = PWM_DUTY_32A & 0xFF;

PWM0_P15 = 1;

PWMEN = 0x01;

}

// ========== ADC初始化 ==========

void ADC_Init(void)

{

ADCCON1 = 0x00;

ADCCON2 = 0x00;

ADCCON0 = 0x00;

AINDIDS = 0x01;

ADCCON0 &= ~0x0F;

}

// ========== 读取CP电压 ==========

unsigned int ADC_Read_CP(void)

{

unsigned int result;

ADCCON0 &= ~0x0F;

ADCCON0 |= 0x40;

while(!(ADCCON0 & 0x80));

result = (ADCRH << 4) | (ADCRL & 0x0F);

ADCCON0 &= ~0x80;

return result;

}

// ========== 设置充电电流 ==========

// 32A -> Duty% = 32 * 10 / 6 = 53.33%

// 占空比寄存器 = 16000 * 53.33% = 8533

void Set_Charging_Current(unsigned char amps)

{

unsigned long duty_percent;

unsigned int  duty_reg;

if(amps < 6)  amps = 6;

if(amps > 63) amps = 63;

duty_percent = (unsigned long)amps * 10 / 6;

duty_reg = (unsigned int)((unsigned long)PWM_PERIOD_VAL * duty_percent / 100);

if(duty_reg > 15360) duty_reg = 15360;

PWM0H = (duty_reg >> 8) & 0xFF;

PWM0L = duty_reg & 0xFF;

pwm_duty = duty_reg;

}

// ========== 毫秒延时 ==========

void Delay_ms(unsigned int ms)

{

unsigned int i, j;

for(i = 0; i < ms; i++)

      for(j = 0; j < 1600; j++);

}
复制代码

/*

* N76E003AT20 交流充电桩控制程序 —— 多档位可调版本

* 严格遵循 GB/T 18487.1—2023 交流充电控制导引流程

*

* 充电电流档位（按键循环切换）：

* 档位 0: 8A  -> Duty 13.33% -> 占空比寄存器 2133 -> LED1亮

* 档位 1: 16A -> Duty 26.67% -> 占空比寄存器 4267 -> LED1+LED2亮

* 档位 2: 32A -> Duty 53.33% -> 占空比寄存器 8533 -> LED1+LED2+LED3亮

*

* 初始档位：8A（档位0）

*

* 核心状态机：

* 状态2 (9V)  -> 车辆已连接，PWM输出，等待车辆准备就绪

* 状态3 (6V)  -> 车辆已闭合S2，供电设备应在3s内闭合继电器

* 状态3'    -> 能量传输中，持续监测CP电压

* 断开       -> CP电压异常/故障，100ms内断开继电器

*

* 注意：档位切换仅在未充电（继电器断开）时生效，

*    充电中按键切换需先断开继电器，避免带载切换电流档位。

*/

#include "N76E003.h"

#include "SFR_Macro.h"

#include "Function_define.h"

#include "Common.h"

#include "Delay.h"

// ========== 充电档位参数 ==========

#define PWM_PERIOD_VAL  16000 // PWM周期（1kHz @ 16MHz）

// 8A  -> Duty% = 8/0.6  = 13.33%  -> 16000*0.1333 ≈ 2133

#define PWM_DUTY_8A    2133

// 16A -> Duty% = 16/0.6 = 26.67%  -> 16000*0.2667 ≈ 4267

#define PWM_DUTY_16A 4267

// 32A -> Duty% = 32/0.6 = 53.33%  -> 16000*0.5333 ≈ 8533

#define PWM_DUTY_32A 8533

// ========== 电压阈值定义（12位ADC原始值） ==========

#define CP_ADC_12V    3100 // +12V 下限

#define CP_ADC_9V_H    2600 // +9V 上限

#define CP_ADC_9V_L    2300 // +9V 下限

#define CP_ADC_6V_H    1900 // +6V 上限

#define CP_ADC_6V_L    1400 // +6V 下限

#define CP_ADC_0V    800    // 接近0V

// ========== 引脚定义 ==========

sbit RELAY    = P1^0; // 继电器控制（高电平吸合）

sbit FAULT_IN  = P1^1; // 故障输入（低有效）

sbit LED1    = P1^2; // 指示灯1（档位0/1/2 都亮）

sbit KEY    = P1^3; // 按键输入（低有效）

sbit LED2    = P1^4; // 指示灯2（档位1/2 亮）

sbit LED3    = P1^6; // 指示灯3（仅档位2 亮）

// ========== 全局变量 ==========

volatile unsigned int pwm_duty = PWM_DUTY_8A; // 当前占空比

volatile unsigned char charge_state = 0;

volatile unsigned int  adc_val = 0;

volatile unsigned char current_gear = 0;       // 当前档位 0/1/2

// ========== 函数声明 ==========

void System_Init(void);

void PWM_Init(void);

void ADC_Init(void);

unsigned int ADC_Read_CP(void);

void Set_Charging_Current(unsigned char amps);

void Apply_Gear(unsigned char gear);

void Update_LEDs(unsigned char gear);

void Delay_ms(unsigned int ms);

unsigned char Key_Scan(void);

// ========== 主函数 ==========

void main(void)

{

unsigned int  cp_adc;

unsigned char conn_cnt = 0;

unsigned char s2_cnt = 0;

unsigned char key_pressed;

System_Init();

RELAY = 0;

charge_state = 0;

current_gear = 0;             // 初始档位 0（8A）

Apply_Gear(current_gear);    // 应用初始档位

Update_LEDs(current_gear);    // 点亮对应指示灯

while(1)

{

      // ---- 按键扫描（切换档位）----

      key_pressed = Key_Scan();

      if(key_pressed)

      {

         // 仅在继电器断开（未充电）时允许切换档位

         // 避免带载切换电流档位造成冲击

         if(RELAY == 0)

         {

            current_gear++;

            if(current_gear > 2) current_gear = 0; // 循环 0->1->2->0

            Apply_Gear(current_gear);             // 切换PWM占空比

            Update_LEDs(current_gear);             // 更新指示灯

         }

      }



      // ---- 故障检测（最高优先级）----

      if(FAULT_IN == 0)

      {

         RELAY = 0;

         charge_state = 0;

         conn_cnt = 0;

         s2_cnt = 0;

         // 故障时指示灯快速闪烁（此处用全部点亮表示故障）

         LED1 = 0; LED2 = 0; LED3 = 0;

         Delay_ms(10);

         continue;

      }



      // ---- 读取CP检测点1电压 ----

      cp_adc = ADC_Read_CP();

      adc_val = cp_adc;



      // ---- 状态判断 ----

      if(cp_adc > CP_ADC_9V_L && cp_adc < CP_ADC_9V_H)

      {

         // +9V：车辆已连接，状态2

         if(conn_cnt < 100) conn_cnt++;

         if(conn_cnt >= 50)

         {

            charge_state = 1;

            RELAY = 0;                   // 状态2保持继电器断开

         }

      }

      else if(cp_adc > CP_ADC_6V_L && cp_adc < CP_ADC_6V_H)

      {

         // +6V：车辆闭合S2，准备就绪，进入状态3

         if(s2_cnt < 150) s2_cnt++;

         if(s2_cnt >= 100 && charge_state == 1)

         {

            RELAY = 1;                   // **闭合继电器，开始充电**

            charge_state = 2;

            // 充电中指示灯保持显示当前档位

            Update_LEDs(current_gear);

         }

      }

      else if(cp_adc > CP_ADC_12V)

      {

         // +12V：车辆未连接

         RELAY = 0;

         charge_state = 0;

         conn_cnt = 0;

         s2_cnt = 0;

         Update_LEDs(current_gear);       // 待机仍显示当前档位

      }

      else

      {

         // 电压异常：故障/断开

         RELAY = 0;

         charge_state = 0;

         conn_cnt = 0;

         s2_cnt = 0;

      }



      Delay_ms(5);

}

}

// ========== 系统初始化 ==========

void System_Init(void)

{

set_OSC1(OSC_HIRC);

// PWM输出 P1.5 推挽

P1M1 &= ~0x20;  P1M0 |=  0x20;

// 继电器 P1.0 推挽

P1M1 &= ~0x01;  P1M0 |=  0x01;

// 故障输入 P1.1 输入

P1M1 |=  0x02;  P1M0 &= ~0x02;

// LED1 P1.2 推挽

P1M1 &= ~0x04;  P1M0 |=  0x04;

// 按键 P1.3 输入（启用内部上拉）

P1M1 &= ~0x08;  P1M0 &= ~0x08;

// LED2 P1.4 推挽

P1M1 &= ~0x10;  P1M0 |=  0x10;

// LED3 P1.6 推挽

P1M1 &= ~0x40;  P1M0 |=  0x40;

// ADC 输入 P0.0

P0M1 |=  0x01;  P0M0 &= ~0x01;

PWM_Init();

ADC_Init();

}

// ========== PWM初始化 ==========

void PWM_Init(void)

{

PWMEN = 0x00;

PWMCLK = 0x00;

PWMCKS = 0x00;

// PWM周期 = 16000 -> 1kHz @ 16MHz

PWMPH = (PWM_PERIOD_VAL >> 8) & 0xFF;

PWMPL = PWM_PERIOD_VAL & 0xFF;

// 初始占空比 = 8A

PWM0H = (PWM_DUTY_8A >> 8) & 0xFF;

PWM0L = PWM_DUTY_8A & 0xFF;

PWM0_P15 = 1;

PWMEN = 0x01;

}

// ========== ADC初始化 ==========

void ADC_Init(void)

{

ADCCON1 = 0x00;

ADCCON2 = 0x00;

ADCCON0 = 0x00;

AINDIDS = 0x01;

ADCCON0 &= ~0x0F;

}

// ========== 读取CP电压 ==========

unsigned int ADC_Read_CP(void)

{

unsigned int result;

ADCCON0 &= ~0x0F;

ADCCON0 |= 0x40;

while(!(ADCCON0 & 0x80));

result = (ADCRH << 4) | (ADCRL & 0x0F);

ADCCON0 &= ~0x80;

return result;

}

// ========== 设置充电电流（直接计算占空比） ==========

void Set_Charging_Current(unsigned char amps)

{

unsigned long duty_percent;

unsigned int  duty_reg;

if(amps < 6)  amps = 6;

if(amps > 63) amps = 63;

duty_percent = (unsigned long)amps * 10 / 6;

duty_reg = (unsigned int)((unsigned long)PWM_PERIOD_VAL * duty_percent / 100);

if(duty_reg > 15360) duty_reg = 15360;

PWM0H = (duty_reg >> 8) & 0xFF;

PWM0L = duty_reg & 0xFF;

pwm_duty = duty_reg;

}

// ========== 应用档位（切换PWM占空比） ==========

// gear = 0 -> 8A

// gear = 1 -> 16A

// gear = 2 -> 32A

void Apply_Gear(unsigned char gear)

{

switch(gear)

{

      case 0:

         Set_Charging_Current(8); // 8A  -> 2133

         break;

      case 1:

         Set_Charging_Current(16); // 16A -> 4267

         break;

      case 2:

         Set_Charging_Current(32); // 32A -> 8533

         break;

      default:

         Set_Charging_Current(8);

         break;

}

}

// ========== 更新指示灯 ==========

// 档位0：LED1亮

// 档位1：LED1+LED2亮

// 档位2：LED1+LED2+LED3亮

// 本电路假设LED为低电平点亮（共阳接法），高电平熄灭

void Update_LEDs(unsigned char gear)

{

switch(gear)

{

      case 0:

         LED1 = 0;  LED2 = 1;  LED3 = 1; // 只亮LED1

         break;

      case 1:

         LED1 = 0;  LED2 = 0;  LED3 = 1; // 亮LED1+LED2

         break;

      case 2:

         LED1 = 0;  LED2 = 0;  LED3 = 0; // 亮LED1+LED2+LED3

         break;

      default:

         LED1 = 0;  LED2 = 1;  LED3 = 1;

         break;

}

}

// ========== 按键扫描（带消抖） ==========

// 返回 1 表示检测到一次有效按下，否则返回 0

unsigned char Key_Scan(void)

{

static unsigned char key_lock = 0; // 按键锁存，防止连按

unsigned char ret = 0;

if(KEY == 0)       // 检测到低电平（按下）

{

      if(key_lock == 0)

      {

         Delay_ms(20);  // 消抖延时

         if(KEY == 0) // 再次确认按下

         {

            ret = 1;

            key_lock = 1;

         }

      }

}

else

{

      key_lock = 0;    // 松开后释放锁

}

return ret;

}

// ========== 毫秒延时 ==========

void Delay_ms(unsigned int ms)

{

unsigned int i, j;

for(i = 0; i < ms; i++)

      for(j = 0; j < 1600; j++);

}
复制代码

真是太厉害了，真这样小白也能成为工程师啦，哈哈