I2CPositionEncoder Class Reference

#include <I2CPositionEncoder.h>

Public Member Functions
void	init (const uint8_t address, const AxisEnum axis)
void	reset ()
void	update ()
void	set_homed ()
void	set_unhomed ()
int32_t	get_raw_count ()
FORCE_INLINE float	mm_from_count (const int32_t count)
FORCE_INLINE float	get_position_mm ()
FORCE_INLINE int32_t	get_position ()
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 ()
FORCE_INLINE int	get_error_count ()
FORCE_INLINE void	set_error_count (const int newCount)
FORCE_INLINE uint8_t	get_address ()
FORCE_INLINE void	set_address (const uint8_t addr)
FORCE_INLINE bool	get_active ()
FORCE_INLINE void	set_active (const bool a)
FORCE_INLINE void	set_inverted (const bool i)
FORCE_INLINE AxisEnum	get_axis ()
FORCE_INLINE bool	get_ec_enabled ()
FORCE_INLINE void	set_ec_enabled (const bool enabled)
FORCE_INLINE uint8_t	get_ec_method ()
FORCE_INLINE void	set_ec_method (const byte method)
FORCE_INLINE float	get_ec_threshold ()
FORCE_INLINE void	set_ec_threshold (const float newThreshold)
FORCE_INLINE int	get_encoder_ticks_mm ()
FORCE_INLINE int	get_ticks_unit ()
FORCE_INLINE void	set_ticks_unit (const int ticks)
FORCE_INLINE uint8_t	get_type ()
FORCE_INLINE void	set_type (const byte newType)
FORCE_INLINE int	get_stepper_ticks ()
FORCE_INLINE void	set_stepper_ticks (const int ticks)

Member Function Documentation

init()

void I2CPositionEncoder::init	(	const uint8_t	address,
		const AxisEnum	axis
	)

reset()

void I2CPositionEncoder::reset

(

)

update()

void I2CPositionEncoder::update

(

)

Here is the caller graph for this function:

set_homed()

void I2CPositionEncoder::set_homed

(

)

Here is the caller graph for this function:

set_unhomed()

void I2CPositionEncoder::set_unhomed

(

)

Here is the caller graph for this function:

get_raw_count()

int32_t I2CPositionEncoder::get_raw_count

(

)

Here is the caller graph for this function:

mm_from_count()

FORCE_INLINE float I2CPositionEncoder::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.settings.axis_steps_per_mm[encoderAxis]);
      }
    }

Here is the caller graph for this function:

get_position_mm()

FORCE_INLINE float I2CPositionEncoder::get_position_mm

(

)

{ return mm_from_count(get_position()); }

Here is the call graph for this function:

get_position()

FORCE_INLINE int32_t I2CPositionEncoder::get_position

(

)

{ return get_raw_count() - zeroOffset; }

Here is the call graph for this function:

Here is the caller graph for this function:

get_axis_error_steps()

int32_t I2CPositionEncoder::get_axis_error_steps

(

const bool

report

)

Here is the caller graph for this function:

get_axis_error_mm()

float I2CPositionEncoder::get_axis_error_mm

(

const bool

report

)

calibrate_steps_mm()

void I2CPositionEncoder::calibrate_steps_mm

(

const uint8_t

iter

)

Here is the caller graph for this function:

passes_test()

bool I2CPositionEncoder::passes_test

(

const bool

report

)

Here is the caller graph for this function:

test_axis()

bool I2CPositionEncoder::test_axis

(

)

Here is the caller graph for this function:

get_error_count()

FORCE_INLINE int I2CPositionEncoder::get_error_count

(

)

{ return errorCount; }

set_error_count()

FORCE_INLINE void I2CPositionEncoder::set_error_count

(

const int

newCount

)

{ errorCount = newCount; }

Here is the caller graph for this function:

get_address()

FORCE_INLINE uint8_t I2CPositionEncoder::get_address

(

)

{ return i2cAddress; }

set_address()

FORCE_INLINE void I2CPositionEncoder::set_address

(

const uint8_t

addr

)

{ i2cAddress = addr; }

get_active()

FORCE_INLINE bool I2CPositionEncoder::get_active

(

)

{ return active; }

set_active()

FORCE_INLINE void I2CPositionEncoder::set_active

(

const bool

a

)

{ active = a; }

set_inverted()

FORCE_INLINE void I2CPositionEncoder::set_inverted

(

const bool

i

)

{ invert = i; }

get_axis()

FORCE_INLINE AxisEnum I2CPositionEncoder::get_axis

(

)

{ return encoderAxis; }

get_ec_enabled()

FORCE_INLINE bool I2CPositionEncoder::get_ec_enabled

(

)

{ return ec; }

set_ec_enabled()

FORCE_INLINE void I2CPositionEncoder::set_ec_enabled

(

const bool

enabled

)

{ ec = enabled; }

Here is the caller graph for this function:

get_ec_method()

FORCE_INLINE uint8_t I2CPositionEncoder::get_ec_method

(

)

{ return ecMethod; }

set_ec_method()

FORCE_INLINE void I2CPositionEncoder::set_ec_method

(

const byte

method

)

{ ecMethod = method; }

get_ec_threshold()

FORCE_INLINE float I2CPositionEncoder::get_ec_threshold

(

)

{ return ecThreshold; }

Here is the caller graph for this function:

set_ec_threshold()

FORCE_INLINE void I2CPositionEncoder::set_ec_threshold

(

const float

newThreshold

)

{ ecThreshold = newThreshold; }

Here is the caller graph for this function:

get_encoder_ticks_mm()

FORCE_INLINE int I2CPositionEncoder::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.settings.axis_steps_per_mm[encoderAxis]);
      }
    }

get_ticks_unit()

FORCE_INLINE int I2CPositionEncoder::get_ticks_unit

(

)

{ return encoderTicksPerUnit; }

set_ticks_unit()

FORCE_INLINE void I2CPositionEncoder::set_ticks_unit

(

const int

ticks

)

{ encoderTicksPerUnit = ticks; }

get_type()

FORCE_INLINE uint8_t I2CPositionEncoder::get_type

(

)

{ return type; }

set_type()

FORCE_INLINE void I2CPositionEncoder::set_type

(

const byte

newType

)

{ type = newType; }

get_stepper_ticks()

FORCE_INLINE int I2CPositionEncoder::get_stepper_ticks

(

)

{ return stepperTicks; }

set_stepper_ticks()

FORCE_INLINE void I2CPositionEncoder::set_stepper_ticks

(

const int

ticks

)

{ stepperTicks = ticks; }