Sending GCODE directly from Python to UM3

[burhop 0]

For a research project, I need to stream gcode commands directly to a UM3 from python.  

 

1. I see Python is installed on my UM3 board.   Is there python module or existing code that lets me send the Gcode commands from there?

2. If I was to use the REST API, is there a way to do the same?  The seems to be too high level as I can only send a job, not individual commands.

 

Thanks for any suggestions!

[burhop 0]

Looking though the code, I see how the services work in .../griffin/main.py  

 

I also see the .../griffin/command_utils.py which has a command to send gcode using these service.  I though I was good so I tried this as a quick test:

 

from griffin import dbusif

def readFromFile(gcodefile):
    file = open(gcodefile, 'r')
    count=0
    for line in file:
        count += 1
        print("Line{}: {}".format(count, line.strip()))
        sendgcode(line)
    file.close()

def sendgcode(gcmd):
    p=dbusif.RemoteObject("printer")
    p.debugSendGCode(gcmd,timeout=120)
    #p.debugSendGcodenoWait()

def run():
    filename ="UM3E_cm-cube.gcode"
    print("Executing "+ filename)
    readFromFile(filename)

 

Unfortunately, there is no buffering/queueing in the printer.debugSendGCode() command.  All it did was cause the print head to have fits. 

 

Looking at a lower level, the Printer service uses a Controler object to  send the gcode.  It is has several functions.  SendRawGcode() is what is called by the printer service but I suspect I need it to call queueGcode()

  ## Send raw gcode to the printer. Note that this ignores any paused state.
    def sendRawGCode(self, gcode_line: str, wait=False) -> str:
        # track position in maintenance mode (assumes no other moves are currently in buffer.)
        return self.__gcode_processor.sendInstantRawGCode(gcode_line, self.getGCodeActiveHotend(), wait)

    ## Send raw gcode to the printer. Note that this ignores any paused state.
    # @param gcode_line: A string containing GCode that needs to be sent to the driver.
    # @return bool: True if the command was queued for sending as soon as possible. False if the buffers were full or the driver is not connected yet.
    def sendRawGCodeNoBlock(self, gcode_line: str) -> bool:
        # track position in maintenance mode (assumes no other moves are currently in buffer.
        return self.__gcode_processor.sendInstantRawGCodeNoBlock(gcode_line, self.getGCodeActiveHotend())

    ## This function is mainly used to queue gcode read from a gcode-file.
    # gcode queued in this way passes through the normal opinicus queue first and is then sent to marlin.
    # When the controller is in a paused state we will blocking wait, unless we are in an un-pausable procedure.
    # @param gcode_line the line of gcode to put in the queue
    def queueGCode(self, gcode_line: str) -> None:
        # only pause if no un-abortable(aka un-pausable) procedures are running.
        if self._abortable.is_set():
            self._running_event.wait()  # Block if the controller is paused

        self.__gcode_processor.processAndQueueGCode(gcode_line, self.getGCodeActiveHotend())

 

I hate to muck with the services code and brick my Ultimaker.   Any other thoughts on how to queue up the gcode?

 

 

 

 

[burhop 0]

What I thought was no buffering above was a mistake.  I was expecting the printer to pause to heat the build plate not realizing the UM3 doesn't just take a dump of GCODEs from a file.  Darn tricky, these Ultimaker engineers 😉

 

It looks like I have to figure out what to do about the header info:

 

Edited June 14 by burhop