__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 sampler

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 = sampler.sample_probe(7, 0, 0.15)
			  #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
	}