//////////////////////////////////////////////////////////////////////////// ///@copyright Copyright (c) 2018, 传控科技 All rights reserved. ///------------------------------------------------------------------------- /// @file bsp_drv.c /// @brief bsp @ driver config ///------------------------------------------------------------------------- /// @version 1.0 /// @author CC /// @date 20180331 /// @note cc_AS_stc02 ////////////////////////////////////////////////////////////////////////////// #include "asp_schain.h" ///#include "common.h" #include "msp_uart1.h" #include "bsp_cs1232.h" #include "debug_drv.h" #define D_sensor_up_down 1/// 称重传感器上下镜像选择 //============================================= ///打开adc输出监控，0kg的试试每一路的输出就是 0kg_out1_adc FF77 FFB3 00A4 FFEA #define D_ch1_0kg_out1_adc (vS16)0xFF77 #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) #define D_ch4_out1_offset (vS16)(D_ch4_wantline-D_ch4_0kg_out1_adc) #define D_ch1_wantline (vS16)0x18da #define D_ch2_wantline (vS16)0x18da #define D_ch3_wantline (vS16)0x18da #define D_ch4_wantline (vS16)0x18da ///cc 2023/04/06--7:39:40 每个传感器放置10kg ///应变片传感器10kg的adc值，选择这个是因为10kg容易获得 并且有一定的重量差 ///这个值需要实验获得 #define D_ch1_10kg_out1_adc (vS16)0x0584 #define D_ch2_10kg_out1_adc (vS16)0x05DE #define D_ch3_10kg_out1_adc (vS16)0x0731 #define D_ch4_10kg_out1_adc (vS16)0x066C #define D_Rsensor_per_10kg ((vS16)10) #define D_adc_per_kg ((D_ch1_10kg_out1_adc-D_ch1_0kg_out1_adc)/D_Rsensor_per_10kg) #define D_adc_zeroout (10*D_adc_per_kg) ///零点都拉到10kg 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; 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; 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 }; TS_task_adc_sample ts_adc_samples[D_ADC_CHANNEL_NUM]; //ch是0123，代表4通道 void L2_task_adc_init(U8 ch) { //通道采集任务初始化 L1_task_reg_clear(&ts_adc_samples[ch].task); L3_task_s_go(ts_adc_samples[ch],D_task_init); ts_adc_samples[ch].pSPara = &TS_adc_SPara[ch]; ts_adc_samples[ch].firstRun = 1; } //ADC Channel 采样任务 #define D_task_ADC_CHx_SAMPLE_JITTER_START_SAMPLE 0x53 #define D_task_ADC_CHx_JITTER 0x63 #define D_task_ADC_CHx_PIANYI 0x93 #define D_task_ADC_CHx_JITTER2 0x83 #define D_task_ADC_CHx_despiking_shift 0x94 #define D_task_ADC_CHx_SAMPLE_WAIT_LOW 0x73 #define D_task_ADC_CHx_SAMPLE_READ 0x54 #define D_task_ADC_CHx_SAMPLE_OUT 0x55 #define D_task_ADC_CHx_SHIFTFILTER 0x56 #define D_task_ADC_CHx_SHIFTFILTER2 0x57 #define D_ADC_JITTER_zero 22///还包含建立时间 至少9个 #define D_ADC_JITTER_FINISH 12///还包含建立时间 至少9个 /******** 80hZ 1000ms/80= 12.5ms/point ushex send = 4Bytes+blank = 5Byte; 115200 0.1ms/Byte 所以发送5Bytes 消耗0.5ms 发送四列 消耗2ms 系统足够响应 *******/ S16 L3_out_tran(vU32 rdata) { S16 t16; /// 24bits 3Bytes rdata >>= 8; t16 = rdata; #if (D_sensor_up_down) t16 *= -1; #else ///t16 *= -1; #endif return t16; } vU16 L3_adc_out_offset(vU16 offset,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 = offset - t16; // L0_uart0_uc('$'); L0_uart0_ushex(ts_adc_samples[ch].offset);L0_uart0_uc(' '); }else { out = t16 + offset; } // L0_uart0_ushex(out);L0_uart0_uc(' '); L0_uart0_uc('R');L0_uart0_0d0a(); return out; } /* adcval adc采样值 ^ | | --.-------------.-------------.------------.---------wantline | . . . . | . . offset3 . | . . . . | . . .ch3.adc . | offset1 offset2 . | . . offset4 ---0---.-------------.--------------------------.------------ | . .ch2.adc . | . . | ch1.adc . | . | ch3.adc. .的数量或高度就是offset adc有正数和负数 */ vU16 L3_adc_get_offset(vU16 wantline,vU16 adcv) { vU16 out; /// L0_uart0_ushex(t16); L0_uart0_uc(' '); if(adcv & 0x8000) //最高位为1，<0则 { out = 0xffFF - adcv;///转变为正数 out += wantline; }else { out = wantline - adcv; } return out; } /* ///cc 2023/04/06--6:34:10 针对西安方片传感器 adc hex dec kg adc/kg 68F 1679 10 168 4196 16790 100 -------------void L2_task_adc_sample(TS_TASK_ADC_SAMPLE *s)---------- s->out1_adc = L3_out_tran(s->out0); ############ s->out2_offset = L3_out_offset(s->ch,s->out1_adc); ############ Lc_despiking_shift3_U16(s->outm);////采样后进行削峰 s->out3_peak = s->outm[1]; ############ s->ts_SAa.out4_shift = (vU16)s->ts_SAa.average; from s->out3_peak s->ts_SAb.out4_shift = (vU16)s->ts_SAb.average;from s->out3_peak ----------void L3_task_weight_handler(TS_TASK_weight_ *s)----------------- ts_adc_samples[3].out5 = ts_adc_samples[3].ts_SAb.out4_shift; ############ ////四个传感器相加后平均 tst_weight.sum32 = ts_adc_samples[0].out5; tst_weight.sum32 += ts_adc_samples[1].out5; tst_weight.sum32 += ts_adc_samples[2].out5; tst_weight.sum32 += ts_adc_samples[3].out5; tst_weight.out6 = tst_weight.sum32 >>2; ############ tst_weight.adc32 = tst_weight.out6; L3_task_weight_cal(); 上电的时候有几种状态 1 有人 2 有物体 3 无人 出厂必备的操作， 1，没有重物清零，数据写入程序， 出厂把adc的值都偏移到 10kg/200kg 如果时基本时1/20偏移 也就是出厂时传感器的值基本一条线 2，以后上电时 或者重新启动时 低于一定重量就清零 3，手工可以清零 --------------------------- 四个传感器 在没有重量 出厂的时候需要拉成偏移 简单的方式 四个传感器累加的模式 */ void L2_task_adc_sample(TS_task_adc_sample *s) { TTSS_Task_init(): ////cc 初始化尽量放到这里，不要放到main ——init中，减少系统启动的时间 s->jitter_start = 0; s->ok = 0; ////printf("\r\nADC_SAMPLE\r\n"); /* printf5("\r\nADC_SAMPLE init ch(%d) wantline:%d(%4X) offset %d(%4X)", (int)s->pSPara->ch, ts_adc_samples[s->pSPara->ch].pSPara->wantline,ts_adc_samples[s->pSPara->ch].pSPara->wantline, 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() ; s->firstRun = 1; /// L2_task_go(D_task_ADC_CHx_SAMPLE_READ); L2_task_go_Tdelay(D_task_ADC_CHx_SAMPLE_READ,D_Tdelay_Msec(1500)); //延时15ms TTSS_Task_step(D_task_ADC_CHx_SAMPLE_READ): if(0 == L0_adc_DOUT_AT(s->pSPara->ch)) {////L0_uart0_uc('X');L0_uart0_uc(0x30+s->ch); //// L0_ADS1231_readCH2(s->ch,&(s->out1)); //// L0_ADS1231_readCH2(s->pSPara->ch,&(s->out0)); L2_task_go(D_task_ADC_CHx_PIANYI); } TTSS_Task_step(D_task_ADC_CHx_PIANYI): s->out1_adc = L3_out_tran(s->out0);///////cc 2023/04/06--6:33:46 最原始的输出 s->out2_offset = L3_adc_out_offset(s->pSPara->offset,s->out1_adc); L2_task_go(D_task_ADC_CHx_despiking_shift); TTSS_Task_step(D_task_ADC_CHx_despiking_shift): s->outm[0] = s->outm[1]; s->outm[1] = s->outm[2]; s->outm[2] = s->out2_offset; Lc_despiking_shift3_U16(s->outm);////采样后进行削峰 s->out3_Peak = s->outm[1]; /// s->pSPara->offset = s->pSPara->wantline - s->out3_Peak; if(s->firstRun)/// {////第一次上电 L2_task_go(D_task_ADC_CHx_JITTER2); }else { L2_task_go(D_task_ADC_CHx_SHIFTFILTER); } TTSS_Task_step(D_task_ADC_CHx_JITTER2): if(s->jitter_start < D_ADC_JITTER_FINISH) { ///printfs("\r\n D_ADC_JITTER_zero---"); L1_uartD_uc('9'); s->jitter_start ++; L2_task_go(D_task_ADC_CHx_SAMPLE_READ); }else { /// 上电的时候如果没有重量可以这样 ，如果有呢？？ ///L3_out_zero(s->ch);///算出当前的偏移量 更新offset s->pSPara->offset = L3_adc_get_offset(s->pSPara->wantline,s->out1_adc);///必须out1_adc 因为偏移是针对 out1_adc的 /// s->pSPara->offset = s->pSPara->wantline - s->out3_Peak; printfs("\r\n D_ADC_JITTER_zero---"); ///printf3("\r\n ch(%d) out3_Peak %5d %5X ",(int)s->pSPara->ch,s->out3_Peak,s->out3_Peak ); printf4("\r\n ch(%d) adc=%5d ->offset %5d wantline %5d ",(int)s->pSPara->ch,s->out1_adc,s->pSPara->offset,s->pSPara->wantline); printf4("\r\n ch(%d) adc=%5X ->offset %5X wantline %5X ",(int)s->pSPara->ch,s->out1_adc,s->pSPara->offset,s->pSPara->wantline); s->ts_SAa.average = (vU32)s->out3_Peak;/// shiftaverage_a路初始化 s->ts_SAa.sum = s->ts_SAa.average << s->pSPara->ashift; /** s->ts_SAb.average = (vU32)s->out3_Peak;/// shiftaverage_b路初始化 s->ts_SAb.sum = s->ts_SAb.average << s->pSPara->bshift; */ s->firstRun = 0; ///刚开始的抖动，先去掉几个最开始的数据 L2_task_go(D_task_ADC_CHx_SHIFTFILTER); } TTSS_Task_step(D_task_ADC_CHx_SHIFTFILTER): //L0_uart0_uc('B'); s->ts_SAa.sum -= s->ts_SAa.average; s->ts_SAa.sum += (vU32)s->out3_Peak; s->ts_SAa.average = s->ts_SAa.sum >> s->pSPara->ashift; // s->ts_SAa.new = s->ts_SAa.average; s->ts_SAa.out4_shift = (vU16)s->ts_SAa.average; /// L0_uart0_uc('s'); L2_task_go(D_task_ADC_CHx_SHIFTFILTER2); TTSS_Task_step(D_task_ADC_CHx_SHIFTFILTER2): s->ok = 1; L2_task_go(D_task_ADC_CHx_SAMPLE_READ); /// L2_task_go(D_task_ADC_CHx_SAMPLE_OUT); TTSS_Task_step(D_task_ADC_CHx_SAMPLE_OUT): /*** L0_uart0_ulhex(s->out0); L0_uart0_uc(0x09); L0_uart0_ushex(s->out1); L0_uart0_uc(0x09); L0_uart0_ushex(s->out2); L0_uart0_uc(0x09); L0_uart0_ushex(s->ts_SAa.out4); L0_uart0_uc(0x09); L0_uart0_ushex(s->ts_SAb.out4); L0_uart0_0d0a(); **/ //// //// L0_uart0_uc('0' + s->ch);L0_uart0_uc('A');// TTSS_Task_end(); } #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;imax;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;imax;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