#include "app_task_adc.h"
#include "../msp/UART0.h"

//TS_ADC_CH_SWITCH ts_adc_ch_switch;
TS_ADC_CH_SAMPLE ts_adc_ch_sample[D_ch_max_num];
//TS_ADC_CH_BLUR ts_adc_ch_blur[D_ch_max_num];
TS_ADC_ALL_BLUR ts_adc_all_blur;
TS_ADC_ALL_OUT ts_adc_all_out;
TS_ADC_SHOW ts_adc_show;
TS_ADC_CH_MID_BLUR ts_adc_ch_mid_blur[D_ch_max_num];
TS_ADC_CH_AVG_BLUR ts_adc_ch_avg_blur[D_ch_max_num];
TS_ADC_CH_SHIFT_BLUR ts_adc_ch_shift_blur[D_ch_max_num];

static U8 count_n(u8 n,u8 d)
{
	if(n < d)
	{	
		return MAX_OUT_NUM + n - d ;
	}
	else
	{
		return n-d;
	}
}

U32 Abs(S32 a)
{
	if(a < 0)
	{
		a = -a;
	}
	return a;
}


void L3_task_adc_init(U8 ch)
{
	

	//通道采集任务初始化
	L1_task_init(&ts_adc_ch_sample[ch].task);
	L3_task_s_go(ts_adc_ch_sample[ch],D_task_init);
	ts_adc_ch_sample[ch].status = R.p.adc_ch_status & (ADC_status_chx_Ready_BASE << ch);
	ts_adc_ch_sample[ch].pool = 0;
	ts_adc_ch_sample[ch].adcval = 0;
	ts_adc_ch_sample[ch].n = 0;
	ts_adc_ch_sample[ch].ch = D_ADCCH_1 + ch;

	//单路中值滤波
	L1_task_init(&ts_adc_ch_mid_blur[ch].task);
	L3_task_s_go(ts_adc_ch_mid_blur[ch],D_task_init);
	ts_adc_ch_mid_blur[ch].n = 0;
	ts_adc_ch_mid_blur[ch].max = 1;
	ts_adc_ch_mid_blur[ch].ch = D_ADCCH_1 + ch;

	//单路均值滤波
	L1_task_init(&ts_adc_ch_avg_blur[ch].task);
	L3_task_s_go(ts_adc_ch_avg_blur[ch],D_task_init);
	ts_adc_ch_avg_blur[ch].max = R.p.cc_blur_ch_avg;
	ts_adc_ch_avg_blur[ch].avgval = 0;
	ts_adc_ch_avg_blur[ch].n = 0;
	ts_adc_ch_avg_blur[ch].ch = D_ADCCH_1 + ch;

	//单路移位滤波
	L1_task_init(&ts_adc_ch_shift_blur[ch].task);
	L3_task_s_go(ts_adc_ch_shift_blur[ch],D_task_init);
	ts_adc_ch_shift_blur[ch].n = 0;
	ts_adc_ch_shift_blur[ch].max = 1;
	ts_adc_ch_shift_blur[ch].sum = 0;
	ts_adc_ch_shift_blur[ch].shiftval = 0;
	ts_adc_ch_shift_blur[ch].ch = D_ADCCH_1 + ch;

#if 0
	L1_task_init(&ts_adc_ch_blur[i].task);
	L3_task_s_go(ts_adc_ch_blur[i],D_task_init);
	ts_adc_ch_blur[i].SA_sum = 0;
	ts_adc_ch_blur[i].SA_avg = 0;
	ts_adc_ch_blur[i].SA_n = 0;
	ts_adc_ch_blur[i].SHA_sum = 0;
	ts_adc_ch_blur[i].SHA_avg = 0;
	ts_adc_ch_blur[i].n = 0;
	ts_adc_ch_blur[i].ch = D_ADCCH_1 + i;
	ts_adc_ch_blur[i].ch_n = TS_ADC_CH_01 + i;
#endif
	L1_task_init(&ts_adc_all_blur.task);
	L3_task_s_go(ts_adc_all_blur,D_task_init);
	ts_adc_all_blur.n = 0;
	ts_adc_all_blur.sum = 0;
	ts_adc_all_blur.SHA_sum_0 = 0;
	ts_adc_all_blur.SHA_avg_0 = 0;
	ts_adc_all_blur.SHA_pool_0[0] = ts_adc_all_blur.SHA_pool_0[1] = ts_adc_all_blur.SHA_pool_0[2] = 0;
	ts_adc_all_blur.SHA_sum_1 = 0;
	ts_adc_all_blur.SHA_avg_1 = 0;
	////ts_adc_all_blur.SHA_pool_1[0] = ts_adc_all_blur.SHA_pool_1[1] = ts_adc_all_blur.SHA_pool_1[2] = 0;


	L1_task_init(&ts_adc_all_out.task);
	L3_task_s_go(ts_adc_all_out,D_task_init);
	ts_adc_all_out.n = 0;
	for(i=0;i<D_ADC_CH_BLUE_POOL_NUM;i++)
	{
		ts_adc_all_out.SHA_pool[i] = 0;
	}

	L1_task_init(&ts_adc_show.task);
	L3_task_s_go(ts_adc_show,D_task_init);
	ts_adc_show.pool_val = 0;
	ts_adc_show.pool_gt = 1;
	ts_adc_show.val = 0;
	for(i=0;i<D_weight_show_limit_num;i++)
	{
		ts_adc_show.times[i] = 0;
	}
}

//#define D_SA_mid(X);	ts_sample[X].midv = Lc_S32_media3(ts_sample[X].mid[0],ts_sample[X].mid[1],ts_sample[X].mid[2]);
#define D_ADC_CHANNEL_READY(X) (R.p.adc_ch_status & (ADC_status_chx_Ready_BASE << X))

#define D_task_ADC_CHx_SAMPLE 0x51
#define D_task_ADC_CHx_WAIT_HIGH_LEVEL 0x52
#define D_task_ADC_CHx_WAIT_LOW_LEVEL 0x53
#define D_task_ADC_CHx_READ 0x54
#define D_task_ADC_CHx_OUT 0x55

void L3_task_adc_ch_sample(TS_ADC_CH_SAMPLE *s)
{
  TTSS_Task_init()
		L2_task_go(D_task_ADC_CHx_SAMPLE);

	TTSS_Task_step(D_task_ADC_CHx_SAMPLE)
		if(D_ADC_CHANNEL_READY(s->ch))
		{
			L2_task_go(D_task_ADC_CHx_WAIT_LOW_LEVEL);
		}
		else
		{
			s->adcval = s->pool;
			L2_task_go(D_task_ADC_CHx_OUT);
		}
		
	TTSS_Task_step(D_task_ADC_CHx_WAIT_LOW_LEVEL)
		if(0 == L0_2dc_DOUT_AT(s->ch))
		{
			L2_task_go(D_task_ADC_CHx_READ);
		}
		
    TTSS_Task_step(D_task_ADC_CHx_READ)
		s->adcval = L0_ADS1231_readCH(s->ch);
		L2_task_go(D_task_ADC_CHx_OUT);
		
	TTSS_Task_step(D_task_ADC_CHx_OUT)
		s->pool = s->adcval;
		s->out[s->n] = s->adcval;
		L0_uart0_ulhex(s->out[s->n]);
		L0_uart0_uc(' ');
		L0_uart0_uc('\n');
		s->n++;
		if(s->n >= D_ADC_CH_SAMPLE_BUF_MAX)
		{
			s->n = 0;
		}
		L2_task_go(D_task_ADC_CHx_SAMPLE);
		
	TTSS_Task_end();
}


//单路中值滤波任务
#define D_task_ADC_CHx_MID_BLUR_GET 0x51
#define D_task_ADC_CHx_MID_BLUR_COUNT 0x52
#define D_task_ADC_CHx_MID_BLUR_OUT 0x53

void L3_task_adc_ch_mid_blur(TS_ADC_CH_MID_BLUR *s)
{
	TTSS_Task_init()
		L2_task_go(D_task_ADC_CHx_MID_BLUR_GET);

  	TTSS_Task_step(D_task_ADC_CHx_MID_BLUR_GET)
		if(ts_adc_ch_sample[s->ch].n >= 1)
		{
			U8 i = 0;
			for(i=0;i<s->max;i++)
			{
				s->in[i] = ts_adc_ch_sample[s->ch].out[i];
			}
			ts_adc_ch_sample[s->ch].n = 0;
			L2_task_go(D_task_ADC_CHx_MID_BLUR_COUNT);
		}

	TTSS_Task_step(D_task_ADC_CHx_MID_BLUR_COUNT)
		s->midval = Lc_vS32_media(s->in, s->max);
		L2_task_go(D_task_ADC_CHx_MID_BLUR_OUT);
	
	TTSS_Task_step(D_task_ADC_CHx_MID_BLUR_OUT)
		s->out[s->n] = s->midval;
		s->n++;
		if(s->n >= MAX_OUT_NUM)
		{
			s->n = 0;
		}
		L2_task_go(D_task_ADC_CHx_MID_BLUR_GET);
		
	TTSS_Task_end();
}

//单路均值滤波任务
#define D_task_ADC_CHx_AVG_BLUR_GET 0x51
#define D_task_ADC_CHx_AVG_BLUR_COUNT 0x52
#define D_task_ADC_CHx_AVG_BLUR_OUT 0x53

void L3_task_adc_ch_avg_blur(TS_ADC_CH_AVG_BLUR *s)
{
	TTSS_Task_init()
		L2_task_go(D_task_ADC_CHx_AVG_BLUR_GET);

  	TTSS_Task_step(D_task_ADC_CHx_AVG_BLUR_GET)
		if(ts_adc_ch_mid_blur[s->ch].n >= s->max)
		{
			U8 i = 0;			
			for(i=0;i<s->max;i++)
			{
				s->in[i] = ts_adc_ch_mid_blur[s->ch].out[i];
			}
			ts_adc_ch_mid_blur[s->ch].n = 0;
			L2_task_go(D_task_ADC_CHx_AVG_BLUR_COUNT);
		}

	TTSS_Task_step(D_task_ADC_CHx_AVG_BLUR_COUNT)
		s->avgval = Lc_vU32_avg(s->in,s->max);
		L2_task_go(D_task_ADC_CHx_AVG_BLUR_OUT);
	
	TTSS_Task_step(D_task_ADC_CHx_AVG_BLUR_OUT)
		s->out[s->n] = s->avgval;
		s->n++;
		if(s->n >= MAX_OUT_NUM)
		{
			s->n = 0;
		}
		L2_task_go(D_task_ADC_CHx_AVG_BLUR_GET);
	
	TTSS_Task_end();
}

//单路移位滤波任务
#define D_task_ADC_CHx_SHIFT_BLUR_GET 0x51
#define D_task_ADC_CHx_SHIFT_BLUR_COUNT 0x52
#define D_task_ADC_CHx_SHIFT_BLUR_OUT 0x54

void L3_task_adc_ch_shift_blur(TS_ADC_CH_SHIFT_BLUR *s)
{
	TTSS_Task_init()
		L2_task_go(D_task_ADC_CHx_SHIFT_BLUR_GET);

  	TTSS_Task_step(D_task_ADC_CHx_SHIFT_BLUR_GET)
		if(s->h != ts_adc_ch_avg_blur[s->ch].n)
		{	
			s->in = ts_adc_ch_avg_blur[s->ch].out[count_n(ts_adc_ch_avg_blur[s->ch].n,1)];
			s->h = ts_adc_ch_avg_blur[s->ch].n;
			L2_task_go(D_task_ADC_CHx_SHIFT_BLUR_COUNT);
		}		
		
	TTSS_Task_step(D_task_ADC_CHx_SHIFT_BLUR_COUNT)
		s->sum -= s->shiftval;
		s->sum += s->in;
		s->shiftval = s->sum >> R.p.cc_blur_ch_shift;
		L2_task_go(D_task_ADC_CHx_SHIFT_BLUR_OUT);
	
	TTSS_Task_step(D_task_ADC_CHx_SHIFT_BLUR_OUT)
		G.weight[s->ch] = D_COUNT_WEIGHT(s->shiftval);
		s->n++;
		L2_task_go(D_task_ADC_CHx_SHIFT_BLUR_GET);
	
	TTSS_Task_end();
}

#define D_task_ADC_SHOW_GET 0x53
#define D_task_ADC_SHOW_1 0x54
#define D_task_ADC_SHOW_DEBUG 0x55
void L3_task_adc_show(TS_ADC_SHOW *s)
{
	U8 i = 0,find = 0,j = 0;
	TTSS_Task_init()
		L2_task_go(D_task_ADC_SHOW_GET);
	
	TTSS_Task_step(D_task_ADC_SHOW_GET)
		if(ts_adc_ch_shift_blur[0].n >= 1)
		{
			ts_adc_ch_shift_blur[0].n = 0;
			ts_adc_ch_shift_blur[1].n = 0;
			ts_adc_ch_shift_blur[2].n = 0;
			ts_adc_ch_shift_blur[3].n = 0;
			s->val =  G.weight[0] + G.weight[1] + G.weight[2] + G.weight[3];
			L2_task_go(D_task_ADC_SHOW_1);
		}

	TTSS_Task_step(D_task_ADC_SHOW_1)
		if((s->val - s->pool_val) * s->pool_gt < 0)
		{
			//符号改变，计数清0
			//L0_uart0_uc('-');
			L3_task_show_times_reset();
		}
		s->pool_gt = (s->val >= s->pool_val) ? 1 : -1;

		s->diff_val = Lc_abs(s->val,s->pool_val);
		for(i=0;i<D_weight_show_limit_num;i++)
		{
			if(R.p.weight_show_limit[i].times == 0)
			{
				break;
			}
			if(s->diff_val >= R.p.weight_show_limit[i].weight)
			{
				find = 1;
				break;
			}
		}
		if(find)
		{
			s->times[i]++;
			for(j=0;j<D_weight_show_limit_num;j++)
			{
				if(j != i)
				{
					s->times[j] = 0;
				}
			}
		}
		else	//小于显示分辨率(<0.02kg)
		{
			L3_task_show_times_reset();
		}
		
		for(i=0;i<D_weight_show_limit_num;i++)
		{
			if(s->times[i] >= R.p.weight_show_limit[i].times)
			{
				L3_task_show_times_reset();
				s->pool_val = s->val;
				G._total_weight = s->pool_val;
				R.total_weight = L3_count_std_weight(G._total_weight);
				break;
			}
		}

		L2_task_go(D_task_ADC_SHOW_GET);
	
	TTSS_Task_end();
}


void L3_task_show_times_reset()
{
	U8 i = 0;
	for(i=0;i<D_weight_show_limit_num;i++)
	{
		ts_adc_show.times[i] = 0;
	}
}


void L3_task_adc_handler(u8 ch)
{
	L3_task_adc_ch_sample(&ts_adc_ch_sample[ch]);
	L3_task_adc_ch_mid_blur(&ts_adc_ch_mid_blur[ch]);
	L3_task_adc_ch_avg_blur(&ts_adc_ch_avg_blur[ch]);
	L3_task_adc_ch_shift_blur(&ts_adc_ch_shift_blur[ch]);
}



#if 0

//单路滤波任务
#define D_task_ADC_CHx_BLUR_GET 0x51
#define D_task_ADC_CHx_BLUR_AVG 0x52
#define D_task_ADC_CHx_BLUR_SHIFT 0x53
#define D_task_ADC_CHx_BLUR_COUNT 0x54

void L3_task_adc_ch_blur(TS_ADC_CH_BLUR *s)
{
	TTSS_Task_init()
		L2_task_go(D_task_ADC_CHx_BLUR_GET);

  TTSS_Task_step(D_task_ADC_CHx_BLUR_GET)
		if(ts_adc_ch_sample[s->ch_n].n >= R.p.cc_blur_ch_avg)
		{
			s->SA_sum = ts_adc_ch_sample[s->ch_n].sum;
			s->SA_n = ts_adc_ch_sample[s->ch_n].n;
			ts_adc_ch_sample[s->ch_n].sum = 0;
			ts_adc_ch_sample[s->ch_n].n = 0;
			L2_task_go(D_task_ADC_CHx_BLUR_AVG);
		}

	TTSS_Task_step(D_task_ADC_CHx_BLUR_AVG)
		s->SA_avg = s->SA_sum / s->SA_n;
		L2_task_go(D_task_ADC_CHx_BLUR_SHIFT);
	
	TTSS_Task_step(D_task_ADC_CHx_BLUR_SHIFT)
		s->SHA_sum -= s->SHA_avg;
		s->SHA_sum += s->SA_avg;
		s->SHA_avg = (S32)(s->SHA_sum >> R.p.cc_blur_ch_shift);
		s->n++;
		L2_task_go(D_task_ADC_CHx_BLUR_COUNT);

	TTSS_Task_step(D_task_ADC_CHx_BLUR_COUNT)
		G.weight[s->ch_n] = D_COUNT_WEIGHT(s->SHA_avg);
		L2_task_go(D_task_ADC_CHx_BLUR_GET);
		
	TTSS_Task_end();
}





#define D_task_ADC_ALL_OUT_GET 0x51
#define D_task_ADC_ALL_OUT_DECIDE 0x52
#define D_task_ADC_ALL_OUT_SHOW 0x53
#define D_task_ADC_ALL_OUT_SHOW_1 0x54
#define D_task_ADC_ALL_OUT_DEBUG 0x55

void L3_task_adc_all_out(TS_ADC_ALL_OUT *s)
{	
	TTSS_Task_init()
		//s->diff_threshold = (R.p.cc_blur_all_out_threshold);
		//s->diff_threshold1 = (R.p.cc_blur_all_out_threshold1);
		//s->diff_threshold2 = (R.p.cc_blur_all_out_threshold2);
		//s->should_show_times_threshold = (R.p.cc_blur_all_out_should_show_times_threshold);
		L2_task_go(D_task_ADC_ALL_OUT_GET);

	TTSS_Task_step(D_task_ADC_ALL_OUT_GET)
		if(ts_adc_all_blur.n >= 1)
		{
			ts_adc_all_blur.n = 0;
			Lc_buf_copy_uc((U8*)s->SHA_pool, (U8*)ts_adc_all_blur.SHA_pool_0, D_ADC_CH_BLUE_POOL_NUM * sizeof(S32));
			s->SHA_diff[0] = Lc_abs(s->SHA_pool[1] , s->SHA_pool[0]);
			s->SHA_diff[1] = Lc_abs(s->SHA_pool[2] , s->SHA_pool[1]);
			s->SHA_ddiff[0] = Lc_abs(s->SHA_diff[1] , s->SHA_diff[0]);
			L2_task_go(D_task_ADC_ALL_OUT_DECIDE);
		}
	
	TTSS_Task_step(D_task_ADC_ALL_OUT_DECIDE)
		if((s->SHA_diff[1] >= R.p.cc_blur_all_out_d_threshold) || (s->SHA_diff[0] >= R.p.cc_blur_all_out_d_threshold) || (s->SHA_ddiff[0] >= R.p.cc_blur_all_out_dd_threshold))
		{
			#if 1
			s->sum = s->SHA_pool[2] + s->SHA_pool[1] + s->SHA_pool[0];
			ts_adc_all_blur.SHA_sum_1 = s->sum;
			ts_adc_all_blur.SHA_sum_1 <<= R.p.cc_blur_all_shift1;
			ts_adc_all_blur.SHA_sum_1 /= 3;
			ts_adc_all_blur.SHA_avg_1 =  (S32)(ts_adc_all_blur.SHA_sum_1 >> R.p.cc_blur_all_shift1);
			//s->val = ts_adc_all_blur.SHA_avg_0;
			s->val = s->sum / 3;
			//s->t = 0;
			#else
			ts_adc_all_blur.SHA_sum_1 = ts_adc_all_blur.SHA_avg_0 <<  R.p.cc_blur_all_shift1;
			ts_adc_all_blur.SHA_avg_1 = ts_adc_all_blur.SHA_avg_0;
			s->val = ts_adc_all_blur.SHA_avg_0;
			//s->t = 0;
			#endif
		} 
		else
		{
			s->val = ts_adc_all_blur.SHA_avg_1;
			//s->t = 1;
		}
		s->n++;
		L2_task_go(D_task_ADC_ALL_OUT_GET);
	TTSS_Task_end();
}
#endif