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.
418 lines
12 KiB
418 lines
12 KiB
////////////////////////////////////////////////////////////////////////////
|
|
///@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]);
|
|
}
|
|
|
|
|
|
|
|
|