arduino/esp8266
1
0
Fork 0
mirror of https://github.com/esp8266/Arduino.git synced 2025-04-19 23:22:16 +03:00
Code

Minimize header use, move Ticker function definitions into cpp file (#6496)

Browse Source 
* Backport from ESP32

* Use new library layout (.../src)

* Cleanup test case.

* C++ style cast required.

* Whitespace

* Inlining via header has better baseline ROM footprint.

* Reordered functions for better code-compare to master

* Reduces ROM footprint some more.

* Avoid unnecessary parameter passing - refactoring, same generated footprint.

* Reformat example sources
This commit is contained in:
Dirk O. Kaar 2019-11-14 14:02:32 +01:00 committed by Develo
parent af85bd2efc
commit 482516e393
5 changed files with 172 additions and 185 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

129
libraries/Ticker/Ticker.h
View File

@ -1,129 +0,0 @@
/*
Ticker.h - esp8266 library that calls functions periodically
Copyright (c) 2014 Ivan Grokhotkov. All rights reserved.
This file is part of the esp8266 core for Arduino environment.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef TICKER_H
#define TICKER_H
#include <functional>
#include <Schedule.h>
#include <ets_sys.h>
class Ticker
{
public:
Ticker();
~Ticker();
typedef void (*callback_with_arg_t)(void *);
typedef std::function<void(void)> callback_function_t;
void attach_scheduled(float seconds, callback_function_t callback)
{
attach(seconds, [callback]() { schedule_function(callback); });
}
void attach(float seconds, callback_function_t callback)
{
_callback_function = std::move(callback);
_attach_s(seconds, true, _static_callback, this);
}
void attach_ms_scheduled(uint32_t milliseconds, callback_function_t callback)
{
attach_ms(milliseconds, [callback]() { schedule_function(callback); });
}
void attach_ms(uint32_t milliseconds, callback_function_t callback)
{
_callback_function = std::move(callback);
_attach_ms(milliseconds, true, _static_callback, this);
}
template<typename TArg>
void attach(float seconds, void (*callback)(TArg), TArg arg)
{
static_assert(sizeof(TArg) <= sizeof(void*), "attach() callback argument size must be <= sizeof(void*)");
// C-cast serves two purposes:
// static_cast for smaller integer types,
// reinterpret_cast + const_cast for pointer types
_attach_s(seconds, true, reinterpret_cast<callback_with_arg_t>(callback), reinterpret_cast<void *>(arg));
}
template<typename TArg>
void attach_ms(uint32_t milliseconds, void (*callback)(TArg), TArg arg)
{
static_assert(sizeof(TArg) <= sizeof(void*), "attach() callback argument size must be <= sizeof(void*)");
_attach_ms(milliseconds, true, reinterpret_cast<callback_with_arg_t>(callback), reinterpret_cast<void *>(arg));
}
void once_scheduled(float seconds, callback_function_t callback)
{
once(seconds, [callback]() { schedule_function(callback); });
}
void once(float seconds, callback_function_t callback)
{
_callback_function = std::move(callback);
_attach_s(seconds, false, _static_callback, this);
}
void once_ms_scheduled(uint32_t milliseconds, callback_function_t callback)
{
once_ms(milliseconds, [callback]() { schedule_function(callback); });
}
void once_ms(uint32_t milliseconds, callback_function_t callback)
{
_callback_function = std::move(callback);
_attach_ms(milliseconds, false, _static_callback, this);
}
template<typename TArg>
void once(float seconds, void (*callback)(TArg), TArg arg)
{
static_assert(sizeof(TArg) <= sizeof(void*), "attach() callback argument size must be <= sizeof(void*)");
_attach_s(seconds, false, reinterpret_cast<callback_with_arg_t>(callback), reinterpret_cast<void *>(arg));
}
template<typename TArg>
void once_ms(uint32_t milliseconds, void (*callback)(TArg), TArg arg)
{
static_assert(sizeof(TArg) <= sizeof(void*), "attach() callback argument size must be <= sizeof(void*)");
_attach_ms(milliseconds, false, reinterpret_cast<callback_with_arg_t>(callback), reinterpret_cast<void *>(arg));
}
void detach();
bool active() const;
protected:
void _attach_ms(uint32_t milliseconds, bool repeat, callback_with_arg_t callback, void* arg);
static void _static_callback(void* arg);
ETSTimer* _timer;
callback_function_t _callback_function = nullptr;
private:
void _attach_s(float seconds, bool repeat, callback_with_arg_t callback, void* arg);
ETSTimer _etsTimer;
};
#endif//TICKER_H

23
libraries/Ticker/examples/TickerParameter/TickerParameter.ino
View File

@ -13,9 +13,17 @@
#include <Ticker.h>
Ticker tickerSetHigh;
Ticker tickerSetAnalog;
Ticker tickerSetLow;
Ticker tickerSetHigh;
Ticker tickerSetChar;
void setPinLow() {
digitalWrite(LED_BUILTIN, 0);
}
void setPinHigh() {
digitalWrite(LED_BUILTIN, 1);
}
void setPin(int state) {
digitalWrite(LED_BUILTIN, state);
@ -27,14 +35,15 @@ void setPinChar(char state) {
void setup() {
pinMode(LED_BUILTIN, OUTPUT);
digitalWrite(1, LOW);
// every 25 ms, call setPin(0)
tickerSetLow.attach_ms(25, setPin, 0);
// every 25 ms, call setPinLow()
tickerSetLow.attach_ms(25, setPinLow);
// every 26 ms, call setPinChar(1)
tickerSetHigh.attach_ms(26, setPinChar, (char)1);
// every 26 ms, call setPinHigh()
tickerSetHigh.attach_ms(26, setPinHigh);
// every 54 ms, call setPinChar(1)
tickerSetChar.attach_ms(26, setPinChar, (char)1);
}
void loop() {

17
libraries/Ticker/keywords.txt
View File

@ -1,11 +1,9 @@
#######################################
# Syntax Coloring Map For Wire
#######################################
#######################################
# Datatypes (KEYWORD1)
#######################################
Ticker KEYWORD1
#######################################
# Methods and Functions (KEYWORD2)
#######################################
@ -16,14 +14,3 @@ once KEYWORD2
once_ms KEYWORD2
detach KEYWORD2
active KEYWORD2
#######################################
# Instances (KEYWORD2)
#######################################
Ticker KEYWORD2
#######################################
# Constants (LITERAL1)
#######################################

55
libraries/Ticker/Ticker.cpp → libraries/Ticker/src/Ticker.cpp
View File

@ -25,60 +25,47 @@
#include "Ticker.h"
namespace
{
constexpr int ONCE = 0;
constexpr int REPEAT = 1;
}
Ticker::Ticker()
: _timer(nullptr)
{
}
: _timer(nullptr) {}
Ticker::~Ticker()
{
detach();
}
void Ticker::_attach_s(float seconds, bool repeat, callback_with_arg_t callback, void* arg)
{
_attach_ms(1000 * seconds, repeat, callback, arg);
detach();
}
void Ticker::_attach_ms(uint32_t milliseconds, bool repeat, callback_with_arg_t callback, void* arg)
{
if (_timer)
{
os_timer_disarm(_timer);
}
else
{
_timer = &_etsTimer;
}
if (_timer)
{
os_timer_disarm(_timer);
}
else
{
_timer = &_etsTimer;
}
os_timer_setfn(_timer, callback, arg);
os_timer_arm(_timer, milliseconds, (repeat) ? REPEAT : ONCE);
os_timer_setfn(_timer, callback, arg);
os_timer_arm(_timer, milliseconds, repeat);
}
void Ticker::detach()
{
if (!_timer)
return;
if (!_timer)
return;
os_timer_disarm(_timer);
_timer = nullptr;
_callback_function = nullptr;
os_timer_disarm(_timer);
_timer = nullptr;
_callback_function = nullptr;
}
bool Ticker::active() const
{
return _timer;
return _timer;
}
void Ticker::_static_callback(void* arg)
{
Ticker* _this = reinterpret_cast<Ticker*>(arg);
if (_this && _this->_callback_function)
_this->_callback_function();
Ticker* _this = reinterpret_cast<Ticker*>(arg);
if (_this && _this->_callback_function)
_this->_callback_function();
}

133
libraries/Ticker/src/Ticker.h Normal file
View File

@ -0,0 +1,133 @@
/*
Ticker.h - esp8266 library that calls functions periodically
Copyright (c) 2014 Ivan Grokhotkov. All rights reserved.
This file is part of the esp8266 core for Arduino environment.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef TICKER_H
#define TICKER_H
#include <functional>
#include <Schedule.h>
#include <ets_sys.h>
class Ticker
{
public:
Ticker();
~Ticker();
typedef void (*callback_with_arg_t)(void*);
typedef std::function<void(void)> callback_function_t;
void attach_scheduled(float seconds, callback_function_t callback)
{
_callback_function = [callback]() { schedule_function(callback); };
_attach_ms(1000UL * seconds, true);
}
void attach(float seconds, callback_function_t callback)
{
_callback_function = std::move(callback);
_attach_ms(1000UL * seconds, true);
}
void attach_ms_scheduled(uint32_t milliseconds, callback_function_t callback)
{
_callback_function = [callback]() { schedule_function(callback); };
_attach_ms(milliseconds, true);
}
void attach_ms(uint32_t milliseconds, callback_function_t callback)
{
_callback_function = std::move(callback);
_attach_ms(milliseconds, true);
}
template<typename TArg>
void attach(float seconds, void (*callback)(TArg), TArg arg)
{
static_assert(sizeof(TArg) <= sizeof(void*), "attach() callback argument size must be <= sizeof(void*)");
_attach_ms(1000UL * seconds, true, reinterpret_cast<callback_with_arg_t>(callback), reinterpret_cast<void*>(arg));
}
template<typename TArg>
void attach_ms(uint32_t milliseconds, void (*callback)(TArg), TArg arg)
{
static_assert(sizeof(TArg) <= sizeof(void*), "attach() callback argument size must be <= sizeof(void*)");
_attach_ms(milliseconds, true, reinterpret_cast<callback_with_arg_t>(callback), reinterpret_cast<void*>(arg));
}
void once_scheduled(float seconds, callback_function_t callback)
{
_callback_function = [callback]() { schedule_function(callback); };
_attach_ms(1000UL * seconds, false);
}
void once(float seconds, callback_function_t callback)
{
_callback_function = std::move(callback);
_attach_ms(1000UL * seconds, false);
}
void once_ms_scheduled(uint32_t milliseconds, callback_function_t callback)
{
_callback_function = [callback]() { schedule_function(callback); };
_attach_ms(milliseconds, false);
}
void once_ms(uint32_t milliseconds, callback_function_t callback)
{
_callback_function = std::move(callback);
_attach_ms(milliseconds, false);
}
template<typename TArg>
void once(float seconds, void (*callback)(TArg), TArg arg)
{
static_assert(sizeof(TArg) <= sizeof(void*), "attach() callback argument size must be <= sizeof(void*)");
_attach_ms(1000UL * seconds, false, reinterpret_cast<callback_with_arg_t>(callback), reinterpret_cast<void*>(arg));
}
template<typename TArg>
void once_ms(uint32_t milliseconds, void (*callback)(TArg), TArg arg)
{
static_assert(sizeof(TArg) <= sizeof(void*), "attach() callback argument size must be <= sizeof(void*)");
_attach_ms(milliseconds, false, reinterpret_cast<callback_with_arg_t>(callback), reinterpret_cast<void*>(arg));
}
void detach();
bool active() const;
protected:
static void _static_callback(void* arg);
void _attach_ms(uint32_t milliseconds, bool repeat, callback_with_arg_t callback, void* arg);
void _attach_ms(uint32_t milliseconds, bool repeat)
{
_attach_ms(milliseconds, repeat, _static_callback, this);
}
ETSTimer* _timer;
callback_function_t _callback_function = nullptr;
private:
ETSTimer _etsTimer;
};
#endif //TICKER_H