编码电位器-从原理到代码

摘要：编码电位器全解析，附带完整源代码

近期有个项目用到了数字矩阵键盘来输入，但板子面积受限，于是改用编码电位器，花了点时间研究下可360º旋转的编码电位器。
从原理出发，按照自己的思路写了一段代码，用起来不错，分享一下。

引言

编码器这个东西最早我还是从伺服电机上看到的，不过那一个编码器就够买好几斤的单片机了，不过和这里讨论的编码电位器有点类似，都有AB相，也是通过相位差判断正反转。更早之前在51单片机上我就写了一个这样的程序，但那个仅仅能实现基本的加减，现在又重新拿出来优化一下。

这个两个东西长这样

分析

硬件

先从原理说起，这种编码器说白了就是把角位移转换成数字量，这就会像ADC一样，有个分辨率的参数。电机上的通常分辨率都在256以上，编码电位器好像我看到的都是15，也就是把360º分成15份，然后转一个(360/15)º就会输出一组电平。我做实验的这个规格书这样描述的:


从图上可以看到，根据分辨率不一样，输出的波形也不一样。分辨率15的转一格每相电平只变化一次，而分辨率20的会变化两次。我这个是只会变化一次的，理论上用这个程序只要除2就可以用于变化两次的编码器。
找到一张网上的原理简图，不太看得明白，具体里面长啥样应该要拆开才看得到了，但是我只有一个，拆了就没了，这东西拆了基本就别想装回去。

对于电路连接来说好像大部分都一样的，这样一接就行了:

代码思路

从电路上看，程序主要就是检测AB两根线的电平，按键就当普通的按键一样处理就行了。为了方便程序处理，把AB两线编码到一个字节的最低两位。硬件直接这样接最舒服了，但是多半的情况没有这样美好，就得额外的处理一下（下面的代码有注释）。
下面从规格书的输出波形图分析关键的两步:

• 识别转动一格，就是检测两线的电平发生了一组[相同—>一些变化—>又相同]这样的变化。第二次相同时即是转动了一格完成。
• 识别转动方向，才两线电平由相同到再次相同这个过程中哪根线先发生变化，就可以认为这根线的相位相比另一根超前一些，认为是正转（当然也可以认为是反转）。

程序流程图是这样的：

代码上手

说了这么多还是代码最实在（下面的代码我已经整理好了，复制就能用）
程序说明
运行MCU：MKL26单片机 CORTEX-M0内核
编译器：MDK_V5 IDE
移植：要提供一个1ms精度的时间戳SysTime（根据需要也可以低一点精度）

程序特点：

• 非阻塞式运行
• 易移植性
• 支持多级可变速度的加减
• 支持旋扭消息队列

源码：

define _PORT _gpio //硬件端口,如果是在同一GPIO下可以使用GPIO寄存器
define _A1B1 0x03  //编码器AB两线构成的特征码
define _A1B0 0x02
define _A0B1 0x01
define _A0B0 0x00
define _KEY  0x04

encode_t encode = {0};             //编码器结构体

static uint8_t _gpio = 0;          //不在同一GPIO下才需要此变量

static uint32_t time_s=0,time_e=0; //计时变量

static int16_t *counter=NULL;      //指向计数器
static uint8_t en_speed_class=0;   //是否使能变速度
static uint8_t en_block=0;         //是否阻塞更新消息，
static uint16_t cnt_max = 9000;    //计数最大值
static uint16_t cnt_min = 0;       //计数最小值


static void (*encoder_active_callback)(void) = NULL;  //编码器有动作时的回调函数
define UPD_BUF_MAX 8  //队列长度
typedef struct
{
	uint8_t kmessage[UPD_BUF_MAX]; //存放键值
	uint8_t  front;  //头
	uint8_t  rear;   //尾
}queue_struct ;
static queue_struct kqueue={0};//队列结构体

//判断队列是否为空
static int8_t IsEmpty(queue_struct* SCQ)
{
    if (SCQ->front == SCQ->rear)
    {
        return 1;
    }
    return 0;
}

//判断队列是否为满
static int8_t IsFull(queue_struct* SCQ)
{
    //尾指针+1追上队头指针，标志队列已经满了
    if ((SCQ->rear + 1) % UPD_BUF_MAX == SCQ->front)
    {
        return 1;
    }
    return 0;
}

//判断队列长度
int encoder_dirqueuelength(void)
{
    uint8_t len = (kqueue.rear-kqueue.front+UPD_BUF_MAX)%UPD_BUF_MAX;
    return len;
}

static uint8_t encoder_dirput(uint8_t value)  //键值入队列
{
	if (IsFull(&kqueue))
    {
        //队列已满，不能入队！
        return 0;
    }
	kqueue.kmessage[kqueue.rear]=value;
	if(++kqueue.rear>=UPD_BUF_MAX)
	{
		kqueue.rear=0;   //实现循环队列
	}
	return 1;

}

uint8_t encoder_dirget(void) //键值出队列，得到键值
{
	uint8_t value;
	if (IsEmpty(&kqueue))
    {
        //队列为空！
        return 0;
    }
    value = kqueue.kmessage[kqueue.front];
    kqueue.front = (kqueue.front + 1) % UPD_BUF_MAX;  //重新设置队头指针
	return value;
}


void encoder_init(void)
{

	port_pin_config_t port_pin_config;
	gpio_pin_config_t io_config;

	io_config.pinDirection = kGPIO_DigitalInput;
	io_config.outputLogic = 0;
	GPIO_PinInit(GPIOA, 4, &io_config);
	GPIO_PinInit(GPIOC, 5, &io_config);
	GPIO_PinInit(GPIOC, 4, &io_config);
	port_pin_config.driveStrength = kPORT_LowDriveStrength;
	port_pin_config.mux = kPORT_MuxAsGpio;
	port_pin_config.passiveFilterEnable = kPORT_PassiveFilterDisable;
	port_pin_config.pullSelect = kPORT_PullUp;    //配置为上拉输入
	port_pin_config.slewRate = kPORT_SlowSlewRate;
	PORT_SetPinConfig(PORTA, 4, &port_pin_config);
	PORT_SetPinConfig(PORTC, 5, &port_pin_config);
	PORT_SetPinConfig(PORTC, 4, &port_pin_config);

}
/**
  * @brief  注册编码器动作回调函数
  * @param  active_callback：回调函数
  * @retval None
  */
void encoder_register_active_callback(void (*active_callback)(void))
{
	encoder_active_callback = active_callback;
}

/**
  * @brief  编码器配置
  * @param  min：最小值，max：最大值，cnt：计数器，en_spe_class：变速度使能
  * @retval None
  */
void encoder_config(uint16_t min, uint16_t max, int16_t *cnt, uint8_t en_spe_class)
{
	cnt_max = max;
	cnt_min = min;
	counter = cnt;
	encode.counter = cnt;
	en_speed_class = en_spe_class;
	en_block = !en_spe_class;
}
/**
  * @brief  编码器扫描，需定时调用，间隔1ms效果良好
  * @param  None
  * @retval None
  */
void encoder_scan(void)
{
	static volatile uint8_t step = 0;
    static volatile uint8_t dif = 0;
	static volatile uint8_t pre_gpio=0;
	static volatile int8_t dc;
	static volatile uint8_t time_flag=0;

    _PORT = (GPIOA->PDIR & 0x10)>>4;  //提取编码器AB两线的电平，根据实际电路修改
	_PORT |= (GPIOC->PDIR & 0x20)>>4;

	if((pre_gpio != _PORT) && ((!en_block) || (en_block && encoder_dirqueuelength()<1 && (!IsFull(&kqueue)))))  //判断电平是否有变化
	{
		dif = _PORT ^ pre_gpio;  //看看是哪个口变化了
		if((dif & _A0B1) && (step == 0))
		{
			step = 1;
			dc = 1;  //B口变化了，加

			if(0 == time_flag) //保存拧第一格的时间
			{
				time_flag = 1;
				time_s = SysTime;
			}
			else if(1 == time_flag)  //保存拧第二格的时间
			{
				time_flag = 0;
				time_e = SysTime;
			}
		}
		else if ((dif & _A1B0) && (step == 0))
		{
			step = 1;
			dc = -1;//A口变化了，减

			if(0 == time_flag)
			{
				time_flag = 1;
				time_s = SysTime;
			}
			else if(1 == time_flag)
			{
				time_flag = 0;
				time_e = SysTime;
			}
		}

		if((_PORT == _A1B1) || (_PORT == _A0B0))
		{
			step = 0;  //两口电平一样了，说明拧完一格了，可以重新开始下一次采集
		}

		pre_gpio = _PORT;  //赋值保存本次gpio状态
	}

	//在key.c中检测
//    if (!(GPIOC->PDIR & 0x10)) //编码电位器带的按键检测
//    {
//        encode.key = 0x01;
//    }

	if(1 == step && dc != 0)  //旋转了一格
	{
		int32_t dt;

		if(NULL != encoder_active_callback)  //调用回调函数
		{
			encoder_active_callback();
		}

		if(en_speed_class)
		{
			if(time_e > time_s)
			{
				dt = time_e - time_s;
			}else
			{
				dt = time_s - time_e;
			}
			dt = dt>300 ? 300 : dt;  //计算前后两次旋转一格使用的时间（ms）

			//速度等级定义
			#define SPEED_CLASS5_TIME 6
			#define SPEED_CLASS5_MULT 64

			#define SPEED_CLASS4_TIME 10
			#define SPEED_CLASS4_MULT 48

			#define SPEED_CLASS3_TIME 20
			#define SPEED_CLASS3_MULT 16

			#define SPEED_CLASS2_TIME 30
			#define SPEED_CLASS2_MULT 4

			#define SPEED_CLASS1_TIME 40
			#define SPEED_CLASS1_MULT 2

			//通过旋转的速度来控制变量的变化增量
			if(dt < SPEED_CLASS5_TIME)
			{
				dc *= SPEED_CLASS5_MULT;
			}
			else if(dt < SPEED_CLASS4_TIME)
			{
				dc *= SPEED_CLASS4_MULT;
			}
			else if(dt < SPEED_CLASS3_TIME)
			{
				dc *= SPEED_CLASS3_MULT;
			}
			else if(dt < SPEED_CLASS2_TIME)
			{
				dc *= SPEED_CLASS2_MULT;
			}
			else if(dt < SPEED_CLASS1_TIME)
			{
				dc *= SPEED_CLASS1_MULT;
			}
		}
		//计算完了增量，实际加到指向的变量上
		if(NULL != counter)
		{
			dt = *counter + dc;

			if(dt > cnt_max)  //限制最大值
			{
				dt = cnt_max;
			}
			if(dt <= cnt_min)  //限制最小值
			{
				dt = cnt_min;
			}
			*counter = dt;
			if(dc>0)
			{
				encoder_dirput(1);  //方向入队列
			}else
			{
				encoder_dirput(2);
			}

			dc = 0;
		}
	}
}

顺带头文件也贴出来吧

ifndef _ENCODER__H_
define _ENCODER__H_


typedef struct
{

    volatile int16_t *counter; //计数器
	volatile uint8_t key;    //按键

} encode_t;
extern encode_t encode;

void encoder_init(void);
void encoder_scan(void);
uint8_t encoder_dirget(void);
int encoder_dirqueuelength(void);
void encoder_register_active_callback(void (*active_callback)(void));
void encoder_config(uint16_t min, uint16_t max, int16_t *cnt, uint8_t en_spe_class);

endif /* _ENCODER__H_ */

使用方法

---

• 1.先调用encoder_init()进行初始化,然后在定时器里定时调用encoder_scan()进行扫描
• 2.使用encoder_config()配置计数变量、计数范围等参数
• 3.（可选）使用encoder_register_active_callback()注册回调函数
• 4.（可选）使用encoder_dirget()读取消息,返回的不是计数值，而是往哪个方向拧了一下

使用效果

---

goooood！

总结

芝士就是力量

本文作者： TDA2030
本文链接： https://tda-2030.github.io/2019/10/20/application-of-encoder/
版权声明： 本作品采用 知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议 进行许可。转载请注明出处！

---

感谢有你，伴我成长。

---