From c0e3f7521aa54e715dd7e9b1304e2e7e7286ded7 Mon Sep 17 00:00:00 2001 From: Cole Deck Date: Fri, 21 Oct 2022 19:33:29 -0500 Subject: [PATCH] Add some stuff --- software/raspberry pi/maestro.py | 169 +++++++++++++++++++++++++ software/raspberry pi/requirements.txt | 1 + 2 files changed, 170 insertions(+) create mode 100644 software/raspberry pi/maestro.py create mode 100644 software/raspberry pi/requirements.txt diff --git a/software/raspberry pi/maestro.py b/software/raspberry pi/maestro.py new file mode 100644 index 0000000..b992779 --- /dev/null +++ b/software/raspberry pi/maestro.py @@ -0,0 +1,169 @@ +import serial +from sys import version_info + +PY2 = version_info[0] == 2 #Running Python 2.x? + +# +#--------------------------- +# Maestro Servo Controller +#--------------------------- +# +# Support for the Pololu Maestro line of servo controllers +# +# Steven Jacobs -- Aug 2013 +# https://github.com/FRC4564/Maestro/ +# +# These functions provide access to many of the Maestro's capabilities using the +# Pololu serial protocol +# +class Controller: + # When connected via USB, the Maestro creates two virtual serial ports + # /dev/ttyACM0 for commands and /dev/ttyACM1 for communications. + # Be sure the Maestro is configured for "USB Dual Port" serial mode. + # "USB Chained Mode" may work as well, but hasn't been tested. + # + # Pololu protocol allows for multiple Maestros to be connected to a single + # serial port. Each connected device is then indexed by number. + # This device number defaults to 0x0C (or 12 in decimal), which this module + # assumes. If two or more controllers are connected to different serial + # ports, or you are using a Windows OS, you can provide the tty port. For + # example, '/dev/ttyACM2' or for Windows, something like 'COM3'. + def __init__(self,ttyStr='/dev/ttyACM0',device=0x0c): + # Open the command port + self.usb = serial.Serial(ttyStr) + # Command lead-in and device number are sent for each Pololu serial command. + self.PololuCmd = chr(0xaa) + chr(device) + # Track target position for each servo. The function isMoving() will + # use the Target vs Current servo position to determine if movement is + # occuring. Upto 24 servos on a Maestro, (0-23). Targets start at 0. + self.Targets = [0] * 24 + # Servo minimum and maximum targets can be restricted to protect components. + self.Mins = [0] * 24 + self.Maxs = [0] * 24 + + # Cleanup by closing USB serial port + def close(self): + self.usb.close() + + # Send a Pololu command out the serial port + def sendCmd(self, cmd): + cmdStr = self.PololuCmd + cmd + if PY2: + self.usb.write(cmdStr) + else: + self.usb.write(bytes(cmdStr,'latin-1')) + + # Set channels min and max value range. Use this as a safety to protect + # from accidentally moving outside known safe parameters. A setting of 0 + # allows unrestricted movement. + # + # ***Note that the Maestro itself is configured to limit the range of servo travel + # which has precedence over these values. Use the Maestro Control Center to configure + # ranges that are saved to the controller. Use setRange for software controllable ranges. + def setRange(self, chan, min, max): + self.Mins[chan] = min + self.Maxs[chan] = max + + # Return Minimum channel range value + def getMin(self, chan): + return self.Mins[chan] + + # Return Maximum channel range value + def getMax(self, chan): + return self.Maxs[chan] + + # Set channel to a specified target value. Servo will begin moving based + # on Speed and Acceleration parameters previously set. + # Target values will be constrained within Min and Max range, if set. + # For servos, target represents the pulse width in of quarter-microseconds + # Servo center is at 1500 microseconds, or 6000 quarter-microseconds + # Typcially valid servo range is 3000 to 9000 quarter-microseconds + # If channel is configured for digital output, values < 6000 = Low ouput + def setTarget(self, chan, target): + # if Min is defined and Target is below, force to Min + if self.Mins[chan] > 0 and target < self.Mins[chan]: + target = self.Mins[chan] + # if Max is defined and Target is above, force to Max + if self.Maxs[chan] > 0 and target > self.Maxs[chan]: + target = self.Maxs[chan] + # + lsb = target & 0x7f #7 bits for least significant byte + msb = (target >> 7) & 0x7f #shift 7 and take next 7 bits for msb + cmd = chr(0x04) + chr(chan) + chr(lsb) + chr(msb) + self.sendCmd(cmd) + # Record Target value + self.Targets[chan] = target + + # Set speed of channel + # Speed is measured as 0.25microseconds/10milliseconds + # For the standard 1ms pulse width change to move a servo between extremes, a speed + # of 1 will take 1 minute, and a speed of 60 would take 1 second. + # Speed of 0 is unrestricted. + def setSpeed(self, chan, speed): + lsb = speed & 0x7f #7 bits for least significant byte + msb = (speed >> 7) & 0x7f #shift 7 and take next 7 bits for msb + cmd = chr(0x07) + chr(chan) + chr(lsb) + chr(msb) + self.sendCmd(cmd) + + # Set acceleration of channel + # This provide soft starts and finishes when servo moves to target position. + # Valid values are from 0 to 255. 0=unrestricted, 1 is slowest start. + # A value of 1 will take the servo about 3s to move between 1ms to 2ms range. + def setAccel(self, chan, accel): + lsb = accel & 0x7f #7 bits for least significant byte + msb = (accel >> 7) & 0x7f #shift 7 and take next 7 bits for msb + cmd = chr(0x09) + chr(chan) + chr(lsb) + chr(msb) + self.sendCmd(cmd) + + # Get the current position of the device on the specified channel + # The result is returned in a measure of quarter-microseconds, which mirrors + # the Target parameter of setTarget. + # This is not reading the true servo position, but the last target position sent + # to the servo. If the Speed is set to below the top speed of the servo, then + # the position result will align well with the acutal servo position, assuming + # it is not stalled or slowed. + def getPosition(self, chan): + cmd = chr(0x10) + chr(chan) + self.sendCmd(cmd) + lsb = ord(self.usb.read()) + msb = ord(self.usb.read()) + return (msb << 8) + lsb + + # Test to see if a servo has reached the set target position. This only provides + # useful results if the Speed parameter is set slower than the maximum speed of + # the servo. Servo range must be defined first using setRange. See setRange comment. + # + # ***Note if target position goes outside of Maestro's allowable range for the + # channel, then the target can never be reached, so it will appear to always be + # moving to the target. + def isMoving(self, chan): + if self.Targets[chan] > 0: + if self.getPosition(chan) != self.Targets[chan]: + return True + return False + + # Have all servo outputs reached their targets? This is useful only if Speed and/or + # Acceleration have been set on one or more of the channels. Returns True or False. + # Not available with Micro Maestro. + def getMovingState(self): + cmd = chr(0x13) + self.sendCmd(cmd) + if self.usb.read() == chr(0): + return False + else: + return True + + # Run a Maestro Script subroutine in the currently active script. Scripts can + # have multiple subroutines, which get numbered sequentially from 0 on up. Code your + # Maestro subroutine to either infinitely loop, or just end (return is not valid). + def runScriptSub(self, subNumber): + cmd = chr(0x27) + chr(subNumber) + # can pass a param with command 0x28 + # cmd = chr(0x28) + chr(subNumber) + chr(lsb) + chr(msb) + self.sendCmd(cmd) + + # Stop the current Maestro Script + def stopScript(self): + cmd = chr(0x24) + self.sendCmd(cmd) + diff --git a/software/raspberry pi/requirements.txt b/software/raspberry pi/requirements.txt new file mode 100644 index 0000000..f6c1a1f --- /dev/null +++ b/software/raspberry pi/requirements.txt @@ -0,0 +1 @@ +pyserial