__init__.py

# coding=utf-8
from __future__ import absolute_import

### (Don't forget to remove me)
# This is a basic skeleton for your plugin's __init__.py. You probably want to adjust the class name of your plugin
# as well as the plugin mixins it's subclassing from. This is really just a basic skeleton to get you started,
# defining your plugin as a template plugin, settings and asset plugin. Feel free to add or remove mixins
# as necessary.
#
# Take a look at the documentation on what other plugin mixins are available.

import subprocess
import time
import threading

import octoprint.plugin
import sys
import os

import gcodeparser as gcp

import flask

sampling = 0

class AutofdpPlugin(octoprint.plugin.SettingsPlugin,
                    octoprint.plugin.AssetPlugin,
                    octoprint.plugin.TemplatePlugin,
		    octoprint.plugin.StartupPlugin,
		    octoprint.plugin.EventHandlerPlugin,
		    octoprint.plugin.SimpleApiPlugin):
# ------------------------------------------------------------------------- #
#			   AUTO FDP CUSTOM FUNCTIONS			    #
#		Implement custom logic and driving code here		    #
# ------------------------------------------------------------------------- #

	def send_layer(self, layer):
		""" Sends a layer to the Octoprint client

		Parameters
		----------
		layer: gcodeparser.Layer
			Layer object to send to the client.
		"""
		data = dict(layer_svg=self.model.layers[layer].to_svg_inline(500,
			    self.model.max_x, self.model.max_y),
			    num_layers=len(self.model.layers),
			    curr_layer=self.curr_layer+1)
		self._plugin_manager.send_plugin_message(self._identifier, data)

	def process_gcode(self, payload):
		""" Process a gcode file

		Parameters
		----------
		payload: dict
			File selected payload from the on-event handler.
		"""
		num_pts = int(self._settings.get(['sampling_points']))
		spacing = int(self._settings.get(['sampling_freq']))
		method = self._settings.get(['sampling_algo'])
		self._logger.info('Processing GCODE with {} layer spacing, {} samples per layer and {}'.format(spacing, num_pts, method))

		full_path = os.path.expanduser("~/.octoprint/uploads/{}".format(payload['name']))
		self.model = gcp.parse_gcode(full_path,spacing, num_pts, method)
		self.num_layers = len(self.model.layers)
		self.curr_layer = 0;

	def sample_layer(self, current_layer):
		""" Sample a layer

		""" 
		layer = []
		next_height = []
		if current_layer != 0:
			layer = self.model.layers[current_layer-1]
			next_height = self.model.layers[current_layer].z_height
		else:
			return True

		def probe_process(self, layer, next_height):
			self._logger.info("Starting sampling run at Z={}".format(layer.z_height))
			result = True
			for point in zip(layer.sample_points['x'], layer.sample_points['y']):
				if self.probe_point(point[0], point[1], layer.z_height):
					self._logger.info("Good reading at X={}, Y={}".format(point[0], point[1]))
				else:
					self._logger.info("Bad reading at X={}, Y={}".format(point[0], point[1]))
					result = False
					break
			if result:
				self._printer.extrude(float(self._settings.get(['retraction'])), None, None)
				pass
			else:
				self._printer.pause_print()
#			self._printer.commands("G0 Z{}".format(next_height))
			self._printer.set_job_on_hold(False)

		if len(layer.sample_points['x']):
			if self._printer.set_job_on_hold(True):
				thread = threading.Thread(target=probe_process, args=[self,layer,next_height])
				thread.daemon = True
				thread.start()
			return None,
		else:
			return True

	def probe_point(self, x, y, z):
		"""
		Probe at selected x,y,z position. Move probe to point, extend probe, measure output, and report result
		"""
		self._logger.info('STARTING PROBE SEQUENCE')

		probe_x = x - self.offsets['x']
		probe_y = y - self.offsets['y']
		probe_z = z + self.offsets['z']

		if (probe_x < 0) or (probe_y < 0) or (probe_z < 0):
			self._logger.info('Sample point outside of printer bounds. Assuming good')
			return True

		# Go to the sample position, accounting for tool offset
		command = 'G0 F4329 X{} Y{}'.format(probe_x, probe_y)
		self._logger.info(command)
		self._printer.commands(command)
		self._printer.commands('G4 P0')
		self._printer.commands('M114')
		self.movement_lock = True
		while(self.movement_lock):
			pass

		reading = subprocess.run("./sample.sh", capture_output=True).stdout.decode("utf-8").strip() == '0'

		return reading

# ------------------------------------------------------------------------- #
#			 OCTOPRINT DEFINED FUNCTIONS			    #
#		Functions and event callbacks from octoprint		    #
# ------------------------------------------------------------------------- #

	def __init__(self):
		self.model = []
		self.curr_layer = 0
		self.num_layers = 0

		self.sample_lock = threading.Lock()

		self.movement_lock = False

		self.offsets = dict([('x', 0), ('y', 0), ('z', 0)])

		self.file_payload = []

	##~~ SimpleApiPlugin mixin
	def get_api_commands(self):
		return dict(
			change_layer=["inc"],
			test_command=[],
			reload_model=[]
		)

	def on_api_command(self, command, data):
		if command == "change_layer":
			if data["inc"] == "+1" and self.curr_layer < self.num_layers - 1:
				self.curr_layer += 1
				self.send_layer(self.curr_layer)
			if data["inc"] == "-1" and self.curr_layer > 0:
				self.curr_layer -= 1
				self.send_layer(self.curr_layer)
		elif command == "reload_model":
			if self.file_payload:
				self._logger.info('reloading model')
				self.on_event('FileSelected', self.file_payload)
			else:
				self._logger.info('no GCODE selected')
		elif command == "test_command":
			self._logger.info(data)

	##~~ EventHandlerPlugin mixin
	def on_event(self, event, payload):
		global sampling
		if event == 'FileSelected':
			self._logger.info('File selected: "{}" at path "{}"'.format(payload['name'], payload['path']))
			self.file_payload = payload
			self.process_gcode(payload)
			self._logger.info('GCODE Processed: {} layers'.format(self.num_layers))
			self.send_layer(0)
		if event == 'ZChange' and self._settings.get(['enable'])==True:
			data = self._printer.get_current_data()
			self._logger.info(data)
			currentZ = data['currentZ']
			try:
				current_layer = self.model.layer_heights.index(currentZ)
				self._logger.info('Current layer: {}'.format(current_layer))
				self._printer.extrude(float(self._settings.get(['retraction'])), None, None)
				self.sample_layer(current_layer)
				self._logger.info('Finished sampling run')
			except:
				self._logger.info('Not a valid layer at z = {}'.format(currentZ))
				return
		if event == 'PositionUpdate' and self._settings.get(['enable'])==True:
			if self.movement_lock == True:
				self.movement_lock = False

	##~~ TemplatePlugin mixin

	def get_template_configs(self):
		return [
			dict(type="tab", custom_bindings=True),
			dict(type="settings", custom_bindings=False)
		]

	def on_after_startup(self):
		self._logger.info(os.getcwd())
		self._logger.info("autoFDP starting, retrieving saved settings...")
		self.offsets['x'] = float(self._settings.get(['x_offset']))
		self.offsets['y'] = float(self._settings.get(['y_offset']))
		self.offsets['z'] = float(self._settings.get(['z_offset']))

	##~~ SettingsPlugin mixin

	def get_settings_defaults(self):
		return dict(
			# put your plugin's default settings here
			enable="False",
			x_offset="0",
			y_offset="0",
			z_offset="0",
			retraction="0",
			sampling_algo="Random sampling",
			sampling_freq="10",
			sampling_points="5"
		)

	def on_settings_save(self, data):
		octoprint.plugin.SettingsPlugin.on_settings_save(self, data)
		self._logger.info("SETTINGS HAVE BEEN CHANGED")
		self._logger.info(self._settings.get(['enable']))
		self._logger.info(self._settings.get(['sampling_algo']))
		#TODO: PROBE UPDATE CODE HERE
		self.offsets['x'] = float(self._settings.get(['x_offset']))
		self.offsets['y'] = float(self._settings.get(['y_offset']))
		self.offsets['z'] = float(self._settings.get(['z_offset']))

		self._logger.info(self._settings.get(['enable']) == "True")
		self._logger.info(self._settings.get(['enable']) == True)
	##~~ AssetPlugin mixin
	def get_assets(self):
		# Define your plugin's asset files to automatically include in the
		# core UI here.
		return dict(
			js=["js/autoFDP.js"],
			#css=["css/autoFDP.css"],
			#less=["less/autoFDP.less"]
		)

	##~~ Softwareupdate hook

	def get_update_information(self):
		# Define the configuration for your plugin to use with the Software Update
		# Plugin here. See https://docs.octoprint.org/en/master/bundledplugins/softwareupdate.html
		# for details.
		return dict(
			autoFDP=dict(
				displayName="Autofdp Plugin",
				displayVersion=self._plugin_version,

				# version check: github repository
				type="github_release",
				user="you",
				repo="OctoPrint-Autofdp",
				current=self._plugin_version,

				# update method: pip
				pip="https://github.com/you/OctoPrint-Autofdp/archive/{target_version}.zip"
			)
		)


# If you want your plugin to be registered within OctoPrint under a different name than what you defined in setup.py
# ("OctoPrint-PluginSkeleton"), you may define that here. Same goes for the other metadata derived from setup.py that
# can be overwritten via __plugin_xyz__ control properties. See the documentation for that.
__plugin_name__ = "AutoFDP Plugin"

# Starting with OctoPrint 1.4.0 OctoPrint will also support to run under Python 3 in addition to the deprecated
# Python 2. New plugins should make sure to run under both versions for now. Uncomment one of the following
# compatibility flags according to what Python versions your plugin supports!
#__plugin_pythoncompat__ = ">=2.7,<3" # only python 2
#__plugin_pythoncompat__ = ">=3,<4" # only python 3
__plugin_pythoncompat__ = ">=2.7,<4" # python 2 and 3

def __plugin_load__():
	global __plugin_implementation__
	__plugin_implementation__ = AutofdpPlugin()

	global __plugin_hooks__
	__plugin_hooks__ = {
		"octoprint.plugin.softwareupdate.check_config": __plugin_implementation__.get_update_information
	}