////////////////////////////////////////////////////////////////////////////  
///@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 "task_adc.h"
#include "../bsp/bsp_config.h"
#include "../bsp/cs1232.h"
#include "../msp/uart0.h"

//=============================================

//S_TASK_ADC_CHANNEL_BLUR   ts_adc_channel_blurs[D_ADC_CHANNEL_NUM];
//S_TASK_ADC_CHANNEL_SHOW  ts_adc_channel_show;

S_TASK_ADC_CHANNEL_SAMPLE ts_adc_channel_samples[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];
S_TASK_ADC_BLUR_SHOW ts_adc_blur_show;

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;
}
//ch是0123，代表4通道
void L3_task_adc_init(U8 ch)
{		
	//通道采集任务初始化
	L1_task_init(&ts_adc_channel_samples[ch].task);
	L3_task_s_go(ts_adc_channel_samples[ch],D_task_init);
	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;

#if 0
	//通道中值滤波任务初始化
	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;
#endif

	//通道均值滤波任务初始化
	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_COUNT_ADC(R.p.adc_blur_threshold[0]); //2KG
//	ts_adc_blur_out[ch].threshold[1] = D_COUNT_ADC(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].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

}


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


//ADC Channel 采样任务
#define D_task_ADC_CHx_SAMPLE_WAIT_LOW 0x53
#define D_task_ADC_CHx_SAMPLE_READ 0x54
#define D_task_ADC_CHx_SAMPLE_OUT 0x55
void L3_task_adc_channel_sample(S_TASK_ADC_CHANNEL_SAMPLE *s)
{
	TTSS_Task_init()
		L2_task_go(D_task_ADC_CHx_SAMPLE_WAIT_LOW);

	TTSS_Task_step(D_task_ADC_CHx_SAMPLE_WAIT_LOW)
		if(s->status == ADC_CHANNEL_STATUS_READY)	//需要判断status是否ready，ready则读取，否则使用pool值
		{
			if(0 == L0_2dc_DOUT_AT(s->ch))
			{
				L2_task_go(D_task_ADC_CHx_SAMPLE_READ);
			}
		}
		else
		{
			s->adcval = s->pool;
			L2_task_go_Tdelay(D_task_ADC_CHx_SAMPLE_OUT,D_Tdelay_Msec(15));	//延时15ms，模拟一次采样过程
		}
		
    TTSS_Task_step(D_task_ADC_CHx_SAMPLE_READ)
		if(s->status == ADC_CHANNEL_STATUS_READY)	//需要重新判断status是否ready，因为channel_switch任务随时可能修改status状态
		{	
			s->adcval = Abs(L0_ADS1231_readCH(s->ch));
			L2_task_go(D_task_ADC_CHx_SAMPLE_OUT);
		}
		else
		{
			L2_task_go(D_task_ADC_CHx_SAMPLE_WAIT_LOW);
		}
		
	TTSS_Task_step(D_task_ADC_CHx_SAMPLE_OUT)
		//不判断ready,不管是采集到的真实数据还是pool数据，都继续执行
		s->pool = s->adcval;
		s->out[s->n] = s->adcval;		
		//R.adval[s->ch] = s->out[s->n];
		//L0_uart0_ulhex(R.adval[s->ch]);L0_uart0_0d0a();
		s->n++;	
	#if 0
		L0_uart0_ulhex(s->out[count_n(s->n,1)]);
		L0_uart0_uc('	'); 
		//L0_uart0_ulhex(ts_adc_blur_mid[s->ch].out[count_n(ts_adc_blur_mid[s->ch].n,1)]);
		//L0_uart0_uc('	');
		L0_uart0_ulhex(ts_adc_blur_avg[s->ch].out[count_n(ts_adc_blur_avg[s->ch].n,1)]);
		L0_uart0_uc('	');
		L0_uart0_ulhex(ts_adc_blur_shift[s->ch].shiftval[0]);
		L0_uart0_uc('	');
		L0_uart0_ulhex(ts_adc_blur_shift[s->ch].shiftval[1]);
		L0_uart0_uc('	');
		L0_uart0_ulhex(ts_adc_blur_shift[s->ch].shiftval[2]);
		L0_uart0_uc('	');	
		L0_uart0_ulhex(R.adval[s->ch]);
		L0_uart0_uc('	');
		L0_uart0_ulhex(ts_adc_blur_out[s->ch].oldnum);		
		L0_uart0_0d0a();
	#endif
		
		if(s->n >= MAX_OUT_NUM)
		{
			s->n = 0;
		}
		L2_task_go(D_task_ADC_CHx_SAMPLE_WAIT_LOW);
		
	TTSS_Task_end();
}

#if 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].out[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_vS32_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();		
}
#endif


//均值滤波任务
#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].out[i];
			}
			L2_task_go(D_task_ADC_CHx_FILTER_AVG_COUNT);
		}		
		
	TTSS_Task_step(D_task_ADC_CHx_FILTER_AVG_COUNT)	
		s->avgval = Lc_vU32_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_filter_shift(S_TASK_ADC_BLUR_SHIFT *s)
{
	TTSS_Task_init()
		L2_task_go(D_task_ADC_CHx_FILTER_SHIFT_GET);
	
	TTSS_Task_step(D_task_ADC_CHx_FILTER_SHIFT_GET)
		if(s->h != ts_adc_blur_avg[s->ch].n)
		{	
			s->in = ts_adc_blur_avg[s->ch].out[count_n(ts_adc_blur_avg[s->ch].n,1)];
			s->h = ts_adc_blur_avg[s->ch].n;
			L2_task_go(D_task_ADC_CHx_FILTER_SHIFT_COUNT);
		}		
		
	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( 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();
//}

void L3_task_adc_handler(u8 ch)
{
	L3_task_adc_channel_sample(&ts_adc_channel_samples[ch]);
	//L3_task_adc_filter_mid(&ts_adc_blur_mid[ch]);
	L3_task_adc_filter_avg(&ts_adc_blur_avg[ch]);
	L3_task_adc_filter_shift(&ts_adc_blur_shift[ch]);
	L3_task_adc_filter_out(&ts_adc_blur_out[ch]);
}