精华内容
下载资源
问答
  • SG90舵机硬件接口:SG90 一共三根线,红线接5v电源,棕线GND,黄线为数据控制线,接到GPIO上舵机参数:SG90 脉冲周期为20ms,脉宽0.5ms-2.5ms对应的角度-90到+90,对应的占空比为2.5%-12。python脚本import RPi.GPIO ...

    8cff430caee3cdde19705d2293ed0eb4.png

    SG90舵机硬件接口:
    SG90 一共三根线,红线接5v电源,棕线GND,黄线为数据控制线,接到GPIO上舵机参数:
    SG90 脉冲周期为20ms,脉宽0.5ms-2.5ms对应的角度-90到+90,对应的占空比为2.5%-12。

    python脚本

    import RPi.GPIO as GPIO
    import time
    import signal
    import atexit
    atexit.register(GPIO.cleanup)
    servopin = 7
    GPIO.setmode(GPIO.BOARD)
    GPIO.setup(servopin, GPIO.OUT, initial=False)
    p = GPIO.PWM(servopin, 50) # 50HZ
    p.start(0)
    time.sleep(2)
    i = input("num:")
    i = int(i)
    while (True):
    p.ChangeDutyCycle(0) # 初始化
    time.sleep(0.4)
    b = input("输入角度:")
    b = int(b)
    c = b/18+2.5 # 计算占空比
    p.ChangeDutyCycle(c) # 设置转动角度
    time.sleep(0.4)
    p.stop()
    GPIO.cleanup()

    展开全文
  • 几年前自己动手DIY做了一智能小车,用的是ARM-A8的开发板做的控制核心,移植的厂家提供的Linux系统,很设备的驱动程序都是自己写的,学习了字符设备驱动、块设备驱动驱动,到网络设备驱动等等系统驱动程序的编写...

    a0566a64c68e6813c95c46b41c3b1865.png

    几年前自己动手DIY做了一个智能小车,用的是ARM-A8的开发板做的控制核心,移植的厂家提供的Linux系统,很多设备的驱动程序都是自己写的,学习了字符设备驱动、块设备驱动驱动,到网络设备驱动等等系统驱动程序的编写,用到了uboot裁剪移植,内核的裁剪和移植,还有文件系统的制作等等内容,应用层软件通过系统调用控制底层设备,还需要封装库等等,很是复杂,这段时间接触到了树莓派和Python,发现很多基础设置现在已经很完善了,开发人员只需要关心应用软件的逻辑和实现就可以了,所以就重新开发了我的智能小车,今天就来控制小车的四个直流减速电机(伺服电机)完成小车的动力控制。

    样子基本就是如下图这样子了。

    caaec30aeb8fd35ebcca76ecfb698579.png

    bffa286e30dc5973b8b7074e59ebebf0.png

    首先,我在这里使用的电机驱动模块是在网上买的L298四直流三步进电机驱动模块,其中使用的是L298N双H桥直流电机驱动芯片,如下图,其中OUT1-OUT8对应的IN1-IN8可以驱动四个直流减速电机。

    24d8d86a3dc35c65af12cbd62b47182f.png

    由于我的四个电机是相对安装的,蓝线和绿线接线如下图,这是从上向下的顶视图。

    8ad614fe688281f1f098afabf4976e7b.png

    下面我们就写一个在树莓派上面运行的PyQt5的程序,可以通过GPIO口控制小车的行进,而且可以在Qt界面中操作。

    一、软件编码

    1、使用PyQt5设计界面

    使用QtDesigner设计一个UI界面,保存为HomePage.ui文件,可以自行设计,主要目的是通过点击按钮,达到控制小车前后左右移动的目的,如下图:

    003b607ff3544a32a953a90c1d0fe57d.png

    2、将HomePage.ui文件转换为ui_HomePage.py,使用pyuic5命令或者在PyCharm中直接转换:

    pyuic5 -o ui_HomePage.py HomePage.ui

    6ce70406b25689ade0a4f246f29a2227.png

    这样我们就创建了一个UI界面,目录结构如下:

    a07c11398ff13480577eabd01ce96914.png

    显示效果如下:

    b0dc5c78b671cbfee6bbcec013684067.png

    3、编写伺服电机驱动模块ServoMotorModule.py

    我在这里将驱动模块都放在了DeviceDriver目录下,大家可以根据自己的习惯设计目录结构,只要import的时候包含路径正确就行。

    9b09b0f7581a025ff47e96bdf99f3eee.png

    ServoMotorModule.py文件的内容如下:

    #!/usr/bin/env python
    """
    4WD直流减速电机控制驱动
    """
    import platform
    if (platform.system()=='Windows'):
     pass
    else:
     import RPi.GPIO as GPIO
    import time
    import signal
    import atexit
    from PyQt5.QtCore import *
    '''
    4WD Device四轮伺服电机驱动
    '''
    global currDir
    currDir = 'stop'
    class ServoMotoWorker(QObject):
     '直流减速电机工作线程'
     def __init__(self):
     super(ServoMotoWorker,self).__init__()
     self.gpioFlag = False
     self.working = True
     self.currDirection = 'stop' #当前方向
     def __del__(self):
     '线程停止'
     self.working = False
       def setGPIO(self,w4dpins):
     '设置GPIO端口'
     self.w4dPins = w4dpins
     self.gpioFlag = True
       def initSelf(self):
     'init 4WD state'
     if (platform.system() == 'Windows'):
     pass
          else:
             GPIO.output(self.w4dPins['left_blue'], GPIO.HIGH)
             GPIO.output(self.w4dPins['left_green'], GPIO.HIGH)
             GPIO.output(self.w4dPins['right_blue'], GPIO.HIGH)
             GPIO.output(self.w4dPins['right_green'], GPIO.HIGH)
     def checkDirection(self):
     global currDir
     if currDir == 'stop':
     self.m_stop()
     elif currDir == 'go':
     self.m_go()
     elif currDir == 'back':
     self.m_back()
     elif currDir == 'left':
     self.m_left()
     elif currDir == 'right':
     self.m_right()
     def doWork(self):
     print('running servoMotor ...')
     if self.gpioFlag == False:
     print('Plase set GPIO by setGPIO()')
     return
          while self.working == True:
     self.checkDirection()
             time.sleep(1)
     def m_go(self):
     print('go')
     if (platform.system() == 'Windows'):
     pass
          else:
             GPIO.output(self.w4dPins['left_blue'], GPIO.LOW)
             GPIO.output(self.w4dPins['left_green'], GPIO.HIGH)
             GPIO.output(self.w4dPins['right_blue'], GPIO.LOW)
             GPIO.output(self.w4dPins['right_green'], GPIO.HIGH)
     global currDir
          currDir = 'stop'
     def m_back(self):
     print('back')
     if (platform.system() == 'Windows'):
     pass
          else:
             GPIO.output(self.w4dPins['left_blue'], GPIO.HIGH)
             GPIO.output(self.w4dPins['left_green'], GPIO.LOW)
             GPIO.output(self.w4dPins['right_blue'], GPIO.HIGH)
             GPIO.output(self.w4dPins['right_green'], GPIO.LOW)
     global currDir
          currDir = 'stop'
     def m_left(self):
     '左转停左边的电机'
     print('left')
     if (platform.system() == 'Windows'):
     pass
          else:
     # 因为反向安装
     GPIO.output(self.w4dPins['right_blue'], GPIO.LOW)
             GPIO.output(self.w4dPins['right_green'], GPIO.LOW)
     global currDir
          currDir = 'stop'
     def m_right(self):
     '右转停右边的电机'
     print('right')
     if (platform.system() == 'Windows'):
     pass
          else:
     # 因为反向安装
     GPIO.output(self.w4dPins['left_blue'], GPIO.LOW)
             GPIO.output(self.w4dPins['left_green'], GPIO.LOW)
     global currDir
          currDir = 'stop'
     def m_stop(self):
     # print('stop')
     if (platform.system() == 'Windows'):
     pass
          else:
     for i in self.w4dPins:
                GPIO.output(self.w4dPins[i], GPIO.LOW)
    class ServoMotoManager(QObject):
     '直流减速电机管理器'
     operate = pyqtSignal()
     def __init__(self):
     super().__init__()
     self.setup()
     self.worker = ServoMotoWorker()
     self.thread = QThread()
     self.worker.moveToThread(self.thread)
     self.worker.setGPIO(self.w4dpins)
     self.thread.finished.connect(self.worker.deleteLater)
     self.operate.connect(self.worker.doWork)
     self.thread.start()
     self.operate.emit()
     def __del__(self):
     self.thread.quit()
     self.thread.wait()
     def setup(self):
     'Init device gpio.'
     self.Q = 6
     self.W = 13
     self.E = 19
     self.R = 26
     self.w4dpins = {'left_blue': self.Q, 'left_green': self.W, 'right_blue': self.E, 'right_green':self.R}
     if (platform.system() == 'Windows'):
     pass
          else:
     for i in self.w4dpins:
                GPIO.setup(self.w4dpins[i], GPIO.OUT)
     def controlCommand(self,cmd):
     global currDir
     if cmd == 'go':
             currDir = 'go'
     elif cmd == 'back':
             currDir = 'back'
     elif cmd == 'left':
             currDir = 'left'
     elif cmd == 'right':
             currDir = 'right'
     elif cmd == 'stop':
             currDir = 'stop'

    我在代码中使用了如下四个GPIO口,使用BCM模式就是6、13、19、26这四个接口,如下图:

    4d41f2199ab36d86639b04afcbefd462.png

    注意,由于我软件编写测试是在Windows平台下PyCharm软件,当测试软件结构性的时候,为方便测试,使用“platform.system()”判断当前运行环境的系统平台。

    4、编写界面分离文件CallHomePage.py,内容如下:

    from PyQt5 import QtCore, QtGui, QtWidgets
    from PyQt5.QtWidgets import *
    from ui_HomePage import Ui_HomePage
    from DeviceDriver.ServoMotorModule import ServoMotoManager
    from PyQt5.QtCore import pyqtSignal,Qt
    import platform
    if (platform.system()=='Windows'):
     pass
    else:
     import RPi.GPIO as GPIO
    class HomePage(QWidget,Ui_HomePage):
    #4WD移动信号
    str4WD = pyqtSignal(str)
    def __init__(self,parent=None):
      super(HomePage, self).__init__(parent)
      self.setupUi(self)
      self.initUI()
      self.initDevice()
    def __del__(self):
      if (platform.system() == 'Windows'):
      pass
      else:
      GPIO.cleanup()
     def initUI(self):
     'iniitUI'
     self.resize(800,480)
     #省略部分界面布局的代码,以下就是绑定小车移动的四个按钮
     self.goButton.clicked.connect(self.buttonSlot)
     self.backButton.clicked.connect(self.buttonSlot)
     self.leftButton_3.clicked.connect(self.buttonSlot)
     self.rightButton_3.clicked.connect(self.buttonSlot)
     self.stopButton.clicked.connect(self.buttonSlot)
     def initDevice(self):
     if (platform.system() == 'Windows'):
      pass
     else:
      GPIO.setmode(GPIO.BCM)
     # 初始化4WD电机
     self.servoMotor = ServoMotoManager()
     self.str4WD.connect(self.servoMotor.controlCommand)
    def buttonSlot(self):
      '按钮点击分发处理函数'
      sender = self.sender()
      if sender == self.goButton:
      self.str4WD.emit('go')#小车前进
     elif sender == self.backButton:
      self.str4WD.emit('back')#小车后退
     elif sender == self.leftButton_3:
      self.str4WD.emit('left')#小车左转
     elif sender == self.rightButton_3:
      self.str4WD.emit('right')#小车右转
     elif sender == self.stopButton:
      self.str4WD.emit('stop')#小车停止
    def keyPressEvent(self,event):
      '键盘事件'
      self.key = ""
      if event.key() == Qt.Key_W:
     self.key = "W"
      elif event.key() == Qt.Key_S:
     self.key = "S"
      elif event.key() == Qt.Key_A:
     self.key = "A"
      elif event.key() == Qt.Key_D:
     self.key = "D"
      print(self.key)

    注意:由于控制舵机时使用的GPIO模式是GPIO.BCM模式,树莓派中的同一个应用程序同时只能使用一种GPIO模式,所以所有驱动都使用的BCM模式。

    树莓派管脚的命令如下:

    6f40e8023349e3daedb2c1a30bacaee4.png

    5、编写main程序入口,我在这里新建了一个main_server.py文件,内容如下:

    from PyQt5.QtWidgets import *
    from CallHomePage import HomePage
    import sys
    
    if __name__ == '__main__':
        app = QApplication(sys.argv)
        mainWindow = HomePage()
        mainWindow.show()
        sys.exit(app.exec_())

    二、连接测试

    实际连接状态如下图:

    fc368c9081decde2ff25af0f966ef699.png

    0b849ebbb588f2a621f6e37b430928f1.png

    06f5beb2dbcff4fa634254298177712e.png

    1、将以上代码传到树莓派中,最好目录结构保持一致

    d58219e434d5f6c6ea7aac9ce27b285a.png

    使用python3命令运行我们的main入口,这样我们就可通过点击界面的按钮来控制舵机的转动了。

    b206616101d3e6927ae0f4d5270c68cb.png

    注意:本人树莓派使用的系统是厂家提供的Raspbian系统,里面已经装好了PyQt5的环境了。

    e6d973507f696c51deb103cd55a08f31.png
    https://www.zhihu.com/video/1202206344331534336
    展开全文
  • 1. 舵机控制程序 2. 配置文件 3. 摄像机控制程序 关于舵机的理论知识,网上有比较的介绍,这里我就不赘述了(我也说不清楚)。这里只是简单说一下我所了解的,以及自己的一些想法: 舵机只能有两旋转方向:...

     

    目录

    1. 舵机控制程序

    2. 配置文件

    3. 摄像机控制程序


    关于舵机的理论知识,网上有比较多的介绍,这里我就不赘述了(我也说不清楚)。这里只是简单说一下我所了解的,以及自己的一些想法:

    • 舵机只能有两个旋转方向:要么正转、要么反转
    • 舵机的转动有一个能够转动的最大角度和最小角度,当转动达到最值,也就不能再转动了(在舵机允许的最值之内,你可以自己重新定义这些最值)
    • 要实现摄像头既能水平方向转动,又能垂直方向转动,那就需要两个舵机
    • 我先实现一个控制舵机的类,用来实现一个舵机运动方向的控制;然后定义一个摄像机控制类,来实现摄像机方向的控制
    • 我所实现的功能是输入对应指令,可以控制摄像头上、下、左、右方向的运动,以及让摄像头回归初始位置

    说明:摄像头实现摄像功能这里就不讲了,网上有很多资料可以参考,我用的是MJPG-Streamer,实现方式还是比较简单的

    安装参考可以戳这里

    1. 舵机控制程序

    steering.py:

    # -*- coding: UTF-8 -*-
    import RPi.GPIO as GPIO
    import time
    import atexit
    # 这个类表示单个的SG90模块
    
    
    class Steering:
        max_delay = 0.2
        min_delay = 0.04
    
        def __init__(self, channel, init_position, min_angle, max_angle, speed):
            self.channel = channel
            self.init_position = init_position
            self.position = init_position
            self.min_angle = min_angle
            self.max_angle = max_angle
            self.speed = speed
    
            atexit.register(GPIO.cleanup)
            GPIO.setmode(GPIO.BOARD)
            GPIO.setwarnings(False)
            GPIO.setup(self.channel, GPIO.OUT, initial=False)
    
            self.pwm = GPIO.PWM(self.channel, 50)  # PWM
            self.pwm.start(2.5 + 10 * self.position / 180)  # 让舵机转到初始位置
            time.sleep(Steering.max_delay)
            self.pwm.ChangeDutyCycle(0)  # 这一步比较重要,如果不加的话,舵机会不规则抖动(具体原因还不知道)
            time.sleep(Steering.min_delay)
    
        def forwardRotation(self):
            print("current postion: " + str(self.position))
    
            if (self.position + self.speed) <= self.max_angle:
                self.position = self.position + self.speed
                self.pwm.ChangeDutyCycle(2.5 + 10 * self.position / 180)  # 设置舵机角度
                time.sleep(Steering.min_delay)
                self.pwm.ChangeDutyCycle(0)  # 舵机回到中位
                time.sleep(Steering.min_delay)
    
        def reverseRotation(self):
            print("current postion: " + str(self.position))
    
            if (self.position - self.speed) >= self.min_angle:
                self.position = self.position - self.speed
                self.pwm.ChangeDutyCycle(2.5 + 10 * self.position / 180)  # 设置舵机角度
                time.sleep(Steering.min_delay)
                self.pwm.ChangeDutyCycle(0)  # 舵机回到中位
                time.sleep(Steering.min_delay)
    
        def reset(self):
            '''
            Reset the steering to the middle
            '''
            self.position = self.init_position
            self.pwm.start(2.5 + 10 * self.init_position / 180)  # 让舵机转到初始位置
            time.sleep(Steering.max_delay)
            self.pwm.ChangeDutyCycle(0)  # 这一步比较重要,如果不加的话,舵机会不规则抖动(具体原因还不知道)
            time.sleep(Steering.min_delay)
    
        def stop(self):
            self.pwm.stop()
            time.sleep(Steering.max_delay)
            GPIO.cleanup()
    
    
    if __name__ == "__main__":
        steer = Steering(38, 90, 45, 136, 5)
        while True:
            direction = input("Please input direction: ")
            if direction == "F":
                steer.forwardRotation()
            elif direction == "R":
                steer.reverseRotation()
            elif direction == "S":
                steer.stop()
    

    2. 配置文件

    config.ini

    [car]
    # This is the parmaters that will control the car's wheels
    # The number is the interface number of GPIO (GPIO.BOARD)
    LEFT_FRONT_1 = 7
    LEFT_FRONT_2 = 11
    
    RIGHT_FRONT_1 = 13
    RIGHT_FRONT_2 = 15
    
    LEFT_BEHIND_1 = 31
    LEFT_BEHIND_2 = 33
    
    RIGHT_BEHIND_1 = 35
    RIGHT_BEHIND_2 = 37
    
    [camera]
    # This is the parameters that will control camera's horizonal direction move
    HIntfNum = 38
    HInitPosition = 90
    HMinPosition = 40
    HMaxPosition = 140
    HSpeed = 5
    
    # This is the parameters that will control camera's vertical direction move
    VIntfNum = 40
    VInitPosition = 120
    VMinPosition = 75
    VMaxPosition = 180
    VSpeed = 5
    
    [server]

    3. 摄像机控制程序

    camera_controler.py

    # -*- coding = UTF-8 -*-
    from steering import Steering
    import time
    import configparser
    
    
    class Camera:
        def __init__(self):
            '''
            Read config file to init camera's parameter
            '''
            config = configparser.ConfigParser()
            config.read("config.ini")
    
            # Horiazonal direction control parameters
            HIntfNum = config.getint("camera", "HIntfNum")
            HInitPosition = config.getint("camera", "HInitPosition")
            HMinPosition = config.getint("camera", "HMinPosition")
            HMaxPosition = config.getint("camera", "HMaxPosition")
            HSpeed = config.getint("camera", "HSpeed")
    
            # Vertical direction control parameters
            VIntfNum = config.getint("camera", "VIntfNum")
            VInitPosition = config.getint("camera", "VInitPosition")
            VMinPosition = config.getint("camera", "VMinPosition")
            VMaxPosition = config.getint("camera", "VMaxPosition")
            VSpeed = config.getint("camera", "VSpeed")
    
            self.HCameraControl = Steering(
                HIntfNum, HInitPosition, HMinPosition, HMaxPosition, HSpeed)
            self.VCameraControl = Steering(
                VIntfNum, VInitPosition, VMinPosition, VMaxPosition, VSpeed)
    
        def cameraRotate(self, direction):
            '''
            This method is used to contorl the camera's rotating
            The value of parameter direction and its meaning as follow:
            HR - Turn right
            HL - Turn left
            VU - Turn upward
            VD - Turn downword
            '''
            if direction == "HL":
                self.HCameraControl.forwardRotation()
            elif direction == "HR":
                self.HCameraControl.reverseRotation()
            elif direction == "VU":
                self.VCameraControl.forwardRotation()
            elif direction == "VD":
                self.VCameraControl.reverseRotation()
            elif direction == "RESET":
                self.HCameraControl.reset()
                self.VCameraControl.reset()
            else:
                print(
                    "Your input for camera direction is wrong, please input: HR, HL, VU, VD or RESET!")
    
    
    if __name__ == "__main__":
        camera = Camera()
        while(True):
            direction = input("Please input direction: ")
            camera.cameraRotate(direction)
    

     

    展开全文
  • 通过树莓派控制舵机旋转固定角度

    千次阅读 2020-03-05 17:11:26
    最近项目遇到一需求:通过转动旋钮对设备进行调焦。傻瓜式操作,只需要一电机带动旋钮就好了。重点倒是如何识别图像是否达到自己想要的清晰度...这边只是测试舵机控制。 import atexit import RPi.GPIO as GPIO ...

    最近项目遇到一个小需求:通过转动旋钮对设备进行调焦。傻瓜式操作,只需要一个电机带动旋钮就好了。重点倒是如何识别图像是否达到自己想要的清晰度。不多说,上代码。
    整体说明一下:通过相机采集图像,键盘按‘q’,采集一张图像,然后通过SMD2去分析得到图像的清晰度,再根据清晰度去对应调整舵机旋转的角度。这边只是测试舵机控制。

    import atexit
    import RPi.GPIO as GPIO                 # 引入GPIO模块
    import time
    import cv2 as cv
    import numpy as np
    import math
    
    atexit.register(GPIO.cleanup)
    #图像采集
    def grap_photo():
        cap = cv.VideoCapture(0)
        while True:
            ret,frame = cap.read()
            if ret:
                cv.imshow('test',frame)
                if cv.waitKey(1) & 0xFF == ord('q'):
                    # ~ file_name = "xieyang.jpeg"
                    # ~ cv2.imwrite(file_name, frame)
                    img=cv.cvtColor(frame,cv.COLOR_BGR2GRAY)
                    return img
                    # ~ break
            else:
                break
        cap.release()
        cv.destroyAllWindows()
    #清晰度分析    
    def SMD2(img):
        '''
        :param img:narray 二维灰度图像
        :return: float 图像约清晰越大
        '''
        img = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
        img = cv.resize(img,(480,640))
        shape = np.shape(img)
        out = 0
        for x in range(0, shape[0]-1):
            for y in range(0, shape[1]-1):
                out+=math.fabs(int(img[x,y])-int(img[x+1,y]))*math.fabs(int(img[x,y]-int(img[x,y+1])))
        return out
    def NEW_SMD2_(img):
        '''
        :param img:narray 二维灰度图像
        :return: float 图像约清晰越大
        '''
        img = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
        img = cv.resize(img,(480,640)) #原来图片的数据类型:uint8
        img = np.float32(img) #转换后:float32
        timeA = time.time()
        h, w = img.shape
        Sharpness = np.sum(np.abs(img[:h-1, :w-1] - img[1:, :w-1]) * np.abs(img[:h-1, :w-1] - img[:h-1, 1:]))
        # print('new: {:.4f}'.format(time.time()-timeA))
        return Sharpness
    #该方法(NEW_SMD2_)采用矩阵运算,处理速度比SMD2要快许多。值得注意的是:需要对img的数据类型转换,
    #原图数据类型是uint8,计算方差时数据较大,会导致数组越界,最后得到的数值和SMD2不一样。所以需要转换
    #可控制300度旋转的舵机
    def Control_300(angle=None):
        try:
            while True:
                # ~ # 等待输入一个0到300的角度
                # ~ direction = angle
                direction = float(input("请输入移动角度: "))
                if direction < 0 or direction > 300:
                    print("请输入正确的角度")
                    continue
    
                duty = (1/30) * direction + 2.5   # 将角度转换为占空比
                pwm.ChangeDutyCycle(duty)         # 改变PWM占空比
                time.sleep(0.02)
        finally:
            pwm.stop()                      # 停止PWM
            GPIO.cleanup()                  # 清理释放GPIO资源,将GPIO复位
    
    
    #可控制360度旋转舵机
    def Control_360(angle=None):
        try:
            while True:
                # ~ # 等待输入一个0到300的角度
                # ~ direction = angle
                direction = float(input("请输入移动角度: "))
                if direction < 0 or direction > 360:
                    print("请输入正确的角度")
                    continue
    
                duty = (1/36) * direction + 2.5   # 将角度转换为占空比
                pwm.ChangeDutyCycle(duty)         # 改变PWM占空比
                time.sleep(0.02)
        finally:
            pwm.stop()                      # 停止PWM
            GPIO.cleanup()                  # 清理释放GPIO资源,将GPIO复位
    
    
    #不可控360度旋转    
    def UnControl_360(angle=None):
        try:
            # 等待输入一个0到300的角度
            direction = angle
            # ~ direction = float(input("请输入移动角度: "))
            if direction < 0 or direction > 360:
                print("请输入正确的角度")
            duty = (1/30) * direction + 2.5   # 将角度转换为占空比
            pwm.ChangeDutyCycle(duty)         # 改变PWM占空比
            time.sleep(0.02)
     
        finally:
            pwm.stop()                      # 停止PWM
            GPIO.cleanup()                  # 清理释放GPIO资源,将GPIO复位 
    if __name__ == '__main__':
        ServoPin = 21
        PWMFreq = 50                      # PWM信号频率
    
        GPIO.setmode(GPIO.BCM)              # 使用BCM编号方式
        GPIO.setup(ServoPin, GPIO.OUT)      # 将GPIO19设置为输出模式
        pwm = GPIO.PWM(ServoPin, PWMFreq)   # 创建PWM对象,并设置频率为50
        pwm.start(0)                        # 启动PWM,并设置初始占空比0
        # ~ UnControl_360()
        Control_360()
        # ~ img = grap_photo()
        # ~ data = SMD2(img)
        # ~ print(data)
        # ~ if data>10000:
            # ~ Control_300(200)
        # ~ else:
            # ~ Control_300(10)
    
    展开全文
  • 树莓派4B-Python-控制舵机

    千次阅读 多人点赞 2020-08-22 21:39:42
    树莓派4B-Python-控制舵机SG90舵机参数介绍工作原理与树莓派4B连接代码 本文采用的是SG90型号的舵机树莓派4B4G版,主要是实现对舵机控制、问题的解决。 SG90舵机 参数介绍 工作原理 与树莓派4B连接 代码 ...
  • 废话不说,准备材料:一、材料树莓派机械臂履带车电源和杜邦线若干,L298N一工具(杂七杂八的)如图:二、接线首选选择gpio做为控制树莓派一共有40gpio,但是并不是所有的适合用。我选择22,23,24,25号gpio口,...
  • 上一篇实现了远程监控,但是太不灵活了,如果在摄像头上加上一个舵机云台来实现摄像头的左右上下转动就再好不过了,先来看一下效果吧,这是把前面的都做完之后整体的效果: 材料: 1.舵机云台 某宝上买的20几...
  • 树莓派3b+控制舵机、伺服电机的驱动代码。

    万次阅读 多人点赞 2017-05-18 21:25:20
    舵机控制一般需要一20ms的时基脉冲,该脉冲的高电平部分一般为0.5ms~2.5ms范围内的角度控制脉冲部分。以180度角度舵机为例,那么对应的控制关系是这样的: 0.5ms--------------0度; 1.0ms------------45度; ...
  • 舵机控制一般需要一20ms的时基脉冲,该脉冲的高电平部分一般为0.5ms~2.5ms范围内的角度控制脉冲部分。以180度角度舵机为例,那么对应的控制关系是这样的: 0.5ms--------------0度; 1.0ms------------45度; ...
  • 树莓派Adafruit_PCA9685,舵机驱动自定义通道,正反转,角度,输入通道,选择正转或者反转,输入角度
  • 一.IIC通信 在raspi-config中的interface选项打开IIC通信 二....也可以去github或者gitee搜索...可参考(17条消息) 树莓派4B通过16路PWM输出的PCA9685模块控制舵机(机械臂)附完整代码_袁六加.的博客-CSDN博...
  • 第8章 树莓派控制伺服电机(舵机

    千次阅读 多人点赞 2019-07-01 22:59:53
      伺服电机主要适用于那些需要角度不断变化并可以保持的控制系统,我们常见的的机械臂...使用树莓派控制伺服电机的实践。   本章我们将继续使用第5章搭建的功能实验平台。此外,还需要一伺服电机...
  • = 2500: #开启循环进行,从up到up+100*n,每次走100 * n距离,当然这里你可以10 * n,这样舵机移动的角度非常小非常小 #我这里500~2500一共是2000,分20下100 * n,当n为1时,则移动20下从最前边到最后边,角度大概...
  • 其中,人脸辨识是一很重要的部分,网络上已经有相当的资源可供下载使用;于是我们使用舵机云台作为镜头旋转的硬件,搭配镜头模块,并结合RaspberryPi作为微控制器,完成一台自制的人脸辨识追踪系统,来看看如何...
  • 然后打开树莓派终端,用sudo apt-get -y install arduino python-serial mercurial这条指令安装Arduino IDE在树莓派上,然后pip3 install pyfirmata安装pyfirmata库,安装完后就可以在树莓派上新建一py文件
  • 机器狗搭建记录2-树莓派连接舵机

    千次阅读 2020-09-13 21:58:44
    3.PCA9685舵机控制器 x1 4.PDI-HV5523MG舵机 x1 1.更新系统软件 sudo apt update -y sudo apt dist-upgrade -y sudo apt autoremove -y 这里最好接入有线,直接插上网线的接口就可以直接连上了。无线贼慢,慢到怀疑...
  • 树莓派+PCA9685+舵机控制:wiringPi实现

    千次阅读 2020-09-01 17:23:47
    树莓派+PCA9685+舵机控制 1舵机控制 1.1舵机介绍 淘宝直接搜索舵机,有90° 180° 270° 370°舵机,通过PWM来进行控制,如下所示: 1.2控制原理 如下图所示:一脉冲周期为20ms,高电平为脉冲宽度,这脉冲宽度...
  •  为了用JAVA操控舵机,用了很长的时间学习,现在来分享一下。 介绍舵机  对于舵机来说,控制其转动不像直流电机那样连接...把舵机控制端口直接连接到树莓派,显然由于针脚数目限制,这种方法有一定局限。(注意
  • 树莓派4B改装RC玩具车玩转opencv系列教程(二)树莓派通过PCA9685控制舵机硬件连接硬件清单树莓派引脚引脚连接表Fritzing硬件连接图PCA9685树莓派库的安装打开树莓派的I^2^C添加SMBus库安装adafruit-circuitpython-...
  • 难度: ★★读者: 适合有C语言或Python编程基础,对舵机和PWM等有...本文将介绍如何在树莓派4B上控制舵机运转,比如控制角度、方向等,带你入门模拟舵机。准备工作:SG90(或其他型号)模拟舵机树莓派4B面包板及若...
  • 树莓派初学者,第一次操作全新树莓派(包括选购器件、安装硬件、烧录镜像、配置所有本次实验需要的树莓派通信环境等等)。 ②python初学者,但是有其他语言基础。 文中有大量试错过程可供参考。】 九月份补充...
  • 树莓派笔记13:舵机云台(一)

    万次阅读 多人点赞 2018-05-26 19:34:47
    1 关于舵机 2 一些关键数据的推算 3 程序设计 4 测试
  • 树莓派3B+ PCA9685舵机驱动板控制舵机

    千次阅读 2019-09-02 22:08:06
    舵机驱动板和树莓派的接线如下 只需要将侧边的 VCC GND SDA SCL四点接入到树莓派中的对应的引脚即可 中间的V+ GND是给舵机供电的,可以单独接入5V的电压 舵机使用的是SG90型号 其具体的接入方法为:橙色接...
  • 树莓派4B通过16路PWM输出的PCA9685模块控制舵机(机械臂)附完整代码 文章目录树莓派4B通过16路PWM输出的PCA9685...Servo Driver HAT是基于树莓派而设计的PWM/舵机扩展板,通过PCA9685芯片扩展16路舵机控制或者PWM输
  • 树莓派:MPU6050控制舵机转向

    千次阅读 2019-07-05 20:47:29
    个舵机 面包板、GPIO扩展板(可有可无,只是方便接在面包板上) 二、电路接线 PCA9685和树莓派的接线 SCL---->SCL1(树莓派) SDA---->SDA1(树莓派) VCC---->+5V(给PCA9685芯片供电) GND---->...
  • 最近想实现一下树莓派摄像头的转动功能,在网上查找资料后发现可以用舵机控制树莓派摄像头的转动。 主要材料: 1、树莓派 X1 2、摄像头模块 X1 3、微型舵机 X2 舵机外观如下: 舵机控制控制舵机需要使用PWM...
  • 随着大规模集成电路技术的发展,把CPU和一单独工作系统所必需的ROM、RAM、I/O端口、A/D、D/A等外围电路集成在一单片内而制成的单片机或微控制器愈来愈方便。目前,世界上许多公司生产单片机,品种很。其中包括...
  • 在石头剪刀布这游戏里面,树莓派需要通过控制舵机的转动来和我进行“猜拳”游戏。这篇文章介绍树莓派控制舵机的基础操作。本文主要参考文章树莓派使用python 控制G90舵机。我使用的舵机是辉盛的SG90。SG90共有三根...
  • 在本教程中,我们将探讨如何在树莓派上使用Python控制多个舵机。 我们的目标是制作一个支持多自由度定位拍照的云台。在这里,你可以看到我们的成品是如何工作的。 主要材料 1、树莓派3 X1 2、摄像头模块 X1 3、9G ...
  • 1、获取误差(x、y方向) 2、PID控制参数 3、保存本次误差 4、得到最终的PID值(P分量) 5、限值 对比:不用PID处理 代码 四、舵机运动 主程序(线程舵机控制) 舵机运动函数 总代码 效果展示 基础理论(人脸识别...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 404
精华内容 161
关键字:

树莓派控制多个舵机