ccsens_hardware
/
ttss_weight
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
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.
8 Commits
3 Branches
0 Tags
8.0 MiB
Branch: dev
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'dev'
${ noResults }
ttss_weight/source/asp/asp_schain.c

727 lines
21 KiB
Raw Permalink Normal View History

Initial Commit
1 year ago
////////////////////////////////////////////////////////////////////////////
///@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 "asp_schain.h"
///#include "common.h"
#include "msp_uart1.h"
#include "bsp_cs1232.h"
#include "debug_drv.h"
#define D_sensor_up_down 1/// 称重传感器上下镜像选择
//=============================================
///打开adc输出监控，0kg的试试每一路的输出就是 0kg_out1_adc FF77 FFB3 00A4 FFEA
#define D_ch1_0kg_out1_adc (vS16)0xFF77
#define D_ch2_0kg_out1_adc (vS16)0xFFB3
#define D_ch3_0kg_out1_adc (vS16)0x00A4
#define D_ch4_0kg_out1_adc (vS16)0xFFEA
/////需要通过测试配置 如果不在意符号位 可以优化 diao
#define D_ch1_out1_offset (vS16)(D_ch1_wantline-D_ch1_0kg_out1_adc)
#define D_ch2_out1_offset (vS16)(D_ch2_wantline-D_ch2_0kg_out1_adc)
#define D_ch3_out1_offset (vS16)(D_ch3_wantline-D_ch3_0kg_out1_adc)
#define D_ch4_out1_offset (vS16)(D_ch4_wantline-D_ch4_0kg_out1_adc)
#define D_ch1_wantline (vS16)0x18da
#define D_ch2_wantline (vS16)0x18da
#define D_ch3_wantline (vS16)0x18da
#define D_ch4_wantline (vS16)0x18da
///cc 2023/04/06--7:39:40 每个传感器放置10kg
///应变片传感器10kg的adc值，选择这个是因为10kg容易获得 并且有一定的重量差
///这个值需要实验获得
#define D_ch1_10kg_out1_adc (vS16)0x0584
#define D_ch2_10kg_out1_adc (vS16)0x05DE
#define D_ch3_10kg_out1_adc (vS16)0x0731
#define D_ch4_10kg_out1_adc (vS16)0x066C
#define D_Rsensor_per_10kg ((vS16)10)
#define D_adc_per_kg ((D_ch1_10kg_out1_adc-D_ch1_0kg_out1_adc)/D_Rsensor_per_10kg)
#define D_adc_zeroout (10*D_adc_per_kg) ///零点都拉到10kg
TS_adc_SPara_ TS_adc_SPara[D_ADC_CHANNEL_NUM]=
{
'A',//0 1 u8 rev1;
0,//2 3 u8 ch;
D_ch1_wantline,///vU16 wantline; ///固定的硬件参数（例如称重中的0kg，压力中的0压力）时想要输出的adc的值
D_ch1_out1_offset,//3 4 vU16 offset;
2,//4 5 vU8 ashift; ///移动的位数 1-2 2-4 3-8 4-16
5,//5 6 vU8 bshift; ///移动的位数 1-2 2-4 3-8 4-16
'A',//0 1 u8 rev1;
1,//2 3 u8 ch;
D_ch1_wantline,///vU16 wantline; ///固定的硬件参数（例如称重中的0kg，压力中的0压力）时想要输出的adc的值
D_ch2_out1_offset,//3 4 vU16 offset;
2,//4 5 vU8 ashift; ///移动的位数 1-2 2-4 3-8 4-16
5,//5 6 vU8 bshift; ///移动的位数 1-2 2-4 3-8 4-16
'A',//0 1 u8 rev1;
2,//2 3 u8 ch;
D_ch1_wantline,///vU16 wantline; ///固定的硬件参数（例如称重中的0kg，压力中的0压力）时想要输出的adc的值
D_ch3_out1_offset,//3 4 vU16 offset;
2,//4 5 vU8 ashift; ///移动的位数 1-2 2-4 3-8 4-16
5,//5 6 vU8 bshift; ///移动的位数 1-2 2-4 3-8 4-16
'A',//0 1 u8 rev1;
3,//2 3 u8 ch;
D_ch1_wantline,///vU16 wantline; ///固定的硬件参数（例如称重中的0kg，压力中的0压力）时想要输出的adc的值
D_ch4_out1_offset,//3 4 vU16 offset;
2,//4 5 vU8 ashift; ///移动的位数 1-2 2-4 3-8 4-16
5//5 6 vU8 bshift; ///移动的位数 1-2 2-4 3-8 4-16
};
TS_task_adc_sample ts_adc_samples[D_ADC_CHANNEL_NUM];
//ch是0123，代表4通道
void L2_task_adc_init(U8 ch)
{
//通道采集任务初始化
L1_task_reg_clear(&ts_adc_samples[ch].task);
L3_task_s_go(ts_adc_samples[ch],D_task_init);
ts_adc_samples[ch].pSPara = &TS_adc_SPara[ch];
ts_adc_samples[ch].firstRun = 1;
}
//ADC Channel 采样任务
#define D_task_ADC_CHx_SAMPLE_JITTER_START_SAMPLE 0x53
#define D_task_ADC_CHx_JITTER 0x63
#define D_task_ADC_CHx_PIANYI 0x93
#define D_task_ADC_CHx_JITTER2 0x83
#define D_task_ADC_CHx_despiking_shift 0x94
#define D_task_ADC_CHx_SAMPLE_WAIT_LOW 0x73
#define D_task_ADC_CHx_SAMPLE_READ 0x54
#define D_task_ADC_CHx_SAMPLE_OUT 0x55
#define D_task_ADC_CHx_SHIFTFILTER 0x56
#define D_task_ADC_CHx_SHIFTFILTER2 0x57
#define D_ADC_JITTER_zero 22///还包含建立时间 至少9个
#define D_ADC_JITTER_FINISH 12///还包含建立时间 至少9个
/********
80hZ
1000ms/80= 12.5ms/point
ushex send = 4Bytes+blank = 5Byte;
115200 0.1ms/Byte
所以发送5Bytes 消耗0.5ms 发送四列 消耗2ms 系统足够响应
*******/
S16 L3_out_tran(vU32 rdata)
{
S16 t16;
/// 24bits 3Bytes
rdata >>= 8;
t16 = rdata;
#if (D_sensor_up_down)
t16 *= -1;
#else
///t16 *= -1;
#endif
return t16;
}
vU16 L3_adc_out_offset(vU16 offset,vU16 t16)
{
vU16 out;
/// L0_uart0_ushex(t16); L0_uart0_uc(' ');
if(t16 & 0x8000) //最高位为1，<0则
{
t16 = 0xffFF - t16;///转变为正数
///*d = D_ADC_OFFSET - t16;
out = offset - t16;
// L0_uart0_uc('$'); L0_uart0_ushex(ts_adc_samples[ch].offset);L0_uart0_uc(' ');
}else
{
out = t16 + offset;
}
// L0_uart0_ushex(out);L0_uart0_uc(' '); L0_uart0_uc('R');L0_uart0_0d0a();
return out;
}
/*
adcval adc采样值
^
|
| --.-------------.-------------.------------.---------wantline
| . . . .
| . . offset3 .
| . . . .
| . . .ch3.adc .
| offset1 offset2 .
| . . offset4
---0---.-------------.--------------------------.------------
| . .ch2.adc .
| . .
| ch1.adc .
| .
| ch3.adc.
.的数量或高度就是offset
adc有正数和负数
*/
vU16 L3_adc_get_offset(vU16 wantline,vU16 adcv)
{
vU16 out;
/// L0_uart0_ushex(t16); L0_uart0_uc(' ');
if(adcv & 0x8000) //最高位为1，<0则
{
out = 0xffFF - adcv;///转变为正数
out += wantline;
}else
{
out = wantline - adcv;
}
return out;
}
/*
///cc 2023/04/06--6:34:10
针对西安方片传感器
adc
hex dec kg adc/kg
68F 1679 10 168
4196 16790 100
-------------void L2_task_adc_sample(TS_TASK_ADC_SAMPLE *s)----------
s->out1_adc = L3_out_tran(s->out0);
############
s->out2_offset = L3_out_offset(s->ch,s->out1_adc);
############
Lc_despiking_shift3_U16(s->outm);////采样后进行削峰
s->out3_peak = s->outm[1];
############
s->ts_SAa.out4_shift = (vU16)s->ts_SAa.average; from s->out3_peak
s->ts_SAb.out4_shift = (vU16)s->ts_SAb.average;from s->out3_peak
----------void L3_task_weight_handler(TS_TASK_weight_ *s)-----------------
ts_adc_samples[3].out5 = ts_adc_samples[3].ts_SAb.out4_shift;
############
////四个传感器相加后平均
tst_weight.sum32 = ts_adc_samples[0].out5;
tst_weight.sum32 += ts_adc_samples[1].out5;
tst_weight.sum32 += ts_adc_samples[2].out5;
tst_weight.sum32 += ts_adc_samples[3].out5;
tst_weight.out6 = tst_weight.sum32 >>2;
############
tst_weight.adc32 = tst_weight.out6;
L3_task_weight_cal();
上电的时候有几种状态
1 有人
2 有物体
3 无人
出厂必备的操作，
1，没有重物清零，数据写入程序，
出厂把adc的值都偏移到 10kg/200kg 如果时基本时1/20偏移
也就是出厂时传感器的值基本一条线
2，以后上电时 或者重新启动时 低于一定重量就清零
3，手工可以清零
---------------------------
四个传感器 在没有重量 出厂的时候需要拉成偏移
简单的方式 四个传感器累加的模式
*/
void L2_task_adc_sample(TS_task_adc_sample *s)
{
TTSS_Task_init():
////cc 初始化尽量放到这里，不要放到main ——init中，减少系统启动的时间
s->jitter_start = 0; s->ok = 0;
////printf("\r\nADC_SAMPLE\r\n");
/*
printf5("\r\nADC_SAMPLE init ch(%d) wantline:%d(%4X) offset %d(%4X)", (int)s->pSPara->ch,
ts_adc_samples[s->pSPara->ch].pSPara->wantline,ts_adc_samples[s->pSPara->ch].pSPara->wantline,
ts_adc_samples[s->pSPara->ch].pSPara->offset,ts_adc_samples[s->pSPara->ch].pSPara->offset);
*/
printf1("\r\nADC_SAMPLE init ch(%d) ", (int)s->pSPara->ch);
L1_uartD_waitFree() ;
s->firstRun = 1;
/// L2_task_go(D_task_ADC_CHx_SAMPLE_READ);
L2_task_go_Tdelay(D_task_ADC_CHx_SAMPLE_READ,D_Tdelay_Msec(1500)); //延时15ms
TTSS_Task_step(D_task_ADC_CHx_SAMPLE_READ):
if(0 == L0_adc_DOUT_AT(s->pSPara->ch))
{////L0_uart0_uc('X');L0_uart0_uc(0x30+s->ch);
//// L0_ADS1231_readCH2(s->ch,&(s->out1)); ////
L0_ADS1231_readCH2(s->pSPara->ch,&(s->out0));
L2_task_go(D_task_ADC_CHx_PIANYI);
}
TTSS_Task_step(D_task_ADC_CHx_PIANYI):
s->out1_adc = L3_out_tran(s->out0);///////cc 2023/04/06--6:33:46 最原始的输出
s->out2_offset = L3_adc_out_offset(s->pSPara->offset,s->out1_adc);
L2_task_go(D_task_ADC_CHx_despiking_shift);
TTSS_Task_step(D_task_ADC_CHx_despiking_shift):
s->outm[0] = s->outm[1];
s->outm[1] = s->outm[2];
s->outm[2] = s->out2_offset;
Lc_despiking_shift3_U16(s->outm);////采样后进行削峰
s->out3_Peak = s->outm[1];
/// s->pSPara->offset = s->pSPara->wantline - s->out3_Peak;
if(s->firstRun)///
{////第一次上电
L2_task_go(D_task_ADC_CHx_JITTER2);
}else
{
L2_task_go(D_task_ADC_CHx_SHIFTFILTER);
}
TTSS_Task_step(D_task_ADC_CHx_JITTER2):
if(s->jitter_start < D_ADC_JITTER_FINISH)
{
///printfs("\r\n D_ADC_JITTER_zero---");
L1_uartD_uc('9');
s->jitter_start ++;
L2_task_go(D_task_ADC_CHx_SAMPLE_READ);
}else
{
/// 上电的时候如果没有重量可以这样 ，如果有呢？？
///L3_out_zero(s->ch);///算出当前的偏移量 更新offset
s->pSPara->offset = L3_adc_get_offset(s->pSPara->wantline,s->out1_adc);///必须out1_adc 因为偏移是针对 out1_adc的
/// s->pSPara->offset = s->pSPara->wantline - s->out3_Peak;
printfs("\r\n D_ADC_JITTER_zero---");
///printf3("\r\n ch(%d) out3_Peak %5d %5X ",(int)s->pSPara->ch,s->out3_Peak,s->out3_Peak );
printf4("\r\n ch(%d) adc=%5d ->offset %5d wantline %5d ",(int)s->pSPara->ch,s->out1_adc,s->pSPara->offset,s->pSPara->wantline);
printf4("\r\n ch(%d) adc=%5X ->offset %5X wantline %5X ",(int)s->pSPara->ch,s->out1_adc,s->pSPara->offset,s->pSPara->wantline);
s->ts_SAa.average = (vU32)s->out3_Peak;/// shiftaverage_a路初始化
s->ts_SAa.sum = s->ts_SAa.average << s->pSPara->ashift;
/**
s->ts_SAb.average = (vU32)s->out3_Peak;/// shiftaverage_b路初始化
s->ts_SAb.sum = s->ts_SAb.average << s->pSPara->bshift;
*/
s->firstRun = 0;
///刚开始的抖动，先去掉几个最开始的数据
L2_task_go(D_task_ADC_CHx_SHIFTFILTER);
}
TTSS_Task_step(D_task_ADC_CHx_SHIFTFILTER):
//L0_uart0_uc('B');
s->ts_SAa.sum -= s->ts_SAa.average;
s->ts_SAa.sum += (vU32)s->out3_Peak;
s->ts_SAa.average = s->ts_SAa.sum >> s->pSPara->ashift;
// s->ts_SAa.new = s->ts_SAa.average;
s->ts_SAa.out4_shift = (vU16)s->ts_SAa.average;
/// L0_uart0_uc('s');
L2_task_go(D_task_ADC_CHx_SHIFTFILTER2);
TTSS_Task_step(D_task_ADC_CHx_SHIFTFILTER2):
s->ok = 1;
L2_task_go(D_task_ADC_CHx_SAMPLE_READ);
/// L2_task_go(D_task_ADC_CHx_SAMPLE_OUT);
TTSS_Task_step(D_task_ADC_CHx_SAMPLE_OUT):
/***
L0_uart0_ulhex(s->out0); L0_uart0_uc(0x09);
L0_uart0_ushex(s->out1); L0_uart0_uc(0x09);
L0_uart0_ushex(s->out2); L0_uart0_uc(0x09);
L0_uart0_ushex(s->ts_SAa.out4); L0_uart0_uc(0x09);
L0_uart0_ushex(s->ts_SAb.out4);
L0_uart0_0d0a();
**/
////
//// L0_uart0_uc('0' + s->ch);L0_uart0_uc('A');//
TTSS_Task_end();
}
#if 0
void L3_out_zero(u8 ch)
{
vS16 t,m;
t = ts_adc_samples[ch].out1_adc;
m = ts_adc_samples[ch].SPara.wantline;
m -= t;
ts_adc_samples[ch].SPara.offset = (vU16)m;
/// L0_waitFree_uartN(0);///混搭使用printf的时候必须加上
/// printf("\r\nzeroout = %4x offset= 0x%4x\r\n", ts_adc_samples[ch].zeroout,ts_adc_samples[ch].offset);
/// D_ADC_OFFSET(ch) = ts_adc_samples[ch].zeroout - ts_adc_samples[ch].out1;
}
vU16 L3_out_offset222(u8 ch,vU16 t16)
{
vU16 out;
/// L0_uart0_ushex(t16); L0_uart0_uc(' ');
if(t16 & 0x8000) //最高位为1，<0则
{
t16 = 0xffFF - t16;///转变为正数
///*d = D_ADC_OFFSET - t16;
out = ts_adc_samples[ch].SPara.offset - t16;
// L0_uart0_uc('$'); L0_uart0_ushex(ts_adc_samples[ch].offset);L0_uart0_uc(' ');
}else
{
out = t16 + ts_adc_samples[ch].SPara.offset;
}
// L0_uart0_ushex(out);L0_uart0_uc(' '); L0_uart0_uc('R');L0_uart0_0d0a();
return out;
}
vU16 L3_out_tran2(vU32 rdata)
{
vU16 t16;
//// L0_ADS1231_readCH2(0,&rdata);
// L0_uart0_uc('0'+ch); L0_uart0_uc(0x09);
// L0_uart0_ulhex(rdata); L0_uart0_uc(0x09);
if (rdata > 0x007fFFff)
{
rdata >>= D_sensor_zoom; ///fixme:此处正负差和移位不一致需要谨慎
rdata |= D_sensor_zoom_FF; /// 1111 1100
}else
{
rdata >>= D_sensor_zoom;
}
// L0_uart0_ulhex(rdata); L0_uart0_uc(0x09);
t16 = rdata;
// L0_uart0_ushex(t16); L0_uart0_uc(0x09);
///L0_uart0_0d0a();
return t16;
}
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;
}
//中值滤波任务
#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].out1[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_S32_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();
}
//均值滤波任务
#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].out1[i];
}
L2_task_go(D_task_ADC_CHx_FILTER_AVG_COUNT);
}
TTSS_Task_step(D_task_ADC_CHx_FILTER_AVG_COUNT)
s->avgval = Lc_vS32_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_ShiftFilter(TS_TASK_ADC_SHIFTFILTER *s)
{
TTSS_Task_init()
s->average = ts_adc_samples[s->ch].out2;///
s->sum = s->average << s->shift;
L2_task_go(D_task_ADC_CHx_FILTER_SHIFT_GET);
TTSS_Task_step(D_task_ADC_CHx_FILTER_SHIFT_GET)
s->sum +=
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 0
L0_uart0_ulhex(s->rough_weight);
L0_uart0_uc(' ');
#endif
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();
}
/*******
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;
//通道中值滤波任务初始化
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;
//通道均值滤波任务初始化
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_blur_threshold_2_1(R.p.adc_blur_threshold[0]); //2KG
ts_adc_blur_out[ch].threshold[1] = D_blur_threshold_2_1(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].oldout = 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
#endif