Simple 64-bit timer for mbed. It is a drastically simplified version of Timer64 class by Tom Doyle. It is meant to be used in single-thread applications, where timer is used frequently, while standard 32-bit Timer is not enough.
Fork of Timer64 by
Diff: Timer64.cpp
- Revision:
- 0:1e0e79e82839
- Child:
- 1:497fba179833
diff -r 000000000000 -r 1e0e79e82839 Timer64.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Timer64.cpp Sat Mar 26 21:44:41 2016 +0000 @@ -0,0 +1,215 @@ + /* + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "Timer64.h" +#include "ticker_api.h" +#include "us_ticker_api.h" + +Timer64::Timer64() : + _timerInitialized(false), + _timerRunning(false), + _tickerStartTimeUsec(0L), + _totalTimeUsec(0L), + _ticker_data(get_us_ticker_data()), + _rollOverCheckTimer(NULL), + _rollOverCheckTimerPeriodInMsec(TIMER64_15MINUTE_ROLLOVER_CHECK_IN_MSECS) +{ + reset(); +} + +Timer64::Timer64(const ticker_data_t *data) : + _timerInitialized(false), + _timerRunning(false), + _tickerStartTimeUsec(0L), + _totalTimeUsec(0L), + _ticker_data(data), + _rollOverCheckTimer(NULL), + _rollOverCheckTimerPeriodInMsec(TIMER64_15MINUTE_ROLLOVER_CHECK_IN_MSECS) +{ + reset(); +} + +int Timer64::init(uint32_t rolloverCheckTimeInMsec) +{ + if (_timerInitialized) + { + return(TIMER64_WARNING_ALREADY_INITIALIZED); + } + + if (rolloverCheckTimeInMsec < TIMER64_MIN_ROLLOVER_CHECK_IN_MSECS) + { + rolloverCheckTimeInMsec = TIMER64_MIN_ROLLOVER_CHECK_IN_MSECS; + } + else if (rolloverCheckTimeInMsec > TIMER64_MAX_ROLLOVER_CHECK_IN_MSECS) + { + rolloverCheckTimeInMsec = TIMER64_MAX_ROLLOVER_CHECK_IN_MSECS; + } + + _timerRunning = false; + _tickerStartTimeUsec = 0L; + _totalTimeUsec = 0L; + _rollOverCheckTimerPeriodInMsec = rolloverCheckTimeInMsec; + _rollOverCheckTimer = new RtosTimer(_rollOverCheck, osTimerPeriodic, this); + _timerInitialized = true; + + return(TIMER64_OK); +} + +int Timer64::release(void) +{ + if (!_timerInitialized) + { + return(TIMER64_ERROR_NOT_INITIALIZED); + } + + if (_timerRunning) + { + stop(); + } + + _tickerStartTimeUsec = 0L; + _totalTimeUsec = 0L; + _timerInitialized = false; + _rollOverCheckTimer->stop(); + delete _rollOverCheckTimer; + _rollOverCheckTimer = NULL; + + return(TIMER64_OK); +} +int Timer64::start(void) +{ + if (!_timerInitialized) + { + return(TIMER64_ERROR_NOT_INITIALIZED); + } + + if (!_timerRunning) + { + _tickerStartTimeUsec = ticker_read(_ticker_data); + _timerRunning = true; + _rollOverCheckTimer->start(_rollOverCheckTimerPeriodInMsec); + } + else + { + return(TIMER64_WARNING_ALREADY_RUNNING); + } + + return(TIMER64_OK); +} + +int Timer64::stop(void) +{ + if (!_timerInitialized) + { + return(TIMER64_ERROR_NOT_INITIALIZED); + } + + if (_timerRunning) + { + _timerRunning = false; + _rollOverCheckTimer->stop(); + } + else + { + return(TIMER64_WARNING_ALREADY_STOPPED); + } + + return(TIMER64_OK); +} + +int Timer64::reset(void) +{ + if (!_timerInitialized) + { + return(TIMER64_ERROR_NOT_INITIALIZED); + } + + if (_timerRunning) + { + _tickerStartTimeUsec = ticker_read(_ticker_data); + _rollOverCheckTimer->start(_rollOverCheckTimerPeriodInMsec); + } + + _totalTimeUsec = 0L; + return(TIMER64_OK); +} + +uint64_t Timer64::read_us(int* status) +{ + if (!_timerInitialized) + { + if (status) + { + *status = TIMER64_ERROR_NOT_INITIALIZED; + } + + return(0L); + } + + if (_timerRunning) + { + timestamp_t ticker_current_timeUsec = ticker_read(_ticker_data); + + // check for ticker time rollover + + if (ticker_current_timeUsec >= _tickerStartTimeUsec) + { + _totalTimeUsec += (uint64_t)(ticker_current_timeUsec - _tickerStartTimeUsec); + } + else + { + // rollover! + _totalTimeUsec += (4294967296L - ((uint64_t)_tickerStartTimeUsec)) + (uint64_t)ticker_current_timeUsec; + + } + + _tickerStartTimeUsec = ticker_current_timeUsec; + } + + return(_totalTimeUsec); +} + +uint64_t Timer64::read_ms(int* status) +{ + return(read_us(status) / 1000L); +} + +double Timer64::read(int* status) +{ + return((double)read_us(status) / 1000000.0L); +} + +#ifdef MBED_OPERATORS +Timer64::operator double() +{ + return read(); +} + +Timer64::operator uint64_t() +{ + return read_us(); +} + +Timer64::operator uint32_t() +{ + return read_us(); +} +#endif + +void Timer64::_rollOverCheck(void const* args) +{ + Timer64* timer = (Timer64*)args; + timer->read_us(); + return; +}