IO_打印流

本文深入解析Java中的PrintStream类,探讨其在控制台和文件输出中的应用,包括构造方法、自动刷新机制及如何重定向输出。

PrintStream是处理流、装饰流(用于System.out),打印的所有字符都使用平台 的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下,应该使用 PrintWriter 类
PrintStream功能:
1.PrintStream 能够方便地打印各种数据值表示形式
2.自动刷新

在这里插入图片描述
程序-(写入)->PrintStream(OutputStream)-(写入)->文件

constructiondescription
PrintStream(File file, String csn)创建具有指定文件和字符集且不带自动行刷新的新打印流。
PrintStream(String fileName, String csn)创建具有指定文件名称和字符集且不带自动行刷新的新打印流。
PrintStream(OutputStream out, boolean autoFlush, String encoding)创建新的打印流。
Modifier and Typefunctiondescription
PrintStreamPrintStream append(char c)将指定字符添加到此输出流。

测试程序:

public class PrintStreamTest {
	public static void main(String[] args) throws FileNotFoundException {
//		System.out默认输出都控制台,因此打印流ps将内容打印到控制台
		PrintStream ps = System.out;
		ps.println("打印流");
		ps.println(true);
//		打印流ps将内容打印到文件流test.txt(+true能自动刷新)
		ps = new PrintStream(new BufferedOutputStream(new FileOutputStream("print.txt")),true);
		ps.println("打印流");
		ps.println(true);
		ps.close();/*关闭FileOutputStream*/
//		重定向输出端
		System.setOut(ps);
		System.out.println("原本是打印到控制台的,重定向输出端为当前这个PrintStream");
//		重定向回控制台(+true能自动刷新)
		System.setOut(new PrintStream(new BufferedOutputStream(new FileOutputStream(FileDescriptor.out)),true));
		System.out.println("我又回来控制台啦!");
		ps.close();/*关闭FileOutputStream*/
	}
}

测试结果:

  1. 控制台:
打印流
true
我又回来控制台啦!
  1. print.txt文件:
    在这里插入图片描述
#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
最新发布
11-28
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值