Tacking 发表于 2024-12-16 14:14

多通道输入捕获干扰问题,诉求大佬们帮忙解决,感谢!

<p>写了一个多通道输入捕获的代码,代码见附件。</p>

<p>目的是想通过TIM3的四个通道同时捕获风扇转速反馈回来的方波波形,再计算相应的转速,风扇方波波形如下图:</p>

<p> &nbsp;</p>

<p>在调试过程中发现,如果我单独捕获某一个通道的频率时数值是很稳定的,但是两个或者多个一起捕获时,通道数值跳变的很厉害!一直找不到原因。在百度上搜索也没有相关资料,但是看到一篇关于多通道PWM波形输出时有类似情况,说是通道之间干扰。不知道是不是这个原因,也不知道如何去解决。还请大佬们帮忙提供下思路、难道非得一个定时器捕获一个风扇么?我总共12个风扇呐!<img height="51" src="https://bbs.eeworld.com.cn/static/editor/plugins/hkemoji/sticker/facebook/cry2.gif" width="66" /></p>

<pre>
<code>四通道输入捕获代码如下:
#include "stm32f10x.h"                  // Device header

/**
* 函    数:风扇转速捕获初始化
* 参    数:无
* 返 回 值:无
*/
void FG_Capture_Init(uint16_t ARR,uint16_t PSC)
{
        /*开启时钟*/
        RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3,ENABLE);                        //开启TIM3的时钟
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);                //开启GPIOA的时钟
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);                //开启GPIOB的时钟
       
        /*GPIO初始化*/
        GPIO_InitTypeDef GPIO_InitStructure;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(GPIOA,&amp;GPIO_InitStructure);                                                        //将PA6、PA7引脚初始化为上拉输入
        GPIO_ResetBits(GPIOA,GPIO_Pin_6);
        GPIO_ResetBits(GPIOA,GPIO_Pin_7);                                                                //将引脚电平全部拉低
       
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1;
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(GPIOB,&amp;GPIO_InitStructure);                                                        //将PB0、PB1引脚初始化为上拉输入
        GPIO_ResetBits(GPIOB,GPIO_Pin_0);
        GPIO_ResetBits(GPIOB,GPIO_Pin_1);                                                                //将引脚电平全部拉低
       
        /*配置时钟源*/
        TIM_InternalClockConfig(TIM3);                                                                        //选择TIM3为内部时钟,若不调用此函数,TIM默认也为内部时钟
       
        /*时基单元初始化*/
        TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;                                //定义结构体变量
        TIM_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1;                //时钟分频,选择不分频,此参数用于配置滤波器时钟,不影响时基单元功能
        TIM_TimeBaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up;        //计数器模式,选择向上计数
        TIM_TimeBaseInitStructure.TIM_Period = ARR;                                                //计数周期,即ARR的值
        TIM_TimeBaseInitStructure.TIM_Prescaler = PSC;                                        //预分频器,即PSC的值
        TIM_TimeBaseInitStructure.TIM_RepetitionCounter = 0;                        //重复计数器,高级定时器才会用到
        TIM_TimeBaseInit(TIM3,&amp;TIM_TimeBaseInitStructure);                                //将结构体变量交给TIM_TimBaseInit,配置TIM3的时基单元
       
        /*输入捕获初始化*/
        TIM_ICInitTypeDef TIM_ICInitStructure;                                                        //定义结构体变量
        TIM_ICInitStructure.TIM_Channel = TIM_Channel_1;                                //选择配置定时器通道1
        TIM_ICInitStructure.TIM_ICFilter = 0x0;                                                        //输入滤波器参数,可以过滤信号抖动
        TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;                //极性,选择为上升沿触发捕获
        TIM_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;                        //捕获预分频,选择不分频,每次信号都触发捕获
        TIM_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI;        //输入信号交叉,选择直通,不交叉
        TIM_ICInit(TIM3,&amp;TIM_ICInitStructure);                                                        //将结构体变量交给TIM_ICInit,配置TIM3的输入捕获通道
       
        TIM_ICInitStructure.TIM_Channel = TIM_Channel_2;                                //选择配置定时器通道2
        TIM_ICInitStructure.TIM_ICFilter = 0x0;
        TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;
        TIM_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;
        TIM_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI;
        TIM_ICInit(TIM3,&amp;TIM_ICInitStructure);
       
        TIM_ICInitStructure.TIM_Channel = TIM_Channel_3;                                //选择配置定时器通道3
        TIM_ICInitStructure.TIM_ICFilter = 0x0;
        TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;
        TIM_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;
        TIM_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI;
        TIM_ICInit(TIM3,&amp;TIM_ICInitStructure);
       
        TIM_ICInitStructure.TIM_Channel = TIM_Channel_4;                                //选择配置定时器通道4
        TIM_ICInitStructure.TIM_ICFilter = 0x0;
        TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;
        TIM_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;
        TIM_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI;
        TIM_ICInit(TIM3,&amp;TIM_ICInitStructure);
       
        /*中断分组优先级初始化*/
        NVIC_InitTypeDef NVIC_InitStructure;                                                        //定义结构体变量
        NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;                                //TIM3中断
        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;                //先占优先级2
        NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;                        //从优先级2
        NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                                 //IRQ通道被使能
        NVIC_Init(&amp;NVIC_InitStructure);                                                                //配置寄存器
        /*
        NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;                                //TIM3中断
        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3;                //先占优先级3
        NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;                        //从优先级3
        NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                                 //IRQ通道被使能
        NVIC_Init(&amp;NVIC_InitStructure);*/                                                                 //配置寄存器
       
        //允许更新中断,允许CCxIE捕获中断
//        TIM_ITConfig(TIM3,TIM_IT_Update|TIM_IT_CC1|TIM_IT_CC2|TIM_IT_CC3|TIM_IT_CC4,ENABLE);
        TIM_ITConfig(TIM3,TIM_IT_Update|TIM_IT_CC1|TIM_IT_CC3,ENABLE);
       
        /*选择触发源及从模式*/
//        TIM_SelectInputTrigger(TIM3, TIM_TS_TI1FP1);                                        //触发源选择TI1FP1
//        TIM_SelectSlaveMode(TIM3, TIM_SlaveMode_Reset);                                        //从模式选择复位
                                                                                                                                        //即TI1产生上升沿时,会触发CNT归零
       
        /*TIM使能*/
        TIM_Cmd(TIM3,ENABLE);                                                                                        //使能TIM3,定时器开始运行
}

uint8_t TIM3CH_CAPTURE_STA = {0};                                                        //输入捕获状态数组
uint16_t TIM3CH_CAPTURE_VAL = {0};                                                        //输入捕获值数组

/*输入捕获状态数组位说明:
--------------------------------------------------------------
    bit7    |       bit6   |       bit5~0
------------|----------------|--------------------------------
捕获完成标志|捕获到高电平标志|捕获到高电平后定时器溢出的次数
--------------------------------------------------------------
*/

/**
* 函    数:定时器3中断服务程序
* 参    数:无
* 返 回 值:无
*/
void TIM3_IRQHandler(void)
{
        //CH1
        if((TIM3CH_CAPTURE_STA &amp; 0X80) == 0)                                //若bit7为0,还未捕获到一个完整的周期       
        {       
                //溢出中断处理部分               
                if (TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)//检测定时器3是否发生中断               
                {                                                                                                  //若发生中断
                        if(TIM3CH_CAPTURE_STA &amp; 0X40)                                //若bit6为1,即已经第一次捕获到高电平
                        {
                                if((TIM3CH_CAPTURE_STA &amp; 0X3F) == 0X3F)        //若高电平太长,且溢出次数超过bit5~0可实现的计数
                                {
                                        TIM3CH_CAPTURE_STA |= 0X80;                        //将bit7赋值为1,标记成功捕获了一次
                                        TIM3CH_CAPTURE_VAL = 0XFFFF;            
                                }
                                else
                                        TIM3CH_CAPTURE_STA++;                                //溢出次数+1               
                        }       
                }
                //捕获中断处理
                if(TIM_GetITStatus(TIM3,TIM_IT_CC1) != RESET)                //捕获1发生捕获事件
                {
                        if(TIM3CH_CAPTURE_STA&amp;0X40)                                        //捕获到第二个上升沿
                        {
                                TIM3CH_CAPTURE_STA |= 0X80;                                //标记捕获到一个完整的周期,给主程序处理
                                TIM3CH_CAPTURE_VAL = TIM_GetCapture1(TIM3);        //获取事件                               
                        }
                        else                                                                                        //捕获到第一个上升沿
                        {
                                TIM3CH_CAPTURE_STA = 0;                                       //清空标志位
                                TIM3CH_CAPTURE_VAL = 0;                                       //清空计时器
                                TIM_SetCounter(TIM3,0);                                               //清空定时器
                                TIM3CH_CAPTURE_STA |= 0X40;                               //标记捕获到第一个上升沿
                        }
                }
        }
        //清除中断标志位
        TIM_ClearITPendingBit(TIM3, TIM_IT_CC1 | TIM_IT_Update);


        //CH2
        if((TIM3CH_CAPTURE_STA &amp; 0X80) == 0)
        {       
                //溢出中断处理部分               
                if (TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)       
                {
                        if(TIM3CH_CAPTURE_STA &amp; 0X40)
                        {
                                if((TIM3CH_CAPTURE_STA &amp; 0X3F) == 0X3F)
                                {
                                        TIM3CH_CAPTURE_STA |= 0X80;
                                        TIM3CH_CAPTURE_VAL = 0XFFFF;            
                                }
                                else
                                        TIM3CH_CAPTURE_STA++;            
                        }       
                }
                //捕获中断处理
                if(TIM_GetITStatus(TIM3,TIM_IT_CC2) != RESET)                //捕获2发生捕获事件
                {
                        if(TIM3CH_CAPTURE_STA&amp;0X40)
                        {
                                TIM3CH_CAPTURE_STA |= 0X80;
                                TIM3CH_CAPTURE_VAL = TIM_GetCapture2(TIM3);                               
                        }
                        else
                        {
                                TIM3CH_CAPTURE_STA = 0;
                                TIM3CH_CAPTURE_VAL = 0;
                                TIM_SetCounter(TIM3,0);
                                TIM3CH_CAPTURE_STA |= 0X40;
                        }
                }
        }
        //清除中断标志位
        TIM_ClearITPendingBit(TIM3, TIM_IT_CC2 | TIM_IT_Update);
       
       
        //CH3
        if((TIM3CH_CAPTURE_STA &amp; 0X80) == 0)       
        {       
                //溢出中断处理部分               
                if (TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)       
                {
                        if(TIM3CH_CAPTURE_STA &amp; 0X40)
                        {
                                if((TIM3CH_CAPTURE_STA &amp; 0X3F) == 0X3F)
                                {
                                        TIM3CH_CAPTURE_STA |= 0X80;
                                        TIM3CH_CAPTURE_VAL = 0XFFFF;            
                                }
                                else
                                        TIM3CH_CAPTURE_STA++;            
                        }       
                }
                //捕获中断处理
                if(TIM_GetITStatus(TIM3,TIM_IT_CC3) != RESET)                //捕获3发生捕获事件
                {
                        if(TIM3CH_CAPTURE_STA&amp;0X40)
                        {
                                TIM3CH_CAPTURE_STA |= 0X80;
                                TIM3CH_CAPTURE_VAL = TIM_GetCapture3(TIM3);                               
                        }
                        else
                        {
                                TIM3CH_CAPTURE_STA = 0;
                                TIM3CH_CAPTURE_VAL = 0;
                                TIM_SetCounter(TIM3,0);
                                TIM3CH_CAPTURE_STA |= 0X40;
                        }
                }
        }
        //清除中断标志位
        TIM_ClearITPendingBit(TIM3, TIM_IT_CC3 | TIM_IT_Update);
       
       
        //CH4
        if((TIM3CH_CAPTURE_STA &amp; 0X80) == 0)
        {
                //溢出中断处理部分               
                if (TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)       
                {
                        if(TIM3CH_CAPTURE_STA &amp; 0X40)
                        {
                                if((TIM3CH_CAPTURE_STA &amp; 0X3F) == 0X3F)
                                {
                                        TIM3CH_CAPTURE_STA |= 0X80;
                                        TIM3CH_CAPTURE_VAL = 0XFFFF;            
                                }
                                else
                                        TIM3CH_CAPTURE_STA++;            
                        }       
                }
                //捕获中断处理
                if(TIM_GetITStatus(TIM3,TIM_IT_CC4) != RESET)                //捕获4发生捕获事件
                {
                        if(TIM3CH_CAPTURE_STA&amp;0X40)
                        {
                                TIM3CH_CAPTURE_STA |= 0X80;
                                TIM3CH_CAPTURE_VAL = TIM_GetCapture4(TIM3);                       
                        }
                        else
                        {
                                TIM3CH_CAPTURE_STA = 0;
                                TIM3CH_CAPTURE_VAL = 0;
                                TIM_SetCounter(TIM3,0);
                                TIM3CH_CAPTURE_STA |= 0X40;
                        }
                }       
        }
        //清除中断标志位
        TIM_ClearITPendingBit(TIM3, TIM_IT_CC4 | TIM_IT_Update);
}
</code></pre>

<p>主程序代码如下:</p>

<p> &nbsp;</p>

Tacking 发表于 2024-12-16 14:36

<p>多个通道捕获时现象如下视频:865639522c91c9c2a61b2c2b4e515a60</p>

<p>单个通道捕获时现象如下视频:c2a04992109ffb7c053b6ca83dec1a50<br />
&nbsp;</p>

tagetage 发表于 2024-12-16 16:11

<h1>&nbsp;STM32输入捕获--&ldquo;PWM输入模式&rdquo;(可拓展多路同时捕获)</h1>

<p>https://www.eeworld.com.cn/mcu/hisic555691.html</p>

Tacking 发表于 2024-12-16 16:20

tagetage 发表于 2024-12-16 16:11
&nbsp;STM32输入捕获--&ldquo;PWM输入模式&rdquo;(可拓展多路同时捕获)

https://www.eeworld.com.cn/m ...

<p>我认真学习下,非常谢谢您!<img height="73" src="https://bbs.eeworld.com.cn/static/editor/plugins/hkemoji/sticker/facebook/wanwan42.gif" width="82" /></p>

tagetage 发表于 2024-12-16 16:25

<p>你的要监测12个风扇的PWM转速值,要我做的话我会用硬件的多通道选择器,比如用2个8通道选择器做一个16通道选择器,用74HC251做,软件用一个PWM定时器捕获就行,因为风扇的速度不会变化太快太频繁,12分时扫描就可以了。。</p>

Tacking 发表于 2024-12-16 16:59

tagetage 发表于 2024-12-16 16:25
你的要监测12个风扇的PWM转速值,要我做的话我会用硬件的多通道选择器,比如用2个8通道选择器做一个16通道 ...

<p>您说的有道理,我之前也考虑过这种方案,但是我看有这么多个输入捕获通道,我就想着用起来,但是现在遇到这个问题,不知道是不是通道间有干扰还是咋回事?</p>

Tacking 发表于 2024-12-16 18:39

<div class='shownolgin' data-isdigest='yes'><p>有没哪位大佬知道这是什么原因导致的不?我还是想找出原因,不甚感激!</p>
</div><script>showreplylogin();</script><script type="text/javascript">(function(d,c){var a=d.createElement("script"),m=d.getElementsByTagName("script"),eewurl="//counter.eeworld.com.cn/pv/count/";a.src=eewurl+c;m.parentNode.insertBefore(a,m)})(document,523)</script>

zhoupxa 发表于 2024-12-16 22:55

<div class='shownolgin' data-isdigest='yes'><p>各个输入捕获通道应该是可以互不干扰、独立运作的,仔细梳理下你的软件前后台处理过程是否存在错误操作或共享冲突</p>
</div><script>showreplylogin();</script>

Tacking 发表于 2024-12-17 09:31

<div class='shownolgin' data-isdigest='yes'>zhoupxa 发表于 2024-12-16 22:55
各个输入捕获通道应该是可以互不干扰、独立运作的,仔细梳理下你的软件前后台处理过程是否存在错误操作或共 ...

<p>好的,感谢回复!我感觉应该是四个捕获通道不停的来中断,进入中断,OLED我采用的软件模拟的形式,是不是OLED刷新不过来导致显示错误,实际上捕捉回来的是没有错误的</p>
</div><script>showreplylogin();</script>

tagetage 发表于 2024-12-21 17:28

<div class='shownolgin' data-isdigest='yes'><p>楼主的问题有进展没有啊 ???</p>
</div><script>showreplylogin();</script>

Tacking 发表于 2024-12-23 11:24

<div class='shownolgin' data-isdigest='yes'>tagetage 发表于 2024-12-21 17:28
楼主的问题有进展没有啊 ???

<p>有进展的,非常感谢您的建议,之前干扰的问题我通过定时器设定标志位定时进行各通道输入捕获,然后再通过OLED显示就没问题了!但是速度稍快还是会出现错乱。索性我就按照您建议的方法通过74HC251来设计了,现在测试结果显示十分正常,且可以任意设置捕获时间,真的非常感谢您<img height="48" src="https://bbs.eeworld.com.cn/static/editor/plugins/hkemoji/sticker/facebook/congra.gif" width="48" /></p>
</div><script>showreplylogin();</script>

Tacking 发表于 2024-12-23 11:26

<div class='shownolgin' data-isdigest='yes'>Tacking 发表于 2024-12-23 11:24
有进展的,非常感谢您的建议,之前干扰的问题我通过定时器设定标志位定时进行各通道输入捕获,然后再通过 ...

<p>另外有个问题还想请教下您:我这四个风扇的FG信号输入到stm32的IO口,但是需要监测这些FG信号的方波什么时候会没有?(也就是监测风扇转不转),经过测试,在风扇不转的时候,FG信号会一直处于高电平,有没什么好的方法来进行监测stm32的IO口是否一直处于高电平啊?</p>
</div><script>showreplylogin();</script>

tagetage 发表于 2024-12-23 11:45

<div class='shownolgin' data-isdigest='yes'>Tacking 发表于 2024-12-23 11:26
另外有个问题还想请教下您:我这四个风扇的FG信号输入到stm32的IO口,但是需要监测这些FG信号的方波什么 ...

<p>很高兴你采纳了我的建议并取得了很好的效果。</p>

<p>来进行监测stm32的IO口是否一直处于高电平啊?----用软件办法比较好。也可以想办法把74HC251的反向输出端用上。</p>

<p>1,定时器里查询IO电平。次数太多就是风扇停转。</p>

<p>2,74HC251的输出还有也反向输出端,可以做IO电平或边沿中断输入,在软件里判断,有中断则正常,没有中断超时则出错。</p>
</div><script>showreplylogin();</script>

tagetage 发表于 2024-12-23 11:48

<div class='shownolgin' data-isdigest='yes'><p>就是74HC251的反向输出端用上,在接一个IO做查询,或中断处理。我想你也能明白。。</p>
</div><script>showreplylogin();</script>

Tacking 发表于 2024-12-23 12:00

<div class='shownolgin' data-isdigest='yes'>tagetage 发表于 2024-12-23 11:48
就是74HC251的反向输出端用上,在接一个IO做查询,或中断处理。我想你也能明白。。

<p>我现在的做法就是将反向端用上了;</p>

<p>IO轮询的话,我考虑的是:一直轮询监测是否是高电平的话,风扇正常运转的话,可能也会刚好多次轮循到高电平的状态,这样会出现误判断</p>

<p>利用中断最好,但是我不知道怎么去判断中断有没有?我尝试了下去监测中断标志位,但是没有达到效果<img height="50" src="https://bbs.eeworld.com.cn/static/editor/plugins/hkemoji/sticker/facebook/funk1.gif" width="53" />。不知道是不是我监测中断的方式不对?按理说没有上升沿或者下降沿它是不会有中断的。</p>

<p>非常感谢您的指导!</p>
</div><script>showreplylogin();</script>

tagetage 发表于 2024-12-23 12:16

<div class='shownolgin' data-isdigest='yes'>Tacking 发表于 2024-12-23 12:00
我现在的做法就是将反向端用上了;

IO轮询的话,我考虑的是:一直轮询监测是否是高电平的话,风扇正常 ...

<p>IO轮询的话,我考虑的是:一直轮询监测是否是高电平的话,风扇正常运转的话,可能也会刚好多次轮循到高电平的状态,这样会出现误判断---------听你这话你软件编程不是老手吧,</p>

<p>这得考虑风扇的最小转数,然后计算PWM值的周期时间,然后在这个时间内最少做3次查询就不会出现误判断。</p>

<p>或者直接判断读到的PWM值来判断(但是这个方法我不太确定好不好用)。</p>
</div><script>showreplylogin();</script>

tagetage 发表于 2024-12-23 12:19

<div class='shownolgin' data-isdigest='yes'><p>不知道是不是我监测中断的方式不对?按理说没有上升沿或者下降沿它是不会有中断的。</p>

<p>非常感谢您的指导!------这个编程你还是画一个流程图比较好,条例会比较清晰,你是不是没有画流程图。</p>
</div><script>showreplylogin();</script>

Tacking 发表于 2024-12-23 12:22

<div class='shownolgin' data-isdigest='yes'>tagetage 发表于 2024-12-23 12:19
不知道是不是我监测中断的方式不对?按理说没有上升沿或者下降沿它是不会有中断的。

非常感谢您的指导! ...

<p>是的,我画个流程图,再重新试试,非常感谢!</p>
</div><script>showreplylogin();</script>

tagetage 发表于 2024-12-23 12:24

<div class='shownolgin' data-isdigest='yes'><p>有几个软件的方法都能做,但是我认为最适合你的方法是,计算风扇的最小转数,然后计算PWM值的周期时间,然后在这个时间内最少做3次查询的这个的方法。</p>
</div><script>showreplylogin();</script>

tagetage 发表于 2024-12-23 12:25

<div class='shownolgin' data-isdigest='yes'><p>按理说没有上升沿或者下降沿它是不会有中断的。-------是的,但是我上面也说了,,在软件里判断,有中断则正常,没有中断超时则出错。</p>
</div><script>showreplylogin();</script>
页: [1] 2
查看完整版本: 多通道输入捕获干扰问题,诉求大佬们帮忙解决,感谢!