wxsmart-test
/
sggt
7
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

更新： 

1、输入信号校准程序完成，待测试验证；
2、校准参数封装成结构体；
This commit is contained in:
吴俊潮 2025-06-30 14:51:23 +08:00
parent caedfcaa43
commit df5bb1c0a9
15 changed files with 19836 additions and 19182 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.vscode/settings.json vendored
View File

@ -43,7 +43,8 @@
"math.h": "c", "math.h": "c",
"modbus_register_process.h": "c", "modbus_register_process.h": "c",
"modbus_rtu_master.h": "c", "modbus_rtu_master.h": "c",
"dac7811.h": "c" "dac7811.h": "c",
"sig24130.h": "c"
}, },
"C_Cpp.errorSquiggles": "disabled", "C_Cpp.errorSquiggles": "disabled",
"idf.pythonInstallPath": "F:\\Espressif\\tools\\idf-python\\3.11.2\\python.exe", "idf.pythonInstallPath": "F:\\Espressif\\tools\\idf-python\\3.11.2\\python.exe",

5
App/DAC7811/dac7811.c
View File

@ -76,7 +76,6 @@ void fun_dac7811_operate(float32 *data_sv)
} }
} }
float res_ohm_out_calibrate_table[CALIBRATE_RES_OHM_OUT_POINTS] = {0};
uint8_t resohm_out_cal_enable = 0; uint8_t resohm_out_cal_enable = 0;
float32 calibrate_res_ohm_out(float32 raw) float32 calibrate_res_ohm_out(float32 raw)
{ {
@ -114,10 +113,10 @@ float32 calibrate_res_ohm_out(float32 raw)
for( uint8_t i = 0; i < CALIBRATE_RES_OHM_OUT_POINTS - 1; i++) for( uint8_t i = 0; i < CALIBRATE_RES_OHM_OUT_POINTS - 1; i++)
{ {
if( (res_ohm_out_calibrate_table[i] <= raw)&&(raw <= res_ohm_out_calibrate_table[i + 1]) ) if( (cali_paras.cali_res_ohm_out[i] <= raw)&&(raw <= cali_paras.cali_res_ohm_out[i + 1]) )
{ {
result = CALIBRATE_RES_OHM_OUT_START + i*interval; //所处区间的左端点 result = CALIBRATE_RES_OHM_OUT_START + i*interval; //所处区间的左端点
result += interval * (raw - res_ohm_out_calibrate_table[i])/(res_ohm_out_calibrate_table[i + 1] - res_ohm_out_calibrate_table[i]); result += interval * (raw - cali_paras.cali_res_ohm_out[i])/(cali_paras.cali_res_ohm_out[i + 1] - cali_paras.cali_res_ohm_out[i]);
break; break;
} }
} }

4
App/DAC7811/dac7811.h
View File

@ -3,13 +3,13 @@
#include "data_type_def.h" #include "data_type_def.h"
#include "eeprom_spi.h" #include "eeprom_spi.h"
#include "mux_signal.h"
#define CALIBRATE_RES_OHM_OUT_START 0 #define CALIBRATE_RES_OHM_OUT_START 0
#define CALIBRATE_RES_OHM_OUT_END 4000 #define CALIBRATE_RES_OHM_OUT_END 4000
#define CALIBRATE_RES_OHM_OUT_POINTS 11
extern BOOL dac7811_spi_init_flag; extern BOOL dac7811_spi_init_flag;
extern float res_ohm_out_calibrate_table[CALIBRATE_RES_OHM_OUT_POINTS];
extern uint8_t resohm_out_cal_enable; extern uint8_t resohm_out_cal_enable;
void fun_dac7811_operate(float32 *data_pv); void fun_dac7811_operate(float32 *data_pv);

10
App/DAC8552/dac8552.c
View File

@ -129,7 +129,6 @@ void dac8552_operation(float32 *data1, float32 *data2)
} }
} }
float cur_ma_out_calibrate_table[CALIBRATE_CUR_MA_OUT_POINTS] = {0};
uint8_t curma_out_cal_enable = 0; uint8_t curma_out_cal_enable = 0;
float32 calibrate_cur_ma_out(float32 raw) float32 calibrate_cur_ma_out(float32 raw)
{ {
@ -167,10 +166,10 @@ float32 calibrate_cur_ma_out(float32 raw)
for( uint8_t i = 0; i < CALIBRATE_CUR_MA_OUT_POINTS - 1; i++) for( uint8_t i = 0; i < CALIBRATE_CUR_MA_OUT_POINTS - 1; i++)
{ {
if( (cur_ma_out_calibrate_table[i] <= raw)&&(raw <= cur_ma_out_calibrate_table[i + 1]) ) if( (cali_paras.cali_cur_mA_out[i] <= raw)&&(raw <= cali_paras.cali_cur_mA_out[i + 1]) )
{ {
result = CALIBRATE_CUR_MA_OUT_START + i*interval; //所处区间的左端点 result = CALIBRATE_CUR_MA_OUT_START + i*interval; //所处区间的左端点
result += interval * (raw - cur_ma_out_calibrate_table[i])/(cur_ma_out_calibrate_table[i + 1] - cur_ma_out_calibrate_table[i]); result += interval * (raw - cali_paras.cali_cur_mA_out[i])/(cali_paras.cali_cur_mA_out[i + 1] - cali_paras.cali_cur_mA_out[i]);
break; break;
} }
} }
@ -190,7 +189,6 @@ float32 calibrate_cur_ma_out(float32 raw)
return result; return result;
} }
float vol_mv_out_calibrate_table[CALIBRATE_VOL_MV_OUT_POINTS] = {0};
uint8_t volmv_out_cal_enable = 0; uint8_t volmv_out_cal_enable = 0;
float32 calibrate_vol_mv_out(float32 raw) float32 calibrate_vol_mv_out(float32 raw)
{ {
@ -228,10 +226,10 @@ float32 calibrate_vol_mv_out(float32 raw)
for( uint8_t i = 0; i < CALIBRATE_VOL_MV_OUT_POINTS - 1; i++) for( uint8_t i = 0; i < CALIBRATE_VOL_MV_OUT_POINTS - 1; i++)
{ {
if( (vol_mv_out_calibrate_table[i] <= raw)&&(raw <= vol_mv_out_calibrate_table[i + 1]) ) if( (cali_paras.cali_vol_mV_out[i] <= raw)&&(raw <= cali_paras.cali_vol_mV_out[i + 1]) )
{ {
result = CALIBRATE_VOL_MV_OUT_START + i*interval; //所处区间的左端点 result = CALIBRATE_VOL_MV_OUT_START + i*interval; //所处区间的左端点
result += interval * (raw - vol_mv_out_calibrate_table[i])/(vol_mv_out_calibrate_table[i + 1] - vol_mv_out_calibrate_table[i]); result += interval * (raw - cali_paras.cali_vol_mV_out[i])/(cali_paras.cali_vol_mV_out[i + 1] - cali_paras.cali_vol_mV_out[i]);
break; break;
} }
} }

10
App/DAC8552/dac8552.h
View File

@ -4,13 +4,11 @@
#include "data_type_def.h" #include "data_type_def.h"
#include "eeprom_spi.h" #include "eeprom_spi.h"
#define CALIBRATE_CUR_MA_OUT_START 0
#define CALIBRATE_CUR_MA_OUT_END 25
#define CALIBRATE_CUR_MA_OUT_POINTS 11
#define CALIBRATE_VOL_MV_OUT_START -2.5f #define CALIBRATE_VOL_MV_OUT_START -2.5f
#define CALIBRATE_VOL_MV_OUT_END 2.5f #define CALIBRATE_VOL_MV_OUT_END 2.5f
#define CALIBRATE_VOL_MV_OUT_POINTS 11
#define CALIBRATE_CUR_MA_OUT_START 0
#define CALIBRATE_CUR_MA_OUT_END 25
typedef enum typedef enum
{ {
@ -45,9 +43,7 @@ typedef struct dac8552_object
} dac8552x_object; } dac8552x_object;
extern dac8552x_object dac8552; extern dac8552x_object dac8552;
extern float cur_ma_out_calibrate_table[CALIBRATE_CUR_MA_OUT_POINTS];
extern uint8_t curma_out_cal_enable; extern uint8_t curma_out_cal_enable;
extern float vol_mv_out_calibrate_table[CALIBRATE_VOL_MV_OUT_POINTS];
extern uint8_t volmv_out_cal_enable; extern uint8_t volmv_out_cal_enable;
void dac8552_init(dac8552x_object *dac, dac8552_write write, dac8552_chip_select cs); void dac8552_init(dac8552x_object *dac, dac8552_write write, dac8552_chip_select cs);

192
App/EEPROM/eeprom_spi.c
View File

@ -577,7 +577,7 @@ void eeprom_datasave_single(uint8_t tag)
case EEPROM_TAG_CAL_CUR_MA_OUT: case EEPROM_TAG_CAL_CUR_MA_OUT:
{ {
uint32_t flt[CALIBRATE_CUR_MA_OUT_POINTS] = {0}; uint32_t flt[CALIBRATE_CUR_MA_OUT_POINTS] = {0};
memcpy(flt, cur_ma_out_calibrate_table, sizeof(flt)); memcpy(flt, cali_paras.cali_cur_mA_out, sizeof(flt));
for(uint8_t i = 0; i < CALIBRATE_CUR_MA_OUT_POINTS; i++) for(uint8_t i = 0; i < CALIBRATE_CUR_MA_OUT_POINTS; i++)
{ {
@ -596,7 +596,7 @@ void eeprom_datasave_single(uint8_t tag)
case EEPROM_TAG_CAL_VOL_V_OUT: case EEPROM_TAG_CAL_VOL_V_OUT:
{ {
uint32_t flt[CALIBRATE_VOL_V_OUT_POINTS] = {0}; uint32_t flt[CALIBRATE_VOL_V_OUT_POINTS] = {0};
memcpy(flt, vol_v_out_calibrate_table, sizeof(flt)); memcpy(flt, cali_paras.cali_vol_V_out, sizeof(flt));
for(uint8_t i = 0; i < CALIBRATE_VOL_V_OUT_POINTS; i++) for(uint8_t i = 0; i < CALIBRATE_VOL_V_OUT_POINTS; i++)
{ {
@ -615,7 +615,7 @@ void eeprom_datasave_single(uint8_t tag)
case EEPROM_TAG_CAL_VOL_MV_OUT: case EEPROM_TAG_CAL_VOL_MV_OUT:
{ {
uint32_t flt[CALIBRATE_VOL_MV_OUT_POINTS] = {0}; uint32_t flt[CALIBRATE_VOL_MV_OUT_POINTS] = {0};
memcpy(flt, vol_mv_out_calibrate_table, sizeof(flt)); memcpy(flt, cali_paras.cali_vol_mV_out, sizeof(flt));
for(uint8_t i = 0; i < CALIBRATE_VOL_MV_OUT_POINTS; i++) for(uint8_t i = 0; i < CALIBRATE_VOL_MV_OUT_POINTS; i++)
{ {
@ -634,7 +634,7 @@ void eeprom_datasave_single(uint8_t tag)
case EEPROM_TAG_CAL_RES_OHM_OUT: case EEPROM_TAG_CAL_RES_OHM_OUT:
{ {
uint32_t flt[CALIBRATE_RES_OHM_OUT_POINTS] = {0}; uint32_t flt[CALIBRATE_RES_OHM_OUT_POINTS] = {0};
memcpy(flt, res_ohm_out_calibrate_table, sizeof(flt)); memcpy(flt, cali_paras.cali_res_ohm_out, sizeof(flt));
for(uint8_t i = 0; i < CALIBRATE_RES_OHM_OUT_POINTS; i++) for(uint8_t i = 0; i < CALIBRATE_RES_OHM_OUT_POINTS; i++)
{ {
@ -650,6 +650,82 @@ void eeprom_datasave_single(uint8_t tag)
} }
break; break;
case EEPROM_TAG_CAL_CUR_MA_IN:
{
uint32_t flt[CALIBRATE_CUR_MA_IN_POINTS] = {0};
memcpy(flt, cali_paras.cali_cur_mA_in, sizeof(flt));
for(uint8_t i = 0; i < CALIBRATE_CUR_MA_IN_POINTS; i++)
{
temp_h = flt[i] >> 24;
temp_mh = flt[i] >> 16;
temp_ml = flt[i] >> 8;
temp_l = flt[i] & 0xFF;
eeprom_writedata(CAL_CUR_MA_IN_ADDR_START + 32*i, temp_h);
eeprom_writedata(CAL_CUR_MA_IN_ADDR_START + 32*i + 8, temp_mh);
eeprom_writedata(CAL_CUR_MA_IN_ADDR_START + 32*i + 16, temp_ml);
eeprom_writedata(CAL_CUR_MA_IN_ADDR_START + 32*i + 24, temp_l);
}
}
break;
case EEPROM_TAG_CAL_VOL_V_IN:
{
uint32_t flt[CALIBRATE_VOL_V_IN_POINTS] = {0};
memcpy(flt, cali_paras.cali_vol_V_in, sizeof(flt));
for(uint8_t i = 0; i < CALIBRATE_VOL_V_IN_POINTS; i++)
{
temp_h = flt[i] >> 24;
temp_mh = flt[i] >> 16;
temp_ml = flt[i] >> 8;
temp_l = flt[i] & 0xFF;
eeprom_writedata(CAL_VOL_V_IN_ADDR_START + 32*i, temp_h);
eeprom_writedata(CAL_VOL_V_IN_ADDR_START + 32*i + 8, temp_mh);
eeprom_writedata(CAL_VOL_V_IN_ADDR_START + 32*i + 16, temp_ml);
eeprom_writedata(CAL_VOL_V_IN_ADDR_START + 32*i + 24, temp_l);
}
}
break;
case EEPROM_TAG_CAL_VOL_MV_IN:
{
uint32_t flt[CALIBRATE_VOL_MV_IN_POINTS] = {0};
memcpy(flt, cali_paras.cali_vol_mV_in, sizeof(flt));
for(uint8_t i = 0; i < CALIBRATE_VOL_MV_IN_POINTS; i++)
{
temp_h = flt[i] >> 24;
temp_mh = flt[i] >> 16;
temp_ml = flt[i] >> 8;
temp_l = flt[i] & 0xFF;
eeprom_writedata(CAL_VOL_MV_IN_ADDR_START + 32*i, temp_h);
eeprom_writedata(CAL_VOL_MV_IN_ADDR_START + 32*i + 8, temp_mh);
eeprom_writedata(CAL_VOL_MV_IN_ADDR_START + 32*i + 16, temp_ml);
eeprom_writedata(CAL_VOL_MV_IN_ADDR_START + 32*i + 24, temp_l);
}
}
break;
case EEPROM_TAG_CAL_RES_OHM_IN:
{
uint32_t flt[CALIBRATE_RES_OHM_IN_POINTS] = {0};
memcpy(flt, cali_paras.cali_res_ohm_in, sizeof(flt));
for(uint8_t i = 0; i < CALIBRATE_RES_OHM_IN_POINTS; i++)
{
temp_h = flt[i] >> 24;
temp_mh = flt[i] >> 16;
temp_ml = flt[i] >> 8;
temp_l = flt[i] & 0xFF;
eeprom_writedata(CAL_RES_OHM_IN_ADDR_START + 32*i, temp_h);
eeprom_writedata(CAL_RES_OHM_IN_ADDR_START + 32*i + 8, temp_mh);
eeprom_writedata(CAL_RES_OHM_IN_ADDR_START + 32*i + 16, temp_ml);
eeprom_writedata(CAL_RES_OHM_IN_ADDR_START + 32*i + 24, temp_l);
}
}
break;
default: default:
break; break;
} }
@ -877,7 +953,7 @@ void eeprom_dataread_single(uint8_t tag)
} }
} }
memcpy(cur_ma_out_calibrate_table, flt, sizeof(cur_ma_out_calibrate_table)); memcpy(cali_paras.cali_cur_mA_out, flt, sizeof(cali_paras.cali_cur_mA_out));
} }
break; break;
@ -902,7 +978,7 @@ void eeprom_dataread_single(uint8_t tag)
} }
} }
memcpy(vol_v_out_calibrate_table, flt, sizeof(vol_v_out_calibrate_table)); memcpy(cali_paras.cali_vol_V_out, flt, sizeof(cali_paras.cali_vol_V_out));
} }
break; break;
@ -927,7 +1003,7 @@ void eeprom_dataread_single(uint8_t tag)
} }
} }
memcpy(vol_mv_out_calibrate_table, flt, sizeof(vol_mv_out_calibrate_table)); memcpy(cali_paras.cali_vol_mV_out, flt, sizeof(cali_paras.cali_vol_mV_out));
} }
break; break;
@ -952,7 +1028,107 @@ void eeprom_dataread_single(uint8_t tag)
} }
} }
memcpy(res_ohm_out_calibrate_table, flt, sizeof(res_ohm_out_calibrate_table)); memcpy(cali_paras.cali_res_ohm_out, flt, sizeof(cali_paras.cali_res_ohm_out));
}
break;
case EEPROM_TAG_CAL_CUR_MA_IN:
{
uint32_t flt[CALIBRATE_CUR_MA_IN_POINTS] = {0};
for(uint8_t i = 0; i < CALIBRATE_CUR_MA_IN_POINTS; i++)
{
temp_h = eeprom_readdata(CAL_CUR_MA_IN_ADDR_START + 32*i);
temp_mh = eeprom_readdata(CAL_CUR_MA_IN_ADDR_START + 32*i + 8);
temp_ml = eeprom_readdata(CAL_CUR_MA_IN_ADDR_START + 32*i + 16);
temp_l = eeprom_readdata(CAL_CUR_MA_IN_ADDR_START + 32*i + 24);
flt[i] = (temp_h << 24)|(temp_mh << 16)|(temp_ml << 8)|(temp_l);
memcpy(&error_check, flt + i, 4);
if( ((int16_t)error_check > CUR.up)||((int16_t)error_check < CUR.low) )
{
//任意一个点异常，随即退出，不启用校准
curma_in_cal_enable = 2;
return;
}
}
memcpy(cali_paras.cali_cur_mA_in, flt, sizeof(cali_paras.cali_cur_mA_in));
}
break;
case EEPROM_TAG_CAL_VOL_V_IN:
{
uint32_t flt[CALIBRATE_VOL_V_IN_POINTS] = {0};
for(uint8_t i = 0; i < CALIBRATE_VOL_V_IN_POINTS; i++)
{
temp_h = eeprom_readdata(CAL_VOL_V_IN_ADDR_START + 32*i);
temp_mh = eeprom_readdata(CAL_VOL_V_IN_ADDR_START + 32*i + 8);
temp_ml = eeprom_readdata(CAL_VOL_V_IN_ADDR_START + 32*i + 16);
temp_l = eeprom_readdata(CAL_VOL_V_IN_ADDR_START + 32*i + 24);
flt[i] = (temp_h << 24)|(temp_mh << 16)|(temp_ml << 8)|(temp_l);
memcpy(&error_check, flt + i, 4);
if( ((int16_t)error_check > VOL[0].up)||((int16_t)error_check < VOL[0].low) )
{
//任意一个点异常，随即退出，不启用校准
volv_in_cal_enable = 2;
return;
}
}
memcpy(cali_paras.cali_vol_V_in, flt, sizeof(cali_paras.cali_vol_V_in));
}
break;
case EEPROM_TAG_CAL_VOL_MV_IN:
{
uint32_t flt[CALIBRATE_VOL_MV_IN_POINTS] = {0};
for(uint8_t i = 0; i < CALIBRATE_VOL_MV_IN_POINTS; i++)
{
temp_h = eeprom_readdata(CAL_VOL_MV_IN_ADDR_START + 32*i);
temp_mh = eeprom_readdata(CAL_VOL_MV_IN_ADDR_START + 32*i + 8);
temp_ml = eeprom_readdata(CAL_VOL_MV_IN_ADDR_START + 32*i + 16);
temp_l = eeprom_readdata(CAL_VOL_MV_IN_ADDR_START + 32*i + 24);
flt[i] = (temp_h << 24)|(temp_mh << 16)|(temp_ml << 8)|(temp_l);
memcpy(&error_check, flt + i, 4);
if( ((int16_t)error_check > VOL[1].up)||((int16_t)error_check < VOL[1].low) )
{
//任意一个点异常，随即退出，不启用校准
volmv_in_cal_enable = 2;
return;
}
}
memcpy(cali_paras.cali_vol_mV_in, flt, sizeof(cali_paras.cali_vol_mV_in));
}
break;
case EEPROM_TAG_CAL_RES_OHM_IN:
{
uint32_t flt[CALIBRATE_RES_OHM_IN_POINTS] = {0};
for(uint8_t i = 0; i < CALIBRATE_RES_OHM_IN_POINTS; i++)
{
temp_h = eeprom_readdata(CAL_RES_OHM_IN_ADDR_START + 32*i);
temp_mh = eeprom_readdata(CAL_RES_OHM_IN_ADDR_START + 32*i + 8);
temp_ml = eeprom_readdata(CAL_RES_OHM_IN_ADDR_START + 32*i + 16);
temp_l = eeprom_readdata(CAL_RES_OHM_IN_ADDR_START + 32*i + 24);
flt[i] = (temp_h << 24)|(temp_mh << 16)|(temp_ml << 8)|(temp_l);
memcpy(&error_check, flt + i, 4);
if( ((int16_t)error_check > RES.up)||((int16_t)error_check < RES.low) )
{
//任意一个点异常，随即退出，不启用校准
resohm_in_cal_enable = 2;
return;
}
}
memcpy(cali_paras.cali_res_ohm_in, flt, sizeof(cali_paras.cali_res_ohm_in));
} }
break; break;
} }

28
App/EEPROM/eeprom_spi.h
View File

@ -147,7 +147,33 @@
#define EEPROM_TAG_CAL_RES_OHM_OUT 21 //电阻Ω输出值校准，tag：21 #define EEPROM_TAG_CAL_RES_OHM_OUT 21 //电阻Ω输出值校准，tag：21
#define CAL_RES_OHM_OUT_ADDR_FLAG CAL_VOL_MV_OUT_ADDR_END //有效标志，是否存在数据，存在：0xAAAA #define CAL_RES_OHM_OUT_ADDR_FLAG CAL_VOL_MV_OUT_ADDR_END //有效标志，是否存在数据，存在：0xAAAA
#define CAL_RES_OHM_OUT_ADDR_START (CAL_RES_OHM_OUT_ADDR_FLAG + EE_INTERVAL) //数据起始地址，EE_START_ADDR + 103*EE_INTERVAL #define CAL_RES_OHM_OUT_ADDR_START (CAL_RES_OHM_OUT_ADDR_FLAG + EE_INTERVAL) //数据起始地址，EE_START_ADDR + 103*EE_INTERVAL
#define CAL_RES_OHM_OUT_ADDR_END (CAL_RES_OHM_OUT_ADDR_START + 2 * EE_INTERVAL * CALIBRATE_RES_OHM_OUT_POINTS) //EE_START_ADDR + 125*EE_INTERVAL #define CAL_RES_OHM_OUT_ADDR_END (CAL_RES_OHM_OUT_ADDR_START + 2 * EE_INTERVAL * CALIBRATE_RES_OHM_OUT_POINTS) //EE_START_ADDR + 125*EE_INTERVAL = 2000(0x7D0)
//2000~2016(0x7D0~0x7E0) -> DEVICE_CHECK
//电流输入校准mA（11个点，10个间隔）
#define EEPROM_TAG_CAL_CUR_MA_IN 22 //电流mA输入值校准，tag：22
#define CAL_CUR_MA_IN_ADDR_FLAG (DEVICE_CHECK + EE_INTERVAL) //有效标志，是否存在数据，存在：0xAAAA
#define CAL_CUR_MA_IN_ADDR_START (CAL_CUR_MA_IN_ADDR_FLAG + EE_INTERVAL) //数据起始地址，EE_START_ADDR + 127*EE_INTERVAL
#define CAL_CUR_MA_IN_ADDR_END (CAL_CUR_MA_IN_ADDR_START + 2 * EE_INTERVAL * CALIBRATE_CUR_MA_IN_POINTS) //EE_START_ADDR + 149*EE_INTERVAL
//电压输入校准V（11个点，10个间隔）
#define EEPROM_TAG_CAL_VOL_V_IN 23 //电压V输入值校准，tag：23
#define CAL_VOL_V_IN_ADDR_FLAG (CAL_CUR_MA_IN_ADDR_END + EE_INTERVAL) //有效标志，是否存在数据，存在：0xAAAA
#define CAL_VOL_V_IN_ADDR_START (CAL_VOL_V_IN_ADDR_FLAG + EE_INTERVAL) //数据起始地址，EE_START_ADDR + 150*EE_INTERVAL
#define CAL_VOL_V_IN_ADDR_END (CAL_VOL_V_IN_ADDR_START + 2 * EE_INTERVAL * CALIBRATE_VOL_V_IN_POINTS) //EE_START_ADDR + 172*EE_INTERVAL
//电压输入校准mV（11个点，10个间隔）
#define EEPROM_TAG_CAL_VOL_MV_IN 24 //电压mV输入值校准，tag：24
#define CAL_VOL_MV_IN_ADDR_FLAG (CAL_VOL_V_IN_ADDR_END + EE_INTERVAL) //有效标志，是否存在数据，存在：0xAAAA
#define CAL_VOL_MV_IN_ADDR_START (CAL_VOL_MV_IN_ADDR_FLAG + EE_INTERVAL) //数据起始地址，EE_START_ADDR + 173*EE_INTERVAL
#define CAL_VOL_MV_IN_ADDR_END (CAL_VOL_MV_IN_ADDR_START + 2 * EE_INTERVAL * CALIBRATE_VOL_MV_IN_POINTS) //EE_START_ADDR + 195*EE_INTERVAL
//电阻输入校准Ω（11个点，10个间隔）
#define EEPROM_TAG_CAL_RES_OHM_IN 25 //电压mV输入值校准，tag：25
#define CAL_RES_OHM_IN_ADDR_FLAG (CAL_VOL_MV_IN_ADDR_END + EE_INTERVAL) //有效标志，是否存在数据，存在：0xAAAA
#define CAL_RES_OHM_IN_ADDR_START (CAL_RES_OHM_IN_ADDR_FLAG + EE_INTERVAL) //数据起始地址，EE_START_ADDR + 196*EE_INTERVAL
#define CAL_RES_OHM_IN_ADDR_END (CAL_RES_OHM_IN_ADDR_START + 2 * EE_INTERVAL * CALIBRATE_RES_OHM_IN_POINTS) //EE_START_ADDR + 218*EE_INTERVAL
//根据需求后续在此处向后添加 //根据需求后续在此处向后添加

64
App/MUX_SIGNAL/mux_signal.c
View File

@ -18,14 +18,8 @@
#include "task.h" #include "task.h"
#include "tim.h" #include "tim.h"
#include "mux_signal.h" #include "mux_signal.h"
#include "dac.h"
#include "adc.h" #include "adc.h"
#include "rn7302.h"
#include <SIG24130.h>
#include "dac8552.h"
#include "ads1220.h"
#include "dac7811.h"
#include "apps_gather.h"
st_mux_signal mux_signal = { st_mux_signal mux_signal = {
.channel = CHX_IN_MAX, .channel = CHX_IN_MAX,
@ -33,6 +27,8 @@ st_mux_signal mux_signal = {
st_freq_signal freq_signal; st_freq_signal freq_signal;
CALIBRATE_PARAGRAMS cali_paras;
void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim) void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{ {
if (&htim3 == htim) if (&htim3 == htim)
@ -140,7 +136,7 @@ void deal_calibrate_affair(void)
case CAL_FLAG_VOUT_V_OUT: case CAL_FLAG_VOUT_V_OUT:
{ {
//存入vol_v_calibrate_table[CALIBRATE_VOL_V_OUT_POINTS]的数据 //存入vol_v_out_calibrate_table[CALIBRATE_VOL_V_OUT_POINTS]的数据
eeprom_datasave_single(EEPROM_TAG_CAL_VOL_V_OUT); eeprom_datasave_single(EEPROM_TAG_CAL_VOL_V_OUT);
//写入0xAAAA标志 //写入0xAAAA标志
@ -151,7 +147,7 @@ void deal_calibrate_affair(void)
case CAL_FLAG_VOUT_MV_OUT: case CAL_FLAG_VOUT_MV_OUT:
{ {
//存入vol_v_calibrate_table[CALIBRATE_VOL_V_OUT_POINTS]的数据 //存入vol_mv_out_calibrate_table[CALIBRATE_VOL_MV_OUT_POINTS]的数据
eeprom_datasave_single(EEPROM_TAG_CAL_VOL_MV_OUT); eeprom_datasave_single(EEPROM_TAG_CAL_VOL_MV_OUT);
//写入0xAAAA标志 //写入0xAAAA标志
@ -162,7 +158,7 @@ void deal_calibrate_affair(void)
case CAL_FLAG_RES_OHM_OUT: case CAL_FLAG_RES_OHM_OUT:
{ {
//存入vol_v_calibrate_table[CALIBRATE_VOL_V_OUT_POINTS]的数据 //存入res_ohm_out_calibrate_table[CALIBRATE_RES_OHM_OUT_POINTS]的数据
eeprom_datasave_single(EEPROM_TAG_CAL_RES_OHM_OUT); eeprom_datasave_single(EEPROM_TAG_CAL_RES_OHM_OUT);
//写入0xAAAA标志 //写入0xAAAA标志
@ -172,19 +168,47 @@ void deal_calibrate_affair(void)
break; break;
case CAL_FLAG_CUR_MA_IN: case CAL_FLAG_CUR_MA_IN:
{} {
//存入cur_ma_in_calibrate_table[CALIBRATE_CUR_MA_IN_POINTS]的数据
eeprom_datasave_single(EEPROM_TAG_CAL_CUR_MA_IN);
//写入0xAAAA标志
eeprom_writedata(CAL_CUR_MA_IN_ADDR_FLAG, 0xAA);
eeprom_writedata(CAL_CUR_MA_IN_ADDR_FLAG + 8, 0xAA);
}
break; break;
case CAL_FLAG_VOUT_V_IN: case CAL_FLAG_VOUT_V_IN:
{} {
//存入vol_v_in_calibrate_table[CALIBRATE_VOL_V_IN_POINTS]的数据
eeprom_datasave_single(EEPROM_TAG_CAL_VOL_V_IN);
//写入0xAAAA标志
eeprom_writedata(CAL_VOL_V_IN_ADDR_FLAG, 0xAA);
eeprom_writedata(CAL_VOL_V_IN_ADDR_FLAG + 8, 0xAA);
}
break; break;
case CAL_FLAG_VOUT_MV_IN: case CAL_FLAG_VOUT_MV_IN:
{} {
//存入vol_mv_in_calibrate_table[CALIBRATE_VOL_MV_IN_POINTS]的数据
eeprom_datasave_single(EEPROM_TAG_CAL_VOL_MV_IN);
//写入0xAAAA标志
eeprom_writedata(CAL_VOL_MV_IN_ADDR_FLAG, 0xAA);
eeprom_writedata(CAL_VOL_MV_IN_ADDR_FLAG + 8, 0xAA);
}
break; break;
case CAL_FLAG_RES_OHM_IN: case CAL_FLAG_RES_OHM_IN:
{} {
//存入res_ohm_in_calibrate_table[CALIBRATE_RES_OHM_IN_POINTS]的数据
eeprom_datasave_single(EEPROM_TAG_CAL_RES_OHM_IN);
//写入0xAAAA标志
eeprom_writedata(CAL_RES_OHM_IN_ADDR_FLAG, 0xAA);
eeprom_writedata(CAL_RES_OHM_IN_ADDR_FLAG + 8, 0xAA);
}
break; break;
default: default:
@ -232,14 +256,14 @@ void mux_signal_switch(st_mux_signal *mux_signal)
case CH1_OUT_VOL_MV: case CH1_OUT_VOL_MV:
{ {
if(mux_set_flag) dac8552_operation(NULL, &mux_signal->data_sv); //设定 if(mux_set_flag) dac8552_operation(NULL, &mux_signal->data_sv); //设定
fun_get_sig16132_ch(4, &mux_signal->data_pv); //回采 fun_get_sig16132_ch(MUX_CHANNEL_MV_FEEDBACK, &mux_signal->data_pv); //回采
} }
break; break;
case CH2_OUT_CUR: case CH2_OUT_CUR:
{ {
if(mux_set_flag) dac8552_operation(&mux_signal->data_sv, NULL); //设定 if(mux_set_flag) dac8552_operation(&mux_signal->data_sv, NULL); //设定
fun_get_sig16132_ch(7, &mux_signal->data_pv); //回采 fun_get_sig16132_ch(MUX_CHANNEL_MA_FEEDBACK, &mux_signal->data_pv); //回采
} }
break; break;
@ -247,7 +271,7 @@ void mux_signal_switch(st_mux_signal *mux_signal)
{ {
if( (tabdata.hart_enable == 0)&&(mux_set_flag) ) if( (tabdata.hart_enable == 0)&&(mux_set_flag) )
{ {
frequence_output(mux_signal->data_sv, pulse, PWM_MUX); //设定 frequence_output(mux_signal->data_sv, pulse, PWM_MUX); //设定
fre_set_mux = mux_signal->data_sv; fre_set_mux = mux_signal->data_sv;
} }
} }
@ -261,15 +285,15 @@ void mux_signal_switch(st_mux_signal *mux_signal)
break; break;
case CH6_IN_VOL: case CH6_IN_VOL:
fun_get_sig16132_ch(2, &mux_signal->data_pv); //输入采集 fun_get_sig16132_ch(MUX_CHANNEL_V_IN, &mux_signal->data_pv); //输入采集
break; break;
case CH7_IN_MVOL: case CH7_IN_MVOL:
fun_get_sig16132_ch(3, &mux_signal->data_pv); //输入采集 fun_get_sig16132_ch(MUX_CHANNEL_MV_IN, &mux_signal->data_pv); //输入采集
break; break;
case CH8_IN_CUR: case CH8_IN_CUR:
fun_get_sig16132_ch(5, &mux_signal->data_pv); //输入采集 fun_get_sig16132_ch(MUX_CHANNEL_MA_IN, &mux_signal->data_pv); //输入采集
break; break;
case CH9_IN_FRE: case CH9_IN_FRE:

33
App/MUX_SIGNAL/mux_signal.h
View File

@ -3,10 +3,25 @@
#include "data_type_def.h" #include "data_type_def.h"
#include "gpio.h" #include "gpio.h"
#include "dac.h"
#include <SIG24130.h>
#include "dac8552.h"
#include "dac7811.h"
#include "ads1220.h"
#include "apps_gather.h"
#define PWM_MUX 0 #define PWM_MUX 0
#define PWM_HART 1 #define PWM_HART 1
#define CALIBRATE_VOL_V_OUT_POINTS 11
#define CALIBRATE_VOL_MV_OUT_POINTS 11
#define CALIBRATE_CUR_MA_OUT_POINTS 11
#define CALIBRATE_RES_OHM_OUT_POINTS 11
#define CALIBRATE_CUR_MA_IN_POINTS 11
#define CALIBRATE_VOL_V_IN_POINTS 11
#define CALIBRATE_VOL_MV_IN_POINTS 11
#define CALIBRATE_RES_OHM_IN_POINTS 11
typedef enum typedef enum
{ {
CH0_OUT_VOL_V = 0, CH0_OUT_VOL_V = 0,
@ -56,10 +71,28 @@ typedef struct
float32 data_pv; float32 data_pv;
float32 pwr_delay; float32 pwr_delay;
float32 sv_calibrated; float32 sv_calibrated;
float32 pv_calibrated;
} st_mux_signal; } st_mux_signal;
typedef struct
{
//信号输出
float32 cali_vol_V_out[CALIBRATE_VOL_V_OUT_POINTS];
float32 cali_vol_mV_out[CALIBRATE_VOL_MV_OUT_POINTS];
float32 cali_cur_mA_out[CALIBRATE_CUR_MA_OUT_POINTS];
float32 cali_res_ohm_out[CALIBRATE_RES_OHM_OUT_POINTS];
//信号输入
float32 cali_vol_V_in[CALIBRATE_VOL_V_IN_POINTS];
float32 cali_vol_mV_in[CALIBRATE_VOL_MV_IN_POINTS];
float32 cali_cur_mA_in[CALIBRATE_CUR_MA_IN_POINTS];
float32 cali_res_ohm_in[CALIBRATE_RES_OHM_IN_POINTS];
}CALIBRATE_PARAGRAMS;
extern st_freq_signal freq_signal; extern st_freq_signal freq_signal;
extern st_mux_signal mux_signal; extern st_mux_signal mux_signal;
extern CALIBRATE_PARAGRAMS cali_paras;
void pwr_cosume(BOOL rst, uint32_t ms); void pwr_cosume(BOOL rst, uint32_t ms);
void mux_signal_switch(st_mux_signal *mux_signal); void mux_signal_switch(st_mux_signal *mux_signal);

312
App/SIG24130/SIG24130.c
View File

@ -55,6 +55,9 @@
// Add printf1 for debug purpose to print out register content. // Add printf1 for debug purpose to print out register content.
#include "usart.h" #include "usart.h"
#include <stdio.h> #include <stdio.h>
#include "mux_signal.h"
#include "eeprom_spi.h"
#define printf1(...) HAL_UART_Transmit((UART_HandleTypeDef *)&huart1, (uint8_t *)u1_buf, \ #define printf1(...) HAL_UART_Transmit((UART_HandleTypeDef *)&huart1, (uint8_t *)u1_buf, \
sprintf((char *)u1_buf, __VA_ARGS__), 0xFFFF); sprintf((char *)u1_buf, __VA_ARGS__), 0xFFFF);
uint8_t u1_buf[256]; uint8_t u1_buf[256];
@ -595,6 +598,7 @@ unsigned long SIG16130_RetrievalData(uint8_t rdata, uint8_t chksum)
return (SIG16130_adc_data); return (SIG16130_adc_data);
} }
float32 cali_test = 0;
void fun_get_sig16132_ch(uint8_t channel, float32 *data) void fun_get_sig16132_ch(uint8_t channel, float32 *data)
{ {
if (!data) if (!data)
@ -647,47 +651,317 @@ void fun_get_sig16132_ch(uint8_t channel, float32 *data)
float32 voltage = (float32)(2.5f * ad_16 / 32767.0f); float32 voltage = (float32)(2.5f * ad_16 / 32767.0f);
//float32 Rt = 0; //float32 Rt = 0;
if (channel == 2) // 0~30V电压输入检测 if (channel == MUX_CHANNEL_V_IN) // if (channel == 2) // 0~30V电压输入检测
{ {
*data = voltage * 16.0f; *data = voltage * 16.0f;
mux_signal.pv_calibrated = calibrate_vol_v_in(cali_test);
//mux_signal.pv_calibrated = calibrate_vol_v_in(*data);
} }
else if (channel == 3) // mV电压输入检测 else if (channel == MUX_CHANNEL_MV_IN) //else if (channel == 3) // mV电压输入检测
{ {
*data = voltage * 1000.0f - 0.2f; *data = voltage * 1000.0f - 0.2f;
mux_signal.pv_calibrated = *data;
} }
else if (channel == 4) //-2.5~2.5V输出反馈 else if (channel == MUX_CHANNEL_MV_FEEDBACK) //else if (channel == 4) //-2.5~2.5V输出反馈
{ {
*data = 2.0f * voltage - 2.5f; *data = 2.0f * voltage - 2.5f;
*data *= 1000; //V -> mV *data *= 1000; //V -> mV
mux_signal.pv_calibrated = *data;
} }
else if (channel == 5) // 4`20mA输入检测 else if (channel == MUX_CHANNEL_MA_IN) //else if (channel == 5) // 4`20mA输入检测
{ {
*data = voltage / 100.0f * 1000.0f; *data = voltage / 100.0f * 1000.0f;
//mux_signal.pv_calibrated = calibrate_cur_ma_in(cali_test);
mux_signal.pv_calibrated = calibrate_cur_ma_in(*data);
} }
else if (channel == 7) // 4`20mA输出反馈 else if (channel == MUX_CHANNEL_MA_FEEDBACK) //else if (channel == 7) // 4`20mA输出反馈
{ {
*data = voltage * 1000.0f * 0.02f * 0.5f; *data = voltage * 1000.0f * 0.02f * 0.5f;
mux_signal.pv_calibrated = *data;
} }
else if (channel == 10) // RTD输入检测 else if (channel == MUX_CHANNEL_RTD_IN) //else if (channel == 10) // RTD输入检测
{ {
// 在0～650℃范围内： // 在0～650℃范围内：
// Rt =R0 (1+At+Bt2) // Rt =R0 (1+At+Bt2)
// 在-190～0℃范围内： // 在-190～0℃范围内：
// Rt =R0 (1+At+Bt2+C(t-100)t3) // Rt =R0 (1+At+Bt2+C(t-100)t3)
// 式中A、B、C 为常数， // 式中A、B、C 为常数，
// A=3.96847×10-3； // A=3.96847×10-3；
// B=-5.847×10-7； // B=-5.847×10-7；
// C=-4.22×10-12； // C=-4.22×10-12；
// #define R0 100.0f // #define R0 100.0f
// #define A 3.96847e-3 // #define A 3.96847e-3
// #define B -5.847e-7 // #define B -5.847e-7
// #define C -4.22e-12 // #define C -4.22e-12
// Rt = voltage * 1000.0f / 1.0f; // Rt = voltage * 1000.0f / 1.0f;
// float32 temp1 = (-A + sqrt(A * A - 4 * B * (1 - Rt / R0))) / (2 * B); // float32 temp1 = (-A + sqrt(A * A - 4 * B * (1 - Rt / R0))) / (2 * B);
// float32 temp2 = (-A - sqrt(A * A - 4 * B * (1 - Rt / R0))) / (2 * B); // float32 temp2 = (-A - sqrt(A * A - 4 * B * (1 - Rt / R0))) / (2 * B);
// *data = temp1; // *data = temp1;
*data = voltage * 1000.0f/ 0.5f; *data = voltage * 1000.0f/ 0.5f;
mux_signal.pv_calibrated = *data;
} }
} }
} }
uint8_t curma_in_cal_enable = 0;
float calibrate_cur_ma_in(float raw)
{
float result = 0;
switch (curma_in_cal_enable)
{
case 0:
{
//开机后只读一次
uint16_t cal_check = 0;
cal_check = eeprom_readdata(CAL_CUR_MA_IN_ADDR_FLAG) << 8;
cal_check |= eeprom_readdata(CAL_CUR_MA_IN_ADDR_FLAG + 8) & 0x00FF;
if(cal_check != 0xAAAA)
{
//不存在校准数据
curma_in_cal_enable = 2;
}
else
{
//存在校准数据
curma_in_cal_enable = 1;
//将读到的数据存储至cur_ma_in_calibrate_table
eeprom_dataread_single(EEPROM_TAG_CAL_CUR_MA_IN);
}
}
break;
case 1:
{
//执行校准
//计算区间间隔（按照规定的点数，在量程范围内平均分配）
float interval = (float32)(CALIBRATE_CUR_MA_IN_END - CALIBRATE_CUR_MA_IN_START)/(float32)(CALIBRATE_CUR_MA_IN_POINTS - 1);
//校准结果 = 所处区间的左端点 + 区间长度 * 换算比例
for( uint8_t i = 0; i < CALIBRATE_CUR_MA_IN_POINTS - 1; i++)
{
if( (cali_paras.cali_cur_mA_in[i] <= raw)&&(raw <= cali_paras.cali_cur_mA_in[i + 1]) )
{
result = CALIBRATE_CUR_MA_IN_START + i*interval;
result += interval * (raw - cali_paras.cali_cur_mA_in[i])/(cali_paras.cali_cur_mA_in[i + 1] - cali_paras.cali_cur_mA_in[i]);
break;
}
}
}
break;
case 2:
{
//不执行校准
result = raw;
}
break;
default:
break;
}
return result;
}
uint8_t volv_in_cal_enable = 0;
float calibrate_vol_v_in(float raw)
{
float result = 0;
switch (volv_in_cal_enable)
{
case 0:
{
//开机后只读一次
uint16_t cal_check = 0;
cal_check = eeprom_readdata(CAL_VOL_V_IN_ADDR_FLAG) << 8;
cal_check |= eeprom_readdata(CAL_VOL_V_IN_ADDR_FLAG + 8) & 0x00FF;
if(cal_check != 0xAAAA)
{
//不存在校准数据
volv_in_cal_enable = 2;
}
else
{
//存在校准数据
volv_in_cal_enable = 1;
//将读到的数据存储至cur_ma_in_calibrate_table
eeprom_dataread_single(EEPROM_TAG_CAL_VOL_V_IN);
}
}
break;
case 1:
{
//执行校准
//计算区间间隔（按照规定的点数，在量程范围内平均分配）
float interval = (float32)(CALIBRATE_VOL_V_IN_END - CALIBRATE_VOL_V_IN_START)/(float32)(CALIBRATE_VOL_V_IN_POINTS - 1);
//校准结果 = 所处区间的左端点 + 区间长度 * 换算比例
for( uint8_t i = 0; i < CALIBRATE_VOL_V_IN_POINTS - 1; i++)
{
if( (cali_paras.cali_vol_V_in[i] <= raw)&&(raw <= cali_paras.cali_vol_V_in[i + 1]) )
{
result = CALIBRATE_VOL_V_IN_START + i*interval;
result += interval * (raw - cali_paras.cali_vol_V_in[i])/(cali_paras.cali_vol_V_in[i + 1] - cali_paras.cali_vol_V_in[i]);
break;
}
}
}
break;
case 2:
{
//不执行校准
result = raw;
}
break;
default:
break;
}
return result;
}
uint8_t volmv_in_cal_enable = 0;
float calibrate_vol_mv_in(float raw)
{
float result = 0;
switch (volmv_in_cal_enable)
{
case 0:
{
//开机后只读一次
uint16_t cal_check = 0;
cal_check = eeprom_readdata(CAL_VOL_MV_IN_ADDR_FLAG) << 8;
cal_check |= eeprom_readdata(CAL_VOL_MV_IN_ADDR_FLAG + 8) & 0x00FF;
if(cal_check != 0xAAAA)
{
//不存在校准数据
volmv_in_cal_enable = 2;
}
else
{
//存在校准数据
volmv_in_cal_enable = 1;
//将读到的数据存储至cur_ma_in_calibrate_table
eeprom_dataread_single(EEPROM_TAG_CAL_VOL_MV_IN);
}
}
break;
case 1:
{
//执行校准
//计算区间间隔（按照规定的点数，在量程范围内平均分配）
float interval = (float32)(CALIBRATE_VOL_MV_IN_END - CALIBRATE_VOL_MV_IN_START)/(float32)(CALIBRATE_VOL_MV_IN_POINTS - 1);
//校准结果 = 所处区间的左端点 + 区间长度 * 换算比例
for( uint8_t i = 0; i < CALIBRATE_VOL_MV_IN_POINTS - 1; i++)
{
if( (cali_paras.cali_vol_mV_in[i] <= raw)&&(raw <= cali_paras.cali_vol_mV_in[i + 1]) )
{
result = CALIBRATE_VOL_MV_IN_START + i*interval;
result += interval * (raw - cali_paras.cali_vol_mV_in[i])/(cali_paras.cali_vol_mV_in[i + 1] - cali_paras.cali_vol_mV_in[i]);
break;
}
}
}
break;
case 2:
{
//不执行校准
result = raw;
}
break;
default:
break;
}
return result;
}
uint8_t resohm_in_cal_enable = 0;
float calibrate_res_ohm_in(float raw)
{
float result = 0;
switch (resohm_in_cal_enable)
{
case 0:
{
//开机后只读一次
uint16_t cal_check = 0;
cal_check = eeprom_readdata(CAL_RES_OHM_IN_ADDR_FLAG) << 8;
cal_check |= eeprom_readdata(CAL_RES_OHM_IN_ADDR_FLAG + 8) & 0x00FF;
if(cal_check != 0xAAAA)
{
//不存在校准数据
resohm_in_cal_enable = 2;
}
else
{
//存在校准数据
resohm_in_cal_enable = 1;
//将读到的数据存储至cur_ma_in_calibrate_table
eeprom_dataread_single(EEPROM_TAG_CAL_RES_OHM_IN);
}
}
break;
case 1:
{
//执行校准
//计算区间间隔（按照规定的点数，在量程范围内平均分配）
float interval = (float32)(CALIBRATE_RES_OHM_IN_END - CALIBRATE_RES_OHM_IN_START)/(float32)(CALIBRATE_RES_OHM_IN_POINTS - 1);
//校准结果 = 所处区间的左端点 + 区间长度 * 换算比例
for( uint8_t i = 0; i < CALIBRATE_RES_OHM_IN_POINTS - 1; i++)
{
if( (cali_paras.cali_res_ohm_in[i] <= raw)&&(raw <= cali_paras.cali_res_ohm_in[i + 1]) )
{
result = CALIBRATE_RES_OHM_IN_START + i*interval;
result += interval * (raw - cali_paras.cali_res_ohm_in[i])/(cali_paras.cali_res_ohm_in[i + 1] - cali_paras.cali_res_ohm_in[i]);
break;
}
}
}
break;
case 2:
{
//不执行校准
result = raw;
}
break;
default:
break;
}
return result;
}

90
App/SIG24130/SIG24130.h
View File

@ -140,42 +140,72 @@ extern "C"
#define CURRENT_500uA 0x06 #define CURRENT_500uA 0x06
#define CURRENT_1000uA 0x07 #define CURRENT_1000uA 0x07
extern void delay_nus(int nus); //channels
extern void SIG24130_SendByte(uint8_t data); #define MUX_CHANNEL_V_IN 2
extern uint8_t SIG24130_ReceiveByte(void); #define MUX_CHANNEL_MV_IN 3
extern uint8_t SPIDEV1_transfer(uint8_t *send, uint8_t *receive, uint8_t bytes_num); #define MUX_CHANNEL_MV_FEEDBACK 4
#define MUX_CHANNEL_MA_IN 5
#define MUX_CHANNEL_MA_FEEDBACK 7
#define MUX_CHANNEL_RTD_IN 10
extern void SIG24130_WriteRegister(uint8_t addr, uint8_t H_DATA, uint8_t M_DATA, uint8_t L_DATA); #define CALIBRATE_CUR_MA_IN_START 0
extern uint32_t SIG24130_ReadRegister(uint8_t addr); #define CALIBRATE_CUR_MA_IN_END 25
extern void SIG24130_SetInputMux(uint8_t muxp, uint8_t muxn); #define CALIBRATE_VOL_V_IN_START 0
extern void SIG24130_SetSpeed(uint8_t speed); #define CALIBRATE_VOL_V_IN_END 30
extern void SIG24130_SetFilter(uint8_t sinc4, uint8_t rej60);
extern void SIG24130_SetGain(uint8_t gain);
extern void SIG24130_SetBuffer(uint8_t buffer);
extern void SIG24130_SetRefMux(uint8_t refmux);
extern void SIG24130_SetSingleShot(uint8_t single);
extern void SIG24130_SetZeroLatency(uint8_t latency);
extern void SIG24130_SetIDAC(uint8_t idac_size, uint8_t idac2_mux, uint8_t idac1_mux, uint8_t idac_pair); #define CALIBRATE_VOL_MV_IN_START -2.5f
extern void SIG24130_SetBCS(uint8_t burnout); #define CALIBRATE_VOL_MV_IN_END 2.5f
extern void SIG24130_SetVbias(uint8_t vbias);
extern void SIG24130_SetDelay(uint8_t delay);
extern void SIG24130_SetRefOut(uint8_t refout);
extern void SIG24130_Reset(void); #define CALIBRATE_RES_OHM_IN_START 18.52f
extern void SIG24130_Sync(void); #define CALIBRATE_RES_OHM_IN_END 332.79f
extern void SIG24130_Sleep(void);
extern void SIG24130_Wakeup(void);
extern void SIG24130_SYSOCAL(void);
extern void SIG24130_SYSGCAL(void);
extern void SIG24130_SELFOCAL(void);
extern void SIG24130_Init(void);
extern unsigned long SIG24130_RetrievalData(uint8_t rdata, uint8_t chksum); extern void delay_nus(int nus);
extern unsigned long SIG16130_RetrievalData(uint8_t rdata, uint8_t chksum); extern void SIG24130_SendByte(uint8_t data);
extern uint8_t SIG24130_ReceiveByte(void);
extern uint8_t SPIDEV1_transfer(uint8_t *send, uint8_t *receive, uint8_t bytes_num);
extern void fun_get_sig16132_ch(uint8_t channel, float32 *data); extern void SIG24130_WriteRegister(uint8_t addr, uint8_t H_DATA, uint8_t M_DATA, uint8_t L_DATA);
extern uint32_t SIG24130_ReadRegister(uint8_t addr);
extern void SIG24130_SetInputMux(uint8_t muxp, uint8_t muxn);
extern void SIG24130_SetSpeed(uint8_t speed);
extern void SIG24130_SetFilter(uint8_t sinc4, uint8_t rej60);
extern void SIG24130_SetGain(uint8_t gain);
extern void SIG24130_SetBuffer(uint8_t buffer);
extern void SIG24130_SetRefMux(uint8_t refmux);
extern void SIG24130_SetSingleShot(uint8_t single);
extern void SIG24130_SetZeroLatency(uint8_t latency);
extern void SIG24130_SetIDAC(uint8_t idac_size, uint8_t idac2_mux, uint8_t idac1_mux, uint8_t idac_pair);
extern void SIG24130_SetBCS(uint8_t burnout);
extern void SIG24130_SetVbias(uint8_t vbias);
extern void SIG24130_SetDelay(uint8_t delay);
extern void SIG24130_SetRefOut(uint8_t refout);
extern void SIG24130_Reset(void);
extern void SIG24130_Sync(void);
extern void SIG24130_Sleep(void);
extern void SIG24130_Wakeup(void);
extern void SIG24130_SYSOCAL(void);
extern void SIG24130_SYSGCAL(void);
extern void SIG24130_SELFOCAL(void);
extern void SIG24130_Init(void);
extern unsigned long SIG24130_RetrievalData(uint8_t rdata, uint8_t chksum);
extern unsigned long SIG16130_RetrievalData(uint8_t rdata, uint8_t chksum);
extern void fun_get_sig16132_ch(uint8_t channel, float32 *data);
float calibrate_cur_ma_in(float raw);
float calibrate_vol_v_in(float raw);
float calibrate_vol_mv_in(float raw);
float calibrate_res_ohm_in(float raw);
extern uint8_t curma_in_cal_enable;
extern uint8_t volv_in_cal_enable;
extern uint8_t volmv_in_cal_enable;
extern uint8_t resohm_in_cal_enable;
#ifdef __cplusplus #ifdef __cplusplus
} }

8
Core/Inc/dac.h
View File

@ -39,17 +39,15 @@ extern DAC_HandleTypeDef hdac;
/* USER CODE BEGIN Private defines */ /* USER CODE BEGIN Private defines */
#define CALIBRATE_VOL_V_OUT_START 0 #define CALIBRATE_VOL_V_OUT_START 0
#define CALIBRATE_VOL_V_OUT_END 30 #define CALIBRATE_VOL_V_OUT_END 30
#define CALIBRATE_VOL_V_OUT_POINTS 11
/* USER CODE END Private defines */ /* USER CODE END Private defines */
void MX_DAC_Init(void); void MX_DAC_Init(void);
/* USER CODE BEGIN Prototypes */ /* USER CODE BEGIN Prototypes */
void dac_set_voltage(float *vol); void dac_set_voltage(float *vol);
float calibrate_vol_v_out(float raw); float calibrate_vol_v_out(float raw);
extern float vol_v_out_calibrate_table[CALIBRATE_VOL_V_OUT_POINTS]; extern uint8_t volv_out_cal_enable;
extern uint8_t volv_out_cal_enable;
/* USER CODE END Prototypes */ /* USER CODE END Prototypes */
#ifdef __cplusplus #ifdef __cplusplus

7
Core/Src/dac.c
View File

@ -124,8 +124,6 @@ void HAL_DAC_MspDeInit(DAC_HandleTypeDef* dacHandle)
} }
/* USER CODE BEGIN 1 */ /* USER CODE BEGIN 1 */
float vol_v_out_calibrate_table[CALIBRATE_VOL_V_OUT_POINTS] = {0};
uint8_t volv_out_cal_enable = 0;
void dac_set_voltage(float *vol) void dac_set_voltage(float *vol)
{ {
@ -166,6 +164,7 @@ void dac_set_voltage(float *vol)
HAL_DAC_SetValue(&hdac, DAC_CHANNEL_1, DAC_ALIGN_12B_R, temp); HAL_DAC_SetValue(&hdac, DAC_CHANNEL_1, DAC_ALIGN_12B_R, temp);
} }
uint8_t volv_out_cal_enable = 0;
float calibrate_vol_v_out(float raw) float calibrate_vol_v_out(float raw)
{ {
float result = 0; float result = 0;
@ -202,10 +201,10 @@ float calibrate_vol_v_out(float raw)
for( uint8_t i = 0; i < CALIBRATE_VOL_V_OUT_POINTS - 1; i++) for( uint8_t i = 0; i < CALIBRATE_VOL_V_OUT_POINTS - 1; i++)
{ {
if( (vol_v_out_calibrate_table[i] <= raw)&&(raw <= vol_v_out_calibrate_table[i + 1]) ) if( (cali_paras.cali_vol_V_out[i] <= raw)&&(raw <= cali_paras.cali_vol_V_out[i + 1]) )
{ {
result = CALIBRATE_VOL_V_OUT_START + i*interval; //所处区间的左端点 result = CALIBRATE_VOL_V_OUT_START + i*interval; //所处区间的左端点
result += interval * (raw - vol_v_out_calibrate_table[i])/(vol_v_out_calibrate_table[i + 1] - vol_v_out_calibrate_table[i]); result += interval * (raw - cali_paras.cali_vol_V_out[i])/(cali_paras.cali_vol_V_out[i + 1] - cali_paras.cali_vol_V_out[i]);
break; break;
} }
} }

14
MDK-ARM/signal_generator.uvoptx
View File

@ -268,22 +268,12 @@
<Ww> <Ww>
<count>22</count> <count>22</count>
<WinNumber>1</WinNumber> <WinNumber>1</WinNumber>
<ItemText>vol_v_out_calibrate_table,0x0A</ItemText> <ItemText>cali_paras</ItemText>
</Ww> </Ww>
<Ww> <Ww>
<count>23</count> <count>23</count>
<WinNumber>1</WinNumber> <WinNumber>1</WinNumber>
<ItemText>cur_ma_out_calibrate_table,0x0A</ItemText> <ItemText>cali_test</ItemText>
</Ww>
<Ww>
<count>24</count>
<WinNumber>1</WinNumber>
<ItemText>vol_mv_out_calibrate_table</ItemText>
</Ww>
<Ww>
<count>25</count>
<WinNumber>1</WinNumber>
<ItemText>res_ohm_out_calibrate_table</ItemText>
</Ww> </Ww>
</WatchWindow1> </WatchWindow1>
<WatchWindow2> <WatchWindow2>

38238
MDK-ARM/signal_generator/signal_generator.hex
View File

File diff suppressed because it is too large Load Diff