基于地奇星开发板内阻测试仪

项目简介

本项目是基于地奇星的电池内阻测试仪。

项目功能

可以测试大部分电池的内阻，以及阻容感在1Khz下的ESR

项目参数

最大量程1.5欧，二档150毫欧，分辨率分别为0.5欧和0.05欧。

原理解析（硬件说明）

单片机使用spwm以50khz产生PWM低通滤波过后，驱动恒流电路产生恒流，加载至被测电池端，然后测试电池两端电压，根据R=U/I，U经运放后送至ADC，可测得，I为恒定，由此可知R。

恒流激励电路

激励.png
2. 电池两端电压放大测量，挡位部分

电压测量.png
3. 供电，电池切换，充电电路，电池保护电路

电源充电.png
4. 地奇星插座，屏幕座及按键

单片机数字.png
5. 负压电路用于运放负电源

负压.png
6.

软件代码

1.先实现printf,参考官方示例

#include "bsp_uart.h"

// 发送完成标志位
volatile bool Uart0_Send_Flag = false;
// 接收完成标志位
volatile bool Uart0_Receive_Flag = false;
// 写入的字节
uint32_t bytes = 1;

//调试串口 UART0 初始化
void UART0_Debug_Init(void)
{
    fsp_err_t err = R_SCI_UART_Open (&g_uart0_ctrl, &g_uart0_cfg);

    if (FSP_SUCCESS != err) {
           printf("串口初始化失败! \n");
           return;
       }
}

/* 串口中断回调 */
void uart0_callback(uart_callback_args_t *p_args)
{
    switch (p_args->event)
    {
        case UART_EVENT_RX_CHAR: //收到数据
        {
            R_SCI_UART_Write(&g_uart0_ctrl, (uint8_t*) &(p_args->data), bytes);
            break;
        }
        case UART_EVENT_RX_COMPLETE:  //接收完整的事件
        {
            Uart0_Receive_Flag = true;
            break;
        }
        case UART_EVENT_TX_COMPLETE://发送完整的事件
        {
            Uart0_Send_Flag = true;
            break;
        }
        default:
        break;
    }
}


// 串口重定义
// 函数前置声明（仅需声明一次）
int __io_putchar(int ch);
int _write(int fd, char *pBuffer, int size);
int _close(int fd);
int _lseek(int fd, off_t ptr, int dir);
int _read(int fd, char *pBuffer, int size);
int _fstat(int fd, struct stat *pStat);
int _isatty(int fd);

// 弱符号实现（仅需实现一次）
__attribute__((weak)) int _close(int fd) {
    (void)fd;  // 忽略未使用参数
    return -1;
}

__attribute__((weak)) int _lseek(int fd, off_t ptr, int dir) {
    (void)fd; (void)ptr; (void)dir;
    return -1;
}

__attribute__((weak)) int _read(int fd, char *pBuffer, int size) {
    (void)fd; (void)pBuffer; (void)size;
    return 0;
}

__attribute__((weak)) int _fstat(int fd, struct stat *pStat) {
    (void)fd; (void)pStat;
    return -1;
}

__attribute__((weak)) int _isatty(int fd) {
    (void)fd;
    return 1;
}

#ifdef __GNUC__
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif

PUTCHAR_PROTOTYPE {
    fsp_err_t err;
    err = R_SCI_UART_Write(&g_uart0_ctrl, (uint8_t *)&ch, 1);
    if (FSP_SUCCESS != err) __BKPT();
    while (Uart0_Send_Flag == false);
    Uart0_Send_Flag = false;
    return ch;
}

int _write(int fd, char *pBuffer, int size) {
    (void)fd;  // 忽略未使用参数
    R_SCI_UART_Write (&g_uart0_ctrl, (uint8_t*) pBuffer, (uint32_t) size);
    while (Uart0_Send_Flag == false);
    Uart0_Send_Flag = false;
    return size;
}

2.读取电池两端电压ADC

uint16_t ADC_read_Ad(void)
{
    uint16_t adc_data = 0;
    // 启动ADC扫描
    fsp_err_t err = R_ADC_ScanStart(&g_adc0_ctrl);
    if (FSP_SUCCESS != err) {
        printf("ADC扫描启动失败! \n");
        return 9999;  // 返回错误值
    }

    // 等待ADC转换完成
    while (!adc_flag);
    adc_flag = false;  // 清除标志位

    // 读取ADC数据
    err = R_ADC_Read(&g_adc0_ctrl, ADC_CHANNEL_7, &adc_data);
    if (FSP_SUCCESS != err) {
        printf("ADC数据读取失败!\n");
        return 9999;  // 返回错误值
    }

    //printf("%d\r\n",adc_data);
    return adc_data;
}

3.计算内阻

// 计算内阻（单位：欧姆）
float Calculate_Resistance(float voltage_rms_adc) {
    float voltage_at_adc;      // ADC输入引脚的电压
    float voltage_at_battery;  // 电池两端的真实电压
    float resistance;          // 内阻值

    // 1. ADC原始值转电压值（单位：V）
    voltage_at_adc = voltage_rms_adc * ADC_REF_VOLTAGE / ADC_RESOLUTION;

    // 2. 除以放大增益，得到电池端真实电压
    voltage_at_battery = voltage_at_adc / AMP_GAIN;

    // 3. 欧姆定律：R = V / I
    resistance = voltage_at_battery / CONST_CURRENT;

    // 4. 转为毫欧显示（可选）
    return resistance * 1000;  // 返回毫欧值
}

4.主函数状态机实现思路（未实现）

typedef enum {
    WAITING,     // 等待测量
    SAMPLING,    // 采集中
    CALCULATING, // 计算中
    DISPLAYING   // 显示中
} state_t;

state_t current_state = WAITING;
volatile uint8_t measurement_ready = 0;
float last_result = 0;

void main(void) {
    // 初始化
    System_Init();
    ADC_Init();
    Timer_Init();  // 配置定时器触发ADC（48kHz）
    
    while(1) {
        switch(current_state) {
            case WAITING:
                if(Button_Read()) {
                    // 开始测量
                    ADC_Start_DMA(adc_buffer, SAMPLE_POINTS);
                    current_state = SAMPLING;
                }
                break;
                
            case SAMPLING:
                if(measurement_ready) {
                    measurement_ready = 0;
                    current_state = CALCULATING;
                }
                break;
                
            case CALCULATING: {
                // 提取1kHz分量
                float rms_adc = Extract_1kHz_Amplitude(adc_buffer, SAMPLE_POINTS);
                
                // 计算内阻
                last_result = Calculate_Resistance(rms_adc);
                
                current_state = DISPLAYING;
                break;
            }
                
            case DISPLAYING:
                // 显示结果（例如：12.34 mΩ）
                LCD_ShowFloat(last_result, 2);  // 显示2位小数
                LCD_ShowString(" mΩ");
                current_state = WAITING;
                break;
        }
    }
}