标题: EC11编码器基于运算解码的算法(原创) [打印本页]

---

作者: zyhlove813    时间: 2023-12-13 22:46
标题: EC11编码器基于运算解码的算法(原创)

EC11编码器基于运算解码的算法(原创)

EC11旋转编码器是一种基于脉冲发生的装置，它的编码逻辑如下图


单片机解码方式主要有几种：
1、MCU定时器自带编码器模式，如GD32、STM32等；
2、使用外部IO中断，在中断时根据A或B的电平状态，来确定编码器的方向并计数；
3、在主程序里循环扫描或定时器中断扫描的方式；
我现在以第3种扫描算法方面来跟大家分享：
目前网上搜索到的代码，基本都是以时序AB相的状态，基于逻辑条件来解码，如：

1. char Encoder_EC11_Scan()     /*  这里只是部分代码  */
   
2. {
   
3. //以下储存A、B上一次值的变量声明为静态全局变量，方便对EC11对应的IO口做初始化
   
4. //  static char EC11_A_Last = 0;
   
5. //  static char EC11_B_Last = 0;
   
6.     char ScanResult = 0;    //返回编码器扫描结果，用于分析编码器的动作
   
7.                             //返回值的取值：   0：无动作；      1：正转；           -1：反转；  
   
8.                             //                  2：只按下按键；    3：按着按键正转；   -3：按着按键反转
   
9. 
   
10.                             //======================================================//
    
11.     if(EC11_Type == 0)      //================一定位对应一脉冲的EC11================//
    
12.     {                       //======================================================//
    
13.         if(EC11_A_Now != EC11_A_Last)   //以A为时钟，B为数据。正转时AB反相，反转时AB同相
    
14.         {
    
15.             if(EC11_A_Now == 0)
    
16.             {
    
17.                 if(EC11_B_Now ==1)      //只需要采集A的上升沿或下降沿的任意一个状态，若A下降沿时B为1，正转                    
    
18.                     ScanResult = 1;     //正转
    
19. 
    
20.                 else                    //反转
    
21.                     ScanResult = -1;
    
22.             }
    
23.             EC11_A_Last = EC11_A_Now;   //更新编码器上一个状态暂存变量
    
24.             EC11_B_Last = EC11_B_Now;   //更新编码器上一个状态暂存变量
    
25.         }
    
26.     }
    
27. return ScanResult;      //返回值的取值：   0：无动作；      1：正转；           -1：反转；
    
28. }

复制代码

也有lkc8210发表的非常不错的方法：一定位一脉冲的EC11旋转编码器最简洁的单片机驱动代码
我通过研究，原创了基于运算解码的算法，先上代码

//算法一
uint8_t KeyA_Last;
uint8_t KeyB_Last;
uint8_t KeyA_Now;
uint8_t KeyB_Now;
int EC_Counter;
int EC_CountTemp;

void Encoder_Ini()
{
    KeyA_Last = P10;
    KeyB_Last = P11;
}
void Encoder_Run()
{
    KeyA_Now = P10;
    KeyB_Now = P11;

EC_Counter +=(1 ^ (KeyA_Last ^ KeyB_Last)) * (int)((KeyA_Last ^ KeyA_Now) - (KeyB_Last ^ KeyB_Now)); //更新计数
    KeyA_Last = KeyA_Now;
    KeyB_Last = KeyB_Now;
}

眼尖的网友可以看到，我的扫描解码程序里并没有逻辑判断，EC_Counter计数值会自动解码加减，什么情况？
我先来解析一下算法：
上次A、B电平相等时，A=1，B=1,或A=0，B=0时，KeyA_Last ^ KeyB_Last的异或运行结果会等于0，这时1^0就变成了1，
这个运算的作用就是如果上次AB相等，就可能会更新EC_Counter的值，因为这个结果后面跟着乘号，如果上次AB不相等时，运算结果为0，0乘以任何数仍为0，
EC_Counter的值就+=0，不变；
A相的电平发生变化时（上升沿或下降沿），KeyA_Last^KeyA_Now运算的结果=1;
A相的电平未发生变化，KeyA_Last^Key_Now运算的结果=0;
同理，B相的电平发生变化时（上升沿或下降沿），KeyB_Last^KeyB_Now运算的结果=1;
B相的电平未发生变化，KeyB_Last^KeyB_Now运算的结果=0;


现以反转时序来分析，从EC11编码器的波形可以看出，
反转时，初始状态要么A=1 ，B=1，要么A=0，B=0，在此以默认A=1，B=1来举例计算：
第一步： A=1，B=1，此时 KeyA_Last=1,  KeyB_Last =1,  KeyA_Now=1 ,  KeyB_Now=1
     1 ^ (KeyA_Last ^ KeyB_Last)= 1^(1^1)=1，
     KeyA_Last^KeyA_Now=1^1=0,
     KeyB_Last^KeyB_Now =1^1=0,
     右边运算结果：1*（0-0）= 0，即EC_Counter+=0 ；


第二步： A=1，B=0 此时 KeyA_Last=1,  KeyB_Last =1,  KeyA_Now=1 ,  KeyB_Now=0
     1 ^ (KeyA_Last ^ KeyB_Last)=1^(1^1)=1,
    KeyA_Last^KeyA_Now=1^1=0,
    KeyB_Last^KeyB_Now =1^0=1，
    右边运算结果：1*（0-1）= -1，即EC_Counter+= -1；
第三步： A=0，B=0 此时 KeyA_Last=1,  KeyB_Last =0,  KeyA_Now=0 ,  KeyB_Now=0
     1 ^ (KeyA_Last ^ KeyB_Last)=1^(1^0)=0,
    KeyA_Last^KeyA_Now=1^0=1,
    KeyB_Last^KeyB_Now =0^0=0，
    右边运算结果：0*（1-0）=0，即EC_Counter+=0；

第四步： A=0，B=1 此时 KeyA_Last=0,  KeyB_Last =0,  KeyA_Now=0 ,  KeyB_Now=1
     1 ^ (KeyA_Last ^ KeyB_Last)=1^(0^0)=1,
    KeyA_Last^KeyA_Now=0^0=0,
    KeyB_Last^KeyB_Now =0^1=1，
    右边运算结果：1*（0-1）=-1，即EC_Counter+=-1；

第五步： A=1，B=1 此时 KeyA_Last=0,  KeyB_Last =1  KeyA_Now=1 ,  KeyB_Now=1
     1 ^ (KeyA_Last ^ KeyB_Last)=1^(0^1)=0,
    KeyA_Last^KeyA_Now=0^1=1,
    KeyB_Last^KeyB_Now =1^1=0，
    右边运算结果：0*（1-0）=0，即EC_Counter+=0；


继续反转的话，又到了第二步；


正转时，初始状态要么A=1 ，B=1，要么A=0，B=0，在此以A=1，B=1来举例计算：
第一步： A=1，B=1，此时 KeyA_Last=1,  KeyB_Last =1,  KeyA_Now=1 ,  KeyB_Now=1
     1 ^ (KeyA_Last ^ KeyB_Last)= 1^(1^1)=1，
     KeyA_Last^KeyA_Now=1^1=0,
     KeyB_Last^KeyB_Now =1^1=0,
     右边运算结果：1*（0-0）= 0，即EC_Counter+=0 ；


第二步： A=0，B=1 此时 KeyA_Last=1,  KeyB_Last =1,  KeyA_Now=0 ,  KeyB_Now=1
     1 ^ (KeyA_Last ^ KeyB_Last)=1^(1^1)=1,
    KeyA_Last^KeyA_Now=1^0=1,
    KeyB_Last^KeyB_Now =1^1=0，
    右边运算结果：1*（1-0）= 1，即EC_Counter+= 1；
第三步： A=0，B=0 此时 KeyA_Last=0,  KeyB_Last =1,  KeyA_Now=0 ,  KeyB_Now=0
     1 ^ (KeyA_Last ^ KeyB_Last)=1^(0^1)=0,
    KeyA_Last^KeyA_Now=0^0=0,
    KeyB_Last^KeyB_Now =1^0=1，
    右边运算结果：0*（0-1）=0，即EC_Counter+=0；

第四步： A=1，B=0 此时 KeyA_Last=0,  KeyB_Last =0,  KeyA_Now=1 ,  KeyB_Now=0
     1 ^ (KeyA_Last ^ KeyB_Last)=1^(0^0)=1,
    KeyA_Last^KeyA_Now=0^1=1,
    KeyB_Last^KeyB_Now =0^0=0，
    右边运算结果：1*（1-0）=1，即EC_Counter+=1；

第五步： A=1，B=1 此时 KeyA_Last=1,  KeyB_Last =0  KeyA_Now=1 ,  KeyB_Now=1
     1 ^ (KeyA_Last ^ KeyB_Last)=1^(1^0)=0,
    KeyA_Last^KeyA_Now=1^1=0,
    KeyB_Last^KeyB_Now =0^1=1，
    右边运算结果：0*（0-1）=0，即EC_Counter+=0；


继续正转的话，又到了第二步；

从上面运算可以，公式以双倍频（旋转嘀嗒一格，两次计数）解码EC11编码器；

有网友问，如果我只要单倍频（旋转嘀嗒一下，单次计数），又怎么解码？
这时，可以要根据你的编码器默认电平来改，默认A=1，B=1时，
加个条件即可
if(KeyA_Last==0 && KeyB_Last==0)  //只有上次都为0时（要与默认值相反），才更新计数
{
   EC_Counter += (int)((KeyA_Last ^ KeyA_Now) - (KeyB_Last ^ KeyB_Now)); //计数值运算
}
默认A=0，B=0时，
加个条件即可
if(KeyA_Last==1 && KeyB_Last==1)  //只有上次都为1时（要与默认值相反），才更新计数
{
   EC_Counter += (int)((KeyA_Last ^ KeyA_Now) - (KeyB_Last ^ KeyB_Now)); //计数值运算
}

单倍频的程序代码如下：

1. uint8_t KeyA_Last;
   
2. uint8_t KeyB_Last;
   
3. uint8_t KeyA_Now;
   
4. uint8_t KeyB_Now;
   
5. int EC_Counter;
   
6. int EC_CountTemp;
   
7. 
   
8. void Encoder_Ini()
   
9. {
   
10.     KeyA_Last = P10;
    
11.     KeyB_Last = P11;
    
12. }
    
13. void Encoder_Run()
    
14. {
    
15.     KeyA_Now = P10;
    
16.     KeyB_Now = P11;
    
17.     if(KeyA_Last==1 && KeyB_Last==1)  //注意此处与编码器默认的电平相
    
18.     {
    
19.      EC_Counter +=(int)((KeyA_Last ^ KeyA_Now) - (KeyB_Last ^ KeyB_Now));//如要调整加减方向，请修改此
    
20.     }
    
21.     KeyA_Last = KeyA_Now;
    
22.     KeyB_Last = KeyB_Now;
    
23. }

复制代码

以上算法是不是很特别？以上代码我通过了验证，如果不用定时中断扫描，正常12格/秒手速旋转无问题，如果加1ms的定时中断扫描，80格/秒手速旋转无问题；编译后代码在N76E003里，汇编行数50行，大小增加100byte
如果网友只需要单倍频，也可以用我下面的算法，汇编行数更少40多行，大小增加72byte,
AB状态一起处理，具体原理大家去分析
//算法二 编译最小，但只适合单倍频
int EC_Counter;
int EC_CountTemp;

uint8_t KeyAB_Last;
uint8_t KeyAB_Now;

void Encoder_Ini()
{
  KeyAB_Last =P1 & 0x03;
}
void Encoder_Run()
{
    uint8_t Temp;
    KeyAB_Now =(P1 & 0x03);
    Temp=KeyAB_Now^KeyAB_Last;
    if(KeyAB_Last==00) //注意此处与编码器默认的电平相反
    {  
      EC_Counter +=(int)((Temp&0x01)-(Temp>>1)); //如要调整方向，请修改此处
    }
                KeyAB_Last=KeyAB_Now;
}

如果有网友说：你上面单倍频的算法，忽略了过程中的一部分，会不会有问题？
我可以放心的告诉大家，我验证的效果和算法一效果相当，可以使用，当然如果你不放心，我还有一种就是把所有的步骤都考虑进去的算法，如下:


//算法三 编译最大，但有考虑顺序步骤，只适合单倍
uint8_t EC_Index;
uint8_t EC_Last;
uint8_t EC_Now;
int EC_Counter;
int EC_CountTemp;
void Encoder_Ini()
{
   EC_Last=P1 & 0x03;
   EC_Counter=0;
         EC_Index=0x40;
}
void Encoder_Run()
{
        uint8_t temp;
        EC_Now=P1 & 0x03;
        temp=EC_Now^EC_Last;
        EC_Last=EC_Now;        
        EC_Index>>=temp;
        if(EC_Now==0x03)  //注意是编码器默认的电平
        {
           EC_Index=0x40;
        }
        if(EC_Index==2 || EC_Index==4)
        {
                EC_Counter+=(EC_Index-3);  //如要调整方向，请修改此处
                EC_Index=0x40;
        }
}

原理解析：
B对应P11 A对应P10
默认编码器值为高电平，即A=1，B=1，
反转分析：
第一步：A=1，B=1，EC_Last=0x03 , EC_Now=0x03  为什么会是0x03 , 因为P1 & 0x03=xxxxxx11 & 00000011=00000011=0x03
EC_Now^EC_Last=0x03^0x03=0,因此temp=0;
EC_Index>>=temp 即 EC_Index>>=0；此时EC_Index不变，还是0x40 二进制是0100 0000
而且，细心的网友会发现，这句程序：
if(EC_Now==0x03)
{
   EC_Index=0x40;  //重置EC_Index
}
因此EC_Index最后还是等于0x40
第二步：A=1，B=0，EC_Last=0x03 , EC_Now=0x01  为什么会是0x01 , 因为P1 & 0x03=xxxxxx01 & 00000011=00000001=0x01
EC_Now^EC_Last=0x01^0x03=2,因此temp=2;
EC_Index>>=temp 即 EC_Index>>=2；此时EC_Index=0x10 二进制是0001 0000

第三步：A=0，B=0，EC_Last=0x01 , EC_Now=0x00  为什么会是0x00 , 因为P1 & 0x03=xxxxxx00 & 00000011=00000000=0x00
EC_Now^EC_Last=0x00^0x01=1,因此temp=1;
EC_Index>>=temp 即 EC_Index>>=1；此时EC_Index=0x0F 二进制是0000 1000

第四步：A=0，B=1，EC_Last=0x00 , EC_Now=0x02  为什么会是0x02 , 因为P1 & 0x03=xxxxxx10 & 00000011=00000010=0x02
EC_Now^EC_Last=0x02^0x00=2,因此temp=2;
EC_Index>>=temp 即 EC_Index>>=2；此时EC_Index=0x02 二进制是0000 0010

此时，EC_Index=0x02 符合条件更新计数的条件 EC_Index==0x02 或 EC_Index==0x04
(EC_Index-3)=2-3=-1
EC_Counter+=(EC_Index-3) ，即EC_Counter+= - 1 ,自动减1了
第五步：A=1，B=1，EC_Last=0x02 , EC_Now=0x03  为什么会是0x03 , 因为P1 & 0x03=xxxxxx11 & 00000011=00000011=0x03
EC_Now^EC_Last=0x03^0x02=1,因此temp=1;
EC_Index>>=temp 即 EC_Index>>=1；此时EC_Index=0x01 二进制是0000 0001
细心的网友会发现，这句程序，
if(EC_Now==0x03)
{
   EC_Index=0x40;  //重置EC_Index
}因此EC_Index最后还是等于0x40；运行到此步后，会从第二步继续循环；

正转分析：
第一步：A=1，B=1，EC_Last=0x03 , EC_Now=0x03  为什么会是0x03 , 因为P1 & 0x03=xxxxxx11 & 00000011=00000011=0x03
EC_Now^EC_Last=0x03^0x03=0,因此temp=0;
EC_Index>>=temp 即 EC_Index>>=0；此时EC_Index不变，还是0x40 二进制是0100 0000
而且，细心的网友会发现，这句程序：
if(EC_Now==0x03)
{
   EC_Index=0x40;  //重置EC_Index
}
因此EC_Index最后还是等于0x40
第二步：A=0，B=1，EC_Last=0x03 , EC_Now=0x02  为什么会是0x02 , 因为P1 & 0x03=xxxxxx10 & 00000011=00000010=0x02
EC_Now^EC_Last=0x02^0x03=1,因此temp=1;
EC_Index>>=temp 即 EC_Index>>=1；此时EC_Index=0x20 二进制是0010 0000

第三步：A=0，B=0，EC_Last=0x02 , EC_Now=0x00  为什么会是0x00 , 因为P1 & 0x03=xxxxxx00 & 00000011=00000000=0x00
EC_Now^EC_Last=0x00^0x02=2,因此temp=2;
EC_Index>>=temp 即 EC_Index>>=2；此时EC_Index=0x0F 二进制是0000 1000

第四步：A=1，B=0，EC_Last=0x00 , EC_Now=0x01  为什么会是0x01 , 因为P1 & 0x03=xxxxxx01 & 00000011=00000001=0x01
EC_Now^EC_Last=0x01^0x00=1,因此temp=1;
EC_Index>>=temp 即 EC_Index>>=1；此时EC_Index=0x04 二进制是0000 0100

此时，EC_Index=0x04 符合条件更新计数的条件 EC_Index==0x02 或 EC_Index==0x04
(EC_Index-3)=4-3=1
EC_Counter+=(EC_Index-3) ，即EC_Counter+=1 ,自动加1了第五步：A=1，B=1，EC_Last=0x01 , EC_Now=0x03  为什么会是0x03 , 因为P1 & 0x03=xxxxxx11 & 00000011=00000011=0x03
EC_Now^EC_Last=0x03^0x01=2,因此temp=2;
EC_Index>>=temp 即 EC_Index>>=2；此时EC_Index=0x01 二进制是0000 0001
细心的网友会发现，这句程序，
if(EC_Now==0x03)
{
   EC_Index=0x40;  //重置EC_Index
}因此EC_Index最后还是等于0x40；运行到此步后，会从第二步继续循环；
从上面的分析可以看出，算法是有按顺序对每个步骤进行处理并关联到了temp和EC_Index的值，从而决定了EC_Counter的值
这个算法的核心是：
反转一格时，EC_Now^EC_Last的值是0，2，1，2, 1 的变化，第一步和第五步为默认状态，EC_Index重置为0x40，移位不起作用，
因此实际反转时，EC_Index右移了2+1+2=5次，最终等于2；
正转一格时，EC_Now^EC_Last的值是0，1，2，1,  2 的变化，第一步和第五步为默认状态，EC_Index重置为0x40，移位不起作用，
因此实际正转时，EC_Index右移了1+2+1=4次，最终等于4；

然后用 EC_Index-3 巧妙的得到了正负1，实现自动正反转加减；
现在可以解析EC_Index重置为0x40的意义：0x40二进制是0100 0000,右移位4或5次时能得到4和2的值，其他数值不行；


以上就是我原创的EC11编码器基于运算解码的算法，希望能给大家抛砖引玉。

---

作者: zyhlove813    时间: 2023-12-13 23:11
同时贴上lkc8210发表的算法：
//算法四: 编译大小不错，只适合单倍频
uint8_t KeyA_Last;
uint8_t KeyB_Last;
uint8_t KeyA_Now;
uint8_t KeyB_Now;
int EC_Counter;

void Encoder_Ini()
{
    KeyA_Last = P10;
    KeyB_Last = P11;
}

void Encoder_Run()
{
        KeyA_Now=P10;
        KeyB_Now=P11;
        if(!KeyA_Now && KeyA_Last && KeyB_Now)
        {
                EC_Counter++;
  }
        KeyA_Last=KeyA_Now;
        if(!KeyB_Now && KeyB_Last && KeyA_Now)
        {
                EC_Counter--;
  }
        KeyB_Last=KeyB_Now;
}

---

作者: joyb    时间: 2023-12-14 08:28
好文章，需要认真学习

---

作者: 紫色的云    时间: 2023-12-14 10:14
讲解的蛮详细的，谢谢楼主的分享

---

作者: lzzasd    时间: 2023-12-14 11:56
经过测试   楼主的程序运行稳定    算法精简高效    感谢楼主
只是 (int)((KeyA_Last ^ KeyA_Now) - (KeyB_Last ^ KeyB_Now)这段编译报错   只好拆成2段
我也贴上我常用的   也是很稳定


if (PinA != PinA_O)        //当A发生跳变时采集B当前的状态，并将B与上一次的状态进行对比。
        {                                   //若A 0->1 时，B 1->0 正转；若A 1->0 时，B 0->1 正转；
                                                                                //若A 0->1 时，B 0->1 反转；若A 1->0 时，B 1->0 反转
                if (PinA == 1)     //EC11_A和上一次状态相比，为上升沿
                {
                if ((PinB_O == 1) && (PinB == 0))   //EC11_B和上一次状态相比，为下降沿
                        encoder_data++;                         //正转
                if ((PinB_O == 0) && (PinB == 1))   //EC11_B和上一次状态相比，为上升沿               
                        encoder_data--;                        //反转
                //>>>>>>>>>>>>>>>>下面为正转一次再反转或反转一次再正转处理<<<<<<<<<<<<<<<<//
                if ((PinB_O == PinB) && (PinB == 0))  //A上升沿时，采集的B不变且为0
                    encoder_data++;                                 //正转
                if ((PinB_O == PinB) && (PinB == 1))  //A上升沿时，采集的B不变且为1
                        encoder_data--;                                //反转
                }

                else                    //EC11_A和上一次状态相比，为下降沿
                {
                if ((PinB_O == 1) && (PinB == 0))   //EC11_B和上一次状态相比，为下降沿
                        encoder_data--;                        //反转
                if ((PinB_O == 0) && (PinB == 1))   //EC11_B和上一次状态相比，为上升沿
                        encoder_data++;                         //正转
                //>>>>>>>>>>>>>>>>下面为正转一次再反转或反转一次再正转处理<<<<<<<<<<<<<<<<//
                if ((PinB_O == PinB) && (PinB == 0))  //A上升沿时，采集的B不变且为0
                    encoder_data--;                                //反转
                if ((PinB_O == PinB) && (PinB == 1))  //A上升沿时，采集的B不变且为1   
                        encoder_data++;                                 //正转
                }
                PinA_O = PinA;   //更新编码器上一个状态暂存变量
                PinB_O = PinB;   //更新编码器上一个状态暂存变量

---

作者: zyhlove813    时间: 2023-12-14 13:08

lzzasd 发表于 2023-12-14 11:56
经过测试   楼主的程序运行稳定    算法精简高效    感谢楼主
只是 (int)((KeyA_Last ^ KeyA_Now) - (KeyB ...

编译什么提示？我是keil4 C51 编译正常，会不会少了个括号标点之类的？

---

作者: zsttom    时间: 2023-12-15 09:54
小白只能顶楼主

---

作者: lzzasd    时间: 2023-12-16 10:27

zyhlove813 发表于 2023-12-14 13:08
编译什么提示？我是keil4 C51 编译正常，会不会少了个括号标点之类的？

APP_EC11.C(59):C193: '-': BAD OPERAND TYPE
后段那个 减号   拆成2段就正常了

---

作者: lzzasd    时间: 2023-12-16 10:42

zyhlove813 发表于 2023-12-14 13:08
编译什么提示？我是keil4 C51 编译正常，会不会少了个括号标点之类的？

刚才看了下   是我定义的变量的问题    我的变量都是BIT 位类型的   编译就出错
楼主使用的是u8类型的   

---

作者: user2402167    时间: 2023-12-24 19:28
楼主钻研精神可嘉，学习了。

---

作者: zyhlove813    时间: 2023-12-25 13:07

发表于 2023-12-24 19:28
楼主钻研精神可嘉，学习了。

共同学习

---

作者: lzuoxin    时间: 2023-12-25 18:09
楼主的算法还需要硬件消抖电路吗

---

作者: lzuoxin    时间: 2023-12-25 19:14
代码精简高效，向楼主学习了

---

作者: zyhlove813    时间: 2023-12-25 21:04

lzuoxin 发表于 2023-12-25 18:09
楼主的算法还需要硬件消抖电路吗

正常应该是要的，我是网购的模块，带电阻和电容滤波，不硬件滤波，你自己可以试下。

---

作者: lzuoxin    时间: 2023-12-26 09:43

zyhlove813 发表于 2023-12-25 21:04
正常应该是要的，我是网购的模块，带电阻和电容滤波，不硬件滤波，你自己可以试下。

好的，我去试一下，谢谢！

---

作者: youlinys    时间: 2023-12-31 21:35
讲解得很详细。UP厉害人。

---

作者: zyhlove813    时间: 2024-1-16 18:04

youlinys 发表于 2023-12-31 21:35
讲解得很详细。UP厉害人。

通过不同的方法去实现目标，可能锻炼自己的思维能力

---

作者: zyhlove813    时间: 2024-7-10 13:28
这么特异的算法都沉底了

---

作者: changjianguo    时间: 2024-7-19 14:35

楼主钻研精神可嘉，向你学习。

---

作者: 上善若水001    时间: 2024-7-19 18:49

zyhlove813 发表于 2024-7-10 13:28
这么特异的算法都沉底了

没有沉，都在学习中。感谢大佬分享的算法

---

作者: zyhlove813    时间: 2024-10-5 16:37
今天玩了一下AI编程Cursor，对我的这个算法分析了下，说得很到位

---

作者: wkman    时间: 2024-10-7 16:32
编码器，判断谁先跳变，就当起始

---

作者: 234134519    时间: 2024-11-6 12:25
讲解的思路真的很清晰啊

---

作者: kkfy888    时间: 2024-11-10 21:39
看了up的视频，特意搜了关键字找到了^_^

---

作者: zyhlove813    时间: 2024-11-14 11:34

kkfy888 发表于 2024-11-10 21:39
看了up的视频，特意搜了关键字找到了^_^

有心了

---

作者: 邰夏留    时间: 2025-2-18 09:57

zyhlove813 发表于 2023-12-13 23:11
同时贴上lkc8210发表的算法：
//算法四: 编译大小不错，只适合单倍频
uint8_t KeyA_Last;

请教一下楼主，这个怎么消抖的呢？

---

作者: zyhlove813    时间: 2025-2-19 15:59

邰夏留 发表于 2025-2-18 09:57
请教一下楼主，这个怎么消抖的呢？

我用的是模块，应该是加了电容消抖。软件消抖这个不好处理，你可以测试下，不消抖有什么问题

---

作者: zhang32568    时间: 2025-2-20 10:54
我经常使用的程序。非常灵敏！定时器3毫秒以内都毫不拖泥带水。
sbit EC11_A = P3^5;           //EC11 A端
sbit EC11_B = P3^3;           //EC11 B端
void EC11_Display()
{
   static bit EC11_Flag=0,Left_Flag=0,Right_Flag=0;

   if((EC11_A)&&(EC11_B))//两个都是1，表示开始第一个脉冲
     {
       EC11_Flag =1 ;//标记为第一个信号收到，可以进行下一个信号
      }

    if(EC11_A!=EC11_B)//第二个信号
     {
       Left_Flag = EC11_A ; //记录AB的信号状态
       Right_Flag = EC11_B ;
      }

    if(EC11_Flag)
     {
       if((EC11_A==0)&&(EC11_B==0))// 第三个信号，处理第二个信号的值
         {
           if(Right_Flag)//右转
          {
                //自己程序      
          }
     else if(Left_Flag) //左转
         {                             
             //自己程序
          }
         EC11_Flag = 0; //把标志位清零，等待下一个周期
       }
    }       
}

---

作者: zying    时间: 2025-2-21 16:54

zhang32568 发表于 2025-2-20 10:54
我经常使用的程序。非常灵敏！定时器3毫秒以内都毫不拖泥带水。
sbit EC11_A = P3^5;           //EC11 A ...

刚试了代码非常稳定可靠！谢谢分享！！！

---

作者: zenghl    时间: 2025-5-17 10:53
代码非常稳定可靠！谢谢分享！！！

---

作者: 不死鸟a    时间: 2025-5-17 13:34
感谢楼主分享

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1