def sendEnableMotors(portName, Res):
if (Res < 0):
Res = 0
if (Res > 5):
Res = 5
if (portName is not None):
ebb_serial.command(portName, 'EM,' + str(Res) + ',' + str(Res) + '\r')
def doXYMove( portName, deltaX, deltaY, duration ): # Move X/Y axes as: "SM,<move_duration>,<axis1>,<axis2><CR>" # Typically, this is wired up such that axis 1 is the Y axis and axis 2 is the X axis of motion. # On EggBot, Axis 1 is the "pen" motor, and Axis 2 is the "egg" motor. if (portName is not None): strOutput = ','.join( ['SM', str( duration ), str( deltaY ), str( deltaX )] ) + '\r' ebb_serial.command( portName, strOutput)
def ServoSetup( self ): # Pen position units range from 0% to 100%, which correspond to # a timing range of 6000 - 30000 in units of 1/(12 MHz). # 1% corresponds to 20 us, or 240 units of 1/(12 MHz). intTemp = 240 * ( self.options.penUpPosition + 25 ) ebb_serial.command( self.serialPort, 'SC,4,' + str( intTemp ) + '\r' ) intTemp = 240 * ( self.options.penDownPosition + 25 ) ebb_serial.command( self.serialPort, 'SC,5,' + str( intTemp ) + '\r' ) #AS intTemp = self.options.invertServo & 1 # just 0 or 1 to NEW SC 99 ebb_serial.command( self.serialPort, 'SC,99,' + str( intTemp ) + '\r' ) # Servo speed units are in units of %/second, referring to the # percentages above. The EBB takes speeds in units of 1/(12 MHz) steps # per 21 ms. Scaling as above, 1% in 1 second corresponds to # 240 steps/s, which corresponds to 0.240 steps/ms, which corresponds # to 5.04 steps/21 ms. Rounding this to 5 steps/21 ms is correct # to within 1 %. intTemp = 5 * self.options.ServoUpSpeed ebb_serial.command( self.serialPort, 'SC,11,' + str( intTemp ) + '\r' ) intTemp = 5 * self.options.ServoDownSpeed ebb_serial.command( self.serialPort, 'SC,12,' + str( intTemp ) + '\r' )
def sendEnableMotors( portName, Res ): if (Res < 0): Res = 0 if (Res > 5): Res = 5 if (portName is not None): ebb_serial.command( portName, 'EM,' + str(Res) + ',' + str(Res) + '\r' )
def sendEnableMotors(port_name, res):
if res < 0:
res = 0
if res > 5:
res = 5
if port_name is not None:
ebb_serial.command(port_name, 'EM,{0},{0}\r'.format(res))
def doXYMove(port_name, delta_x, delta_y, duration):
# Move X/Y axes as: "SM,<move_duration>,<axis1>,<axis2><CR>"
# Typically, this is wired up such that axis 1 is the Y axis and axis 2 is the X axis of motion.
# On EggBot, Axis 1 is the "pen" motor, and Axis 2 is the "egg" motor.
if port_name is not None:
str_output = 'SM,{0},{1},{2}\r'.format(duration,delta_y,delta_x)
ebb_serial.command(port_name, str_output)
def doABMove(portName, deltaA, deltaB, duration):
# Issue command to move A/B axes as: "XM,<move_duration>,<axisA>,<axisB><CR>"
# Then, <Axis1> moves by <AxisA> + <AxisB>, and <Axis2> as <AxisA> - <AxisB>
if (portName is not None):
strOutput = ','.join(
['XM', str(duration),
str(deltaA), str(deltaB)]) + '\r'
ebb_serial.command(portName, strOutput)
def doXYAccelMove(port_name, delta_x, delta_y, v_initial, v_final):
# Move X/Y axes as: "AM,<initial_velocity>,<final_velocity>,<axis1>,<axis2><CR>"
# Typically, this is wired up such that axis 1 is the Y axis and axis 2 is the X axis of motion.
# On EggBot, Axis 1 is the "pen" motor, and Axis 2 is the "egg" motor.
# Note that minimum move duration is 5 ms.
# Important: Requires firmware version 2.4 or higher.
if port_name is not None:
str_output = 'AM,{0},{1},{2},{3}\r'.format(v_initial, v_final, delta_x, delta_y)
ebb_serial.command(port_name, str_output)
def doXYAccelMove( portName, deltaX, deltaY, vInitial, vFinal ): # Move X/Y axes as: "AM,<initial_velocity>,<final_velocity>,<axis1>,<axis2><CR>" # Typically, this is wired up such that axis 1 is the Y axis and axis 2 is the X axis of motion. # On EggBot, Axis 1 is the "pen" motor, and Axis 2 is the "egg" motor. # Note that minimum move duration is 5 ms. # Important: Requires firmware version 2.4 or higher. if (portName is not None): strOutput = ','.join( ['AM', str( vInitial ), str( vFinal ), str( deltaX ), str( deltaY )] ) + '\r' ebb_serial.command( portName, strOutput)
def sendEnableMotors(self, Res=1):
self.getReady()
if (Res < 0):
Res = 0
if (Res > 5):
Res = 5
if (self.port is not None):
ebb_serial.command(self.port,
'EM,' + str(Res) + ',' + str(Res) + '\r')
def doLowLevelMove(port_name, ri1, steps1, delta_r1, ri2, steps2, delta_r2):
# A "pre-computed" XY movement of the form
# "LM,RateTerm1,AxisSteps1,DeltaR1,RateTerm2,AxisSteps2,DeltaR2<CR>"
# See http://evil-mad.github.io/EggBot/ebb.html#LM for documentation.
# Important: Requires firmware version 2.5.1 or higher.
if port_name is not None:
if ((ri1 == 0 and delta_r1 == 0) or steps1 == 0) and ((ri2 == 0 and delta_r2 == 0) or steps2 == 0):
return
str_output = 'LM,{0},{1},{2},{3},{4},{5}\r'.format(ri1, steps1, delta_r1, ri2, steps2, delta_r2)
ebb_serial.command(port_name, str_output)
def doTimedPause(port_name, n_pause):
if port_name is not None:
while n_pause > 0:
if n_pause > 750:
td = 750
else:
td = n_pause
if td < 1:
td = 1 # don't allow zero-time moves
ebb_serial.command(port_name, 'SM,{0},0,0\r'.format(td))
n_pause -= td
def doTimedPause( portName, nPause ): if (portName is not None): while ( nPause > 0 ): if ( nPause > 750 ): td = int( 750 ) else: td = nPause if ( td < 1 ): td = int( 1 ) # don't allow zero-time moves ebb_serial.command( portName, 'SM,' + str( td ) + ',0,0\r') nPause -= td
def doTimedPause(portName, nPause):
if (portName is not None):
while (nPause > 0):
if (nPause > 750):
td = int(750)
else:
td = nPause
if (td < 1):
td = int(1) # don't allow zero-time moves
ebb_serial.command(portName, 'SM,' + str(td) + ',0,0\r')
nPause -= td
def doTimedPause(self, nPause):
self.getReady()
if (self.port is not None):
while (nPause > 0):
if (nPause > 750):
td = int(750)
else:
td = nPause
if (td < 1):
td = int(1) # don't allow zero-time moves
ebb_serial.command(self.port, 'SM,' + str(td) + ',0,0\r')
nPause -= td
def configServo(self, value1, value2):
if ((0 < value1 < 255) == False):
print("value1 is invalid ")
return
if ((0 < value2 < 65535) == False):
print("value2 is invalid ")
return
self.getReady()
if (self.port is not None):
strOutput = ','.join(['SC', str(value1), str(value2)]) + '\r'
ebb_serial.command(self.port, strOutput)
def PBOutConfig(port_name, pin, state):
# Enable an I/O pin. Pin: {0,1,2, or 3}. State: {0 or 1}.
# Note that B0 is used as an alternate pause button input.
# Note that B1 is used as the pen-lift servo motor output.
# Note that B3 is used as the EggBot engraver output.
# For use with a laser (or similar implement), pin 3 is recommended
if port_name is not None:
# Set initial Bx pin value, high or low:
str_output = 'PO,B,{0},{1}\r'.format(pin, state)
ebb_serial.command(port_name, str_output)
# Configure I/O pin Bx as an output
str_output = 'PD,B,{0},0\r'.format(pin)
ebb_serial.command(port_name, str_output)
def doABMove(self, deltaA, deltaB, duration=500):
#print("delta : %s, %s"%(deltaA, deltaB))
#check the speed limit .
timeA = abs(int(float(deltaA + deltaB) / float(self.speedlimit)))
timeB = abs(int(float(deltaA - deltaB) / float(self.speedlimit)))
timemax = max(timeA, timeB)
if timemax == 0:
return
# Issue command to move A/B axes as: "XM,<move_duration>,<axisA>,<axisB><CR>"
# Then, <Axis1> moves by <AxisA> + <AxisB>, and <Axis2> as <AxisA> - <AxisB>
if (self.port is not None):
strOutput = ','.join(
['XM', str(timemax),
str(deltaA), str(deltaB)]) + '\r'
self.getReady()
ebb_serial.command(self.port, strOutput)
def doLowLevelMove(portName, Ri1, Steps1, DeltaR1, Ri2, Steps2, DeltaR2):
# A "pre-computed" XY movement of the form
# "LM,RateTerm1,AxisSteps1,DeltaR1,RateTerm2,AxisSteps2,DeltaR2<CR>"
# See http://evil-mad.github.io/EggBot/ebb.html#LM for documentation.
# Important: Requires firmware version 2.5.1 or higher.
if (portName is not None):
if ((((Ri1 == 0) and (DeltaR1 == 0)) or (Steps1 == 0))
and (((Ri2 == 0) and (DeltaR2 == 0)) or (Steps2 == 0))):
return
strOutput = ','.join([
'LM',
str(Ri1),
str(Steps1),
str(DeltaR1),
str(Ri2),
str(Steps2),
str(DeltaR2)
]) + '\r'
ebb_serial.command(portName, strOutput)
def ServoSetup( self ): # Pen position units range from 0% to 100%, which correspond to # a timing range of 6000 - 30000 in units of 1/(12 MHz). # 1% corresponds to 20 us, or 240 units of 1/(12 MHz). intTemp = 240 * ( self.options.penUpPosition + 25 ) ebb_serial.command( self.serialPort, 'SC,4,' + str( intTemp ) + '\r' ) intTemp = 240 * ( self.options.penDownPosition + 25 ) ebb_serial.command( self.serialPort, 'SC,5,' + str( intTemp ) + '\r' ) # Servo speed units are in units of %/second, referring to the # percentages above. The EBB takes speeds in units of 1/(12 MHz) steps # per 21 ms. Scaling as above, 1% in 1 second corresponds to # 240 steps/s, which corresponds to 0.240 steps/ms, which corresponds # to 5.04 steps/21 ms. Rounding this to 5 steps/21 ms is correct # to within 1 %. intTemp = 5 * self.options.ServoUpSpeed ebb_serial.command( self.serialPort, 'SC,11,' + str( intTemp ) + '\r' ) intTemp = 5 * self.options.ServoDownSpeed ebb_serial.command( self.serialPort, 'SC,12,' + str( intTemp ) + '\r' )
def setPenDownPos(port_name, servo_max):
if port_name is not None:
ebb_serial.command(port_name, 'SC,5,{0}\r'.format(servo_max))
def TogglePen(port_name):
if port_name is not None:
ebb_serial.command(port_name, 'TP\r')
def PBOutValue(port_name, pin, state):
# Set state of the I/O pin. Pin: {0,1,2, or 3}. State: {0 or 1}.
# Set the pin as an output with OutputPinBConfigure before using this.
if port_name is not None:
str_output = 'PO,B,{0},{1}\r'.format(pin, state)
ebb_serial.command(port_name, str_output)
def engraverOff( self ): # Note: we don't bother checking self.engraverIsOn -- turn it off regardless # Reason being that we may not know the true hardware state if self.options.engraving: ebb_serial.command( self.serialPort, 'PO,B,3,0\r') self.engraverIsOn = False
def sendPenUp(port_name, pen_delay):
if port_name is not None:
str_output = 'SP,1,{0}\r'.format(pen_delay)
ebb_serial.command(port_name, str_output)
def doABMove( portName, deltaA, deltaB, duration ): # Issue command to move A/B axes as: "XM,<move_duration>,<axisA>,<axisB><CR>" # Then, <Axis1> moves by <AxisA> + <AxisB>, and <Axis2> as <AxisA> - <AxisB> if (portName is not None): strOutput = ','.join( ['XM', str( duration ), str( deltaA ), str( deltaB )] ) + '\r' ebb_serial.command( portName, strOutput)
def setPenUpRate(port_name, pen_up_rate):
if port_name is not None:
ebb_serial.command(port_name, 'SC,11,{0}\r'.format(pen_up_rate))
def doABMove(port_name, delta_a, delta_b, duration):
# Issue command to move A/B axes as: "XM,<move_duration>,<axisA>,<axisB><CR>"
# Then, <Axis1> moves by <AxisA> + <AxisB>, and <Axis2> as <AxisA> - <AxisB>
if port_name is not None:
str_output = 'XM,{0},{1},{2}\r'.format(duration, delta_a, delta_b)
ebb_serial.command(port_name, str_output)
def engraverOffManual( self ): # Turn off engraver, whether or not the engraver is enabled. # This is only called by manual commands like "engraver off" and "motors off." ebb_serial.command( self.serialPort, 'PO,B,3,0\r') self.engraverIsOn = False
def setPenDownRate(port_name, pen_down_rate):
if port_name is not None:
ebb_serial.command(port_name, 'SC,12,{0}\r'.format(pen_down_rate))
def sendPenUp(self):
if (self.port is not None):
strOutput = 'SP,0' + '\r'
ebb_serial.command(self.port, strOutput)
time.sleep(self.sleeptime_pen)
def sendPenDown( portName, PenDelay ): if (portName is not None): ebb_serial.command( portName, 'SP,0\r') if (PenDelay > 0): doTimedPause( portName,PenDelay)
def plotLineAndTime( self ):
'''
Send commands out the com port as a line segment (dx, dy) and a time (ms) the segment
should take to implement
'''
if self.bStopped:
return
if ( self.fPrevX is None ):
return
nDeltaX = int( self.fX ) - int( self.fPrevX )
nDeltaY = int( self.fY ) - int( self.fPrevY )
if self.bPenIsUp:
self.fSpeed = self.options.penUpSpeed
if ( self.options.wraparound ):
if ( nDeltaX > self.halfWrapSteps ):
while ( nDeltaX > self.halfWrapSteps ):
nDeltaX -= self.wrapSteps
elif ( nDeltaX < -1 * self.halfWrapSteps ):
while ( nDeltaX < -1 * self.halfWrapSteps ):
nDeltaX += self.wrapSteps
else:
self.fSpeed = self.options.penDownSpeed
if ( plot_utils.distance( nDeltaX, nDeltaY ) > 0 ):
self.nodeCount += 1
if self.resumeMode:
if ( self.nodeCount > self.nodeTarget ):
self.resumeMode = False
if ( not self.virtualPenIsUp ):
self.penDown()
self.fSpeed = self.options.penDownSpeed
nTime = int( math.ceil( 1000 / self.fSpeed * plot_utils.distance( nDeltaX, nDeltaY ) ) )
while ( ( abs( nDeltaX ) > 0 ) or ( abs( nDeltaY ) > 0 ) ):
if ( nTime > 750 ):
xd = int( round( ( 750.0 * nDeltaX ) / nTime ) )
yd = int( round( ( 750.0 * nDeltaY ) / nTime ) )
td = int( 750 )
else:
xd = nDeltaX
yd = nDeltaY
td = nTime
if ( td < 1 ):
td = 1 # don't allow zero-time moves.
if ( not self.resumeMode ):
if ( self.options.revPenMotor ):
yd2 = yd
else:
yd2 = -yd
if ( self.options.revEggMotor ):
xd2 = -xd
else:
xd2 = xd
strOutput = ','.join( ['SM', str( td ), str( yd2 ), str( xd2 )] ) + '\r'
self.svgTotalDeltaX += xd
self.svgTotalDeltaY += yd
ebb_serial.command( self.serialPort, strOutput )
nDeltaX -= xd
nDeltaY -= yd
nTime -= td
#self.doCommand('NI\r') #Increment node counter on EBB
strButton = ebb_motion.QueryPRGButton(self.serialPort) #Query if button pressed
if strButton[0] == '0':
pass #button not pressed
else:
self.svgNodeCount = self.nodeCount;
inkex.errormsg( 'Plot paused by button press after node number ' + str( self.nodeCount ) + '.' )
inkex.errormsg( 'Use the "resume" feature to continue.' )
#self.penUp() # Should be redundant...
self.engraverOff()
self.bStopped = True
return
def manualCommand( self ): """Execute commands from the "manual" tab""" if self.options.manualType == "none": return if self.serialPort is None: return if self.options.manualType == "raise-pen": self.ServoSetupWrapper() self.penUp() elif self.options.manualType == "lower-pen": self.ServoSetupWrapper() self.penDown() elif self.options.manualType == "enable-motors": ebb_motion.sendEnableMotors(self.serialPort, 1) # 16X microstepping elif self.options.manualType == "disable-motors": self.sendDisableMotors() elif self.options.manualType == "version-check": strVersion = ebb_serial.query( self.serialPort, 'v\r' ) inkex.errormsg( 'I asked the EBB for its version info, and it replied:\n ' + strVersion ) elif self.options.manualType == "enable-engraver": if ( not self.options.engraving ): inkex.errormsg( gettext.gettext( "The engraver option is disabled. " + \ " Please enable it first from the \"Options\" tab." ) ) else: self.engraverOn() elif self.options.manualType == 'disable-engraver': self.engraverOffManual() #Force engraver off, even if it is not enabled. else: # self.options.manualType is "walk-egg-motor" or "walk-pen-motor": if self.options.manualType == "walk-egg-motor": nDeltaX = self.options.WalkDistance nDeltaY = 0 elif self.options.manualType == "walk-pen-motor": nDeltaY = self.options.WalkDistance nDeltaX = 0 else: return ebb_motion.sendEnableMotors(self.serialPort, 1) # 16X microstepping #Query pen position: 1 up, 0 down (followed by OK) strVersion = ebb_serial.query( self.serialPort, 'QP\r' ) if strVersion[0] == '0': self.fSpeed = self.options.penDownSpeed if strVersion[0] == '1': self.fSpeed = self.options.penUpSpeed if ( self.options.revPenMotor ): nDeltaY = -1 * nDeltaY if ( self.options.revEggMotor ): nDeltaX = -1 * nDeltaX nTime = 10000.00 / self.fSpeed * plot_utils.distance( nDeltaX, nDeltaY ) nTime = int( math.ceil(nTime / 10.0)) strOutput = ','.join( ['SM', str( nTime ), str( nDeltaY ), str( nDeltaX )] ) + '\r' #inkex.errormsg( 'strOutput: ' + strOutput ) ebb_serial.command( self.serialPort, strOutput )
def engraverOn( self ): if self.options.engraving and ( not self.engraverIsOn ): self.engraverIsOn = True ebb_serial.command( self.serialPort, 'PD,B,3,0\r') #Added 6/6/2011, necessary. ebb_serial.command( self.serialPort, 'PO,B,3,1\r' )
def setPenUpPos(port_name, servo_min):
if port_name is not None:
ebb_serial.command(port_name, 'SC,4,{0}\r'.format(servo_min))
def getReset(self):
return ebb_serial.command(self.port, "R\r")
def setEBBLV(port_name, ebb_lv):
# Set the EBB "Layer" Variable, an 8-bit number we can read and write.
# (Unrelated to our plot layers; name is an historical artifact.)
if port_name is not None:
ebb_serial.command(port_name, 'SL,{0}\r'.format(ebb_lv))
def sendPenDown(port_name, pen_delay, pen_pin=1):
if port_name is not None:
str_output = 'SP,0,{0},{1}\r'.format(pen_delay, pen_pin)
ebb_serial.command(port_name, str_output)
def sendDisableMotors( portName ): if (portName is not None): ebb_serial.command( portName, 'EM,0,0\r')
def sendDisableMotors(port_name):
if port_name is not None:
ebb_serial.command(port_name, 'EM,0,0\r')
def sendPenDown( portName, PenDelay ): if (portName is not None): strOutput = ','.join( ['SP,0', str( PenDelay )] ) + '\r' ebb_serial.command( portName, strOutput)
def TogglePen( portName ): if (portName is not None): ebb_serial.command( portName, 'TP\r')
