#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;

void L3_task_adc_init(void)
{
	U8 i = 0;
	for(i=0;i<D_ch_max_num;i++)
	{
		L1_task_init(&ts_adc_ch_sample[i].task);
		L3_task_s_go(ts_adc_ch_sample[i],D_task_init);
	    //ts_adc_ch_sample[i].error = 0;
		//ts_adc_ch_sample[i].n = 0;
		//ts_adc_ch_sample[i].pool = 0;
		//ts_adc_ch_sample[i].sum = 0;
		ts_adc_ch_sample[i].ch = D_ADCCH_1 + i;
		ts_adc_ch_sample[i].ch_n = TS_ADC_CH_01 + i;

		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;
	}

	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_n))
		{
			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->sum += s->adcval;
		++s->n;
		if(s->n >= D_ADC_CH_SAMPLE_BUF_MAX)
		{
			s->n = 0;
			s->sum = 0;
		}
		L2_task_go(D_task_ADC_CHx_SAMPLE);
		
	TTSS_Task_end();
}

//单路滤波任务
#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_BLUR_GET 0x51
#define D_task_ADC_ALL_BLUR_SHIFT0 0x52
#define D_task_ADC_ALL_BLUR_SHIFT1 0x53

void L3_task_adc_all_blur(TS_ADC_ALL_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_blur[D_ch_max_num-1].n >= 1)
		if(ts_adc_ch_blur[0].n >= 1)
		{
			ts_adc_ch_blur[0].n = 0;
			ts_adc_ch_blur[1].n = 0;
			ts_adc_ch_blur[2].n = 0;
			ts_adc_ch_blur[3].n = 0;
			s->sum = G.weight[0] + G.weight[1] + G.weight[2] + G.weight[3];
			L2_task_go(D_task_ADC_ALL_BLUR_SHIFT0);
		}
	
	TTSS_Task_step(D_task_ADC_ALL_BLUR_SHIFT0)
		s->SHA_sum_0 -= s->SHA_avg_0;
		s->SHA_sum_0 += s->sum;
		s->SHA_avg_0 = (S32)(s->SHA_sum_0 >> R.p.cc_blur_all_shift0);
		s->SHA_pool_0[0] = s->SHA_pool_0[1];
		s->SHA_pool_0[1] = s->SHA_pool_0[2];
		s->SHA_pool_0[2] = s->SHA_avg_0;
		L2_task_go(D_task_ADC_ALL_BLUR_SHIFT1);
		
	TTSS_Task_step(D_task_ADC_ALL_BLUR_SHIFT1)
		s->SHA_sum_1 -= s->SHA_avg_1;
		s->SHA_sum_1 += s->sum;
		s->SHA_avg_1 = (S32)(s->SHA_sum_1 >> R.p.cc_blur_all_shift1);
		//s->SHA_pool_1[0] = s->SHA_pool_1[1];
		//s->SHA_pool_1[1] = s->SHA_pool_1[2];
		//s->SHA_pool_1[2] = s->SHA_avg_1;

		s->n++;
		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();
}

#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_all_out.n >= 1)
		{
			ts_adc_all_out.n = 0;
			s->val = ts_adc_all_out.val;
			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);
		//L2_task_go(D_task_ADC_SHOW_DEBUG);
#if 0		
	TTSS_Task_step(D_task_ADC_SHOW_DEBUG)
		//L0_uart0_uc(s->t == 0 ? '0' : '1');
		s->u16_v = (vU16)(s->pool_val >> 16);
		L0_uart0_ushex(s->u16_v);
		s->u16_v = (vU16)(s->pool_val & 0x0000ffff);
		L0_uart0_ushex(s->u16_v);//Lc_delay_us(500);
		//L0_uart0_uc(0x0d);	L0_uart0_uc(0x0a);
		//L0_uart0_uc(' ');
		//L0_uart0_uc(' ');
		L2_task_go(D_task_ADC_SHOW_GET);
#endif		
	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;
	}
}