ttss_weight/source/asp/asp_schain.c

////////////////////////////////////////////////////////////////////////////  
///@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;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