PrintCounter Class Reference

#include <printcounter.h>

Inheritance diagram for PrintCounter:

Collaboration diagram for PrintCounter:

Static Public Member Functions
static void	init ()
	Initialize the print counter. More...
static FORCE_INLINE bool	isLoaded ()
	Check if Print Statistics has been loaded. More...
static void	incFilamentUsed (float const &amount)
	Increment the total filament used. More...
static void	initStats ()
	Reset the Print Statistics. More...
static void	loadStats ()
	Load the Print Statistics. More...
static void	saveStats ()
	Save the Print Statistics. More...
static void	showStats ()
	Serial output the Print Statistics. More...
static printStatistics	getStats ()
	Return the currently loaded statistics. More...
static void	tick ()
	Loop function. More...
static bool	start ()
static bool	stop ()
static void	reset ()
Static Public Member Functions inherited from Stopwatch
static FORCE_INLINE void	init ()
	Initialize the stopwatch. More...
static bool	stop ()
	Stop the stopwatch. More...
static bool	pause ()
	Pause the stopwatch. More...
static bool	start ()
	Start the stopwatch. More...
static void	resume (const millis_t with_time)
	Resume the stopwatch. More...
static void	reset ()
	Reset the stopwatch. More...
static FORCE_INLINE bool	isRunning ()
	Check if the timer is running. More...
static FORCE_INLINE bool	isPaused ()
	Check if the timer is paused. More...
static millis_t	duration ()
	Get the running time. More...

Static Protected Member Functions
static millis_t	deltaDuration ()
	dT since the last call More...

Member Function Documentation

deltaDuration()

millis_t PrintCounter::deltaDuration ( )

staticprotected

dT since the last call

Return the elapsed time in seconds since the last call, this is used internally for print statistics accounting is not intended to be a user callable function.

                                     {
  #if ENABLED(DEBUG_PRINTCOUNTER)
    debug(PSTR("deltaDuration"));
  #endif
 
  millis_t tmp = lastDuration;
  lastDuration = duration();
  return lastDuration - tmp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

init()

static void PrintCounter::init ( )

static

Initialize the print counter.

                              {
      super::init();
      loadStats();
    }

Here is the call graph for this function:

isLoaded()

static FORCE_INLINE bool PrintCounter::isLoaded ( )

static

Check if Print Statistics has been loaded.

Return true if the statistical data has been loaded.

Returns

bool

{ return loaded; }

Here is the caller graph for this function:

incFilamentUsed()

void PrintCounter::incFilamentUsed ( float const &  amount )

static

Increment the total filament used.

The total filament used counter will be incremented by "amount".

Parameters

amount

The amount of filament used in mm

                                                      {
  #if ENABLED(DEBUG_PRINTCOUNTER)
    debug(PSTR("incFilamentUsed"));
  #endif
 
  // Refuses to update data if object is not loaded
  if (!isLoaded()) return;
 
  data.filamentUsed += amount; // mm
}

Here is the call graph for this function:

initStats()

void PrintCounter::initStats ( )

static

Reset the Print Statistics.

Reset the statistics to zero and saves them to EEPROM creating also the magic header.

                             {
  #if ENABLED(DEBUG_PRINTCOUNTER)
    debug(PSTR("initStats"));
  #endif
 
  loaded = true;
  data = { 0, 0, 0, 0, 0.0
    #if HAS_SERVICE_INTERVALS
      #if SERVICE_INTERVAL_1 > 0
        , SERVICE_INTERVAL_SEC_1
      #endif
      #if SERVICE_INTERVAL_2 > 0
        , SERVICE_INTERVAL_SEC_2
      #endif
      #if SERVICE_INTERVAL_3 > 0
        , SERVICE_INTERVAL_SEC_3
      #endif
    #endif
  };
 
  saveStats();
  persistentStore.access_start();
  persistentStore.write_data(address, (uint8_t)0x16);
  persistentStore.access_finish();
}

Here is the call graph for this function:

Here is the caller graph for this function:

loadStats()

void PrintCounter::loadStats ( )

static

Load the Print Statistics.

Load the statistics from EEPROM

                             {
  #if ENABLED(DEBUG_PRINTCOUNTER)
    debug(PSTR("loadStats"));
  #endif
 
  // Check if the EEPROM block is initialized
  uint8_t value = 0;
  persistentStore.access_start();
  persistentStore.read_data(address, &value, sizeof(uint8_t));
  if (value != 0x16)
    initStats();
  else
    persistentStore.read_data(address + sizeof(uint8_t), (uint8_t*)&data, sizeof(printStatistics));
  persistentStore.access_finish();
  loaded = true;
 
  #if HAS_SERVICE_INTERVALS
    bool doBuzz = false;
    #if SERVICE_INTERVAL_1 > 0
      if (data.nextService1 == 0) doBuzz = _service_warn(PSTR(" " SERVICE_NAME_1));
    #endif
    #if SERVICE_INTERVAL_2 > 0
      if (data.nextService2 == 0) doBuzz = _service_warn(PSTR(" " SERVICE_NAME_2));
    #endif
    #if SERVICE_INTERVAL_3 > 0
      if (data.nextService3 == 0) doBuzz = _service_warn(PSTR(" " SERVICE_NAME_3));
    #endif
    #if HAS_BUZZER && SERVICE_WARNING_BUZZES > 0
      if (doBuzz) for (int i = 0; i < SERVICE_WARNING_BUZZES; i++) BUZZ(200, 404);
    #else
      UNUSED(doBuzz);
    #endif
  #endif // HAS_SERVICE_INTERVALS
}

Here is the call graph for this function:

Here is the caller graph for this function:

saveStats()

void PrintCounter::saveStats ( )

static

Save the Print Statistics.

Save the statistics to EEPROM

                             {
  #if ENABLED(DEBUG_PRINTCOUNTER)
    debug(PSTR("saveStats"));
  #endif
 
  // Refuses to save data if object is not loaded
  if (!isLoaded()) return;
 
  // Saves the struct to EEPROM
  persistentStore.access_start();
  persistentStore.write_data(address + sizeof(uint8_t), (uint8_t*)&data, sizeof(printStatistics));
  persistentStore.access_finish();
 
  #if ENABLED(EXTENSIBLE_UI)
    ExtUI::onConfigurationStoreWritten(true);
  #endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

showStats()

void PrintCounter::showStats ( )

static

Serial output the Print Statistics.

This function may change in the future, for now it directly prints the statistical data to serial.

                             {
  char buffer[21];
 
  SERIAL_ECHOPGM(MSG_STATS);
  SERIAL_ECHOLNPAIR(
    "Prints: ", data.totalPrints,
    ", Finished: ", data.finishedPrints,
    ", Failed: ", data.totalPrints - data.finishedPrints
                    - ((isRunning() || isPaused()) ? 1 : 0) // Remove 1 from failures with an active counter
  );
 
  SERIAL_ECHOPGM(MSG_STATS);
  duration_t elapsed = data.printTime;
  elapsed.toString(buffer);
  SERIAL_ECHOPAIR("Total time: ", buffer);
  #if ENABLED(DEBUG_PRINTCOUNTER)
    SERIAL_ECHOPAIR(" (", data.printTime);
    SERIAL_CHAR(')');
  #endif
 
  elapsed = data.longestPrint;
  elapsed.toString(buffer);
  SERIAL_ECHOPAIR(", Longest job: ", buffer);
  #if ENABLED(DEBUG_PRINTCOUNTER)
    SERIAL_ECHOPAIR(" (", data.longestPrint);
    SERIAL_CHAR(')');
  #endif
 
  SERIAL_ECHOPAIR("\n" MSG_STATS "Filament used: ", data.filamentUsed / 1000);
  SERIAL_CHAR('m');
  SERIAL_EOL();
 
  #if SERVICE_INTERVAL_1 > 0
    _service_when(buffer, PSTR(SERVICE_NAME_1), data.nextService1);
  #endif
  #if SERVICE_INTERVAL_2 > 0
    _service_when(buffer, PSTR(SERVICE_NAME_2), data.nextService2);
  #endif
  #if SERVICE_INTERVAL_3 > 0
    _service_when(buffer, PSTR(SERVICE_NAME_3), data.nextService3);
  #endif
}

Here is the call graph for this function:

getStats()

static printStatistics PrintCounter::getStats ( )

static

Return the currently loaded statistics.

Return the raw data, in the same structure used internally

{ return data; }

tick()

void PrintCounter::tick ( )

static

Loop function.

This function should be called at loop, it will take care of periodically save the statistical data to EEPROM and do time keeping.

                        {
  if (!isRunning()) return;
 
  millis_t now = millis();
 
  static uint32_t update_next; // = 0
  if (ELAPSED(now, update_next)) {
    #if ENABLED(DEBUG_PRINTCOUNTER)
      debug(PSTR("tick"));
    #endif
    millis_t delta = deltaDuration();
    data.printTime += delta;
 
    #if SERVICE_INTERVAL_1 > 0
      data.nextService1 -= _MIN(delta, data.nextService1);
    #endif
    #if SERVICE_INTERVAL_2 > 0
      data.nextService2 -= _MIN(delta, data.nextService2);
    #endif
    #if SERVICE_INTERVAL_3 > 0
      data.nextService3 -= _MIN(delta, data.nextService3);
    #endif
 
    update_next = now + updateInterval * 1000;
  }
 
  static uint32_t eeprom_next; // = 0
  if (ELAPSED(now, eeprom_next)) {
    eeprom_next = now + saveInterval * 1000;
    saveStats();
  }
}

Here is the call graph for this function:

start()

bool PrintCounter::start ( )

static

The following functions are being overridden

                         {
  #if ENABLED(DEBUG_PRINTCOUNTER)
    debug(PSTR("start"));
  #endif
 
  bool paused = isPaused();
 
  if (super::start()) {
    if (!paused) {
      data.totalPrints++;
      lastDuration = 0;
    }
    return true;
  }
 
  return false;
}

Here is the call graph for this function:

stop()

bool PrintCounter::stop ( )

static

                        {
  #if ENABLED(DEBUG_PRINTCOUNTER)
    debug(PSTR("stop"));
  #endif
 
  if (super::stop()) {
    data.finishedPrints++;
    data.printTime += deltaDuration();
 
    if (duration() > data.longestPrint)
      data.longestPrint = duration();
 
    saveStats();
    return true;
  }
  else return false;
}

Here is the call graph for this function:

reset()

void PrintCounter::reset ( )

static

                         {
  #if ENABLED(DEBUG_PRINTCOUNTER)
    debug(PSTR("stop"));
  #endif
 
  super::reset();
  lastDuration = 0;
}

Here is the call graph for this function: