• Python的电机控制模拟程序

    一个带有EPICS支持的虚拟电机控制器。

    1）Status类：其实例化对象代表一个电机轴的状态。 

    1. #!/usr/bin/env python
    2. '''
    3.     Status类代表一个电机处于的状态：
    4.     1、DIRECTION状态位：设置运动方向
    5.     2、DONE_MOVING状态字：置位表示结束运动
    6.     3、MOVING状态字：置位表示正在运动
    7.     4、HIGH_LIMIT状态字：置位表示触发高限位
    8.     5、LOW_LIMIT状态字：置位表示触发低限位
    9.     6、HOMING：置位表示正在寻HOME位
    10.     7、HOMING_LIMIT：置位表示触发HOME开关
    11.     8、HOMED：置位表示寻HOME结尾
    12.     9、ERROR：置位表示出错
    13. '''
    14. class Status:
    15. 	'''
    16. 	代表轴状态的类：初始化这个对象
    17. 	'''
    18. 	def __init__(self):
    19. 		# 初始化方向，方向1表示正方向
    20. 		self.direction = 1
    21. 		# 初始化运动状态为静止
    22. 		self.doneMoving = 1
    23. 		self.moving = 0
    24. 		# 初始化高低限位信号为无效
    25. 		self.highLimitActive = 0
    26. 		self.lowLimitActive = 0
    27. 		# 初始化归位：未在归位中，归位无效
    28. 		self.homing = 0
    29. 		self.homed = 0
    30. 		self.homeSwitchActive = 0
    31. 		# 初始化错误：没有
    32. 		self.error = False
    33. 		self.errorMessage = None
    34.  
    35. 		# 状态位定义：每种状态所在的位
    36.         #方向：第0BIT、结束运行：第1BIT、移动中：第2BIT
    37.         # 高限位：第3BIT、低限位：第4BIT、归位中：第5BI
    38.         # 归位开关：第6BIT，已经归位：第7BIT，错误：第8BIT
    39. 		self.DIRECTION = 1 << 0
    40. 		self.DONE_MOVING = 1 << 1
    41. 		self.MOVING = 1 << 2
    42. 		self.HIGH_LIMIT = 1 << 3
    43. 		self.LOW_LIMIT = 1 << 4
    44. 		self.HOMING = 1 >> 5
    45. 		self.HOME_LIMIT = 1 << 6
    46. 		self.HOMED = 1 << 7
    47. 		self.ERROR = 1 << 8
    48.  
    49. 		# 初始状态为0，通过以上状态定义计算状态
    50. 		self.status = 0
    51. 		self.calcStatus()
    52.  
    53.     # 设置错误状态码和错误消息
    54. 	def setError(self, flag, message):
    55. 		self.error = flag  # 设置错误标记
    56. 		self.errorMessage = message
    57.         # 错误标记非0，状态中置位ERROR对应的BIT位状态
    58.         # 错误标记为0， 状态中复位ERROR对应的BIT位状态
    59. 		if self.error:
    60. 			self.status |= self.ERROR
    61. 		else:
    62. 			self.status &= ~self.ERROR
    63.  
    64.     # 设置为运动，结束移动的标志置0，运动的标志置1，状态中对结束移动标的志置0，对运动标志置1
    65. 	def setMoving(self):
    66. 		self.doneMoving = 0
    67. 		self.moving = 1
    68. 		self.status |= self.MOVING
    69. 		self.status &= ~self.DONE_MOVING
    70.  
    71.     # 设置为结束，结束移动的标志置1，运动的标志置0，状态中对结束移动标的志置1，对运动标志置0
    72. 	def setDoneMoving(self):
    73. 		self.doneMoving = 1
    74. 		self.moving = 0
    75. 		self.status |= self.DONE_MOVING
    76. 		self.status &= ~self.MOVING
    77.  
    78.     # 设置正方向，方向标志为1
    79. 	def setDirPositive(self):
    80. 		self.direction = 1
    81. 		self.status |= self.DIRECTION
    82.  
    83.     # 设置负方向，方向标志为0
    84. 	def setDirNegative(self):
    85. 		self.direction = 0
    86. 		self.status &= ~self.DIRECTION
    87.  
    88.     # 设置高限位为1
    89. 	def setHighLimit(self):
    90. 		self.highLimitActive = 1
    91. 		self.status |= self.HIGH_LIMIT
    92.     # 重置高限位
    93. 	def resetHighLimit(self):
    94. 		self.highLimitActive = 0
    95. 		self.status &= ~self.HIGH_LIMIT
    96.     # 设置低限位
    97. 	def setLowLimit(self):
    98. 		self.lowLimitActive = 1
    99. 		self.status |= self.LOW_LIMIT
    100.     # 重置低限位
    101. 	def resetLowLimit(self):
    102. 		self.lowLimitActive = 0
    103. 		self.status &= ~self.LOW_LIMIT
    104.     
    105.     # 返回当前状态
    106. 	def getStatus(self):
    107. 		return self.status
    108.  
    109.     # 根据方向标志、结束运行的标志、移动的标志，高限位的标志，低限位的标志，归位的标志、归位开关标志、归位结束的标志，以及
    110.     # 错误标志，构造状态
    111.     # 根据Status对象的diretion, doneMoving, moving, highLimitActive, lowLimitActive, homing, homed, homeSwitchActive
    112.     # error成员的状态计算成员status
    113. 	def calcStatus(self):
    114. 		status = 0
    115. 		if self.direction:
    116. 			status |= self.DIRECTION
    117. 		if self.doneMoving:
    118. 			status |= self.DONE_MOVING
    119. 		if self.moving:
    120. 			status |= self.MOVING
    121. 		if self.highLimitActive:
    122. 			status |= self.HIGH_LIMIT
    123. 		if self.lowLimitActive:
    124. 			status |= self.LOW_LIMIT
    125. 		if self.homing:
    126. 			status |= self.HOMING
    127. 		if self.homeSwitchActive:
    128. 			status |= self.HOME_LIMIT
    129. 		if self.homed:
    130. 			status |= self.HOMED
    131. 		if self.error:
    132. 			status |= self.ERROR
    133. 		self.status = status
    134. 		return

    2） Axis类，其实例化代表电机的一个运动轴：

    1. #!/usr/bin/env python
    2. import status
    3. import datetime
    4. import math
    5. import time
    6.  
    7. class Axis:
    8.     """
    9.     代表电机一个运动轴的类
    10.     """
    11.  
    12.     def __init__(self, index):
    13.         self.index = index
    14.  
    15.         # 基速度和匀速速度
    16.         self.baseVelocity = 0
    17.         self.velocity = 400
    18.  
    19.         # 加速度和减速度
    20.         self.acceleration = 400
    21.         self.deceleration = 400
    22.  
    23.         # 上下限位
    24.         self.highLimit = 40000
    25.         self.lowLimit = -40000
    26.  
    27.         # 单位
    28.         self.units = "counts"
    29.  
    30.         # 分辨率
    31.         self.resolution = 1.0
    32.  
    33.         # 启动开始时刻，移动取消时刻
    34.         self.moveStartTime = None
    35.         self.abortTime = None
    36.  
    37.         # 轴的上次位置，当前位置，当前偏移量，目标位置，方向，移动速度
    38.         self.lastPosition = 0
    39.         self.currentPosition = 0
    40.         self.currentDisplacement = 0
    41.         self.targetPosition = 0
    42.         self.direction = 1
    43.         self.moveVelocity = self.velocity
    44.  
    45.         # 加速持续时间，加速阶段的距离，减速持续时间，减速阶段的距离
    46.         self.accelDistance = 0.0
    47.         self.accelDuration = 0.0
    48.         self.decelDistance = 0.0
    49.         self.decelDuration = 0.0
    50.  
    51.         # 移动距离，匀速持续时间，减速启动时间，移动持续时间
    52.         self.moveDistance = 0
    53.         self.constVelDuration = 0.0
    54.         self.decelStartTime = 0.0
    55.         self.moveDuration = 0.0
    56.  
    57.         # 默认执行限位检查
    58.         self.enforceLimits = True
    59.  
    60.         # 实例化一个默认的Status对象，代表电机轴的状态
    61.         self.status = status.Status()
    62.  
    63.     def move(self, targetPosition):
    64.         # 已经移动，则忽略，检查启动时刻是否已经存在
    65.         if self.moveStartTime != None:
    66.             return "Busy"
    67.  
    68.  
    69.         self.targetPosition = targetPosition
    70.         self.lastPosition = self.currentPosition
    71.  
    72.         # 比较当前位置和目标位置，来设置方向
    73.         # 此处的direction用于计算位置
    74.         if self.targetPosition < self.lastPosition:
    75.             self.direction = -1
    76.             self.status.setDirNegative()
    77.         else:
    78.             self.direction = 1
    79.             self.status.setDirPositive()
    80.  
    81.         print("move:direction:" , self.direction)
    82.         # 检查上下限位情况
    83.         if (self.enforceLimits == True) and (self.direction == 1) and (self.status.highLimitActive == 1):
    84.             self.status.setError(True, "Can't move in positive direction when high limit is active")
    85.             print("hh")
    86.         elif (self.enforceLimits == True) and (self.direction == -1) and (self.status.lowLimitActive == 1):
    87.             self.status.setError(True, "Can't move in negative direction when low limit is active")
    88.             print("ll")
    89.         else:
    90.             # 设置启动时刻，表示电机轴开始移动了
    91.             self.moveStartTime = datetime.datetime.now()
    92.             # 计算移动距离
    93.             self.moveDistance = abs(self.targetPosition - self.lastPosition)
    94.             print("moveDistance , ", self.moveDistance)
    95.             # 加速时间
    96.             self.accelDuration = (self.velocity - self.baseVelocity) / self.acceleration
    97.             # 加速过程中，移动的距离：vb*t+1/2*a*t^2,a=(v-vb)/t==>vb*t+0.5*(v-vb)*t
    98.             self.accelDistance = self.baseVelocity * self.accelDuration + self.accelDuration * 0.5 * (self.velocity - self.baseVelocity)
    99.             # 减速时间，减速过程的距离
    100.             self.decelDuration = (self.velocity - self.baseVelocity) / self.deceleration
    101.             #! debug: print("decelDuration = ", self.decelDuration)
    102.             self.decelDistance = self.baseVelocity * self.decelDuration + self.decelDuration * 0.5 * (self.velocity - self.baseVelocity)
    103.  
    104.             if self.moveDistance < (self.accelDistance + self.decelDistance):
    105.                 # 这点距离不能使得轴达到运行速度，加速到一个峰值速度后，就进行减速
    106.                 peakVelocity = math.sqrt(2 * self.acceleration * self.deceleration * self.moveDistance / (self.acceleration + self.deceleration))
    107.                 print("---------+-------------")
    108.                 print("peakVelocity = ", peakVelocity)
    109.                 self.moveVelocity = peakVelocity
    110.  
    111.                 # 重新计算：加速所用时间，加速的距离，减速所用时间，减速的距离
    112.                 self.accelDuration = (peakVelocity - self.baseVelocity) / self.acceleration
    113.                 self.accelDistance = self.baseVelocity * self.accelDuration + self.accelDuration * 0.5 * (peakVelocity - self.baseVelocity)
    114.                 self.decelDuration = (peakVelocity - self.baseVelocity) / self.deceleration
    115.                 self.decelDistance = self.baseVelocity * self.decelDuration + self.decelDuration * 0.5 * (peakVelocity - self.baseVelocity)
    116.  
    117.                 self.constVelDuration = 0.0
    118.             else:
    119.                 self.moveVelocity = self.velocity
    120.                 # 匀速移动距离，匀速移动时间
    121.                 self.constVelDuration = (self.moveDistance - self.accelDistance - self.decelDistance) / self.moveVelocity
    122.             # 开始减速的时刻
    123.             self.decelStartTime = self.accelDuration + self.constVelDuration
    124.             # 整个移动时间
    125.             self.moveDuration = self.decelStartTime + self.decelDuration
    126.  
    127.             # 打印轴移动的信息：
    128.             # 轴编码，起始位置，终止位置，移动距离，移动持续时间，加速距离，匀速时间
    129.             # 减速时刻，减速持续时间，减速距离
    130.             print("+-----------motor %d :" %  (self.index + 1))
    131.             print("Start Position: ", self.lastPosition, self.units)
    132.             print("End   Position: ", self.targetPosition, self.units)
    133.             print()
    134.             print("Move Duration : ", self.moveDuration, "seconds")
    135.             print("Move Distance : ", self.moveDistance, self.units)
    136.             print()
    137.             print("Accel Duration: ", self.accelDuration, "seconds")
    138.             print("Accel Distance: ", self.accelDistance, self.units)
    139.             print()
    140.             print("Constant Vel Duration: ", self.constVelDuration, "seconds")
    141.             print("Decel Start Time     : ", self.decelStartTime, "seconds")
    142.             print()
    143.             print("Decel Duration       : ", self.decelDuration, "seconds")
    144.             print("Decel Distance       : ", self.decelDistance,  self.units)
    145.             print()
    146.  
    147.         return "OK"
    148.  
    149.     def moveRelative(self, displacement):
    150.         if self.moveStartTime != None:
    151.             return "Busy"
    152.  
    153.         self.lastPosition = self.currentPosition
    154.         targetPosition = self.lastPosition + displacement
    155.         print("current %s to target %s"  % (self.lastPosition, targetPosition))
    156.         retval = self.move(targetPosition)
    157.  
    158.         return retval
    159.  
    160.     def jog(self, velocity):
    161.         print("Velocity: ", velocity)
    162.  
    163.         displacement = velocity * 3600.0
    164.         retval = self.moveRelative(displacement)
    165.  
    166.         return retval
    167.  
    168.     def stop(self):
    169.         if self.moveStartTime == None: #未开始移动
    170.             self.abortTime = None
    171.  
    172.         else:
    173.             if self.abortTime != None: # 已经发送了取消命令
    174.                 pass
    175.             else:
    176.                 # 记录当前取消时刻
    177.                 self.abortTime = datetime.datetime.now()
    178.                 # 到取消时刻已经运行了多少时间
    179.                 abortTimeDelta = self.abortTime - self.moveStartTime
    180.                 abortTimeSeconds = abortTimeDelta.total_seconds()
    181.  
    182.                 # 重新计算移动的距离
    183.                 if abortTimeSeconds < self.accelDuration: # 在加速阶段就取消了
    184.                     self.accelDuration = abortTimeSeconds
    185.                     self.accelDistance = self.baseVelocity * abortTimeSeconds + 0.5 * self.acceleration * abortTimeSeconds * abortTimeSeconds
    186.                     peakVelocity = self.acceleration * abortTimeSconds
    187.                     self.constVelDuration = 0.0
    188.                     self.decelDuration = (peakVelocity - baseVelocity)/ self.deceleraction
    189.                     self.decelDistance = self.baseVelocity * self.decelDuration + 0.5 * self.deceleration * self.decelDuration * self.decelDuration
    190.                     # 实际移动距离=加速的距离+减速的距离
    191.                     self.moveDistance = self.accelDistance + self.decelDistance
    192.                     # 实际移动时间=加速所用时间+减速所用时间
    193.                     self.moveDuration = self.accelDuration + self.decelDuration
    194.                     # 移动峰值速度
    195.                     self.moveVelocity = peakVelocity
    196.                 elif abortTimeSeconds < self.decelStartTime: # 在匀速阶段取消
    197.                     self.decelStartTime = abortTimeSeconds
    198.                     # 匀速运动所用时间
    199.                     self.constVelDuration = abortTimeSeconds - self.accelDuration
    200.                     # 移动距离
    201.                     self.moveDistance = self.accelDistance + self.moveVelocity * self.constVelDuration + self.decelDistance
    202.                     # 移动的时间
    203.                     self.moveDuration = self.accelDuration + self.constVelDuration  + self.decelDuration
    204.                 elif abortTimeSeconds <= self.moveDuration:  # 在减速阶段取消
    205.                     pass
    206.                 else:
    207.                     print("Error: Stop received after a move shoud have been complete.")
    208.                     self.status.setError(True, "Error: Stop received after a move should been complete.")
    209.  
    210.         return "OK"
    211.  
    212.     # 读取当前位置
    213.     def readPosition(self):
    214.         if self.moveStartTime == None: # 电机轴未移动
    215.             pass
    216.         else:
    217.             # 设置移动标志
    218.             moveFlag = True
    219.  
    220.             currentTime = datetime.datetime.now()
    221.             # 计算移动时间：当前时间 - 启动时间
    222.             movingTimeDelta = currentTime - self.moveStartTime
    223.             movingTimeSeconds = movingTimeDelta.total_seconds()
    224.             print("readPosition timedelta:  ", movingTimeSeconds)
    225.  
    226.             self.currentDisplacement = 0
    227.  
    228.             if movingTimeSeconds < self.accelDuration: # 加速阶段中，偏移量
    229.                 self.currentDisplacement = self.baseVelocity * movingTimeSeconds + 0.5 * self.acceleration * movingTimeSeconds * movingTimeSeconds
    230.             elif movingTimeSeconds < self.decelStartTime: #  匀速阶段中，偏移量
    231.                 self.currentDisplacement = self.baseVelocity * self.accelDuration + 0.5 * self.acceleration * self.accelDuration * self.accelDuration + (movingTimeSeconds - self.accelDuration) * self.moveVelocity
    232.             elif movingTimeSeconds < self.moveDuration:  # 减速阶段中，偏移量
    233.                 self.currentDisplacement = self.baseVelocity * self.accelDuration + 0.5 * self.acceleration * self.accelDuration * self.accelDuration + self.constVelDuration * self.moveVelocity  + self.baseVelocity * (movingTimeSeconds - self.decelStartTime) + 0.5 * self.deceleration * (movingTimeSeconds - self.decelStartTime) * (movingTimeSeconds - self.decelStartTime)
    234.             else: # 已经超出了运行时间, 设置移动标志
    235.                 moveFlag = False
    236.  
    237.             #print("In readPosition--> currentDisplacement", self.currentDisplacement)
    238.  
    239.             print("in readPosition: direction : ", self.direction)
    240.  
    241.             if moveFlag == True:# 还在移动，计算当前位置
    242.                 self.currentPosition = self.lastPosition + self.direction * self.currentDisplacement
    243.             else:
    244.                 if self.abortTime == None:  # 运动自然结束
    245.                     self.currentPosition = self.targetPosition
    246.                 else:# 运动被取消
    247.                     self.currentPostion = self.lastPosition + self.direction * self.moveDistance
    248.                     self.abortTime = None
    249.  
    250.                 self.latPosition = self.currentPosition
    251.                 self.moveStartTime = None
    252.  
    253.         return self.currentPosition
    254.  
    255.     def setPosition(self,  newPostion):
    256.         if self.moveStartTime == None: # 电机轴未移动
    257.             self.currentPosition = newPosition
    258.             self.lastPosition = self.currentPosition
    259.  
    260.         else:
    261.             pass
    262.         return "OK"
    263.  
    264.     def readStatus(self):
    265.         if self.moveStartTime == None:
    266.             self.status.setDoneMoving()
    267.         else:
    268.             currentTime = datetime.datetime.now()
    269.  
    270.             movingTimeDelta = currentTime - self.moveStartTime
    271.             movingTimeSeconds = movingTimeDelta.total_seconds()
    272.  
    273.             if movingTimeSeconds < self.moveDuration:
    274.                 self.status.setMoving()
    275.             else:
    276.                 self.status.setDoneMoving()
    277.  
    278.         if self.enforceLimits == True:
    279.             if  self.currentPosition > self.highLimit:
    280.                 self.status.setHighLimit()
    281.                 if (self.status.doneMoving == 0)  and (self.direction == 1):
    282.                     self.stop()
    283.             else:
    284.                 self.status.resetHighLimit()
    285.  
    286.             if self.currentPosition < self.lowLimit:
    287.                 self.status.setLowLimit()
    288.                 if (self.status.doneMoving == 0) and (self.direction == -1):
    289.                     self.stop()
    290.             else:
    291.                 self.status.resetLowLimit()
    292.         else:
    293.             self.status.resetLowLimit()
    294.             self.status.resetHighLimit()
    295.  
    296.         return self.status.getStatus()
    297.  
    298.     def setVelocity(self, velocity):
    299.         self.velocity = abs(velocity)
    300.         return "OK"
    301.  
    302.     def getVelocity(self):
    303.         return self.velocity
    304.  
    305.     def setBaseVelocity(self, velocity):
    306.         self.baseVelocity = abs(velocity)
    307.         return "OK"
    308.  
    309.     def getBaseVelocity(self):
    310.         return self.baseVelocity
    311.  
    312.     def setAcceleration(self, acceleration):
    313.         self.acceleration = acceleration
    314.         return "OK"
    315.  
    316.     def setDeceleration(self, deceleration):
    317.         self.deceleration = accceleration
    318.         return "OK"
    319.  
    320.     def getAcceleration(self):
    321.         return self.acceleration
    322.  
    323.     def getDeceleration(self):
    324.         return self.deceleration
    325.  
    326.     def setHighLimit(self, highLimit):
    327.         self.highLimit = highLimit
    328.         return "OK"
    329.  
    330.     def getHighLimit(self):
    331.         return self.highLimit
    332.  
    333.     def setLowLimit(self, lowLimit):
    334.         self.lowLimit = lowLimit
    335.         return "OK"
    336.  
    337.     def getLowLimit(self):
    338.         return self.lowLimit
    339.  
    340.  
    341. # 以下是测试一个Axis实例的代码
    342. if __name__ == "__main__":
    343.     print("working")
    344.     axis = Axis(1)
    345.     print("Velocity:", axis.getVelocity())
    346.     print("BaseVelocity:",axis.getBaseVelocity())
    347.     print("Acceleratoin:", axis.getAcceleration())
    348.     print("High Limit:", axis.getHighLimit())
    349.     print("Low Limit", axis.getLowLimit())
    350.     print()
    351.     print("Start Move 1", axis.move(1000))
    352.     print()
    353.  
    354.     for i in range(10):
    355.         pos = axis.readPosition()
    356.         status = axis.readStatus()
    357.         print("pos: %s, status: %s"  % (pos, status))
    358.         time.sleep(0.5)
    359.     print("move stop\n")
    360.  
    361.  
    362.     print("lastPosition: " , axis.lastPosition)
    363.     print("currentPosition: ", axis.currentPosition)
    364.  
    365.     print("Start Move 2", axis.moveRelative(-1000))
    366.     for i in range(10):
    367.         pos = axis.readPosition()
    368.         status = axis.readStatus()
    369.         print("pos: %s, status: %s"  % (pos, status))
    370.         time.sleep(0.5)
    371.     print("move stop\n")
    372.     print("lastPosition: " , axis.lastPosition)
    373.     print("currentPosition: ", axis.currentPosition)

    3） 控制器的类：一个电机控制器

    1. #!/usr/bin/evn python3
    2. import axis
    3. import time
    4.  
    5. class Controller:
    6.     """
    7.         代表电机控制器的类
    8.     """
    9.     def __init__(self):
    10.         # 控制器中有8个轴
    11.         self.numAxes = 8
    12.         # 轴名称的列表
    13.         self.axisNameList = ['X', 'Y', 'Z','T', 'U', 'V', 'R','S']
    14.         # 轴数值编号的列表
    15.         self.axisNumberList = [str(x) for x in range(1, self.numAxes + 1)]
    16.         # 命令字典
    17.         self.commandDict = {3:{'MV': self.moveAxis,
    18.                                 'MR':self.moveRelative,
    19.                                 'JOG':self.jog,
    20.                                 'POS':self.setPosition,
    21.                                 'ACC':self.setAcceleration,
    22.                                 'VEL':self.setVelocity,
    23.                                 'BAS':self.setBaseVelocity,
    24.                                 'LL':self.setLowLimit,
    25.                                 'HL':self.setHighLimit},
    26.                             2:{'POS?':self.queryPosition,
    27.                                 'ST?':self.queryStatus,
    28.                                 'ACC?':self.queryAcceleration,
    29.                                 'VEL?':self.queryVelocity,
    30.                                 'LL?':self.queryLowLimit,
    31.                                 'HL?':self.queryHighLimit,
    32.                                 'AB':self.stopAxis}
    33.                             }
    34.         # 轴对象的字典
    35.         self.axisDict = {}
    36.         # 轴对象的列表
    37.         self.axisList = []
    38.         # 默认执行限位检查
    39.         self.enforceLimits = True
    40.  
    41.         for i in range(self.numAxes): #实例子化八个Axis对象，
    42.             # 追加到一个列表末尾
    43.             self.axisList.append(axis.Axis(i))
    44.             # 键值对：轴名称----axis对象索引号； 轴编号----Axis对象索引号
    45.             self.axisDict[self.axisNameList[i]] = i
    46.             self.axisDict[self.axisNumberList[i]] =i
    47.  
    48.         print(self.axisDict) # 打印字典
    49.         print(self.axisDict.keys()) # 打印字典的键
    50.  
    51.     def refinePos(self, inputPos):
    52.         # 把来自Axis对象的raw位置转换成一个合适输出的东西
    53.         # 返回一个int，由于控制器使用单位为计数
    54.         return round(inputPos)
    55.  
    56.     def handleCommand(self, command):
    57.         # 命令字符串格式： 轴名称/轴编号 命令名称 <命令参数> 或者 轴名称/轴编号 命令名称
    58.         print("In Controller  ", command)
    59.         if command == '':
    60.             retVal = None
    61.         else:
    62.             args = command.split(' ')
    63.             numArgs = len(args)   # 获取命令串中分隔出的参数数目
    64.  
    65.             print("split params:", args, "numArgs:", numArgs)
    66.             print("commandDict.keys()",  self.commandDict.keys())
    67.             print("axisDict.keys()", self.axisDict.keys())
    68.             print("2 parameters command", self.commandDict[2].keys())
    69.             print("3 parameters command", self.commandDict[3].keys())
    70.  
    71.             if numArgs not in self.commandDict.keys(): # 参数数目不为2或3， 不对
    72.                 retVal = "Argument error"
    73.             elif args[0] not in self.axisDict.keys():
    74.                 retVal = "Axis name error" # 给的轴名称/轴编号错误
    75.             else: #如果是3个字符串的参数，则格式如 X MV 400
    76.                 if args[1]  in self.commandDict[numArgs].keys(): # 命令名称出错
    77.                     if numArgs == 2:  # 轴 +  命令
    78.                         retVal = self.commandDict[numArgs][args[1]](args[0])
    79.                     elif numArgs == 3: # 轴 + 命令 + 命令参数
    80.                         print("command: %s %s %s" % (args[1], args[0], args[2]))
    81.                         retVal = self.commandDict[numArgs][args[1]](args[0], args[2])
    82.                     else:
    83.                         retVal = "Strange error"
    84.         print("retVal:", retVal)
    85.  
    86.         return retVal
    87.  
    88.     def queryPosition(self, axis):
    89.         # 由于控制器单位是计数，取整结果
    90.         return self.refinePos(self.axisList[self.axisDict[axis]].readPosition())
    91.  
    92.     def setPosition(self, axis, pos):
    93.         return self.axisList[self.axisDict[axis]].setPosition(int(pos))
    94.  
    95.     def queryStatus(self, axis):
    96.         return self.axisList[self.axisDict[axis]].readStatus()
    97.  
    98.     def moveAxis(self, axis, pos):
    99.         return self.axisList[self.axisDict[axis]].move(int(pos))
    100.  
    101.     def moveRelative(self, axis, pos):
    102.         return self.axisList[self.axisDict[axis]].moveRelative(int(pos))
    103.  
    104.     def jog(self, axis, velocity):
    105.             return self.axisList[self.axisDict[axis]].jog(float(velocity))
    106.  
    107.     def stopAxis(self, axis):
    108.             return self.axisList[self.axisDict[axis]].stop()
    109.  
    110.     def setVelocity(self, axis, velocity):
    111.             return self.axisList[self.axisDict[axis]].setVelocity(float(velocity))
    112.  
    113.     def queryVelocity(self, axis):
    114.             return self.axisList[self.axisDict[axis]].readVelocity()
    115.  
    116.     def setBaseVelocity(self, axis, velocity):
    117.             return self.axisList[self.axisDict[axis]].setBaseVelocity(float(velocity))
    118.  
    119.     def queryBaseVelocity(self, axis):
    120.             return self.axisList[self.axisDict[axis]].readBaseVelocity()
    121.  
    122.     def setAcceleration(self, axis, acceleration):
    123.             return self.axisList[self.axisDict[axis]].setAcceleration(float(acceleration))
    124.  
    125.     def queryAcceleration(self, axis):
    126.             return self.axisList[self.axisDict[axis]].readAcceleration()
    127.  
    128.     def queryHighLimit(self, axis):
    129.             return self.axisList[self.axisDict[axis]].readHighLimit()
    130.  
    131.     def setHighLimit(self, axis, highLimit):
    132.             return self.axisList[self.axisDict[axis]].setHighLimit(int(highLimit))
    133.  
    134.     def queryLowLimit(self, axis):
    135.             return self.axisList[self.axisDict[axis]].readLowLimit()
    136.  
    137.     def setLowLimit(self, axis, lowLimit):
    138.             return  self.axisList[self.axisDict[axis]].setLowLimit(int(lowLimit))
    139.  
    140.  
    141. # 此处是测试一个控制器实例的代码
    142. if __name__ == "__main__":
    143.     controller = Controller()
    144.     print("Test X axis:")
    145.     print(controller.queryStatus("X"))
    146.     print()
    147.     print(controller.moveAxis("X",1000))
    148.     for i in range(10):
    149.         time.sleep(0.5)
    150.         pos = controller.queryPosition("X")
    151.         status = controller.queryStatus("X")
    152.         print("pos: %s, status: %s" % (pos, status))
    153.  
    154.     print()
    155.     print(controller.moveAxis("X",0))
    156.     for i in range(10):
    157.         time.sleep(0.5)
    158.         pos = controller.queryPosition("X")
    159.         status = controller.queryStatus("X")
    160.         print("pos: %s, status: %s" % (pos, status))

    4） 服务器程序：为电机控制器提供网路服务

    服务器表现类似一个8轴控制器。
    默认轴值保持与半步模式的步进电机一致(每个分辨400步)。
    可以用名称(X, Y, Z, T, U, V, R, S)或者数值(1, 2, 3, 4, 5, 6, 7, 8)访问轴。
    控制器接受以计数单位的值。为了响应非查询命令，服务器返回一个"OK"。

    启动服务器：
    $ python3 server.py
    这将启动这个服务器，它默认在31337端口上监听。
    可以通过修改server.py中的DEFAULT_PORT更高这个端口号。

    命令参考：
    输入终止符: \r\n
    输出终止符: \r

    命令语法: [argument]
    命令：

    • axis MV                         # 绝对移动(计数)
    • axis MR                # 相对移动(计数)
    • axis  JOG                       # Jog (计数/s, 符号)
    • axis POS                      # 设置位置 (计数)
    • axis ACC               # 设置加速度(计数/s/s)
    • axis VEL                       # 设置速度 (计数/s)
    • axis BAS             # 设置基速度(计数/s)
    • axis AB                                        # 取消移动
    • axis POS?                                   # 查询位置(返回：计数)
    • axis ST?                                      # 查询状态(返回：整数)
    1.      状态位
    2.      方向：        0x1
    3.      结束移动：    0x2
    4.      移动中：    0x4
    5.      高限制：    0x8
    6.      低限位：    0x10
    7.      寻home：    0x20
    8.      home限位：    0x40
    9.      已经找到home：        0x80
    10.      错误：        0x100
    • axis ACC?                    # 查询加速度(返回：计数/s/s)
    • axis VEL?                    # 查询速度(返回：计数/s)
    • axis LL        # 设置低限位(计数)
    • axis HL       # 设置高限位(计数)
    • axis LL?                     # 查询低限位返回：计数)
    • axis HL?                    # 查询高限位返回：计数)
    1. #!/usr/bin/env python3
    2. import getopt
    3. import os
    4. import sys
    5. import asyncore
    6. import asynchat
    7. import socket
    8. import controller
    9.  
    10. DEFAULT_PORT = 6666
    11.  
    12. class ConnectionDispatcher(asyncore.dispatcher):
    13.     def __init__(self, port):
    14.         asyncore.dispatcher.__init__(self)
    15.         self.port = port
    16.         self.device = controller.Controller()
    17.         self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
    18.         self.set_reuse_addr()
    19.         self.bind(("", port))
    20.         self.listen(5)
    21.  
    22.     def handle_accept(self):
    23.         # client_info is a tuple with socket as the 1st element
    24.         client_info = self.accept()
    25.         ConnectionHandler(client_info[0], self.device)
    26.  
    27.  
    28. class ConnectionHandler(asynchat.async_chat):
    29.     ## regular expressions, if necessary, can go here
    30.  
    31.     def __init__(self, sock, device):
    32.         asynchat.async_chat.__init__(self, sock)
    33.         self.set_terminator(b"\r")
    34.         #
    35.         self.outputTerminator = "\r\n"
    36.         self.device = device
    37.         self.buffer = ""
    38.  
    39.     def collect_incoming_data(self, data):
    40.         self.buffer = self.buffer + data.decode()
    41.  
    42.     def found_terminator(self):
    43.         data = self.buffer
    44.         self.buffer = ""
    45.         self.handleClientRequest(data)
    46.  
    47.     def handleClientRequest(self, request):
    48.         request = request.strip()
    49.  
    50.         # 打印接收到的命令
    51.         print("command from client:",request)
    52.         response = self.device.handleCommand(request)
    53.  
    54.         if response != None:
    55.             self.sendClientResponse("{}".format(response))
    56.  
    57.         # 打印发送给客户端的命令：
    58.         print("comand sent to client:", response)
    59.         print("send finished!")
    60.  
    61.         return
    62.  
    63.     def sendClientResponse(self, response=""):
    64.         data = response + self.outputTerminator
    65.         self.push(data.encode())
    66. # 获取本程序名
    67. def getProgramName(args=None):
    68.     # 获取命令行参数列表, args[0]即是程序名
    69.     if args == None:
    70.         args = sys.argv
    71.     if len(args) == 0 or args[0] == "-c":
    72.         return "PROGRAM_NAME"
    73.     print(args)
    74.     return os.path.basename(args[0])
    75.  
    76. # 打印这个程序的使用方法
    77. def printUsage():
    78.     print("""\
    79. Usage: {} [-ph]
    80.             -p, --port=NUMBER   Listen on the specified port NUMBER for incoming
    81.                                 connections (default:{})
    82.             -h, --help          Print usage message and exit""".format(getProgramName(), DEFAULT_PORT)
    83.             )
    84.  
    85. # 解析命令行参数，并且返回一个端口号
    86. def parseCommandLineArgs(args):
    87.     # 指定长参数和短参数格式中的选项名称：-p  -help; --port= --help
    88.     # 解析后选项被放入一个元组列表 [('-p', port), ('--port', 'port'), ...]
    89.     # 参数后面带:或者=的选项，必须有选项参数
    90.     (options, extra) = getopt.getopt(args[1:], "p:h", ["port=", "help"])
    91.  
    92.     port = DEFAULT_PORT
    93.  
    94.     # 用于调试
    95.     #!print(options)
    96.     #!print(extra)
    97.     # 除选项及对应的选项参数外，还有其它参数
    98.     if len(extra) > 0:
    99.         print("Error: unexpected command-line argument \"{}\"".format(extra[0]))
    100.         printUsage()
    101.         sys.exit(1)
    102.  
    103.     for eachOptName, eachOptValue in options:
    104.         if eachOptName in ("-p", "--port"):
    105.             port = int(eachOptValue)
    106.         elif eachOptName in ("-h", "--help"):
    107.             printUsage()
    108.             sys.exit(0)
    109.  
    110.     return port
    111.  
    112. def main(args):
    113.     port = parseCommandLineArgs(args)
    114.     server = ConnectionDispatcher(port)
    115.     print("Use Port: ", port)
    116.     try:
    117.         asyncore.loop()
    118.     except KeyboardInterrupt:
    119.         print()
    120.         print("Shutting down the server...")
    121.         sys.exit(0)
    122.  
    123.  
    124.  
    125.  
    126. if __name__ == "__main__":
    127.      # 检测python版本
    128.     if sys.version_info < (3,0,0) and sys.version_info < (3,12,0):
    129.         sys.stderr.write("You need Python 3.0 or later (but less than 3.12) to run this script\n")
    130.         input("Press enter to quit... ")
    131.         sys.exit(1)
    132.  
    133.     # Try to run the server
    134.     try:
    135.             main(sys.argv)
    136.     except Exception as e:
    137.             if isinstance(e, SystemExit):
    138.                     raise e
    139.             else:
    140.                     print("Error: {}".format(e))
    141.                     sys.exit(1)

    4） 运行以上服务器代码，并且用客户端测试：

    客户端测试了MV，POS?，ST？三个命令：

    • MV：移动电机轴到指定位置。
    • POS?：查询电机轴当前处于的位置。
    • ST?：查询电机轴的状态。

    Python电机仿真程序用于练习EPICS电机控制器驱动程序(EPICS motor驱动程序实例_EPICS Technical的博客-CSDN博客)的编写。 

  • 相关阅读:
    猿人学第一题
    只用二十行代码，用Python实现获取网抑云榜单文件保存本地，非常简单...
    编程基础都要懂的计算机组成
    零距离揭秘绝地求生：玩家最关心的吃鸡要领和细节全攻略！
    软考76-上午题-【面向对象技术3-设计模式】-创建型设计模式01
    机器学习之增强学习DQN(Deep Q Network)
    【场景化解决方案】慧穗云开票，让钉钉与业务数据流转更灵活
    MySQL 索引
    Python每日一练-DAY01
    【LIN总线测试】——LIN主节点调度表测试
  • 原文地址：https://blog.csdn.net/yuyuyuliang00/article/details/132483050