#include "ls_system.h"
#include <stdio.h>
#include "write_analog.h"
#include "hv_voltage_ctrl.h"
#include <math.h>
#include "ls_spi.h"
#include "ls_io_ctrl.h"
#include "delay.h"
#include "hal_spi.h"
#include "hal_gpio.h"
#include "hal_rcc.h"
#include "mm32_device.h"
// 全局系统状态
static hv_system_status_t g_hv_sys_status = {0};
// -------------------------- 静态函数声明 --------------------------
static WriteAnalog_t* get_write_analog_instance(uint8_t module_id); // 获取对应模块的DAC实例
static bool check_module_version(uint8_t module_id); // 检查模块版本号
static void reset_all_modules(void); // 复位所有模块
// -------------------------- 公共函数实现 -------------------------
/*********************** 测试函数:模块1输出50V ***********************/
hv_error_t hv_test_module1_output_50v(void) {
// 1. 初始化高压系统(确保SPI/DAC/IO已初始化)
hv_error_t ret = hv_voltage_init();
if (ret != HV_ERR_SUCCESS) {
return ret;
}
// 2. 安全优先:关闭所有模块的输出和使能
hv_voltage_shutdown();
DELAY_Ms(100); // 等待电压泄放
// 3. 配置模块1输出50V
uint8_t target_module = 1; // 仅用模块1
float target_vol = 50.0f; // 目标电压50V
hv_module_status_t* module = &g_hv_sys_status.modules[target_module - 1];
WriteAnalog_t* analog = get_write_analog_instance(target_module);
DacIcDev_t* dac_dev = &xDacIcDev1 + (target_module - 1);
// 校验模块/DAC实例有效性
if (analog == NULL || dac_dev == NULL) {
hv_voltage_shutdown();
return HV_ERR_MODULE_INVALID;
}
// 4. 计算50V对应的DAC值(12位DAC,范围0~4095)
uint16_t dac_val = (uint16_t)(target_vol * DAC_VOLTAGE_TO_VALUE);
dac_val = (dac_val > 4095) ? 4095 : dac_val; // 限制最大值
// 计算结果:50 * 33.42857142857 = 1671.428 → 取整1671(有效范围,无溢出)
// 5. 发送DAC指令配置模块1电压
analog->vInit(analog, dac_dev); // 初始化模块1的DAC
analog->vSetA(analog, dac_val); // 设置DAC值
// 6. 使能模块1并等待电压稳定
hv_set_s1_ex(target_module, 1); // 使能模块1
DELAY_Ms(500); // 模块电压稳定延时
// 7. 打开模块1的高压输出
hv_set_s2_ex(target_module, 1);
DELAY_Ms(200); // 输出稳定延时
// 8. 更新系统状态
module->target_voltage = target_vol;
module->dac_value = dac_val;
module->is_enabled = true;
g_hv_sys_status.active_module_cnt = 1;
g_hv_sys_status.total_target_voltage = target_vol;
// 9. 验证实际输出电压(误差±5%以内)
float actual_vol = 0.0f;
ret = hv_read_total_voltage(&actual_vol);
if (ret != HV_ERR_SUCCESS) {
hv_voltage_shutdown();
return HV_ERR_ADC_READ_FAILED;
}
// 校验电压误差(50V±5% → 47.5V ~ 52.5V)
if (fabsf(actual_vol - target_vol) > target_vol * 0.05f) {
hv_voltage_shutdown();
return HV_ERR_MODULE_FAULT;
}
// 10. 输出成功日志
printf("Module 1 output 50V success! Actual voltage: %.2fV\n", actual_vol);
return HV_ERR_SUCCESS;
}
/******************一、高压系统初始化 hv_voltage_init-************************ */
hv_error_t hv_voltage_init(void) {
// 1. 初始化驱动层SPI
spi_dac_global_init();
// 2. 初始化5个模块的DAC上层控制
for (uint8_t i = 0; i < HV_MODULE_COUNT; i++) {
WriteAnalog_t* analog = get_write_analog_instance(i + 1);
if (analog == NULL) return HV_ERR_MODULE_INVALID;
// 初始化DAC
analog->vInit(analog, &xDacIcDev1 + i);
hv_set_s1_ex(i + 1, 0); // 禁用模块
hv_set_s2_ex(i + 1, 0); // 关闭高压输出
}
// 3. 复位系统状态
reset_all_modules();
return HV_ERR_SUCCESS;
}
/**********************二、设置总目标电压*****************************/
hv_error_t hv_set_voltage(float vol) {
// 1. 参数合法性校验
if (vol < HV_MODULE_MIN_VOLTAGE) {
return HV_ERR_VOLTAGE_LOW;
}
if (vol > HV_TOTAL_MAX_VOLTAGE) {
return HV_ERR_VOLTAGE_HIGH;
}
// 2. 计算需要的模块数量(向上取整)
uint8_t modules_needed = (uint8_t)ceilf(vol / HV_MODULE_MAX_VOLTAGE);
float voltage_per_module = vol / modules_needed;
// 3. 确保每个模块电压不低于最小值(不足则增加模块数)
if (voltage_per_module < HV_MODULE_MIN_VOLTAGE) {
modules_needed = (uint8_t)ceilf(vol / HV_MODULE_MIN_VOLTAGE);
voltage_per_module = vol / modules_needed;
// 再次校验(避免极端情况)
if (modules_needed > HV_MODULE_COUNT || voltage_per_module < HV_MODULE_MIN_VOLTAGE) {
return HV_ERR_MODULE_INVALID;
}
}
// 4. 先关闭所有高压输出和模块使能(安全优先)
for (uint8_t i = 0; i < HV_MODULE_COUNT; i++) {
hv_set_s2_ex(i + 1, 0);
hv_set_s1_ex(i + 1, 0);
g_hv_sys_status.modules[i].is_enabled = false;
g_hv_sys_status.modules[i].is_faulty = false;
}
DELAY_Ms(100); // 等待电压泄放
// 5. 配置每个启用的模块
float total_calc_vol = 0.0f;
for (uint8_t i = 0; i < modules_needed; i++) {
hv_module_status_t* module = &g_hv_sys_status.modules[i];
WriteAnalog_t* analog = get_write_analog_instance(i + 1);
DacIcDev_t* dac_dev = &xDacIcDev1 + i;
if (analog == NULL || dac_dev == NULL) {
hv_voltage_shutdown();
return HV_ERR_MODULE_INVALID;
}
// 计算当前模块电压(最后一个模块分摊剩余电压,避免误差)
float module_vol = (i == modules_needed - 1) ?
(vol - voltage_per_module * (modules_needed - 1)) :
voltage_per_module;
// 计算DAC值(12位范围限制)
uint16_t dac_val = (uint16_t)(module_vol * DAC_VOLTAGE_TO_VALUE);
dac_val = (dac_val > 4095) ? 4095 : dac_val;
// 发送DAC指令(确保DAC设备指针正确传入)
analog->vSetA(analog, dac_val);
// 更新模块状态
module->target_voltage = module_vol;
module->dac_value = dac_val;
module->is_enabled = true;
total_calc_vol += module_vol;
}
// 6. 启用模块并等待稳定
for (uint8_t i = 0; i < modules_needed; i++) {
hv_set_s1_ex(i + 1, 1); // 使能模块
}
DELAY_Ms(500); // 模块电压稳定延时
// 7. 打开高压输出
//hv_set_s2_ex(1, 1); // 优先打开第一个模块的输出
for (uint8_t i = 0; i < modules_needed; i++) {
hv_set_s2_ex(i + 1, 1);
DELAY_Ms(10); // 模块间延时
}
// 8. 更新系统状态
g_hv_sys_status.active_module_cnt = modules_needed;
g_hv_sys_status.total_target_voltage = vol;
// 9. 回读电压验证
float actual_vol = 0.0f;
if (hv_read_total_voltage(&actual_vol) != HV_ERR_SUCCESS) {
hv_voltage_shutdown();
return HV_ERR_ADC_READ_FAILED;
}
// 电压误差允许±5%
if (fabsf(actual_vol - vol) > vol * 0.05f) {
hv_voltage_shutdown();
return HV_ERR_MODULE_FAULT;
}
return HV_ERR_SUCCESS;
}
/****************三、读取总实际电压 hv_read_total_voltage******************* */
hv_error_t hv_read_total_voltage(float* actual_vol) {
if (actual_vol == NULL) return HV_ERR_ADC_READ_FAILED;
float total_vol = 0.0f;
bool read_ok = true;
// 读取每个启用模块的输出电压
for (uint8_t i = 0; i < HV_MODULE_COUNT; i++) {
hv_module_status_t* module = &g_hv_sys_status.modules[i];
if (!module->is_enabled) continue;
// 读取ADC通道1(模块输出电压)
uint16_t adc_val = hv_spi_adc_read(i + 1, 1);
float module_vol = adc_val * ADC_MODULE_VOLTAGE_COEF;
// 读取ADC通道2(高压线电压,交叉验证)
uint16_t adc_line_val = hv_spi_adc_read(i + 1, 2);
float line_vol = adc_line_val * ADC_MODULE_VOLTAGE_COEF;
// 读取ADC通道6(DAC反馈电压,验证DAC设置)
uint16_t adc_dac_val = hv_spi_adc_read(i + 1, 6);
float dac_vol = adc_dac_val * ADC_DAC_VOLTAGE_COEF;
float expected_dac_vol = module->target_voltage / (DAC_VOLTAGE_TO_VALUE * (5.0f / 4095.0f));
// 故障判断(误差超限标记故障)
if (fabsf(module_vol - module->target_voltage) > module->target_voltage * 0.1f) {
module->is_faulty = true;
read_ok = false;
}
if (fabsf(line_vol - module_vol) > module_vol * 0.1f) {
module->is_faulty = true;
read_ok = false;
}
if (fabsf(dac_vol - expected_dac_vol) > 0.5f) { // DAC反馈误差±0.5V
module->is_faulty = true;
read_ok = false;
}
module->actual_voltage = module_vol;
total_vol += module_vol;
}
*actual_vol = total_vol;
g_hv_sys_status.total_actual_voltage = total_vol;
return read_ok ? HV_ERR_SUCCESS : HV_ERR_ADC_READ_FAILED;
}
/*************************四、 读取系统状态 hv_get_system_status**************************** */
hv_error_t hv_get_system_status(hv_system_status_t* status) {
if (status == NULL) return HV_ERR_ADC_READ_FAILED;
*status = g_hv_sys_status;
return HV_ERR_SUCCESS;
}
/**************************五、高压系统自检 hv_voltage_self_test*************** */
hv_error_t hv_voltage_self_test(void) {
// 1. 复位所有模块
reset_all_modules();
DELAY_Ms(500);
// 2. 检查所有模块版本号
for (uint8_t i = 0; i < HV_MODULE_COUNT; i++) {
if (!check_module_version(i + 1)) {
g_hv_sys_status.modules[i].is_faulty = true;
hv_voltage_shutdown();
return HV_ERR_MODULE_FAULT;
}
}
// 3. 逐个模块测试(输出50V,验证电压)
for (uint8_t i = 0; i < HV_MODULE_COUNT; i++) {
uint8_t module_id = i + 1;
hv_module_status_t* module = &g_hv_sys_status.modules[i];
WriteAnalog_t* analog = get_write_analog_instance(module_id);
DacIcDev_t* dac_dev = &xDacIcDev1 + i;
if (analog == NULL || dac_dev == NULL) {
hv_voltage_shutdown();
return HV_ERR_MODULE_INVALID;
}
// 关闭所有输出
for (uint8_t j = 0; j < HV_MODULE_COUNT; j++) {
hv_set_s2_ex(j + 1, 0);
hv_set_s1_ex(j + 1, 0);
}
DELAY_Ms(500);
// 配置测试电压(50V)
float test_vol = 50.0f;
uint16_t dac_val = (uint16_t)(test_vol * DAC_VOLTAGE_TO_VALUE);
dac_val = (dac_val > 4095) ? 4095 : dac_val;
// 启用模块并发送DAC指令
hv_set_s1_ex(module_id, 1);
analog->vInit(analog, dac_dev);
analog->vSetA(analog, dac_val);
DELAY_Ms(500);
// 打开该模块的高压输出
hv_set_s2_ex(module_id, 1);
DELAY_Ms(200);
// 读取测试数据
uint16_t adc_module = hv_spi_adc_read(module_id, 1); // 模块输出电压
uint16_t adc_line = hv_spi_adc_read(module_id, 2); // 高压线电压
uint16_t adc_dac = hv_spi_adc_read(module_id, 6); // DAC反馈电压
float module_vol = adc_module * ADC_MODULE_VOLTAGE_COEF;
float line_vol = adc_line * ADC_MODULE_VOLTAGE_COEF;
float dac_vol = adc_dac * ADC_DAC_VOLTAGE_COEF;
// 故障判断(按模块说明文档逻辑)
bool module_fault = false;
if (fabsf(module_vol - test_vol) > test_vol * 0.1f &&
fabsf(line_vol - test_vol) > test_vol * 0.1f) {
if (line_vol < 100.0f) {
module_fault = true; // 高压模块-高压输入错误
} else if (fabsf(dac_vol - (test_vol / DAC_VOLTAGE_TO_VALUE * 4095.0f / 5.0f)) > 1.0f) {
module_fault = true; // 高压模块-ADC/DAC错误
} else if (line_vol > 100.0f && fabsf(dac_vol - (test_vol / DAC_VOLTAGE_TO_VALUE * 4095.0f / 5.0f)) <= 1.0f) {
module_fault = true; // 高压模块-调压错误
}
}
// 读取版本号再次验证
if (!check_module_version(module_id)) {
module_fault = true;
}
if (module_fault) {
module->is_faulty = true;
hv_set_s2_ex(module_id, 0);
hv_set_s1_ex(module_id, 0);
hv_voltage_shutdown();
return HV_ERR_MODULE_FAULT;
}
// 关闭当前模块测试
hv_set_s2_ex(module_id, 0);
hv_set_s1_ex(module_id, 0);
DELAY_Ms(100);
}
// 4. 测试通过,复位状态
reset_all_modules();
return HV_ERR_SUCCESS;
}
/***********************六、紧急停机 hv_voltage_shutdown******************************************* */
void hv_voltage_shutdown(void) {
// 关闭所有高压输出和模块使能
for (uint8_t i = 0; i < HV_MODULE_COUNT; i++) {
hv_set_s2_ex(i + 1, 0);
hv_set_s1_ex(i + 1, 0);
g_hv_sys_status.modules[i].is_enabled = false;
g_hv_sys_status.modules[i].is_faulty = false;
}
// 复位系统状态
g_hv_sys_status.active_module_cnt = 0;
g_hv_sys_status.total_target_voltage = 0.0f;
g_hv_sys_status.total_actual_voltage = 0.0f;
}
// -------------------------- 静态函数实现 --------------------------
static WriteAnalog_t* get_write_analog_instance(uint8_t module_id) {
switch (module_id) {
case 1: return &xWriteAnalog1;
case 2: return &xWriteAnalog2;
case 3: return &xWriteAnalog3;
case 4: return &xWriteAnalog4;
case 5: return &xWriteAnalog5;
default: return NULL;
}
}
static bool check_module_version(uint8_t module_id) {
// 读取ADC通道7
uint16_t adc_val = hv_spi_adc_read(module_id, 7);
float version_vol = adc_val * ADC_VERSION_COEF;
// 版本号有效范围:0.5V~2.5V
if (version_vol >= 0.5f && version_vol <= 2.5f) {
g_hv_sys_status.modules[module_id - 1].version_voltage = version_vol;
return true;
}
return false;
}
static void reset_all_modules(void) {
for (uint8_t i = 0; i < HV_MODULE_COUNT; i++) {
hv_module_status_t* module = &g_hv_sys_status.modules[i];
module->is_enabled = false;
module->target_voltage = 0.0f;
module->actual_voltage = 0.0f;
module->dac_value = 0;
module->is_faulty = false;
module->version_voltage = 0.0f;
}
g_hv_sys_status.active_module_cnt = 0;
g_hv_sys_status.total_target_voltage = 0.0f;
g_hv_sys_status.total_actual_voltage = 0.0f;
}
// -------------------------- 底层硬件接口实现 --------------------------
/************1. 控制模块使能引脚 S1_EX hv_set_s1_ex*************** */
void hv_set_s1_ex(uint8_t module_id, uint8_t enable) {
// 校验模块ID(1~5)
if (module_id < 1 || module_id > HV_MODULE_COUNT) return;
// 使用静态数组映射模块ID到IO引脚
static const io_ctrl_id_et s1_pins[HV_MODULE_COUNT] = {
IO_CTRL_HV_S1_1, // 模块1
IO_CTRL_HV_S1_2, // 模块2
IO_CTRL_HV_S1_3, // 模块3
IO_CTRL_HV_S1_4, // 模块4
IO_CTRL_HV_S1_5 // 模块5
};
io_ctrl_id_et io_id = s1_pins[module_id - 1];
static bool s1_inited[HV_MODULE_COUNT] = {false};
if (!s1_inited[module_id - 1]) {
io_ctrl.init(io_id, IO_MODE_OUTPUT_PP); // 推挽输出
s1_inited[module_id - 1] = true;
}
io_ctrl.set(io_id, enable ? IO_SET : IO_RESET);
}
/************2. 读取 ADC 值 hv_spi_adc_read********************** */
uint16_t hv_spi_adc_read(uint8_t module_id, uint8_t channel) {
// 1. 参数合法性校验
if (module_id < 1 || module_id > HV_MODULE_COUNT ||
channel < 1 || channel > 7) {
return 0;
}
// 2. 初始化ADC片选引脚
io_ctrl_id_et cs_pin;
switch(module_id) {
case 1: cs_pin = IO_CTRL_HV_ADC_DECODE0; break;
case 2: cs_pin = IO_CTRL_HV_ADC_DECODE1; break;
case 3: cs_pin = IO_CTRL_HV_ADC_DECODE2; break;
case 4: cs_pin = IO_CTRL_HV_ADC_DECODE0; break;
case 5: cs_pin = IO_CTRL_HV_ADC_DECODE1; break;
default: return 0;
}
io_ctrl.init(cs_pin, IO_MODE_OUTPUT_PP);
io_ctrl.set(cs_pin, IO_SET); // 初始高电平,未选中
// 3. 拉低片选,选中ADC
io_ctrl.set(cs_pin, IO_RESET);
//ls_sys.DELAY_Ms(1); // 片选稳定延时
// 4. 构建SPI命令
uint8_t cmd = ( (channel - 1) << 4 ) | 0x0C; // 通道选择+配置位
uint8_t rx_buf[2] = {0};
// 5. SPI收发数据(基于ls_spi库,同步发送命令并接收数据)
SPI_SendData(SPI1, cmd);
while (RESET == SPI_GetFlagStatus(SPI1, SPI_FLAG_TXEPT)); // 等待发送完成
while (RESET == SPI_GetFlagStatus(SPI1, SPI_FLAG_RXAVL)); // 等待接收完成
rx_buf[0] = SPI_ReceiveData(SPI1); // 接收高8位数据
SPI_SendData(SPI1, 0x00); // 占位字节,触发第二次接收
while (RESET == SPI_GetFlagStatus(SPI1, SPI_FLAG_TXEPT));
while (RESET == SPI_GetFlagStatus(SPI1, SPI_FLAG_RXAVL));
rx_buf[1] = SPI_ReceiveData(SPI1); // 接收低8位数据
// 6. 拉高片选,结束通信
io_ctrl.set(cs_pin, IO_SET);
// 7. 转换为12位ADC值(TLA2518输出16位,取高12位)
return ( (rx_buf[0] << 8) | rx_buf[1] ) >> 4;
}
/*********3. 控制高压输出引脚 hv_set_s2_ex************** */
void hv_set_s2_ex(uint8_t module_id, uint8_t enable) {
// 校验模块ID(1~5)
if (module_id < 1 || module_id > HV_MODULE_COUNT) return;
static bool s2_inited = false;
if (!s2_inited) {
// 初始化S2解码引脚为推挽输出
io_ctrl.init(IO_CTRL_HV_S2_DECODE0, IO_MODE_OUTPUT_PP);
io_ctrl.init(IO_CTRL_HV_S2_DECODE1, IO_MODE_OUTPUT_PP);
io_ctrl.init(IO_CTRL_HV_S2_DECODE2, IO_MODE_OUTPUT_PP);
s2_inited = true;
}
// 仅允许一个模块使能:先关闭所有,再打开目标
if (enable) {
io_ctrl.set(IO_CTRL_HV_S2_DECODE0, (module_id & 0x01) ? IO_SET : IO_RESET);
io_ctrl.set(IO_CTRL_HV_S2_DECODE1, (module_id & 0x02) ? IO_SET : IO_RESET);
io_ctrl.set(IO_CTRL_HV_S2_DECODE2, (module_id & 0x04) ? IO_SET : IO_RESET);
} else {
// 禁用时关闭所有解码引脚
io_ctrl.set(IO_CTRL_HV_S2_DECODE0, IO_RESET);
io_ctrl.set(IO_CTRL_HV_S2_DECODE1, IO_RESET);
io_ctrl.set(IO_CTRL_HV_S2_DECODE2, IO_RESET);
}
}
/************4. 延时函数实现(调用delay.h中的底层延时)*************** */
void DELAY_Ms(uint32_t ms) {
ls_sys.delay_ms(ms);
}
/************5. SPI DAC全局初始化(复用write_analog.c逻辑,补全时钟使能)*************** */
void spi_dac_global_init(void) {
GPIO_InitTypeDef GPIO_InitStruct;
SPI_InitTypeDef SPI_InitStruct;
// 1. 使能GPIO和SPI时钟(关键修复:之前注释导致外设无法工作)
RCC_AHBPeriphClockCmd(RCC_AHBENR_GPIOB, ENABLE); // PB口时钟(SPI引脚)
RCC_AHBPeriphClockCmd(RCC_AHBENR_GPIOC, ENABLE); // PC口时钟(CS引脚)
RCC_APB2PeriphClockCmd(RCC_APB2ENR_SPI1, ENABLE); // SPI1时钟
// 2. GPIO引脚复用配置(PB3=SCK, PB4=MISO, PB5=MOSI)
GPIO_PinAFConfig(GPIOB, GPIO_PinSource3, GPIO_AF_0);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource4, GPIO_AF_0);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource5, GPIO_AF_0);
// 3. CS引脚配置(PC6:推挽输出)
GPIO_StructInit(&GPIO_InitStruct);
GPIO_InitStruct.GPIO_Pin = GPIO_Pin_6;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIOC, &GPIO_InitStruct);
GPIO_SetBits(GPIOC, GPIO_Pin_6); // 初始高电平,未选中
// 4. SPI引脚配置(SCK/MOSI推挽输出,MISO浮空输入)
GPIO_StructInit(&GPIO_InitStruct);
GPIO_InitStruct.GPIO_Pin = GPIO_Pin_3 | GPIO_Pin_5; // SCK+MOSI
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(GPIOB, &GPIO_InitStruct);
GPIO_StructInit(&GPIO_InitStruct);
GPIO_InitStruct.GPIO_Pin = GPIO_Pin_4; // MISO
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_FLOATING;
GPIO_Init(GPIOB, &GPIO_InitStruct);
// 5. SPI参数配置(主机模式,8位数据,CPOL低,CPHA第2沿)
SPI_DeInit(SPI1);
SPI_StructInit(&SPI_InitStruct);
SPI_InitStruct.SPI_Mode = SPI_Mode_Master;
SPI_InitStruct.SPI_DataSize = SPI_DataSize_8b;
SPI_InitStruct.SPI_DataWidth = 8;
SPI_InitStruct.SPI_CPOL = SPI_CPOL_Low;
SPI_InitStruct.SPI_CPHA = SPI_CPHA_2Edge;
SPI_InitStruct.SPI_NSS = SPI_NSS_Soft;
SPI_InitStruct.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_64;
SPI_InitStruct.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_Init(SPI1, &SPI_InitStruct);
// 6. 启用SPI收发双向模式
SPI_BiDirectionalLineConfig(SPI1, SPI_Direction_Rx);
SPI_BiDirectionalLineConfig(SPI1, SPI_Direction_Tx);
SPI_Cmd(SPI1, ENABLE);
}
#ifndef HV_VOLTAGE_CTRL_H
#define HV_VOLTAGE_CTRL_H
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include "write_analog.h"
// -------------------------- 硬件参数宏定义 --------------------------
#define HV_MODULE_COUNT 5 // 总高压模块数
#define HV_MODULE_MIN_VOLTAGE 10.0f // 单个模块最低输出电压(V)
#define HV_MODULE_MAX_VOLTAGE 100.0f // 单个模块最高输出电压(V)
#define HV_TOTAL_MAX_VOLTAGE (HV_MODULE_COUNT * HV_MODULE_MAX_VOLTAGE) // 总最高电压(500V)
// DAC/ADC系数(来自高压电源模块说明)
#define DAC_VOLTAGE_TO_VALUE 33.42857142857f // DAC值 = 模块输出电压 × 该系数
#define ADC_MODULE_VOLTAGE_COEF 0.12332112332f // ADC通道1/2:电压 = ADC值 × 该系数
#define ADC_DAC_VOLTAGE_COEF (5.0f / 4095.0f) // ADC通道6:DAC反馈电压系数(5V参考/12位)
#define ADC_VERSION_COEF (5.0f / 4095.0f) // ADC通道7:版本号电压系数
// 错误码定义
typedef enum {
HV_ERR_SUCCESS = 0, // 成功
HV_ERR_VOLTAGE_LOW, // 电压低于最小值
HV_ERR_VOLTAGE_HIGH, // 电压高于最大值
HV_ERR_MODULE_INVALID, // 模块配置无效
HV_ERR_SPI_FAILED, // SPI通信失败
HV_ERR_ADC_READ_FAILED, // ADC读取失败
HV_ERR_MODULE_FAULT // 模块故障
} hv_error_t;
// 单个模块状态结构体
typedef struct {
bool is_enabled; // 是否启用
float target_voltage; // 目标电压(V)
float actual_voltage; // 实际电压(V)
uint16_t dac_value; // DAC设置值
bool is_faulty; // 是否故障
float version_voltage; // 版本号电压(V)
} hv_module_status_t;
// 系统整体状态结构体
typedef struct {
hv_module_status_t modules[HV_MODULE_COUNT]; // 各模块状态
uint8_t active_module_cnt; // 活跃模块数
float total_target_voltage; // 总目标电压
float total_actual_voltage; // 总实际电压
} hv_system_status_t;
// -------------------------- 外部接口声明 --------------------------
// S1_EX:模块使能(1=使能,0=禁用)
void hv_set_s1_ex(uint8_t module_id, uint8_t enable);
// S2_EX:高压输出使能(1=有效,0=无效;仅允许一个模块有效!)
void hv_set_s2_ex(uint8_t module_id, uint8_t enable);
// ADC读取(module_id:1~5;channel:1~7;返回ADC原始值)
uint16_t hv_spi_adc_read(uint8_t module_id, uint8_t channel);
// 延时函数(ms)
void DELAY_Ms(uint32_t ms);
// SPI DAC全局初始化
void spi_dac_global_init(void);
// -------------------------- 高压控制核心接口 --------------------------
/**
* @brief 高压系统初始化
* @param 无
* @return hv_error_t:错误码
*/
hv_error_t hv_voltage_init(void);
/**
* @brief 设置总目标电压
* @param vol:总目标电压(V),范围:10V ~ 500V
* @return hv_error_t:错误码
*/
hv_error_t hv_set_voltage(float vol);
/**
* @brief 读取总实际电压
* @param actual_vol:输出参数,总实际电压(V)
* @return hv_error_t:错误码
*/
hv_error_t hv_read_total_voltage(float* actual_vol);
/**
* @brief 读取系统状态
* @param status:输出参数,系统状态
* @return hv_error_t:错误码
*/
hv_error_t hv_get_system_status(hv_system_status_t* status);
/**
* @brief 高压系统自检
* @param 无
* @return hv_error_t:错误码(HV_ERR_SUCCESS=自检通过)
*/
hv_error_t hv_voltage_self_test(void);
/**
* @brief 关闭高压系统(紧急停机)
* @param 无
* @return 无
*/
void hv_voltage_shutdown(void);
/**
* @brief 测试函数:第一个模块输出50V
* @param 无
* @return hv_error_t:错误码
*/
hv_error_t hv_test_module1_output_50v(void);
#endif // HV_VOLTAGE_CTRL_H
#include <stdio.h>
#include "ls_io_ctrl.h"
#include "ls_system.h"
#include "ls_uart0.h"
#include "ls_spi.h"
#include "sys_config.h"
#include "io_comm.h" // IOͨ��Э��ͷ�ļ�
#include "led.h"
#include "task.h"
//#include "ad5322.h"
#include "tla2518_A.h"
#include "write_analog.h"
#include "delay.h"
#include "hv_voltage_ctrl.h"
#include "mm32_device.h"
#define LOG_TAG "main.c"
#define LOG_LEVEL LOG_LEVEL_VERBOSE
#include "logger.h"
//���ṹ�庯��ָ��ת��Ϊֱ�Ӻ�������
void io_ctrl_init(io_ctrl_id_et io, io_ctrl_mode_et mode)
{
io_ctrl.init(io, mode); // ����GPIO��ʼ������
}
void io_ctrl_set(io_ctrl_id_et io, mfU16_t val)
{
io_ctrl.set(io, val); // ����GPIO������?
}
io_ctrl_level_et io_ctrl_get(io_ctrl_id_et id)
{
return (io_ctrl_level_et)io_ctrl.get(id); // ��ȡGPIO������?
}
static void drv_port_init(void)
{
/***************PA*********/
io_ctrl.init(IO_CTRL_CURRENT_DECODE_0, IO_MODE_OUTPUT_PP);
io_ctrl.init(IO_CTRL_CURRENT_DECODE_1, IO_MODE_OUTPUT_PP);
io_ctrl.init(IO_CTRL_CURRENT_DECODE_2, IO_MODE_OUTPUT_PP);
io_ctrl.init(IO_CTRL_SELF_CHECK_CURRENT,IO_MODE_OUTPUT_PP);
io_ctrl.init(IO_CTRL_STATE_LED4,IO_MODE_OUTPUT_PP);
io_ctrl.init(IO_CTRL_LED,IO_MODE_OUTPUT_PP);
io_ctrl.set(IO_CTRL_SELF_CHECK_CURRENT, IO_SET);//
io_ctrl.set(IO_CTRL_CURRENT_DECODE_0, IO_SET);
io_ctrl.set(IO_CTRL_CURRENT_DECODE_1,IO_SET);
io_ctrl.set(IO_CTRL_CURRENT_DECODE_2, IO_SET);
io_ctrl.set(IO_CTRL_STATE_LED4,IO_SET);
io_ctrl.set(IO_CTRL_LED,IO_SET);
/***********PB***********/
io_ctrl.init(IO_CTRL_STATE_LED3,IO_MODE_OUTPUT_PP);
io_ctrl.init(IO_CTRL_STATE_LED2,IO_MODE_OUTPUT_PP);
io_ctrl.init(IO_CTRL_STATE_LED1,IO_MODE_OUTPUT_PP);
io_ctrl.init(IO_CTRL_HV_DAC_DECODE0,IO_MODE_OUTPUT_PP);
io_ctrl.init(IO_CTRL_HV_DAC_DECODE1,IO_MODE_OUTPUT_PP);
io_ctrl.set(IO_CTRL_STATE_LED3, IO_SET);
io_ctrl.set(IO_CTRL_STATE_LED2, IO_SET);
io_ctrl.set(IO_CTRL_STATE_LED1,IO_SET);
io_ctrl.set(IO_CTRL_HV_DAC_DECODE0,IO_SET);
io_ctrl.set(IO_CTRL_HV_DAC_DECODE1,IO_SET);
io_ctrl.init(IO_CTRL_HV_DAC_DECODE2,IO_MODE_OUTPUT_PP);
io_ctrl.init(IO_CTRL_HV_ADC_DECODE0,IO_MODE_OUTPUT_PP);
io_ctrl.init(IO_CTRL_HV_ADC_DECODE1,IO_MODE_OUTPUT_PP);
io_ctrl.init(IO_CTRL_HV_ADC_DECODE2,IO_MODE_OUTPUT_PP);
io_ctrl.init(IO_CTRL_HV_S2_DECODE0,IO_MODE_OUTPUT_PP);
io_ctrl.init(IO_CTRL_HV_S2_DECODE1,IO_MODE_OUTPUT_PP);
io_ctrl.init(IO_CTRL_HV_S2_DECODE2,IO_MODE_OUTPUT_PP);
io_ctrl.set(IO_CTRL_HV_DAC_DECODE2, IO_SET);
io_ctrl.set(IO_CTRL_HV_ADC_DECODE0, IO_SET);
io_ctrl.set(IO_CTRL_HV_ADC_DECODE1,IO_SET);
io_ctrl.set(IO_CTRL_HV_ADC_DECODE2,IO_SET);
io_ctrl.set(IO_CTRL_HV_S2_DECODE0,IO_SET);
io_ctrl.set(IO_CTRL_HV_S2_DECODE1,IO_SET);
io_ctrl.set(IO_CTRL_HV_S2_DECODE2, IO_SET);
/****PC****/
io_ctrl.init(IO_CTRL_HV_LEVEL,IO_MODE_OUTPUT_PP);
io_ctrl.init(IO_CTRL_LV_LEVEL1,IO_MODE_OUTPUT_PP); //10V
io_ctrl.init(IO_CTRL_LV_LEVEL2,IO_MODE_OUTPUT_PP); //24V
io_ctrl.init(IO_CTRL_LV_LEVEL3,IO_MODE_OUTPUT_PP); //48V
io_ctrl.init(IO_CTRL_HV_S1_1,IO_MODE_OUTPUT_PP);
io_ctrl.init(IO_CTRL_HV_S1_2,IO_MODE_OUTPUT_PP);
io_ctrl.init(IO_CTRL_HV_S1_3,IO_MODE_OUTPUT_PP);
io_ctrl.init(IO_CTRL_HV_S1_4,IO_MODE_OUTPUT_PP);
io_ctrl.init(IO_CTRL_HV_S1_5,IO_MODE_OUTPUT_PP);
io_ctrl.set(IO_CTRL_HV_LEVEL,IO_RESET);//
io_ctrl.set(IO_CTRL_LV_LEVEL1,IO_SET);
io_ctrl.set(IO_CTRL_LV_LEVEL2,IO_SET);
io_ctrl.set(IO_CTRL_LV_LEVEL3,IO_RESET);
io_ctrl.set(IO_CTRL_HV_S1_1,IO_SET);
io_ctrl.set(IO_CTRL_HV_S1_2,IO_SET);
io_ctrl.set(IO_CTRL_HV_S1_3,IO_SET);
io_ctrl.set(IO_CTRL_HV_S1_4,IO_SET);
io_ctrl.set(IO_CTRL_HV_S1_5,IO_SET);
}
static void bsp_init(void)
{
ls_sys.sys_rcu_init();
ls_sys.systick_init();
uart0.init();
drv_port_init();
io_comm.init();
led_init();
hv_voltage_init();
tla2518_A.init();
// ad5322.init();
xWriteAnalog1.vInit(&xWriteAnalog1, &xDacIcDev1);
xWriteAnalog2.vInit(&xWriteAnalog2, &xDacIcDev2);
xWriteAnalog3.vInit(&xWriteAnalog3, &xDacIcDev3);
xWriteAnalog4.vInit(&xWriteAnalog4, &xDacIcDev4);
xWriteAnalog5.vInit(&xWriteAnalog5, &xDacIcDev5);
uart0.send_bytes((mfU8_t *)VERSION_NAME, VERSION_SIZE);
LOG_I("Building at %s %s",__DATE__,__TIME__);
LOG_I("SystemCoreClock : %d",ls_sys.system_clock);
}
int main(void) {
bsp_init();
LOG_I("System device init ok!");
// 调用测试函数,输出50V
hv_error_t ret = hv_test_module1_output_50v();
if (ret == HV_ERR_SUCCESS) {
printf("Output 50V success!\n");
} else {
// 输出失败,处理错误(比如打印错误码)
printf("Output 50V failed, error code: %d\n", ret);
}
while(1) {
// 循环监测电压(可选)
float actual_vol;
hv_read_total_voltage(&actual_vol);
// 3. 中文替换为英文
printf("Current output voltage: %.2fV\n", actual_vol);
DELAY_Ms(1000);
}
}
/*
int main(void)
{
bsp_init();
LOG_I("System device init ok!");
task_start();
return 0;
}
*/
/*
int main(void)
{
bsp_init();
LOG_I("System device init ok!");
// 注释原任务启动函数,改为死循�?实现电压切换
// task_start();
while(1)
{
// 输出48V:置�?48V对应控制引脚
io_ctrl.set(IO_CTRL_LV_LEVEL3, IO_SET);
ls_sys.delay_ms(50); // 延时50ms
// 输出0V:拉�?48V对应控制引脚(关�?48V输出�?
io_ctrl.set(IO_CTRL_LV_LEVEL3, IO_RESET);
ls_sys.delay_ms(50); // 延时50ms
}
}
*/
现在可以了吗,能不能保证只输出50V
最新发布