|
|
|
@ -24,7 +24,7 @@ |
|
|
|
#define D_ch2_0kg_out1_adc (vS16)0xFFB3 |
|
|
|
#define D_ch3_0kg_out1_adc (vS16)0x00A4 |
|
|
|
#define D_ch4_0kg_out1_adc (vS16)0xFFEA |
|
|
|
/////需要通过测试配置 如果不在意符号位 可以优化 diao
|
|
|
|
/////需要通过测试配置 如果不在意符号位 可以优化掉
|
|
|
|
#define D_ch1_out1_offset (vS16)(D_ch1_wantline-D_ch1_0kg_out1_adc) |
|
|
|
#define D_ch2_out1_offset (vS16)(D_ch2_wantline-D_ch2_0kg_out1_adc) |
|
|
|
#define D_ch3_out1_offset (vS16)(D_ch3_wantline-D_ch3_0kg_out1_adc) |
|
|
|
@ -50,34 +50,34 @@ |
|
|
|
TS_adc_SPara_ TS_adc_SPara[D_ADC_CHANNEL_NUM]= |
|
|
|
{ |
|
|
|
|
|
|
|
'A',//0 1 u8 rev1;
|
|
|
|
0,//2 3 u8 ch;
|
|
|
|
D_ch1_wantline,///vU16 wantline; ///固定的硬件参数（例如称重中的0kg，压力中的0压力）时想要输出的adc的值
|
|
|
|
D_ch1_out1_offset,//3 4 vU16 offset;
|
|
|
|
2,//4 5 vU8 ashift; ///移动的位数 1-2 2-4 3-8 4-16
|
|
|
|
5,//5 6 vU8 bshift; ///移动的位数 1-2 2-4 3-8 4-16
|
|
|
|
'A', //0 1 u8 rev1;
|
|
|
|
0, //2 3 u8 ch;
|
|
|
|
D_ch1_wantline, //vU16 wantline; ///固定的硬件参数（例如称重中的0kg，压力中的0压力）时想要输出的adc的值
|
|
|
|
D_ch1_out1_offset, //3 4 vU16 offset;
|
|
|
|
2, //4 5 vU8 ashift; ///移动的位数 1-2 2-4 3-8 4-16
|
|
|
|
5, //5 6 vU8 bshift; ///移动的位数 1-2 2-4 3-8 4-16
|
|
|
|
|
|
|
|
'A',//0 1 u8 rev1;
|
|
|
|
1,//2 3 u8 ch;
|
|
|
|
D_ch1_wantline,///vU16 wantline; ///固定的硬件参数（例如称重中的0kg，压力中的0压力）时想要输出的adc的值
|
|
|
|
D_ch2_out1_offset,//3 4 vU16 offset;
|
|
|
|
2,//4 5 vU8 ashift; ///移动的位数 1-2 2-4 3-8 4-16
|
|
|
|
5,//5 6 vU8 bshift; ///移动的位数 1-2 2-4 3-8 4-16
|
|
|
|
'A', //0 1 u8 rev1;
|
|
|
|
1, //2 3 u8 ch;
|
|
|
|
D_ch1_wantline, //vU16 wantline; ///固定的硬件参数（例如称重中的0kg，压力中的0压力）时想要输出的adc的值
|
|
|
|
D_ch2_out1_offset, //3 4 vU16 offset;
|
|
|
|
2, //4 5 vU8 ashift; ///移动的位数 1-2 2-4 3-8 4-16
|
|
|
|
5, //5 6 vU8 bshift; ///移动的位数 1-2 2-4 3-8 4-16
|
|
|
|
|
|
|
|
'A',//0 1 u8 rev1;
|
|
|
|
2,//2 3 u8 ch;
|
|
|
|
D_ch1_wantline,///vU16 wantline; ///固定的硬件参数（例如称重中的0kg，压力中的0压力）时想要输出的adc的值
|
|
|
|
D_ch3_out1_offset,//3 4 vU16 offset;
|
|
|
|
2,//4 5 vU8 ashift; ///移动的位数 1-2 2-4 3-8 4-16
|
|
|
|
5,//5 6 vU8 bshift; ///移动的位数 1-2 2-4 3-8 4-16
|
|
|
|
'A', //0 1 u8 rev1;
|
|
|
|
2, //2 3 u8 ch;
|
|
|
|
D_ch1_wantline, //vU16 wantline; ///固定的硬件参数（例如称重中的0kg，压力中的0压力）时想要输出的adc的值
|
|
|
|
D_ch3_out1_offset, //3 4 vU16 offset;
|
|
|
|
2, //4 5 vU8 ashift; ///移动的位数 1-2 2-4 3-8 4-16
|
|
|
|
5, //5 6 vU8 bshift; ///移动的位数 1-2 2-4 3-8 4-16
|
|
|
|
|
|
|
|
|
|
|
|
'A',//0 1 u8 rev1;
|
|
|
|
3,//2 3 u8 ch;
|
|
|
|
D_ch1_wantline,///vU16 wantline; ///固定的硬件参数（例如称重中的0kg，压力中的0压力）时想要输出的adc的值
|
|
|
|
D_ch4_out1_offset,//3 4 vU16 offset;
|
|
|
|
2,//4 5 vU8 ashift; ///移动的位数 1-2 2-4 3-8 4-16
|
|
|
|
5//5 6 vU8 bshift; ///移动的位数 1-2 2-4 3-8 4-16
|
|
|
|
'A', //0 1 u8 rev1;
|
|
|
|
3, //2 3 u8 ch;
|
|
|
|
D_ch1_wantline, //vU16 wantline; ///固定的硬件参数（例如称重中的0kg，压力中的0压力）时想要输出的adc的值
|
|
|
|
D_ch4_out1_offset, //3 4 vU16 offset;
|
|
|
|
2, //4 5 vU8 ashift; ///移动的位数 1-2 2-4 3-8 4-16
|
|
|
|
5 //5 6 vU8 bshift; ///移动的位数 1-2 2-4 3-8 4-16
|
|
|
|
|
|
|
|
|
|
|
|
}; |
|
|
|
@ -264,7 +264,7 @@ L3_task_weight_cal(); |
|
|
|
void L2_task_adc_sample(TS_task_adc_sample *s) |
|
|
|
{ |
|
|
|
TTSS_Task_init(): |
|
|
|
////cc 初始化尽量放到这里，不要放到main ——init中，减少系统启动的时间
|
|
|
|
////cc 初始化尽量放到这里，不要放到main——init中，减少系统启动的时间
|
|
|
|
s->jitter_start = 0; s->ok = 0; |
|
|
|
////printf("\r\nADC_SAMPLE\r\n");
|
|
|
|
/*
|
|
|
|
@ -273,8 +273,8 @@ void L2_task_adc_sample(TS_task_adc_sample *s) |
|
|
|
ts_adc_samples[s->pSPara->ch].pSPara->offset,ts_adc_samples[s->pSPara->ch].pSPara->offset); |
|
|
|
*/ |
|
|
|
|
|
|
|
printf1("\r\nADC_SAMPLE init ch(%d) ", (int)s->pSPara->ch); |
|
|
|
L1_uartD_waitFree() ; |
|
|
|
printf1("\r\nADC_SAMPLE init ch(%d)",(int)s->pSPara->ch); |
|
|
|
L1_uartD_waitFree(); |
|
|
|
|
|
|
|
s->firstRun = 1; |
|
|
|
|
|
|
|
@ -379,347 +379,6 @@ void L2_task_adc_sample(TS_task_adc_sample *s) |
|
|
|
} |
|
|
|
|
|
|
|
#if 0 |
|
|
|
void L3_out_zero(u8 ch) |
|
|
|
{ |
|
|
|
vS16 t,m; |
|
|
|
|
|
|
|
|
|
|
|
t = ts_adc_samples[ch].out1_adc; |
|
|
|
m = ts_adc_samples[ch].SPara.wantline; |
|
|
|
m -= t; |
|
|
|
ts_adc_samples[ch].SPara.offset = (vU16)m; |
|
|
|
/// L0_waitFree_uartN(0);///混搭使用printf的时候必须加上
|
|
|
|
/// printf("\r\nzeroout = %4x offset= 0x%4x\r\n", ts_adc_samples[ch].zeroout,ts_adc_samples[ch].offset);
|
|
|
|
|
|
|
|
/// D_ADC_OFFSET(ch) = ts_adc_samples[ch].zeroout - ts_adc_samples[ch].out1;
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
vU16 L3_out_offset222(u8 ch,vU16 t16) |
|
|
|
{ |
|
|
|
vU16 out; |
|
|
|
|
|
|
|
/// L0_uart0_ushex(t16); L0_uart0_uc(' ');
|
|
|
|
if(t16 & 0x8000) //最高位为1，<0则
|
|
|
|
{ |
|
|
|
t16 = 0xffFF - t16;///转变为正数
|
|
|
|
///*d = D_ADC_OFFSET - t16;
|
|
|
|
out = ts_adc_samples[ch].SPara.offset - t16; |
|
|
|
// L0_uart0_uc('$'); L0_uart0_ushex(ts_adc_samples[ch].offset);L0_uart0_uc(' ');
|
|
|
|
}else |
|
|
|
{ |
|
|
|
out = t16 + ts_adc_samples[ch].SPara.offset; |
|
|
|
} |
|
|
|
// L0_uart0_ushex(out);L0_uart0_uc(' '); L0_uart0_uc('R');L0_uart0_0d0a();
|
|
|
|
return out; |
|
|
|
} |
|
|
|
|
|
|
|
vU16 L3_out_tran2(vU32 rdata) |
|
|
|
{ |
|
|
|
vU16 t16; |
|
|
|
//// L0_ADS1231_readCH2(0,&rdata);
|
|
|
|
// L0_uart0_uc('0'+ch); L0_uart0_uc(0x09);
|
|
|
|
// L0_uart0_ulhex(rdata); L0_uart0_uc(0x09);
|
|
|
|
if (rdata > 0x007fFFff) |
|
|
|
{ |
|
|
|
rdata >>= D_sensor_zoom; ///fixme:此处正负差和移位不一致需要谨慎
|
|
|
|
rdata |= D_sensor_zoom_FF; /// 1111 1100
|
|
|
|
}else |
|
|
|
{ |
|
|
|
rdata >>= D_sensor_zoom; |
|
|
|
} |
|
|
|
|
|
|
|
// L0_uart0_ulhex(rdata); L0_uart0_uc(0x09);
|
|
|
|
t16 = rdata; |
|
|
|
// L0_uart0_ushex(t16); L0_uart0_uc(0x09);
|
|
|
|
///L0_uart0_0d0a();
|
|
|
|
return t16; |
|
|
|
} |
|
|
|
|
|
|
|
void L3_task_show_init(void) |
|
|
|
{ |
|
|
|
//显示任务初始化
|
|
|
|
L1_task_init(&ts_adc_blur_show.task); |
|
|
|
L3_task_s_go(ts_adc_blur_show,D_task_init); |
|
|
|
ts_adc_blur_show.rough_weight = 0; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
//中值滤波任务
|
|
|
|
#define D_task_ADC_CHx_FILTER_MID_GET 0x50 |
|
|
|
#define D_task_ADC_CHx_FILTER_MID_COUNT 0x51 |
|
|
|
#define D_task_ADC_CHx_FILTER_MID_OUT 0x52 |
|
|
|
void L3_task_adc_filter_mid(S_TASK_ADC_BLUR_MID *s) |
|
|
|
{ |
|
|
|
TTSS_Task_init() |
|
|
|
L2_task_go(D_task_ADC_CHx_FILTER_MID_GET); |
|
|
|
|
|
|
|
TTSS_Task_step(D_task_ADC_CHx_FILTER_MID_GET) |
|
|
|
if(ts_adc_channel_samples[s->ch].n >= s->max) |
|
|
|
{ |
|
|
|
U8 i = 0; |
|
|
|
for(i=0;i<s->max;i++) |
|
|
|
{ |
|
|
|
s->in[i] = ts_adc_channel_samples[s->ch].out1[i]; |
|
|
|
} |
|
|
|
ts_adc_channel_samples[s->ch].n = 0; |
|
|
|
L2_task_go(D_task_ADC_CHx_FILTER_MID_COUNT); |
|
|
|
} |
|
|
|
|
|
|
|
TTSS_Task_step(D_task_ADC_CHx_FILTER_MID_COUNT) |
|
|
|
s->midval = Lc_S32_media(s->in, s->max); |
|
|
|
L2_task_go(D_task_ADC_CHx_FILTER_MID_OUT); |
|
|
|
|
|
|
|
TTSS_Task_step(D_task_ADC_CHx_FILTER_MID_OUT) |
|
|
|
s->out[s->n] = s->midval; |
|
|
|
//R.adval[s->ch] = s->out[s->n];
|
|
|
|
s->n++; |
|
|
|
if(s->n >= MAX_OUT_NUM) |
|
|
|
{ |
|
|
|
s->n = 0; |
|
|
|
} |
|
|
|
L2_task_go(D_task_ADC_CHx_FILTER_MID_GET); |
|
|
|
|
|
|
|
TTSS_Task_end(); |
|
|
|
|
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
//均值滤波任务
|
|
|
|
#define D_task_ADC_CHx_FILTER_AVG_GET 0x50 |
|
|
|
#define D_task_ADC_CHx_FILTER_AVG_COUNT 0x51 |
|
|
|
#define D_task_ADC_CHx_FILTER_AVG_OUT 0x52 |
|
|
|
void L3_task_adc_filter_avg(S_TASK_ADC_BLUR_AVG *s) |
|
|
|
{ |
|
|
|
TTSS_Task_init() |
|
|
|
L2_task_go(D_task_ADC_CHx_FILTER_AVG_GET); |
|
|
|
|
|
|
|
TTSS_Task_step(D_task_ADC_CHx_FILTER_AVG_GET) |
|
|
|
if(ts_adc_channel_samples[s->ch].n >= s->max) |
|
|
|
{ |
|
|
|
U8 i = 0; |
|
|
|
ts_adc_channel_samples[s->ch].n = 0; |
|
|
|
for(i=0;i<s->max;i++) |
|
|
|
{ |
|
|
|
s->in[i] = ts_adc_channel_samples[s->ch].out1[i]; |
|
|
|
} |
|
|
|
L2_task_go(D_task_ADC_CHx_FILTER_AVG_COUNT); |
|
|
|
} |
|
|
|
|
|
|
|
TTSS_Task_step(D_task_ADC_CHx_FILTER_AVG_COUNT) |
|
|
|
s->avgval = Lc_vS32_avg(s->in,s->max); |
|
|
|
L2_task_go(D_task_ADC_CHx_FILTER_AVG_OUT); |
|
|
|
|
|
|
|
TTSS_Task_step(D_task_ADC_CHx_FILTER_AVG_OUT) |
|
|
|
s->out[s->n] = s->avgval; |
|
|
|
//R.adval[s->ch] = s->out[s->n];
|
|
|
|
s->n++; |
|
|
|
if(s->n >= MAX_OUT_NUM) |
|
|
|
{ |
|
|
|
s->n = 0; |
|
|
|
} |
|
|
|
L2_task_go(D_task_ADC_CHx_FILTER_AVG_GET); |
|
|
|
|
|
|
|
TTSS_Task_end(); |
|
|
|
|
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
//移位滤波任务
|
|
|
|
#define D_task_ADC_CHx_FILTER_SHIFT_GET 0x50 |
|
|
|
#define D_task_ADC_CHx_FILTER_SHIFT_COUNT 0x51 |
|
|
|
#define D_task_ADC_CHx_FILTER_SHIFT_OUT 0x52 |
|
|
|
void L3_task_adc_ShiftFilter(TS_TASK_ADC_SHIFTFILTER *s) |
|
|
|
{ |
|
|
|
TTSS_Task_init() |
|
|
|
s->average = ts_adc_samples[s->ch].out2;///
|
|
|
|
s->sum = s->average << s->shift; |
|
|
|
L2_task_go(D_task_ADC_CHx_FILTER_SHIFT_GET); |
|
|
|
|
|
|
|
TTSS_Task_step(D_task_ADC_CHx_FILTER_SHIFT_GET) |
|
|
|
s->sum += |
|
|
|
|
|
|
|
|
|
|
|
TTSS_Task_step(D_task_ADC_CHx_FILTER_SHIFT_COUNT) |
|
|
|
s->sum[0] -= s->shiftval[0]; |
|
|
|
s->sum[0] += s->in; |
|
|
|
s->shiftval[0] = s->sum[0] >> s->shiftreg[0]; |
|
|
|
s->sum[1] -= s->shiftval[1]; |
|
|
|
s->sum[1] += s->in; |
|
|
|
s->shiftval[1] = s->sum[1] >> s->shiftreg[1]; |
|
|
|
s->sum[2] -= s->shiftval[2]; |
|
|
|
s->sum[2] += s->in; |
|
|
|
s->shiftval[2] = s->sum[2] >> s->shiftreg[2]; |
|
|
|
L2_task_go(D_task_ADC_CHx_FILTER_SHIFT_OUT); |
|
|
|
|
|
|
|
TTSS_Task_step(D_task_ADC_CHx_FILTER_SHIFT_OUT) |
|
|
|
s->out[0][s->n] = s->shiftval[0]; |
|
|
|
s->out[1][s->n] = s->shiftval[1]; |
|
|
|
s->out[2][s->n] = s->shiftval[2]; |
|
|
|
|
|
|
|
|
|
|
|
//R.adval[s->ch] = s->out[0][s->n] = s->shiftval[0];
|
|
|
|
s->n++; |
|
|
|
if(s->n >= MAX_OUT_NUM) |
|
|
|
{ |
|
|
|
s->n = 0; |
|
|
|
} |
|
|
|
L2_task_go(D_task_ADC_CHx_FILTER_SHIFT_GET); |
|
|
|
|
|
|
|
TTSS_Task_end(); |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
//输出判定任务
|
|
|
|
#define D_task_ADC_CHx_FILTER_OUT_GET 0x50 |
|
|
|
#define D_task_ADC_CHx_FILTER_OUT_COUNT 0x51 |
|
|
|
#define D_task_ADC_CHx_FILTER_OUT_CHANGE 0x52 |
|
|
|
#define D_task_ADC_CHx_FILTER_OUT_OUT 0x53 |
|
|
|
void L3_task_adc_filter_out(S_TASK_ADC_BLUR_OUT *s) |
|
|
|
{ |
|
|
|
TTSS_Task_init() |
|
|
|
L2_task_go(D_task_ADC_CHx_FILTER_OUT_GET); |
|
|
|
|
|
|
|
TTSS_Task_step(D_task_ADC_CHx_FILTER_OUT_GET) |
|
|
|
if(s->h != ts_adc_blur_shift[s->ch].n) |
|
|
|
{ |
|
|
|
s->h = ts_adc_blur_shift[s->ch].n; |
|
|
|
s->in[0] = ts_adc_blur_avg[s->ch].out[count_n(ts_adc_blur_avg[s->ch].n, 1)]; |
|
|
|
s->in[1] = ts_adc_blur_avg[s->ch].out[count_n(ts_adc_blur_avg[s->ch].n, 2)]; |
|
|
|
//获取输出曲线val
|
|
|
|
s->newout = ts_adc_blur_shift[s->ch].out[s->oldnum][count_n(ts_adc_blur_shift[s->ch].n, 1)]; |
|
|
|
L2_task_go(D_task_ADC_CHx_FILTER_OUT_COUNT); |
|
|
|
} |
|
|
|
|
|
|
|
TTSS_Task_step(D_task_ADC_CHx_FILTER_OUT_COUNT) //根据阀值选择输出的曲线
|
|
|
|
//判断选择新曲线
|
|
|
|
if(Lc_abs(s->in[0] , s->in[1]) >= s->threshold[0])//2KG
|
|
|
|
{ |
|
|
|
s->newnum = 0; |
|
|
|
} |
|
|
|
else if(Lc_abs(s->in[0] , s->in[1]) >= s->threshold[1]) //0.5KG
|
|
|
|
{ |
|
|
|
s->newnum = 1; |
|
|
|
} |
|
|
|
else |
|
|
|
{ |
|
|
|
s->newnum = 2; |
|
|
|
} |
|
|
|
//L2_task_go(D_task_ADC_CHx_FILTER_OUT_OUT);
|
|
|
|
L2_task_go(D_task_ADC_CHx_FILTER_OUT_CHANGE); |
|
|
|
|
|
|
|
TTSS_Task_step(D_task_ADC_CHx_FILTER_OUT_CHANGE) |
|
|
|
if(s->newnum != s->oldnum)//切换移位滤波时调整其他滤波的SUM
|
|
|
|
{ |
|
|
|
s->oldnum = s->newnum; //不能只调整新值，所有曲线都要一起调整
|
|
|
|
//ts_adc_blur_shift[s->ch].sum[1] = (ts_adc_blur_avg[s->ch].out[ts_adc_blur_avg[s->ch].n] * R.adc_blur_avg);
|
|
|
|
ts_adc_blur_shift[s->ch].sum[0] = s->newout << ts_adc_blur_shift[s->ch].shiftreg[0]; |
|
|
|
ts_adc_blur_shift[s->ch].shiftval[0] = s->newout; |
|
|
|
ts_adc_blur_shift[s->ch].sum[1] = s->newout << ts_adc_blur_shift[s->ch].shiftreg[1]; |
|
|
|
ts_adc_blur_shift[s->ch].shiftval[1] = s->newout; |
|
|
|
ts_adc_blur_shift[s->ch].sum[2] = s->newout << ts_adc_blur_shift[s->ch].shiftreg[2]; |
|
|
|
ts_adc_blur_shift[s->ch].shiftval[2] = s->newout; |
|
|
|
} |
|
|
|
L2_task_go(D_task_ADC_CHx_FILTER_OUT_OUT); |
|
|
|
|
|
|
|
TTSS_Task_step(D_task_ADC_CHx_FILTER_OUT_OUT) |
|
|
|
R.adval[s->ch] = s->newout; |
|
|
|
//R.adval[s->ch] = ts_adc_channel_samples[s->ch].adcval;
|
|
|
|
L2_task_go(D_task_ADC_CHx_FILTER_OUT_GET); |
|
|
|
|
|
|
|
TTSS_Task_end(); |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
//显示任务
|
|
|
|
#define D_task_ADC_CHx_SHOW 0x50 |
|
|
|
void L3_task_adc_filter_show(S_TASK_ADC_BLUR_SHOW *s) |
|
|
|
{ |
|
|
|
TTSS_Task_init() |
|
|
|
L2_task_go(D_task_ADC_CHx_SHOW); |
|
|
|
|
|
|
|
TTSS_Task_step(D_task_ADC_CHx_SHOW) |
|
|
|
R.ch_weight[0] = D_COUNT_WEIGHT(R.adval[0]); |
|
|
|
R.ch_weight[1] = D_COUNT_WEIGHT(R.adval[1]); |
|
|
|
R.ch_weight[2] = D_COUNT_WEIGHT(R.adval[2]); |
|
|
|
R.ch_weight[3] = D_COUNT_WEIGHT(R.adval[3]); |
|
|
|
s->rough_weight = R.ch_weight[0] + R.ch_weight[1] + R.ch_weight[2] + R.ch_weight[3]; //毛重
|
|
|
|
#if 0 |
|
|
|
L0_uart0_ulhex(s->rough_weight); |
|
|
|
L0_uart0_uc(' '); |
|
|
|
#endif |
|
|
|
if( ABS(R.rough_weight,s->rough_weight) >= 50) //变化超过0.05KG
|
|
|
|
{ |
|
|
|
R.rough_weight = s->rough_weight; |
|
|
|
R.total_weight = (R.rough_weight > R.total_zweight) ? (R.rough_weight - R.total_zweight) : (0);//净重
|
|
|
|
} |
|
|
|
L2_task_go_Tdelay(D_task_ADC_CHx_SHOW,D_Tdelay_Msec(15)); //延时15ms
|
|
|
|
|
|
|
|
TTSS_Task_end(); |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*******
|
|
|
|
ts_adc_channel_samples[ch].status = (R.p.adc_ch_status >> ch) & 0x1; |
|
|
|
ts_adc_channel_samples[ch].pool = 0; |
|
|
|
ts_adc_channel_samples[ch].adcval = 0; |
|
|
|
ts_adc_channel_samples[ch].n = 0; |
|
|
|
ts_adc_channel_samples[ch].ch = D_ADCCH_1 + ch; |
|
|
|
|
|
|
|
//通道中值滤波任务初始化
|
|
|
|
L1_task_init(&ts_adc_blur_mid[ch].task); |
|
|
|
L3_task_s_go(ts_adc_blur_mid[ch],D_task_init); |
|
|
|
ts_adc_blur_mid[ch].n = 0; |
|
|
|
ts_adc_blur_mid[ch].max = R.p.adc_blur_mid; |
|
|
|
ts_adc_blur_mid[ch].ch = D_ADCCH_1 + ch; |
|
|
|
|
|
|
|
//通道均值滤波任务初始化
|
|
|
|
L1_task_init(&ts_adc_blur_avg[ch].task); |
|
|
|
L3_task_s_go(ts_adc_blur_avg[ch],D_task_init); |
|
|
|
ts_adc_blur_avg[ch].max = R.p.adc_blur_avg; |
|
|
|
ts_adc_blur_avg[ch].avgval = 0; |
|
|
|
ts_adc_blur_avg[ch].n = 0; |
|
|
|
ts_adc_blur_avg[ch].ch = D_ADCCH_1 + ch; |
|
|
|
|
|
|
|
//通道移位滤波任务初始化
|
|
|
|
L1_task_init(&ts_adc_blur_shift[ch].task); |
|
|
|
L3_task_s_go(ts_adc_blur_shift[ch],D_task_init); |
|
|
|
ts_adc_blur_shift[ch].n = 0; |
|
|
|
ts_adc_blur_shift[ch].h = 0; |
|
|
|
ts_adc_blur_shift[ch].shiftreg[0] = R.p.adc_blur_shift[0]; |
|
|
|
ts_adc_blur_shift[ch].shiftreg[1] = R.p.adc_blur_shift[1]; |
|
|
|
ts_adc_blur_shift[ch].shiftreg[2] = R.p.adc_blur_shift[2]; |
|
|
|
ts_adc_blur_shift[ch].sum[0] = 0; |
|
|
|
ts_adc_blur_shift[ch].sum[1] = 0; |
|
|
|
ts_adc_blur_shift[ch].sum[2] = 0; |
|
|
|
ts_adc_blur_shift[ch].shiftval[0] = 0; |
|
|
|
ts_adc_blur_shift[ch].shiftval[1] = 0; |
|
|
|
ts_adc_blur_shift[ch].shiftval[2] = 0; |
|
|
|
ts_adc_blur_shift[ch].ch = D_ADCCH_1 + ch; |
|
|
|
|
|
|
|
//输出判定任务初始化
|
|
|
|
L1_task_init(&ts_adc_blur_out[ch].task); |
|
|
|
L3_task_s_go(ts_adc_blur_out[ch],D_task_init); |
|
|
|
ts_adc_blur_out[ch].h= 0; |
|
|
|
ts_adc_blur_out[ch].threshold[0] = D_blur_threshold_2_1(R.p.adc_blur_threshold[0]); //2KG
|
|
|
|
ts_adc_blur_out[ch].threshold[1] = D_blur_threshold_2_1(R.p.adc_blur_threshold[1]); //0.5KG
|
|
|
|
ts_adc_blur_out[ch].newnum = 0; |
|
|
|
ts_adc_blur_out[ch].oldnum = 0; |
|
|
|
ts_adc_blur_out[ch].oldout = 0; |
|
|
|
ts_adc_blur_out[ch].newout = 0; |
|
|
|
ts_adc_blur_out[ch].n = 0; |
|
|
|
ts_adc_blur_out[ch].ch = D_ADCCH_1 + ch; |
|
|
|
*****/ |
|
|
|
|
|
|
|
#if 0 |
|
|
|
//通道切换任务初始化
|
|
|
|
//L1_task_init(&ts_adc_channel_switch.task);
|
|
|
|
L3_task_s_go(ts_adc_channel_switch,D_task_init); |
|
|
|
#endif |
|
|
|
|
|
|
|
#endif |
|
|
|
|
|
|
|
|
Zhangwen
10 months ago