You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
473 lines
12 KiB
473 lines
12 KiB
#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
|
|
|
|
|
|
|