15 changed files with 119 additions and 746 deletions
Binary file not shown.
@ -1,418 +0,0 @@ |
|||
////////////////////////////////////////////////////////////////////////////
|
|||
///@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]); |
|||
} |
|||
|
|||
|
|||
|
|||
@ -1,119 +0,0 @@ |
|||
////////////////////////////////////////////////////////////////////////////
|
|||
///@copyright Copyright (c) 2018, 传控科技 All rights reserved.
|
|||
///-------------------------------------------------------------------------
|
|||
/// @file bsp_drv.h
|
|||
/// @brief bsp @ driver config
|
|||
///-------------------------------------------------------------------------
|
|||
/// @version 1.0
|
|||
/// @author CC
|
|||
/// @date 20180331
|
|||
/// @note cc_AS_stc02
|
|||
|
|||
//////////////////////////////////////////////////////////////////////////////
|
|||
|
|||
#ifndef _APP_TASK_ADC_H |
|||
#define _APP_TASK_ADC_H |
|||
|
|||
#include "../app/app_config.h" |
|||
#include "../ctask/task.h" |
|||
#include "../clib/clib.h" |
|||
|
|||
|
|||
#define ADC_CHANNEL_STATUS_UNREADY 0 //UnReady状态，不能读取
|
|||
#define ADC_CHANNEL_STATUS_READY 1 //ready状态，可以读取
|
|||
|
|||
//AD_CHANNEL_SAMPLE 采样
|
|||
#define MAX_OUT_NUM 6 |
|||
typedef struct _s_task_adc_channel_sample |
|||
{ |
|||
TS_task task; |
|||
vU8 status; |
|||
vU8 ch; |
|||
vU32 adcval; |
|||
vU32 pool; |
|||
vU8 n; |
|||
vU32 out[MAX_OUT_NUM]; |
|||
}S_TASK_ADC_CHANNEL_SAMPLE; |
|||
|
|||
//AD_BLUR_MID 中值滤波
|
|||
typedef struct _s_task_adc_blur_mid |
|||
|
|||
{ |
|||
TS_task task; |
|||
vU8 ch; |
|||
vU8 max; |
|||
vU32 in[MAX_OUT_NUM]; |
|||
vU32 midval; |
|||
vU8 n; |
|||
vU32 out[MAX_OUT_NUM]; |
|||
}S_TASK_ADC_BLUR_MID; |
|||
|
|||
//AD_BLUR_AVG 均值滤波
|
|||
typedef struct _s_task_adc_blur_avg |
|||
{ |
|||
TS_task task; |
|||
vU8 ch; |
|||
vU8 max; |
|||
vU32 in[MAX_OUT_NUM]; |
|||
vU32 avgval; |
|||
vU8 n; |
|||
vU32 out[MAX_OUT_NUM]; |
|||
}S_TASK_ADC_BLUR_AVG; |
|||
|
|||
//AD_BLUR_SHIFT 移位滤波
|
|||
typedef struct _s_task_adc_blur_shift |
|||
{ |
|||
TS_task task; |
|||
vU8 ch; |
|||
vU8 n; |
|||
vU8 h; |
|||
vU8 shiftreg[3]; |
|||
//vU8 max;
|
|||
vU32 in; |
|||
vU32 sum[3]; |
|||
vU32 shiftval[3]; |
|||
vU32 out[3][MAX_OUT_NUM]; |
|||
}S_TASK_ADC_BLUR_SHIFT; |
|||
|
|||
//AD_BLUR_DECIDE 输出判定
|
|||
typedef struct _s_task_adc_blur_out |
|||
{ |
|||
TS_task task; |
|||
vU8 ch; |
|||
vU32 in[2]; |
|||
U32 threshold[2]; |
|||
vU8 h; |
|||
vU8 oldnum; |
|||
vU8 newnum; |
|||
vU32 newout; |
|||
vU8 n; |
|||
}S_TASK_ADC_BLUR_OUT; |
|||
|
|||
//AD_BLUR_SHOW 显示
|
|||
typedef struct _s_task_adc_blur_show |
|||
{ |
|||
TS_task task; |
|||
vU32 rough_weight; |
|||
}S_TASK_ADC_BLUR_SHOW; |
|||
|
|||
|
|||
extern S_TASK_ADC_CHANNEL_SAMPLE ts_adc_channel_samples[D_ADC_CHANNEL_NUM]; |
|||
//extern S_TASK_ADC_BLUR_MID ts_adc_blur_mid[D_ADC_CHANNEL_NUM];
|
|||
extern S_TASK_ADC_BLUR_AVG ts_adc_blur_avg[D_ADC_CHANNEL_NUM]; |
|||
extern S_TASK_ADC_BLUR_SHIFT ts_adc_blur_shift[D_ADC_CHANNEL_NUM]; |
|||
extern S_TASK_ADC_BLUR_OUT ts_adc_blur_out[D_ADC_CHANNEL_NUM]; |
|||
extern S_TASK_ADC_BLUR_SHOW ts_adc_blur_show; |
|||
|
|||
|
|||
extern void L3_task_adc_init(U8 ch); |
|||
extern void L3_task_show_init(void); |
|||
extern void L3_task_adc_handler(U8 ch); |
|||
extern void L3_task_adc_init_handler(void); |
|||
extern void L3_task_adc_channel_switch_handler(void); |
|||
extern void L3_task_adc_filter_show(S_TASK_ADC_BLUR_SHOW *s); |
|||
|
|||
|
|||
|
|||
|
|||
#endif // #ifndef _APP_TASK_ADC_H
|
|||
|
|||
@ -1,63 +0,0 @@ |
|||
////////////////////////////////////////////////////////////////////////////
|
|||
///@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_register.h" |
|||
#include "../app/app_config.h" |
|||
#include "../bsp/bsp_config.h" |
|||
#include "../msp/uart0.h" |
|||
|
|||
//=============================================
|
|||
|
|||
S_TASK_REGVAL_LISTEN s_task_reglisten; |
|||
|
|||
void L3_task_reglisten_init(void) |
|||
{ |
|||
L1_task_init(&s_task_reglisten.task); |
|||
L3_task_s_go(s_task_reglisten,D_task_init); |
|||
} |
|||
|
|||
//清零任务
|
|||
#define D_task_WEIGHT_COUNT 0x50 |
|||
#define D_task_IAP 0x51 |
|||
void L3_task_reglisten_handle(S_TASK_REGVAL_LISTEN *s) |
|||
{ |
|||
|
|||
TTSS_Task_init() |
|||
L2_task_go(D_task_WEIGHT_COUNT); |
|||
|
|||
TTSS_Task_step(D_task_WEIGHT_COUNT) |
|||
if(R.zero != 0) |
|||
{ |
|||
R.total_zweight = R.rough_weight; //皮重 = 毛重
|
|||
R.total_weight = (R.rough_weight > R.total_zweight) ? (R.rough_weight - R.total_zweight) : (0);//净重
|
|||
R.zero = 0; |
|||
} |
|||
L2_task_go(D_task_IAP); //延时100ms
|
|||
|
|||
|
|||
TTSS_Task_step(D_task_IAP) |
|||
if(R.status_eep_save != 0) |
|||
{ |
|||
R.status_eep_save = 0; |
|||
L3_reg_2_iap();//写入IAP
|
|||
} |
|||
L2_task_go_Tdelay(D_task_WEIGHT_COUNT,D_Tdelay_Msec(100)); //延时100ms
|
|||
|
|||
|
|||
TTSS_Task_end(); |
|||
|
|||
} |
|||
|
|||
|
|||
|
|||
|
|||
|
|||
@ -1,32 +0,0 @@ |
|||
////////////////////////////////////////////////////////////////////////////
|
|||
///@copyright Copyright (c) 2018, 传控科技 All rights reserved.
|
|||
///-------------------------------------------------------------------------
|
|||
/// @file bsp_drv.h
|
|||
/// @brief bsp @ driver config
|
|||
///-------------------------------------------------------------------------
|
|||
/// @version 1.0
|
|||
/// @author CC
|
|||
/// @date 20180331
|
|||
/// @note cc_AS_stc02
|
|||
|
|||
//////////////////////////////////////////////////////////////////////////////
|
|||
|
|||
#ifndef _APP_TASK_REG_H |
|||
#define _APP_TASK_REG_H |
|||
|
|||
#include "../ctask/task.h" |
|||
#include "../clib/clib.h" |
|||
|
|||
typedef struct _s_task_reglisten |
|||
{ |
|||
TS_task task; |
|||
}S_TASK_REGVAL_LISTEN; |
|||
|
|||
extern S_TASK_REGVAL_LISTEN s_task_reglisten; |
|||
|
|||
extern void L3_task_reglisten_init(void); |
|||
extern void L3_task_reglisten_handle(S_TASK_REGVAL_LISTEN *s); |
|||
|
|||
|
|||
#endif // #ifndef _APP_TASK_ADC_H
|
|||
|
|||
Loading…
Reference in new issue