Blame | Last modification | View Log | RSS feed
/*** Marlin 3D Printer Firmware* Copyright (C) 2016, 2017 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]** Based on Sprinter and grbl.* Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm** This program is free software: you can redistribute it and/or modify* it under the terms of the GNU General Public License as published by* the Free Software Foundation, either version 3 of the License, or* (at your option) any later version.** This program is distributed in the hope that it will be useful,* but WITHOUT ANY WARRANTY; without even the implied warranty of* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the* GNU General Public License for more details.** You should have received a copy of the GNU General Public License* along with this program. If not, see <http://www.gnu.org/licenses/>.**/#ifndef I2CPOSENC_H#define I2CPOSENC_H#include "MarlinConfig.h"#if ENABLED(I2C_POSITION_ENCODERS)#include "enum.h"#include "macros.h"#include "types.h"#include <Wire.h>//=========== Advanced / Less-Common Encoder Configuration Settings ==========#define I2CPE_EC_THRESH_PROPORTIONAL // if enabled adjusts the error correction threshold// proportional to the current speed of the axis allows// for very small error margin at low speeds without// stuttering due to reading latency at high speeds#define I2CPE_DEBUG // enable encoder-related debug serial echos#define I2CPE_REBOOT_TIME 5000 // time we wait for an encoder module to reboot// after changing address.#define I2CPE_MAG_SIG_GOOD 0#define I2CPE_MAG_SIG_MID 1#define I2CPE_MAG_SIG_BAD 2#define I2CPE_MAG_SIG_NF 255#define I2CPE_REQ_REPORT 0#define I2CPE_RESET_COUNT 1#define I2CPE_SET_ADDR 2#define I2CPE_SET_REPORT_MODE 3#define I2CPE_CLEAR_EEPROM 4#define I2CPE_LED_PAR_MODE 10#define I2CPE_LED_PAR_BRT 11#define I2CPE_LED_PAR_RATE 14#define I2CPE_REPORT_DISTANCE 0#define I2CPE_REPORT_STRENGTH 1#define I2CPE_REPORT_VERSION 2// Default I2C addresses#define I2CPE_PRESET_ADDR_X 30#define I2CPE_PRESET_ADDR_Y 31#define I2CPE_PRESET_ADDR_Z 32#define I2CPE_PRESET_ADDR_E 33#define I2CPE_DEF_AXIS X_AXIS#define I2CPE_DEF_ADDR I2CPE_PRESET_ADDR_X// Error event counter; tracks how many times there is an error exceeding a certain threshold#define I2CPE_ERR_CNT_THRESH 3.00#define I2CPE_ERR_CNT_DEBOUNCE_MS 2000#if ENABLED(I2CPE_ERR_ROLLING_AVERAGE)#define I2CPE_ERR_ARRAY_SIZE 32#define I2CPE_ERR_PRST_ARRAY_SIZE 10#endif// Error Correction Methods#define I2CPE_ECM_NONE 0#define I2CPE_ECM_MICROSTEP 1#define I2CPE_ECM_PLANNER 2#define I2CPE_ECM_STALLDETECT 3// Encoder types#define I2CPE_ENC_TYPE_ROTARY 0#define I2CPE_ENC_TYPE_LINEAR 1// Parser#define I2CPE_PARSE_ERR 1#define I2CPE_PARSE_OK 0#define LOOP_PE(VAR) LOOP_L_N(VAR, I2CPE_ENCODER_CNT)#define CHECK_IDX() do{ if (!WITHIN(idx, 0, I2CPE_ENCODER_CNT - 1)) return; }while(0)typedef union {volatile int32_t val = 0;uint8_t bval[4];} i2cLong;class I2CPositionEncoder {private:AxisEnum encoderAxis = I2CPE_DEF_AXIS;uint8_t i2cAddress = I2CPE_DEF_ADDR,ecMethod = I2CPE_DEF_EC_METHOD,type = I2CPE_DEF_TYPE,H = I2CPE_MAG_SIG_NF; // Magnetic field strengthint encoderTicksPerUnit = I2CPE_DEF_ENC_TICKS_UNIT,stepperTicks = I2CPE_DEF_TICKS_REV,errorCount = 0,errorPrev = 0;float ecThreshold = I2CPE_DEF_EC_THRESH;bool homed = false,trusted = false,initialised = false,active = false,invert = false,ec = true;int32_t zeroOffset = 0,lastPosition = 0,position;millis_t lastPositionTime = 0,nextErrorCountTime = 0,lastErrorTime;#if ENABLED(I2CPE_ERR_ROLLING_AVERAGE)uint8_t errIdx = 0, errPrstIdx = 0;int err[I2CPE_ERR_ARRAY_SIZE] = { 0 },errPrst[I2CPE_ERR_PRST_ARRAY_SIZE] = { 0 };#endifpublic:void init(const uint8_t address, const AxisEnum axis);void reset();void update();void set_homed();int32_t get_raw_count();FORCE_INLINE float mm_from_count(const int32_t count) {switch (type) {default: return -1;case I2CPE_ENC_TYPE_LINEAR:return count / encoderTicksPerUnit;case I2CPE_ENC_TYPE_ROTARY:return (count * stepperTicks) / (encoderTicksPerUnit * planner.axis_steps_per_mm[encoderAxis]);}}FORCE_INLINE float get_position_mm() { return mm_from_count(get_position()); }FORCE_INLINE int32_t get_position() { return get_raw_count() - zeroOffset; }int32_t get_axis_error_steps(const bool report);float get_axis_error_mm(const bool report);void calibrate_steps_mm(const uint8_t iter);bool passes_test(const bool report);bool test_axis(void);FORCE_INLINE int get_error_count(void) { return errorCount; }FORCE_INLINE void set_error_count(const int newCount) { errorCount = newCount; }FORCE_INLINE uint8_t get_address() { return i2cAddress; }FORCE_INLINE void set_address(const uint8_t addr) { i2cAddress = addr; }FORCE_INLINE bool get_active(void) { return active; }FORCE_INLINE void set_active(const bool a) { active = a; }FORCE_INLINE void set_inverted(const bool i) { invert = i; }FORCE_INLINE AxisEnum get_axis() { return encoderAxis; }FORCE_INLINE bool get_ec_enabled() { return ec; }FORCE_INLINE void set_ec_enabled(const bool enabled) { ec = enabled; }FORCE_INLINE uint8_t get_ec_method() { return ecMethod; }FORCE_INLINE void set_ec_method(const byte method) { ecMethod = method; }FORCE_INLINE float get_ec_threshold() { return ecThreshold; }FORCE_INLINE void set_ec_threshold(const float newThreshold) { ecThreshold = newThreshold; }FORCE_INLINE int get_encoder_ticks_mm() {switch (type) {default: return 0;case I2CPE_ENC_TYPE_LINEAR:return encoderTicksPerUnit;case I2CPE_ENC_TYPE_ROTARY:return (int)((encoderTicksPerUnit / stepperTicks) * planner.axis_steps_per_mm[encoderAxis]);}}FORCE_INLINE int get_ticks_unit() { return encoderTicksPerUnit; }FORCE_INLINE void set_ticks_unit(const int ticks) { encoderTicksPerUnit = ticks; }FORCE_INLINE uint8_t get_type() { return type; }FORCE_INLINE void set_type(const byte newType) { type = newType; }FORCE_INLINE int get_stepper_ticks() { return stepperTicks; }FORCE_INLINE void set_stepper_ticks(const int ticks) { stepperTicks = ticks; }};class I2CPositionEncodersMgr {private:static bool I2CPE_anyaxis;static uint8_t I2CPE_addr, I2CPE_idx;public:static void init(void);// consider only updating one endoder per call / tick if encoders become too time intensivestatic void update(void) { LOOP_PE(i) encoders[i].update(); }static void homed(const AxisEnum axis) {LOOP_PE(i)if (encoders[i].get_axis() == axis) encoders[i].set_homed();}static void report_position(const int8_t idx, const bool units, const bool noOffset);static void report_status(const int8_t idx) {CHECK_IDX();SERIAL_ECHOPAIR("Encoder ",idx);SERIAL_ECHOPGM(": ");encoders[idx].get_raw_count();encoders[idx].passes_test(true);}static void report_error(const int8_t idx) {CHECK_IDX();encoders[idx].get_axis_error_steps(true);}static void test_axis(const int8_t idx) {CHECK_IDX();encoders[idx].test_axis();}static void calibrate_steps_mm(const int8_t idx, const int iterations) {CHECK_IDX();encoders[idx].calibrate_steps_mm(iterations);}static void change_module_address(const uint8_t oldaddr, const uint8_t newaddr);static void report_module_firmware(const uint8_t address);static void report_error_count(const int8_t idx, const AxisEnum axis) {CHECK_IDX();SERIAL_ECHOPAIR("Error count on ", axis_codes[axis]);SERIAL_ECHOLNPAIR(" axis is ", encoders[idx].get_error_count());}static void reset_error_count(const int8_t idx, const AxisEnum axis) {CHECK_IDX();encoders[idx].set_error_count(0);SERIAL_ECHOPAIR("Error count on ", axis_codes[axis]);SERIAL_ECHOLNPGM(" axis has been reset.");}static void enable_ec(const int8_t idx, const bool enabled, const AxisEnum axis) {CHECK_IDX();encoders[idx].set_ec_enabled(enabled);SERIAL_ECHOPAIR("Error correction on ", axis_codes[axis]);SERIAL_ECHOPGM(" axis is ");serialprintPGM(encoders[idx].get_ec_enabled() ? PSTR("en") : PSTR("dis"));SERIAL_ECHOLNPGM("abled.");}static void set_ec_threshold(const int8_t idx, const float newThreshold, const AxisEnum axis) {CHECK_IDX();encoders[idx].set_ec_threshold(newThreshold);SERIAL_ECHOPAIR("Error correct threshold for ", axis_codes[axis]);SERIAL_ECHOPAIR_F(" axis set to ", newThreshold);SERIAL_ECHOLNPGM("mm.");}static void get_ec_threshold(const int8_t idx, const AxisEnum axis) {CHECK_IDX();const float threshold = encoders[idx].get_ec_threshold();SERIAL_ECHOPAIR("Error correct threshold for ", axis_codes[axis]);SERIAL_ECHOPAIR_F(" axis is ", threshold);SERIAL_ECHOLNPGM("mm.");}static int8_t idx_from_axis(const AxisEnum axis) {LOOP_PE(i)if (encoders[i].get_axis() == axis) return i;return -1;}static int8_t idx_from_addr(const uint8_t addr) {LOOP_PE(i)if (encoders[i].get_address() == addr) return i;return -1;}static int8_t parse();static void M860();static void M861();static void M862();static void M863();static void M864();static void M865();static void M866();static void M867();static void M868();static void M869();static I2CPositionEncoder encoders[I2CPE_ENCODER_CNT];};extern I2CPositionEncodersMgr I2CPEM;FORCE_INLINE static void gcode_M860() { I2CPEM.M860(); }FORCE_INLINE static void gcode_M861() { I2CPEM.M861(); }FORCE_INLINE static void gcode_M862() { I2CPEM.M862(); }FORCE_INLINE static void gcode_M863() { I2CPEM.M863(); }FORCE_INLINE static void gcode_M864() { I2CPEM.M864(); }FORCE_INLINE static void gcode_M865() { I2CPEM.M865(); }FORCE_INLINE static void gcode_M866() { I2CPEM.M866(); }FORCE_INLINE static void gcode_M867() { I2CPEM.M867(); }FORCE_INLINE static void gcode_M868() { I2CPEM.M868(); }FORCE_INLINE static void gcode_M869() { I2CPEM.M869(); }#endif //I2C_POSITION_ENCODERS#endif //I2CPOSENC_H