2021-04-13

Micropython——基于Openmv的霍尔编码器电机测速与使用

因为在Micropython的Timer库中有专门的编码器读取模式，该模式是在CH1和CH2改变时改变，所以技术方式为4倍频。

Timer.ENC_AB — 配置编码器模式下的定时器。定时器只在CH1和CH2改变时改变。

``本电机对应的脉冲计速方法
减速比为30：1，线数为390，即在一倍频、单相的情况下，每圈会有390个脉冲；在四倍频、AB相的情况下，每圈会有1560个脉冲。

编码器电机接线

电机-------------------------PYB
编码器A相-----------------P7(TIM4,CH1)
编码器B相---------------- P8(TIM4,CH2)
编码器5V------------------ V+(Vin)
编码器GND----------------GND
电机12V---------------------12V电源
电机GND--------------------电源GND

encoder.py

import pyb
from pyb import Timer, Pin
import cmath

#配置编码器AB相读取模式,利用定时器中断进行读取
p1_A = Pin("P7")
p2_A = Pin("P8")
tim_A = pyb.Timer(4)
tim_A.init(prescaler=0,period=30000)
ch1_A = tim_A.channel(1,pyb.Timer.ENC_AB,pin=p1_A)
ch2_A = tim_A.channel(2,pyb.Timer.ENC_AB,pin=p2_A)



class Encoder:
    def __init__(self, encoder_freq, tim_A):
        '''
        入口参数：编码器读取频率
        修改：
            1.需要自行定义编码器引脚及其相关定时器配置
            2.需要自行定义编码器精度
        #速度值=(采集到的脉冲数/编码器分辨率)*轮子周长*控制频率
        '''
        # 初始化常量
        self.pi = cmath.pi # pi的值
        self.encoder_precision = 4*13*30 # 编码器精度 = 倍频数*编码器精度（电机驱动线数）*电机减速比
        # self.control_time = 1/encoder_freq # 单位为 s

        self.encoder_freq = encoder_freq
        self.tim_A = tim_A

        self.encoder_A = 0

        # 定时器中断：固定时间读取编码器数值
        timer_read = Timer(3,freq=self.encoder_freq,callback=self.encoder_cb)

    def encoder_cb(self, encoder):
        '''
        函数功能：通过定时器中断读取编码器A、B计数值，并重置编码器
        '''
        # self.encoder_A = self.tim_A.counter()

        self.encoder_A = (30000 - self.tim_A.counter())

        if self.encoder_A == 30000:
            self.encoder_A = 0


        # print("encoder_A:", self.encoder_A)
        self.tim_A.counter(0)


    def get_speed_A(self):
        '''
        函数功能：读取编码器A计数值,将编码器A计数值转化为速度值，同时将编码器值置零
        入口参数：编码器对应定时器
        返回值  ：编码器值
        #速度值=(采集到的脉冲数/编码器分辨率)*轮子周长*控制频率
        '''
        print("encoder_A:", self.encoder_A)
        speed = (self.encoder_A / self.encoder_precision ) * (2*self.pi*0.03) * self.encoder_freq
        print("speed_A:", speed)
        return speed

car.py

from pyb import Pin, Timer
inverse_left=False  #change it to True to inverse left wheel
inverse_right=False #change it to True to inverse right wheel

ain1 =  Pin('P0', Pin.OUT_PP)
ain2 =  Pin('P1', Pin.OUT_PP)
bin1 =  Pin('P2', Pin.OUT_PP)
bin2 =  Pin('P3', Pin.OUT_PP)
ain1.low()
ain2.low()
bin1.low()
bin2.low()

pwma = Pin('P7')
pwmb = Pin('P8')
tim = Timer(4, freq=1000)
ch1 = tim.channel(1, Timer.PWM, pin=pwma)
ch2 = tim.channel(2, Timer.PWM, pin=pwmb)
ch1.pulse_width_percent(0)
ch2.pulse_width_percent(0)

def run(left_speed, right_speed):
    if inverse_left==True:
        left_speed=(-left_speed)
    if inverse_right==True:
        right_speed=(-right_speed)

    if left_speed < 0:
        ain1.low()
        ain2.high()
    else:
        ain1.high()
        ain2.low()
    ch1.pulse_width_percent(int(abs(left_speed)))

    if right_speed < 0:
        bin1.low()
        bin2.high()
    else:
        bin1.high()
        bin2.low()
    ch2.pulse_width_percent(int(abs(right_speed)))

调用方法

main.py

import encoder
import car

if __name__ == '__main__':
    # 编码器初始化

    enc = encoder.Encoder(5, encoder.tim_A)

while True:
    car.run (50,50)
    print("enc.encoder_A:",enc.encoder_A)
    speed_A = enc.get_speed_A() # 获取当前速度值