//////////////////////////////////////////////////////////////////////////// ///@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_uart0.h" #include "bsp_cs1232.h" //============================================= //S_TASK_ADC_CHANNEL_BLUR ts_adc_channel_blurs[D_ADC_CHANNEL_NUM]; //S_TASK_ADC_CHANNEL_SHOW ts_adc_channel_show; TS_TASK_ADC_SAMPLE ts_adc_samples[D_ADC_CHANNEL_NUM]; /*********** TS_TASK_ADC_SHIFTFILTER ts_adc_ShiftFilter[D_ADC_CHANNEL_NUM]; S_TASK_ADC_BLUR_MID ts_adc_blur_mid[D_ADC_CHANNEL_NUM]; S_TASK_ADC_BLUR_AVG ts_adc_blur_avg[D_ADC_CHANNEL_NUM]; S_TASK_ADC_BLUR_SHIFT ts_adc_blur_shift[D_ADC_CHANNEL_NUM]; S_TASK_ADC_BLUR_OUT ts_adc_blur_out[D_ADC_CHANNEL_NUM]; *********/ void L2_task_adc_SAinit(U8 ch,U8 *a,U8 *b) { ts_adc_samples[ch].ts_SAa.shift = *a; ts_adc_samples[ch].ts_SAb.shift = *b; } //ch是0123，代表4通道 void L2_task_adc_init(U8 ch) { //通道采集任务初始化 L1_task_init(&ts_adc_samples[ch].task); L3_task_s_go(ts_adc_samples[ch],D_task_init); ts_adc_samples[D_Wch1].ch = D_Wch1; ts_adc_samples[D_Wch2].ch = D_Wch2; ts_adc_samples[D_Wch3].ch = D_Wch3; ts_adc_samples[D_Wch4].ch = D_Wch4; } //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 11///还包含建立时间 至少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 系统足够响应 *******/ /**************** ^ | |--------------------------zeroout | | | | | offset | | | | . | . | | 0------.----|-------------> 0 | . 四个点是四个传感器的采样值 ts_adc_samples[3].offset = R.sd.zeroout; ts_adc_samples[0].zeroout = R.sd.zeroout; R.sd.zeroout= 2418 = 0x 972 offset 2418 = 0x 972 R.sd.zeroout= 2418 = 0x 972 offset 2418 = 0x 972 R.sd.zeroout= 2418 = 0x 972 offset 2418 = 0x 972 R.sd.zeroout= 2418 = 0x 972 offset 2418 = 0x 972 4 out1 offset Z00 0116 085C Z01 F671 1301 Z02 1642 F330 Z03 FF66 0A0C 092B 0967 0928 0954 0943 0000 08DF 0956 08E0 0929 090F 0000 0895 0945 089C 0900 08DD 0000 R.sd.zeroout= 8049 = 0x1f71 offset 8049 = 0x1f71 4 Z00 0415 1B5C Z01 F482 2AEF Z02 1902 066F Z03 02C7 1CAA 0000 1F4D 1F16 1F35 1766 000F 0000 1F34 1EB7 1F08 173C 000E 0000 1F19 1E6C 1E73 *********************/ void L3_out_zero(u8 ch) { vS16 t,m; t = ts_adc_samples[ch].out1; m = ts_adc_samples[ch].zeroout; m -= t; ts_adc_samples[ch].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_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; } S16 L3_out_tran(vU32 rdata) { S16 t16; /// 24bits 3Bytes rdata >>= 8; t16 = rdata; return t16; } vU16 L3_out_offset(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].offset - t16; // L0_uart0_uc('$'); L0_uart0_ushex(ts_adc_samples[ch].offset);L0_uart0_uc(' '); }else { out = t16 + ts_adc_samples[ch].offset; } // L0_uart0_ushex(out);L0_uart0_uc(' '); L0_uart0_uc('R');L0_uart0_0d0a(); return out; } void L2_task_adc_sample(TS_TASK_ADC_SAMPLE *s) { TTSS_Task_init(): ////cc 初始化尽量放到这里，不要放到main ——init中，减少系统启动的时间 s->jitter_start = 0; s->ok = 0; /// L0_uart0_sendstr("\r\nADC_SAMPLE\r\n"); /// 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->ch)) {////L0_uart0_uc('X');L0_uart0_uc(0x30+s->ch); //// L0_ADS1231_readCH2(s->ch,&(s->out1)); //// L0_ADS1231_readCH2(s->ch,&(s->out0)); L2_task_go(D_task_ADC_CHx_PIANYI); } TTSS_Task_step(D_task_ADC_CHx_PIANYI): s->out1 = L3_out_tran(s->out0); ////s->out1a = L3_out_tran2(s->out0); /// L0_uart0_uc('0' + s->ch); s->out2 = L3_out_offset(s->ch,s->out1); 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; Lc_despiking_shift3_U16(s->outm);////采样后进行削峰 s->out3 = s->outm[1]; L2_task_go(D_task_ADC_CHx_JITTER2); TTSS_Task_step(D_task_ADC_CHx_JITTER2): ///刚开始的抖动，先去掉几个最开始的数据 if(D_ADC_JITTER_FINISH == s->jitter_start) { s->ts_SAa.average = (vU32)s->out3;///shiftaverage_a路初始化 s->ts_SAa.sum = s->ts_SAa.average << s->ts_SAa.shift; s->ts_SAb.average = (vU32)s->out3;///shiftaverage_b路初始化 s->ts_SAb.sum = s->ts_SAb.average << s->ts_SAb.shift; L2_task_go(D_task_ADC_CHx_SHIFTFILTER); }else if(D_ADC_JITTER_zero == s->jitter_start) {/// L3_out_zero(s->ch);///算出当前的偏移量 更新offset L0_uart0_uc('Z');L0_uart0_uchex(s->ch); L0_uart0_uc(' ');L0_uart0_ushex(s->out1);L0_uart0_uc(' '); L0_uart0_uc(' ');L0_uart0_ushex(s->offset);L0_uart0_uc(' '); s->jitter_start ++; L2_task_go(D_task_ADC_CHx_SAMPLE_READ); }else { s->jitter_start ++; L2_task_go(D_task_ADC_CHx_SAMPLE_READ); } 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; s->ts_SAa.average = s->ts_SAa.sum >> s->ts_SAa.shift; // s->ts_SAa.new = s->ts_SAa.average; s->ts_SAa.out4 = (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->ts_SAb.sum -= s->ts_SAb.average; s->ts_SAb.sum += (vU32)s->out3; s->ts_SAb.average = s->ts_SAb.sum >> s->ts_SAb.shift; s->ts_SAb.out4 = (vU16)s->ts_SAb.average; ///out4 = out3 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_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