Clock Class Reference

#include <Clock.h>

Static Public Member Functions
static uint64_t	ticks (uint32_t frequency=Clock::frequency)
static uint64_t	nanosToTicks (uint64_t ns, uint32_t frequency=Clock::frequency)
static uint64_t	ticksToNanos (uint64_t tick, uint32_t frequency=Clock::frequency)
static void	setFrequency (uint32_t freq)
static uint64_t	nanos ()
static uint64_t	micros ()
static uint64_t	millis ()
static double	seconds ()
static void	delayCycles (uint64_t cycles)
static void	delayMicros (uint64_t micros)
static void	delayMillis (uint64_t millis)
static void	delaySeconds (double secs)
static void	setTimeMultiplier (double tm)

Detailed Description

Marlin 3D Printer Firmware Copyright (c) 2019 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/.

Member Function Documentation

ticks()

static uint64_t Clock::ticks ( uint32_t  frequency = Clock::frequency )

static

                                                             {
    return (Clock::nanos() - Clock::startup.count()) / (1000000000ULL / frequency);
  }

Here is the call graph for this function:

nanosToTicks()

static uint64_t Clock::nanosToTicks ( uint64_t  ns, uint32_t  frequency = Clock::frequency  )

static

                                                                                 {
    return ns / (1000000000ULL / frequency);
  }

ticksToNanos()

static uint64_t Clock::ticksToNanos ( uint64_t  tick, uint32_t  frequency = Clock::frequency  )

static

                                                                                   {
    return (tick * (1000000000ULL / frequency)) / Clock::time_multiplier;
  }

setFrequency()

static void Clock::setFrequency ( uint32_t  freq )

static

                                          {
    Clock::frequency = freq;
  }

nanos()

static uint64_t Clock::nanos ( )

static

                          {
    auto now = std::chrono::high_resolution_clock::now().time_since_epoch();
    return (now.count() - Clock::startup.count()) * Clock::time_multiplier;
  }

Here is the caller graph for this function:

micros()

static uint64_t Clock::micros ( )

static

                           {
    return Clock::nanos() / 1000;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

millis()

static uint64_t Clock::millis ( )

static

                           {
    return Clock::micros() / 1000;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

seconds()

static double Clock::seconds ( )

static

                          {
    return Clock::nanos() / 1000000000.0;
  }

Here is the call graph for this function:

delayCycles()

static void Clock::delayCycles ( uint64_t  cycles )

static

                                           {
    std::this_thread::sleep_for(std::chrono::nanoseconds( (1000000000L / frequency) * cycles) / Clock::time_multiplier );
  }

Here is the caller graph for this function:

delayMicros()

static void Clock::delayMicros ( uint64_t  micros )

static

                                           {
    std::this_thread::sleep_for(std::chrono::microseconds( micros ) / Clock::time_multiplier);
  }

Here is the call graph for this function:

delayMillis()

static void Clock::delayMillis ( uint64_t  millis )

static

                                           {
    std::this_thread::sleep_for(std::chrono::milliseconds( millis ) / Clock::time_multiplier);
  }

Here is the call graph for this function:

delaySeconds()

static void Clock::delaySeconds ( double  secs )

static

                                        {
    std::this_thread::sleep_for(std::chrono::duration<double, std::milli>(secs * 1000) / Clock::time_multiplier);
  }

setTimeMultiplier()

static void Clock::setTimeMultiplier ( double  tm )

static

                                           {
    Clock::time_multiplier = tm;
  }