149 lines
7.1 KiB
C++
149 lines
7.1 KiB
C++
/// @file globals.h
|
|
#pragma once
|
|
#include <stdint.h>
|
|
#include "../config/config.h"
|
|
|
|
namespace modules {
|
|
|
|
/// The globals namespace provides all necessary facilities related to keeping track of global state of the firmware.
|
|
namespace globals {
|
|
|
|
/// Different stages of filament load.
|
|
/// Beware:
|
|
/// - the firmware depends on the order of these values to check for various situations.
|
|
/// - the unit tests abuse the bitmask-like values to check for multiple situations easily
|
|
enum FilamentLoadState : uint8_t {
|
|
NotLoaded = 0, ///< not loaded in the MMU at all
|
|
AtPulley = 1, ///< loaded to mmu (idler and pulley can grab it)
|
|
InSelector = 2, ///< 'P1' loaded in selector (i.e. unsure where the filament is while doing some operation)
|
|
InFSensor = 4, ///< 'f1' loaded into printer's filament sensor
|
|
InNozzle = 8, ///< 'f2' loaded into printer's nozzle
|
|
};
|
|
|
|
static_assert(
|
|
/*(FilamentLoadState::NotLoaded < FilamentLoadState::AtPulley)
|
|
&&*/
|
|
(FilamentLoadState::AtPulley < FilamentLoadState::InSelector)
|
|
&& (FilamentLoadState::InSelector < FilamentLoadState::InFSensor)
|
|
&& (FilamentLoadState::InFSensor < FilamentLoadState::InNozzle),
|
|
"incorrect order of Slot Filament Load States");
|
|
|
|
/// Globals keep track of global state variables in the firmware.
|
|
class Globals {
|
|
public:
|
|
/// Initializes the global storage hive - basically looks into EEPROM to gather information.
|
|
void Init();
|
|
|
|
/// @returns active filament slot on the MMU unit. This value basically means there is some piece of filament blocking the selector from moving freely.
|
|
/// Slots are numbered 0-4
|
|
uint8_t ActiveSlot() const;
|
|
|
|
/// @returns true if filament is considered as loaded
|
|
FilamentLoadState FilamentLoaded() const;
|
|
|
|
/// Sets the filament loaded flag value, usually after some command/operation.
|
|
/// Also updates the EEPROM records accordingly
|
|
/// @param slot slot index
|
|
/// @param newFilamentLoaded new state
|
|
void SetFilamentLoaded(uint8_t slot, FilamentLoadState newFilamentLoaded);
|
|
|
|
/// @returns the total number of MMU errors so far
|
|
/// Errors are stored in the EEPROM
|
|
uint16_t DriveErrors() const;
|
|
|
|
/// Increment MMU errors by 1
|
|
void IncDriveErrors();
|
|
|
|
/// Set normal or stealth mode for all of the motors
|
|
/// Used to keep track of the last set mode to be able to return to it properly
|
|
/// after homing sequences and/or after restarting the MMU
|
|
/// @param stealth true means use stealth mode, false means use normal mode
|
|
void SetMotorsMode(bool stealth);
|
|
|
|
/// @returns true if the motors are to be operated in stealth mode
|
|
bool MotorsStealth() const { return stealthMode; }
|
|
|
|
config::U_mm FSensorToNozzle_mm() const { return config::U_mm({ (long double)fsensorToNozzle_mm }); }
|
|
void ResetFSensorToNozzle() { fsensorToNozzle_mm = config::fsensorToNozzle.v; }
|
|
void SetFSensorToNozzle_mm(uint8_t fss2Nozzle_mm) { fsensorToNozzle_mm = fss2Nozzle_mm; }
|
|
|
|
config::U_mm FSensorUnloadCheck_mm() const { return config::U_mm({ (long double)fsensorUnloadCheck_mm }); }
|
|
void ResetFSensorUnloadCheck() { fsensorUnloadCheck_mm = config::fsensorUnloadCheckDistance.v; }
|
|
void SetFSensorUnloadCheck_mm(uint8_t fs2UnlCheck_mm) { fsensorUnloadCheck_mm = fs2UnlCheck_mm; }
|
|
|
|
config::U_mm_s PulleyLoadFeedrate_mm_s() const { return config::U_mm_s({ (long double)pulleyLoadFeedrate_mm_s }); }
|
|
void ResetPulleyLoadFeedrate() { pulleyLoadFeedrate_mm_s = config::pulleyLoadFeedrate.v; }
|
|
void SetPulleyLoadFeedrate_mm_s(uint16_t pulleyLoadFR_mm_s) { pulleyLoadFeedrate_mm_s = pulleyLoadFR_mm_s; }
|
|
|
|
config::U_mm_s PulleySlowFeedrate_mm_s() const { return config::U_mm_s({ (long double)pulleySlowFeedrate_mm_s }); }
|
|
void ResetPulleySlowFeedrate() { pulleySlowFeedrate_mm_s = config::pulleySlowFeedrate.v; }
|
|
void SetPulleySlowFeedrate_mm_s(uint16_t pulleySlowFR_mm_s) { pulleySlowFeedrate_mm_s = pulleySlowFR_mm_s; }
|
|
|
|
config::U_mm_s PulleyUnloadFeedrate_mm_s() const { return config::U_mm_s({ (long double)pulleyUnloadFeedrate_mm_s }); }
|
|
void ResetPulleyUnloadFeedrate() { pulleyUnloadFeedrate_mm_s = config::pulleyUnloadFeedrate.v; }
|
|
void SetPulleyUnloadFeedrate_mm_s(uint16_t pulleyUnloadFR_mm_s) { pulleyUnloadFeedrate_mm_s = pulleyUnloadFR_mm_s; }
|
|
|
|
config::U_mm_s SelectorFeedrate_mm_s() const { return config::U_mm_s({ (long double)selectorFeedrate_mm_s }); }
|
|
void ResetSelectorFeedrate() { selectorFeedrate_mm_s = config::selectorFeedrate.v; }
|
|
void SetSelectorFeedrate_mm_s(uint16_t selectorFR_mm_s) { selectorFeedrate_mm_s = selectorFR_mm_s; }
|
|
|
|
config::U_deg_s IdlerFeedrate_deg_s() const { return config::U_deg_s({ (long double)idlerFeedrate_deg_s }); }
|
|
void ResetIdlerFeedrate() { idlerFeedrate_deg_s = config::idlerFeedrate.v; }
|
|
void SetIdlerFeedrate_deg_s(uint16_t idlerFR_deg_s) { idlerFeedrate_deg_s = idlerFR_deg_s; }
|
|
|
|
config::U_mm_s SelectorHomingFeedrate_mm_s() const { return config::U_mm_s({ (long double)selectorHomingFeedrate_mm_s }); }
|
|
void ResetSelectorHomingFeedrate() { selectorHomingFeedrate_mm_s = config::selectorHomingFeedrate.v; }
|
|
void SetSelectorHomingFeedrate_mm_s(uint16_t selectorFR_mm_s) { selectorHomingFeedrate_mm_s = selectorFR_mm_s; }
|
|
|
|
config::U_deg_s IdlerHomingFeedrate_deg_s() const { return config::U_deg_s({ (long double)idlerHomingFeedrate_deg_s }); }
|
|
void ResetIdlerHomingFeedrate() { idlerHomingFeedrate_deg_s = config::idlerHomingFeedrate.v; }
|
|
void SetIdlerHomingFeedrate_deg_s(uint16_t idlerFR_deg_s) { idlerHomingFeedrate_deg_s = idlerFR_deg_s; }
|
|
|
|
/// @returns current StallGuard threshold for an axis
|
|
uint8_t StallGuardThreshold(config::Axis axis) const;
|
|
/// Stores the new StallGuard threshold for an axis into EEPROM (does not affect the current state of TMC drivers at all)
|
|
void SetStallGuardThreshold(config::Axis axis, uint8_t sgthrs);
|
|
|
|
/// @returns Cut iRun current level (value for TMC2130)
|
|
uint8_t CutIRunCurrent() const { return cutIRunCurrent; }
|
|
void ResetCutIRunCurrent() { cutIRunCurrent = config::selectorCutIRun; }
|
|
void SetCutIRunCurrent(uint8_t v) { cutIRunCurrent = v; }
|
|
|
|
config::U_mm CutLength() const { return config::U_mm({ (long double)cutLength_mm }); }
|
|
void ResetCutLength() { cutLength_mm = config::cutLength.v; }
|
|
void SetCutLength(uint8_t v) { cutLength_mm = v; }
|
|
|
|
private:
|
|
/// Sets the active slot, usually after some command/operation.
|
|
/// Also updates the EEPROM records accordingly
|
|
/// @param newActiveSlot the new slot index to set
|
|
void SetActiveSlot(uint8_t newActiveSlot);
|
|
|
|
uint8_t activeSlot;
|
|
FilamentLoadState filamentLoaded;
|
|
bool stealthMode;
|
|
uint8_t fsensorToNozzle_mm;
|
|
uint8_t fsensorUnloadCheck_mm;
|
|
|
|
uint16_t pulleyLoadFeedrate_mm_s;
|
|
uint16_t pulleySlowFeedrate_mm_s;
|
|
uint16_t pulleyUnloadFeedrate_mm_s;
|
|
|
|
uint16_t selectorFeedrate_mm_s;
|
|
uint16_t selectorHomingFeedrate_mm_s;
|
|
|
|
uint16_t idlerFeedrate_deg_s;
|
|
uint16_t idlerHomingFeedrate_deg_s;
|
|
|
|
uint8_t cutIRunCurrent;
|
|
uint8_t cutLength_mm;
|
|
};
|
|
|
|
/// The one and only instance of global state variables
|
|
extern Globals globals;
|
|
|
|
} // namespace globals
|
|
} // namespace modules
|
|
|
|
namespace mg = modules::globals;
|