j3d1/esp-open-rtos
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Implemented C++11 stype wrapper and example.

Browse source
This commit is contained in:
Florian Eich 2017-09-28 17:55:54 +02:00
parent b83c2629b9
commit ff0970f614
9 changed files with 706 additions and 1 deletions
Download patch file Download diff file Expand all files Collapse all files

33
extras/cpp11/component.mk Normal file
View file

@ -0,0 +1,33 @@
# --------------------------------------------------------------------------- #
# Copyright 2017 Florian Eich <florian.eich@gmail.com>
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice,
# this list of conditions and the following disclaimer.
#
# 2. Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation
# and/or other materials provided with the distribution.
#
# 3. Neither the name of the copyright holder nor the names of its
# contributors may be used to endorse or promote products derived from this
# software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE./ limitations under the License.
# --------------------------------------------------------------------------- #
# Component makefile for extras/cpp11
INC_DIRS += $(ROOT)extras/cpp11/include

95
extras/cpp11/include/countdown.hpp Normal file
View file

@ -0,0 +1,95 @@
/* --------------------------------------------------------------------------*\
* Copyright 2017 Florian Eich <florian.eich@gmail.com>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE./ limitations under the License.
\* --------------------------------------------------------------------------*/
#ifndef ESP_OPEN_RTOS_EXTRAS_CPP11_COUNTDOWN_HPP_
#define ESP_OPEN_RTOS_EXTRAS_CPP11_COUNTDOWN_HPP_
#include "FreeRTOS.h"
#include "util.hpp"
namespace cxx {
/*!
* \brief Wrapper for FreeRTOS TickType_t.
*/
class countdown
{
public:
/*!
* \brief Default constructor for countdown class.
*/
countdown() : _interval_end_ms(0L) {}
/*!
* \brief Constructor for countdown class with milliseconds parameter.
* \param ms Specify milliseconds for countdown timer.
*/
countdown(const int ms) : _interval_end_ms(millis() + ms) {}
/*!
* \brief Function to check if countdown has expired.
* \returns boolean
*/
bool expired() {
return (_interval_end_ms > 0L) && (millis() >= _interval_end_ms);
}
/*!
* \brief Setter for countdown.
* \param ms Number of milliseconds.
*/
void countdown_ms(const unsigned long ms) {
_interval_end_ms = ms + millis();
}
/*!
* \brief Setter for countdown.
* \param s Number of seconds.
*/
void countdown_s(const unsigned long s) { countdown_ms(s * 1000L); }
/*!
* \brief Function to check time left.
* \returns Remaining time in milliseconds.
*/
int left_ms() { return _interval_end_ms - millis(); }
private:
TickType_t _interval_end_ms;
};
} // namespace cxx
#endif // ESP_OPEN_RTOS_EXTRAS_CPP11_COUNTDOWN_HPP_

96
extras/cpp11/include/mutex.hpp Normal file
View file

@ -0,0 +1,96 @@
/* --------------------------------------------------------------------------*\
* Copyright 2017 Florian Eich <florian.eich@gmail.com>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE./ limitations under the License.
\* --------------------------------------------------------------------------*/
#ifndef ESP_OPEN_RTOS_EXTRAS_CPP11_MUTEX_HPP_
#define ESP_OPEN_RTOS_EXTRAS_CPP11_MUTEX_HPP_
#include "FreeRTOS.h"
#include "semphr.h"
namespace cxx {
/*!
* \brief Wrapper for FreeRTOS SemaphoreHande_t.
*/
class mutex
{
public:
/*!
* \brief Default constructor for mutex class.
*/
mutex() : _mutex(xSemaphoreCreateMutex()) {}
// Disable copy construction and assigment.
mutex(const mutex &) = delete;
mutex & operator=(const mutex &) = delete;
/*!
* \brief Destructor for mutex class releases underlying resource actively.
*/
~mutex() { vQueueDelete(_mutex); }
/*!
* \brief Check if mutex is usable.
* \returns boolean: true if usable.
*/
bool usable() const { return _mutex != nullptr; }
/*!
* \brief Try locking mutex with no timeout.
* \returns boolean: true if successfully locked.
*/
bool try_lock() { return xSemaphoreTake(_mutex, portMAX_DELAY) == pdTRUE; }
/*!
* \brief Try locking mutex with timeout.
* \param ms Timeout delay in milliseconds.
* \returns boolean: true if successfully locked.
*/
bool try_lock(const unsigned long ms) {
return xSemaphoreTake(_mutex, ms / portTICK_PERIOD_MS) == pdTRUE;
}
/*!
* \brief Unlock mutex.
* \returns boolean: true if successfully unlocked.
*/
bool unlock() { return xSemaphoreGive(_mutex) == pdTRUE; }
private:
SemaphoreHandle_t _mutex;
};
} // namespace cxx
#endif // ESP_OPEN_RTOS_EXTRAS_CPP11_MUTEX_HPP_

99
extras/cpp11/include/queue.hpp Normal file
View file

@ -0,0 +1,99 @@
/* --------------------------------------------------------------------------*\
* Copyright 2017 Florian Eich <florian.eich@gmail.com>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE./ limitations under the License.
\* --------------------------------------------------------------------------*/
#ifndef ESP_OPEN_RTOS_EXTRAS_CPP11_QUEUE_HPP_
#define ESP_OPEN_RTOS_EXTRAS_CPP11_QUEUE_HPP_
#include "FreeRTOS.h"
#include "queue.h"
namespace cxx {
/*!
* \brief Wrapper for FreeRTOS QueueHandle_t.
*/
template <class D>
class queue
{
public:
/*!
* \brief Constructor for queue class.
* \param uxQueueLength Length of queue.
*/
queue(const unsigned portBASE_TYPE uxQueueLength)
: _queue(xQueueCreate(uxQueueLength, sizeof(D))) {}
// Disable default constructor, copy constructor and assignment operator.
queue() = delete;
queue(const queue &) = delete;
queue & operator=(const queue &) = delete;
/*!
* \brief Destructor for queue class releases underlying resource actively.
*/
~queue() { vQueueDelete(_queue); }
/*!
* \brief Check if queue is usable.
* \returns boolean: true if usable.
*/
bool usable() const { return _queue != nullptr; }
/*!
* \brief Send function.
* \param data Data container.
* \param ms Timeout delay, default: 0.
* \returns boolean: true if successful.
*/
bool send(const D & data, unsigned long ms = 0) {
return xQueueSend(_queue, &data, ms / portTICK_PERIOD_MS) == pdTRUE;
}
/*!
* \brief Receive function.
* \param data Data container.
* \param ms Timeout delay, default: 0.
* \returns boolean: true if successful.
*/
bool receive(D & data, unsigned long ms = 0) {
return xQueueReceive(_queue, &data, ms / portTICK_PERIOD_MS) == pdTRUE;
}
private:
QueueHandle_t _queue;
};
} // namespace cxx
#endif // ESP_OPEN_RTOS_EXTRAS_CPP11_QUEUE_HPP_

175
extras/cpp11/include/task.hpp Normal file
View file

@ -0,0 +1,175 @@
/* --------------------------------------------------------------------------*\
* Copyright 2017 Florian Eich <florian.eich@gmail.com>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE./ limitations under the License.
\* --------------------------------------------------------------------------*/
#ifndef ESP_OPEN_RTOS_EXTRAS_CPP11_TASK_HPP_
#define ESP_OPEN_RTOS_EXTRAS_CPP11_TASK_HPP_
#include <utility>
#include "FreeRTOS.h"
#include "task.h"
namespace cxx {
/*!
* \brief Wrapper for the FreeRTOS task.
* \param F Template parameter specifying the type of the function, which is
* some form of a lambda. Do *NOT* specify this by hand - use the
* `make_task` function to instantiate tasks.
*/
template <class F>
class task
{
public:
/*!
* \brief Constructor for the task class.
* \param name Name of the task.
* \param stack_depth Stack depth for the task (use 256 as default).
* \param priority FreeRTOS priority of the task (use 2 as default).
* \param param Parameter passed to task execution (use nullptr as default).
* \param thread Function executed by the task.
*/
task(const char * name,
const unsigned short stack_depth,
const unsigned portBASE_TYPE priority,
void * param,
F thread)
: _name(name),
_stack_depth(stack_depth),
_priority(priority),
_param(param),
_thread(thread) {}
/*!
* \brief Destructor for task class deletes FreeRTOS task.
*/
~task() {
if (_active) { vTaskDelete(_handle); }
}
// Disable default construction, copy construction and assignment.
task() = delete;
task(const task &) = delete;
task & operator=(const task &) = delete;
// Default move semantics
task(task && other) = default;
void run() {
_active =
xTaskCreate(
+_thread, _name, _stack_depth, _param, _priority, &_handle) == pdPASS;
}
/*!
* \brief Check if task is currently active.
* \returns boolean: true if task is active.
*/
bool active() const { return _active; }
private:
const char * _name;
const unsigned short _stack_depth;
const unsigned portBASE_TYPE _priority;
void * _param;
F _thread;
TaskHandle_t _handle;
bool _active{false};
};
/*!
* \brief Function to generate task object.
* \param name Name of the task.
* \param stack_depth Stack depth for the task.
* \param priority FreeRTOS priority of the task.
* \param thread Function executed by the task.
* \param param Parameters passed to task execution, nullptr by default.
* \returns task object.
*/
template <class F>
constexpr task<F> make_task(const char * name,
const unsigned short stack_depth,
const unsigned portBASE_TYPE priority,
void * param,
F thread) {
return std::move(task<F>(name, stack_depth, priority, param, thread));
}
/*!
* \brief Function to generate task object.
* \param name Name of the task.
* \param stack_depth Stack depth for the task.
* \param priority FreeRTOS priority of the task.
* \param thread Function executed by the task.
* \returns task object.
*/
template <class F>
constexpr task<F> make_task(const char * name,
const unsigned short stack_depth,
const unsigned portBASE_TYPE priority,
F thread) {
return std::move(task<F>(name, stack_depth, priority, nullptr, thread));
}
/*!
* \brief Function to generate task object.
* \param name Name of the task.
* \param stack_depth Stack depth for the task.
* \param thread Function executed by the task.
* \returns task object.
*/
template <class F>
constexpr task<F> make_task(const char * name,
const unsigned short stack_depth,
F thread) {
return std::move(task<F>(name, stack_depth, 2, nullptr, thread));
}
/*!
* \brief Function to generate task object.
* \param name Name of the task.
* \param thread Function executed by the task.
* \returns task object.
*/
template <class F>
constexpr task<F> make_task(const char * name, F thread) {
return std::move(task<F>(name, 256, 2, nullptr, thread));
}
} // namespace cxx
#endif // ESP_OPEN_RTOS_EXTRAS_CPP11_TASK_HPP_

44
extras/cpp11/include/util.hpp Normal file
View file

@ -0,0 +1,44 @@
// Copyright 2017 Florian Eich <florian.eich@gmail.com>
//
// 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.
#ifndef ESP_OPEN_RTOS_EXTRAS_CPP11_UTIL_HPP_
#define ESP_OPEN_RTOS_EXTRAS_CPP11_UTIL_HPP_
#include "FreeRTOS.h"
namespace cxx {
/*!
* \brief Function to determine current task time.
* \returns Time spent on task in milliseconds.
*/
unsigned long millis() {
return xTaskGetTickCount() * portTICK_PERIOD_MS;
}
/*!
* \brief Function to sleep for some time.
* \param ms Time to sleep in milliseconds.
*/
void sleep(const unsigned long ms) {
vTaskDelay(ms / portTICK_PERIOD_MS);
}
} // namespace cxx
#endif // ESP_OPEN_RTOS_EXTRAS_CPP11_UTIL_HPP_