ALPAKA/sta-core
1
0
Fork 0
mirror of https://git.intern.spaceteamaachen.de/ALPAKA/sta-core.git synced 2025-08-05 18:21:54 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Fix indentation. Update doxygen comments

Browse Source
This commit is contained in:
Henrik Stickann
2023-02-02 22:22:14 +01:00
parent fc4eed38d5
commit 59585b2ae5
46 changed files with 2020 additions and 1960 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
include/sta/arduino/.gitkeep
View File

12
include/sta/arduino/not_implemented.hpp Normal file
View File

@@ -0,0 +1,12 @@
#ifndef STA_CORE_ARDUINO_NOT_IMPLEMENTED_HPP
#define STA_CORE_ARDUINO_NOT_IMPLEMENTED_HPP
/**
* @defgroup sta_core_arduino Arduino
* @ingroup sta_core_platforms
* @brief Modules implemented for the Arduino platform.
*/
#endif // STA_CORE_ARDUINO_NOT_IMPLEMENTED_HPP

63
include/sta/assert.hpp
View File

@@ -11,20 +11,14 @@
#define STA_CORE_ASSERT_HPP
/**
* @defgroup staCore Core
* @defgroup sta_core Core
* @brief STA Core library
*/
/**
* @defgroup staCoreBuildConfig Build Config
* @ingroup staCore
* @brief Build configuration options
*/
/**
* @defgroup staCoreAssert Assert
* @ingroup staCore
* @brief Assertion handling.
* @defgroup sta_core_platforms Platforms
* @ingroup sta_core
* @brief Platform specific implementations.
*/
@@ -49,8 +43,21 @@
#include <cstdint>
/**
* @defgroup sta_core_assert Assert
* @ingroup sta_core
* @brief Assertion handling.
*/
namespace sta
{
/**
* @ingroup sta_core_assert
* @{
*/
/**
* @brief Handle failed assertions.
*
@@ -62,8 +69,6 @@ namespace sta
* @param expr Asserted expression or message
* @param file File name
* @param line Line number
*
* @ingroup staCoreAssert
*/
void assert_failed(const char * expr, const char * file, uint32_t line);
@@ -71,48 +76,38 @@ namespace sta
* @brief Stop execution.
*
* Weak implementation can be overridden.
*
* @ingroup staCoreAssert
*/
void assert_halt();
/** @} */
} // namespace sta
/**
* @def STA_HALT
* @brief Set function called after failed asserts.
*
* @ingroup staCoreBuildConfig
* @ingroup sta_core_assert
* @{
*/
# ifndef STA_HALT
# define STA_HALT() sta::assert_halt()
# endif // !STA_HALT
/**
* @brief Assert expression.
*
* @param expr Expression
*
* @ingroup staCoreAssert
*/
# define STA_ASSERT(expr) ( (void)( !(expr) && ( sta::assert_failed(#expr, __FILE__, __LINE__), 1 ) && ( STA_HALT(), 1 ) ) )
# define STA_ASSERT(expr) ( (void)( !(expr) && ( sta::assert_failed(#expr, __FILE__, __LINE__), 1 ) && ( sta::assert_halt(), 1 ) ) )
/**
* @brief Assert expression.
*
* @param expr Expression
* @param msg Message shown on failure
*
* @ingroup staCoreAssert
*/
# define STA_ASSERT_MSG(expr, msg) ( (void)( !(expr) && ( sta::assert_failed(msg, __FILE__, __LINE__), 1 ) && ( STA_HALT(), 1 ) ) )
# define STA_ASSERT_MSG(expr, msg) ( (void)( !(expr) && ( sta::assert_failed(msg, __FILE__, __LINE__), 1 ) && ( sta::assert_halt(), 1 ) ) )
/**
* @brief Assert expression if condition is true.
*
* @param cond Condition
* @param expr Expression
*
* @ingroup staCoreAssert
*/
# define STA_ASSERT_COND(cond, expr) ( (void)( (cond) ? STA_ASSERT(expr) : 1 ) )
/**
@@ -121,13 +116,17 @@ namespace sta
* @param cond Condition
* @param expr Expression
* @param msg Message shown on failure
*
* @ingroup staCoreAssert
*/
# define STA_ASSERT_COND_MSG(cond, expr, msg) ( (void)( (cond) ? STA_ASSERT_MSG(expr, msg) ) )
/**
* @brief Expression only evaluated when assertions are enabled.
*
* @param expr Expression
*/
# define STA_ASSERT_EXTRA(expr) expr
# define STA_ASSERT_EXTRA(expr) expr;
/** @} */
#else // !STA_ASSERT_ENABLED

26
include/sta/atomic/mutex.hpp
View File

@@ -8,11 +8,13 @@
#ifndef STA_CORE_ATOMIC_MUTEX_HPP
#define STA_CORE_ATOMIC_MUTEX_HPP
#include <sta/config.hpp>
#ifdef STA_STDLIB_HAS_ATOMIC
# define STA_ATOMIC_ENABLED
#endif // STA_STDLIB_HAS_ATOMIC
#if defined(STA_ATOMIC_ENABLED) || defined(DOXYGEN)
#include <sta/mutex.hpp>
@@ -22,20 +24,20 @@
namespace sta
{
/**
* @brief Implementation of `Mutex` interface using `std::atomic_flag`.
*/
class AtomicMutex : public Mutex
{
public:
AtomicMutex();
/**
* @brief Implementation of `Mutex` interface using `std::atomic_flag`.
*/
class AtomicMutex : public Mutex
{
public:
AtomicMutex();
void acquire() override;
void release() override;
void acquire() override;
void release() override;
private:
std::atomic_flag lock_; /**< Atomic flag used as lock */
};
private:
std::atomic_flag lock_; /**< Atomic flag used as lock */
};
} // namespace sta

30
include/sta/atomic/signal.hpp
View File

@@ -8,11 +8,13 @@
#ifndef STA_CORE_ATOMIC_SIGNAL_HPP
#define STA_CORE_ATOMIC_SIGNAL_HPP
#include <sta/config.hpp>
#ifdef STA_STDLIB_HAS_ATOMIC
# define STA_ATOMIC_ENABLED
#endif // STA_STDLIB_HAS_ATOMIC
#if defined(STA_ATOMIC_ENABLED) || defined(DOXYGEN)
#include <sta/signal.hpp>
@@ -22,22 +24,22 @@
namespace sta
{
/**
* @brief Implementation of `Signal` interface using `std::atomic`.
*/
class AtomicSignal : public Signal
{
public:
AtomicSignal();
/**
* @brief Implementation of `Signal` interface using `std::atomic`.
*/
class AtomicSignal : public Signal
{
public:
AtomicSignal();
void notify() override;
bool peek() override;
bool test() override;
void wait() override;
void notify() override;
bool peek() override;
bool test() override;
void wait() override;
private:
std::atomic<bool> signal_; /**< Atomic bool used as signal */
};
private:
std::atomic<bool> signal_; /**< Atomic bool used as signal */
};
} // namespace sta

165
include/sta/can/controller.hpp
View File

@@ -6,16 +6,11 @@
#define STA_CORE_CAN_CONTROLLER_HPP
/**
* @defgroup can CAN
* @defgroup sta_core_can CAN
* @ingroup sta_core
* @brief CAN controller driver interface.
*/
/**
* @defgroup canAPI API
* @ingroup can
* @brief Public interface.
*/
#include <sta/can/filter.hpp>
#include <sta/can/headers.hpp>
@@ -24,96 +19,96 @@
namespace sta
{
/**
* @brief CAN controller driver interface.
*
* @ingroup canAPI
*/
class CanController
{
public:
// RX/TX
//
/**
* @brief CAN controller driver interface.
*
* @ingroup sta_core_can
*/
class CanController
{
public:
// RX/TX
//
/**
* @brief Send frame to CAN controller for transmission.
*
* @param header CAN frame TX header
* @param payload CAN frame payload
* @return True on success
*/
virtual bool sendFrame(const CanTxHeader & header, const uint8_t * payload) = 0;
/**
* @brief Send frame to CAN controller for transmission.
*
* @param header CAN frame TX header
* @param payload CAN frame payload
* @return True on success
*/
virtual bool sendFrame(const CanTxHeader & header, const uint8_t * payload) = 0;
/**
* @brief Get received frame from the CAN controller.
*
* @param[in] fifo FIFO storing frame
* @param[out] header CAN frame RX header destination
* @param[out] payload CAN frame payload destination
* @return True on success
*/
virtual bool receiveFrame(uint8_t fifo, CanRxHeader * header, uint8_t * payload) = 0;
/**
* @brief Get received frame from the CAN controller.
*
* @param[in] fifo FIFO storing frame
* @param[out] header CAN frame RX header destination
* @param[out] payload CAN frame payload destination
* @return True on success
*/
virtual bool receiveFrame(uint8_t fifo, CanRxHeader * header, uint8_t * payload) = 0;
/**
* @brief Get RX FIFO flags.
*
* @return FIFO flags
*/
virtual uint32_t getRxFifoFlags() = 0;
/**
* @brief Get RX FIFO flags.
*
* @return FIFO flags
*/
virtual uint32_t getRxFifoFlags() = 0;
/**
* @brief Get list of RX FIFO indices with pending messages.
*/
virtual CanPendingRxFifos getPendingRxFifos() = 0;
/**
* @brief Get list of RX FIFO indices with pending messages.
*/
virtual CanPendingRxFifos getPendingRxFifos() = 0;
// RX filter
//
// RX filter
//
/**
* @brief Change filter settings.
*
* @param idx Filter index
* @param filter Filter configuration
* @param active Enable filter after applying settings
*/
virtual void configureFilter(uint8_t idx, const CanFilter & filter, bool active = false) = 0;
/**
* @brief Enable filter.
*
* @param idx Filter index
*/
virtual void enableFilter(uint8_t idx) = 0;
/**
* @brief Disable filter.
*
* @param idx Filter index
*/
virtual void disableFilter(uint8_t idx) = 0;
/**
* @brief Disable and clear all filters.
*/
virtual void clearFilters() = 0;
/**
* @brief Change filter settings.
*
* @param idx Filter index
* @param filter Filter configuration
* @param active Enable filter after applying settings
*/
virtual void configureFilter(uint8_t idx, const CanFilter & filter, bool active = false) = 0;
/**
* @brief Enable filter.
*
* @param idx Filter index
*/
virtual void enableFilter(uint8_t idx) = 0;
/**
* @brief Disable filter.
*
* @param idx Filter index
*/
virtual void disableFilter(uint8_t idx) = 0;
/**
* @brief Disable and clear all filters.
*/
virtual void clearFilters() = 0;
// Info
//
// Info
//
/**
* @brief Get number of available filters.
*/
virtual uint8_t maxFilterCount() const = 0;
/**
* @brief Get number of available filters.
*/
virtual uint8_t maxFilterCount() const = 0;
/**
* @brief Get number of available FIFOs.
*/
virtual uint8_t maxFifoCount() const = 0;
/**
* @brief Get number of available FIFOs.
*/
virtual uint8_t maxFifoCount() const = 0;
/**
* @brief Get maximum supported payload size.
*/
virtual uint8_t maxPayloadSize() const = 0;
};
/**
* @brief Get maximum supported payload size.
*/
virtual uint8_t maxPayloadSize() const = 0;
};
} // namespace sta

56
include/sta/can/filter.hpp
View File

@@ -12,37 +12,37 @@
namespace sta
{
/**
* @defgroup canFilter Filters
* @ingroup canAPI
* @brief CAN message filter types.
*/
/**
* @defgroup sta_core_can_filters Filters
* @ingroup sta_core_can
* @brief CAN message filter types.
* @{
*/
/**
* @brief ID format matched by CAN filter.
*
* @ingroup canFilter
*/
enum class CanFilterIdFormat
{
ANY, /**< Match both ID formats */
STD, /**< Match standard format IDs */
EXT /**< Match extended format IDs */
};
/**
* @brief ID format matched by CAN filter.
*/
enum class CanFilterIdFormat
{
ANY, /**< Match both ID formats */
STD, /**< Match standard format IDs */
EXT /**< Match extended format IDs */
};
/**
* @brief CAN filter settings.
*
* @ingroup canFilter
*/
struct CanFilter
{
CanId obj; /**< ID object */
CanId mask; /**< ID mask */
CanFilterIdFormat type; /**< ID format to match */
uint8_t fifo; /**< FIFO to store matches */
};
/**
* @brief CAN filter settings.
*/
struct CanFilter
{
CanId obj; /**< ID object */
CanId mask; /**< ID mask */
CanFilterIdFormat type; /**< ID format to match */
uint8_t fifo; /**< FIFO to store matches */
};
/** @} */
} // namespace sta

54
include/sta/can/headers.hpp
View File

@@ -12,36 +12,36 @@
namespace sta
{
/**
* @defgroup canHeader Frame headers
* @ingroup canAPI
* @brief CAN header types for transmitted / received frames.
*/
/**
* @defgroup sta_core_can_headers Frame headers
* @ingroup sta_core_can
* @brief CAN header types for transmitted / received frames.
* @{
*/
/**
* @brief CAN TX frame header.
*
* @ingroup canHeader
*/
struct CanTxHeader
{
CanFrameId id; /**< Frame ID */
uint8_t payloadLength; /**< Size of data to send */
};
/**
* @brief CAN TX frame header.
*/
struct CanTxHeader
{
CanFrameId id; /**< Frame ID */
uint8_t payloadLength; /**< Size of data to send */
};
/**
* @brief CAN RX frame header.
*
* @ingroup canHeader
*/
struct CanRxHeader
{
CanFrameId id; /**< Frame ID */
uint8_t payloadLength; /**< Size of received data */
uint32_t timestamp; /**< RX timestamp */
uint8_t filter; /**< RX filter match */
};
/**
* @brief CAN RX frame header.
*/
struct CanRxHeader
{
CanFrameId id; /**< Frame ID */
uint8_t payloadLength; /**< Size of received data */
uint32_t timestamp; /**< RX timestamp */
uint8_t filter; /**< RX filter match */
};
/** @} */
} // namespace sta

152
include/sta/can/id.hpp
View File

@@ -10,107 +10,99 @@
namespace sta
{
/**
* @defgroup canID Frame IDs
* @ingroup canAPI
* @brief Types for working with CAN ID values and formats.
*/
/**
* @defgroup sta_core_can_ids Frame IDs
* @ingroup sta_core_can
* @brief Types for working with CAN ID values and formats.
*/
/**
* @brief CAN frame ID format.
*
* @ingroup canID
*/
enum class CanIdFormat : uint8_t
{
STD, /**< Standard format */
EXT /**< Extended format */
};
/**
* @brief CAN frame ID format.
*
* @ingroup sta_core_can_ids
*/
enum class CanIdFormat : uint8_t
{
STD, /**< Standard format */
EXT /**< Extended format */
};
/**
* @brief CAN frame ID.
*
* @ingroup canID
*/
struct CanId
{
uint32_t sid; /**< Standard ID field (11 bits) */
uint32_t eid; /**< Extended ID field (18 bits) */
};
/**
* @brief CAN frame ID.
*
* @ingroup sta_core_can_ids
*/
struct CanId
{
uint32_t sid; /**< Standard ID field (11 bits) */
uint32_t eid; /**< Extended ID field (18 bits) */
};
/**
* @brief CAN frame ID and format.
*
* @ingroup canID
*/
struct CanFrameId
{
CanIdFormat format; /**< ID format */
uint32_t sid; /**< Standard ID field (11 bits) */
uint32_t eid; /**< Extended ID field (18 bits) */
};
/**
* @brief CAN frame ID and format.
*
* @ingroup sta_core_can_ids
*/
struct CanFrameId
{
CanIdFormat format; /**< ID format */
uint32_t sid; /**< Standard ID field (11 bits) */
uint32_t eid; /**< Extended ID field (18 bits) */
};
// Comparison operators
//
// Comparison operators
//
/**
* @brief Equal to operator.
*
* @param lhs Left hand side CAN ID
* @param rhs Right hand side CAN ID
* @return True if CAN IDs are equal
*
* @ingroup canID
*/
bool operator ==(const CanId & lhs, const CanId & rhs);
/**
* @brief Not equal to operator.
*
* @param lhs Left hand side CAN ID
* @param rhs Right hand side CAN ID
* @return True if CAN IDs are not equal
*
* @ingroup canID
*/
bool operator !=(const CanId & lhs, const CanId & rhs);
/**
* @brief Equal to operator.
*
* @param lhs Left hand side CAN ID
* @param rhs Right hand side CAN ID
* @return True if CAN IDs are equal
*/
bool operator ==(const CanId & lhs, const CanId & rhs);
/**
* @brief Not equal to operator.
*
* @param lhs Left hand side CAN ID
* @param rhs Right hand side CAN ID
* @return True if CAN IDs are not equal
*/
bool operator !=(const CanId & lhs, const CanId & rhs);
/**
* @brief Equal to operator.
*
* @param lhs Left hand side CAN Frame ID
* @param rhs Right hand side CAN Frame ID
* @return True if CAN Frame IDs are equal
*
* @ingroup canID
*/
bool operator ==(const CanFrameId & lhs, const CanFrameId & rhs);
/**
* @brief Not equal to operator.
*
* @param lhs Left hand side CAN Frame ID
* @param rhs Right hand side CAN Frame ID
* @return True if CAN Frame IDs are not equal
*
* @ingroup canID
*/
bool operator !=(const CanFrameId & lhs, const CanFrameId & rhs);
/**
* @brief Equal to operator.
*
* @param lhs Left hand side CAN Frame ID
* @param rhs Right hand side CAN Frame ID
* @return True if CAN Frame IDs are equal
*/
bool operator ==(const CanFrameId & lhs, const CanFrameId & rhs);
/**
* @brief Not equal to operator.
*
* @param lhs Left hand side CAN Frame ID
* @param rhs Right hand side CAN Frame ID
* @return True if CAN Frame IDs are not equal
*/
bool operator !=(const CanFrameId & lhs, const CanFrameId & rhs);
} // namespace sta
/**
* @brief Maximum CAN standard ID value.
*
* @ingroup canID
* @ingroup sta_core_can_ids
*/
#define CAN_SID_MAX UINT32_C(0x7FF)
/**
* @brief Maximum CAN extended ID value.
*
* @ingroup canID
* @ingroup sta_core_can_ids
*/
#define CAN_EID_MAX UINT32_C(0x3FFFF)

91
include/sta/can/iter.hpp
View File

@@ -10,57 +10,72 @@
namespace sta
{
class CanPendingRxFifos
{
public:
using value_type = uint8_t;
using reference = value_type &;
using const_reference = const value_type &;
using size_type = uint8_t;
/**
* @brief Iterable container interface for CAN RX flags.
*
* @ingroup sta_core_can_ids
*/
class CanPendingRxFifos
{
public:
using value_type = uint8_t;
using reference = value_type &;
using const_reference = const value_type &;
using size_type = uint8_t;
class const_iterator
{
public:
using value_type = CanPendingRxFifos::value_type;
using reference = const_reference;
using pointer = const value_type *;
/**
* @brief Custom iterator for active RX queues.
*/
class const_iterator
{
public:
using value_type = CanPendingRxFifos::value_type;
using reference = const_reference;
using pointer = const value_type *;
public:
const_iterator(const const_iterator & iter);
public:
const_iterator(const const_iterator & iter);
const_iterator & operator=(const const_iterator & iter);
const_iterator & operator=(const const_iterator & iter);
bool operator==(const const_iterator & iter) const;
bool operator!=(const const_iterator & iter) const;
bool operator==(const const_iterator & iter) const;
bool operator!=(const const_iterator & iter) const;
const_iterator & operator++();
const_iterator operator++(int);
const_iterator & operator++();
const_iterator operator++(int);
reference operator*() const;
reference operator*() const;
private:
const_iterator(uint32_t rxFlags, uint8_t idx, uint8_t endIdx);
private:
const_iterator(uint32_t rxFlags, uint8_t idx, uint8_t endIdx);
bool isRxPending() const;
/**
* @brief Check if current RX queue has pending data.
*/
bool isRxPending() const;
friend class CanPendingRxFifos;
friend class CanPendingRxFifos;
private:
uint32_t rxFlags_;
uint8_t idx_;
uint8_t endIdx_;
};
private:
uint32_t rxFlags_; /**< RX flag bits */
uint8_t idx_; /**< Current flag index */
uint8_t endIdx_; /**< Iterator end index */
};
public:
CanPendingRxFifos(uint32_t rxFlags, uint8_t numFifos);
public:
/**
* @param rxFlags RX flag bits
* @param numFifos Number of RX FIFOs
*/
CanPendingRxFifos(uint32_t rxFlags, uint8_t numFifos);
const_iterator begin() const;
const_iterator end() const;
const_iterator begin() const;
const_iterator end() const;
private:
uint32_t rxFlags_;
uint8_t numFifos_;
};
private:
uint32_t rxFlags_; /**< RX flag bits */
uint8_t numFifos_; /**< Number of RX FIFOs */
};
} // namespace sta

136
include/sta/can/subscribable.hpp
View File

@@ -11,90 +11,88 @@
namespace sta
{
/**
* @defgroup canSub Subscription
* @ingroup canAPI
* @brief Subscription interface for CAN controller drivers.
*/
/**
* @defgroup sta_core_can_sub Subscription
* @ingroup sta_core_can
* @brief Subscription interface for CAN controller drivers.
* @{
*/
/**
* @brief Callback for handling received frames.
*
* @param header Frame header
* @param buffer Frame payload buffer
*
* @ingroup canSub
*/
using CanRxCallback = void (*) (const CanRxHeader & header, const uint8_t * buffer);
/**
* @brief Callback for handling received frames.
*
* @param header Frame header
* @param buffer Frame payload buffer
*/
using CanRxCallback = void (*) (const CanRxHeader & header, const uint8_t * buffer);
/**
* @brief Filter configuration and message handler.
*
* @ingroup canSub
*/
struct CanFilterConfig
{
CanFilter filter; /**< Filter handled by callback */
CanRxCallback callback; /**< Callback for message handling */
};
/**
* @brief Filter configuration and message handler.
*/
struct CanFilterConfig
{
CanFilter filter; /**< Filter handled by callback */
CanRxCallback callback; /**< Callback for message handling */
};
/**
* @brief CAN controller with subscriptions.
*
* @tparam T Implementation of CanController interface
*
* @ingroup canSub
*/
template <typename T>
class SubscribableCanController : public T
{
public:
using T::T;
/**
* @brief CAN controller with subscriptions.
*
* @tparam T Implementation of CanController interface
*/
template <typename T>
class SubscribableCanController : public T
{
public:
using T::T;
// Subscriptions
//
// Subscriptions
//
/**
* @brief Subscribe to specific message types.
*
* @param subscriptions Array of message filters and handlers
* @param num Number of array entries
*/
bool subscribe(const CanFilterConfig * subscriptions, uint8_t num);
/**
* @brief Subscribe to specific message types.
*
* @param subscriptions Array of message filters and handlers
* @param num Number of array entries
*/
bool subscribe(const CanFilterConfig * subscriptions, uint8_t num);
/**
* @brief Subscribe to all messages.
*
* @param callback Called when message is received
* @param fifo FIFO used for received messages
*/
void subscribeAll(CanRxCallback callback, uint8_t fifo);
/**
* @brief Subscribe to all messages.
*
* @param callback Called when message is received
* @param fifo FIFO used for received messages
*/
void subscribeAll(CanRxCallback callback, uint8_t fifo);
/**
* @brief Unsubscribe from all messages.
*
* No more messages will be received.
*/
void unsubscribeAll();
/**
* @brief Unsubscribe from all messages.
*
* No more messages will be received.
*/
void unsubscribeAll();
/**
* @brief Read message from RX FIFO and notify subscriber.
*/
void receiveAndNotify(uint8_t fifo);
/**
* @brief Read message from RX FIFO and notify subscriber.
*/
void receiveAndNotify(uint8_t fifo);
/**
* @brief Process pending frames from RX FIFOs.
*/
void processMessages();
/**
* @brief Process pending frames from RX FIFOs.
*/
void processMessages();
private:
CanRxCallback filterCallbacks_[T::MAX_FILTER_COUNT]; /**< Callbacks for RX filters */
};
private:
CanRxCallback filterCallbacks_[T::MAX_FILTER_COUNT]; /**< Callbacks for RX filters */
};
/** @} */
} // namespace sta

158
include/sta/can/subscribable.tpp
View File

@@ -15,105 +15,105 @@
namespace sta
{
template <typename T>
bool SubscribableCanController<T>::subscribe(const CanFilterConfig * subscriptions, uint8_t num)
{
// Check bounds
if (num > T::MAX_FILTER_COUNT)
return false;
template <typename T>
bool SubscribableCanController<T>::subscribe(const CanFilterConfig * subscriptions, uint8_t num)
{
// Check bounds
if (num > T::MAX_FILTER_COUNT)
return false;
// Clear previous subscriptions
unsubscribeAll();
// Clear previous subscriptions
unsubscribeAll();
for (uint8_t i = 0; i < num; ++i)
{
// Save handler callback
filterCallbacks_[i] = subscriptions[i].callback;
for (uint8_t i = 0; i < num; ++i)
{
// Save handler callback
filterCallbacks_[i] = subscriptions[i].callback;
// Configure and enable filter
T::configureFilter(i, subscriptions[i].filter, true);
}
// Configure and enable filter
T::configureFilter(i, subscriptions[i].filter, true);
}
return true;
}
return true;
}
template <typename T>
void SubscribableCanController<T>::subscribeAll(CanRxCallback callback, uint8_t fifo)
{
uint8_t filterIdx = 0;
template <typename T>
void SubscribableCanController<T>::subscribeAll(CanRxCallback callback, uint8_t fifo)
{
uint8_t filterIdx = 0;
// Clear previous subscriptions
unsubscribeAll();
// Clear previous subscriptions
unsubscribeAll();
// Setup default filter
CanFilter filter{};
filter.type = CanFilterIdFormat::ANY;
filter.fifo = fifo;
// Setup default filter
CanFilter filter{};
filter.type = CanFilterIdFormat::ANY;
filter.fifo = fifo;
// Store callback
filterCallbacks_[filterIdx] = callback;
// Store callback
filterCallbacks_[filterIdx] = callback;
// Configure and enable default filter
T::configureFilter(filterIdx, filter, true);
}
// Configure and enable default filter
T::configureFilter(filterIdx, filter, true);
}
template <typename T>
void SubscribableCanController<T>::unsubscribeAll()
{
// Disable all filters
T::clearFilters();
template <typename T>
void SubscribableCanController<T>::unsubscribeAll()
{
// Disable all filters
T::clearFilters();
// Clear filter callbacks
// Clear filter callbacks
#ifndef STA_STDLIB_DISABLE
std::fill_n(filterCallbacks_, T::MAX_FILTER_COUNT, nullptr);
std::fill_n(filterCallbacks_, T::MAX_FILTER_COUNT, nullptr);
#else // STA_STDLIB_DISABLE
for (uint8_t i = 0; i < T::MAX_FILTER_COUNT; ++i)
{
filterCallbacks_[i] = nullptr;
}
for (uint8_t i = 0; i < T::MAX_FILTER_COUNT; ++i)
{
filterCallbacks_[i] = nullptr;
}
#endif // STA_STDLIB_DISABLE
}
}
template <typename T>
void SubscribableCanController<T>::receiveAndNotify(uint8_t fifo)
{
CanRxHeader header;
uint8_t payload[T::MAX_PAYLOAD_SIZE];
template <typename T>
void SubscribableCanController<T>::receiveAndNotify(uint8_t fifo)
{
CanRxHeader header;
uint8_t payload[T::MAX_PAYLOAD_SIZE];
if (T::receiveFrame(fifo, &header, payload))
{
//displayFrameUART(frame);
if (T::receiveFrame(fifo, &header, payload))
{
//displayFrameUART(frame);
// Forward frame to filter callback
if (fifo <= T::MAX_FILTER_COUNT && filterCallbacks_[header.filter])
{
filterCallbacks_[header.filter](header, payload);
}
}
}
// Forward frame to filter callback
if (fifo <= T::MAX_FILTER_COUNT && filterCallbacks_[header.filter])
{
filterCallbacks_[header.filter](header, payload);
}
}
}
template <typename T>
void SubscribableCanController<T>::processMessages()
{
// Read RX interrupt flags
uint32_t RFIF = T::getRxFifoFlags();
template <typename T>
void SubscribableCanController<T>::processMessages()
{
// Read RX interrupt flags
uint32_t RFIF = T::getRxFifoFlags();
if (RFIF != 0)
{
// Check all flags
for (uint8_t fifo = 0; fifo < T::MAX_FIFO_COUNT; ++fifo)
{
// Process messages if flag is set
if (RFIF & 0x1)
{
receiveAndNotify(fifo);
}
if (RFIF != 0)
{
// Check all flags
for (uint8_t fifo = 0; fifo < T::MAX_FIFO_COUNT; ++fifo)
{
// Process messages if flag is set
if (RFIF & 0x1)
{
receiveAndNotify(fifo);
}
// Shift next RX flag to LSB
RFIF >>= 1;
}
}
}
// Shift next RX flag to LSB
RFIF >>= 1;
}
}
}
} // namespace sta

29
include/sta/debug_serial.hpp
View File

@@ -11,11 +11,6 @@
#ifndef STA_CORE_DEBUG_SERIAL_HPP
#define STA_CORE_DEBUG_SERIAL_HPP
/**
* @defgroup staCoreDebug Debug Serial
* @ingroup staCore
* @brief Debug serial output.
*/
#include <sta/config.hpp>
@@ -35,19 +30,27 @@
# endif // !STA_DEBUG_SERIAL_FORCE
#endif // STA_DEBUG_SERIAL_UART
#if defined(STA_DEBUG_SERIAL_ENABLED) || defined(DOXYGEN)
#include <sta/printable_uart.hpp>
/**
* @defgroup sta_core_debug Debug Serial
* @ingroup sta_core
* @brief Debug serial output.
*/
namespace sta
{
/**
* @brief %UART print object for debug serial output.
*
* @ingroup staCoreDebug
*/
extern PrintableUART DebugSerial;
/**
* @brief %UART print object for debug serial output.
*
* @ingroup sta_core_debug
*/
extern PrintableUART DebugSerial;
} // namespace sta
@@ -56,7 +59,7 @@ namespace sta
*
* @param ... See @ref sta::PrintableUART::print
*
* @ingroup staCoreDebug
* @ingroup sta_core_debug
*/
# define STA_DEBUG_PRINT(...) sta::DebugSerial.print(__VA_ARGS__)
/**
@@ -64,7 +67,7 @@ namespace sta
*
* @param ... See @ref sta::PrintableUART::println
*
* @ingroup staCoreDebug
* @ingroup sta_core_debug
*/
# define STA_DEBUG_PRINTLN(...) sta::DebugSerial.println(__VA_ARGS__)
#else // !STA_DEBUG_SERIAL_ENABLED

92
include/sta/endian.hpp
View File

@@ -5,11 +5,6 @@
#ifndef STA_CORE_ENDIAN_HPP
#define STA_CORE_ENDIAN_HPP
/**
* @defgroup staCoreEndian Endian
* @ingroup staCore
* @brief Endian handling.
*/
#include <sta/config.hpp>
@@ -18,99 +13,95 @@
#endif // !STA_MCU_BIG_ENDIAN && !STA_MCU_LITTLE_ENDIAN
/**
* @defgroup sta_core_endian Endian
* @ingroup sta_core
* @brief Endian handling.
* @{
*/
/**
* @brief Get 16-bit value with swapped byte order.
*
* @param u16 16-bit input value
* @return 16-bit value w/ swapped byte order
*
* @ingroup staCoreEndian
*/
#define STA_UINT16_SWAP_BYTE_ORDER(u16) \
( \
((u16 & 0x00FF) << 8) \
| ((u16 & 0xFF00) >> 8) \
)
( \
((u16 & 0x00FF) << 8) \
| ((u16 & 0xFF00) >> 8) \
)
/**
* @brief Get 32-bit value with swapped byte order.
*
* @param u32 32-bit input value
* @return 32-bit value w/ swapped byte order
*
* @ingroup staCoreEndian
*/
#define STA_UINT32_SWAP_BYTE_ORDER(u32) \
( \
((u32 & 0x000000FF) << 24) \
| ((u32 & 0x0000FF00) << 8) \
| ((u32 & 0x00FF0000) >> 8) \
| ((u32 & 0xFF000000) >> 24) \
)
( \
((u32 & 0x000000FF) << 24) \
| ((u32 & 0x0000FF00) << 8) \
| ((u32 & 0x00FF0000) >> 8) \
| ((u32 & 0xFF000000) >> 24) \
)
/**
* @brief Get initializer list for byte array with big-endian byte order from 16-bit value.
*
* @param u16 16-bit input value
* @return Initializer list for uint8_t[2]
*
* @ingroup staCoreEndian
*/
#define STA_UINT16_TO_BYTES_BE(u16) \
{ \
static_cast<uint8_t>(u16 >> 8), \
static_cast<uint8_t>(u16) \
}
{ \
static_cast<uint8_t>(u16 >> 8), \
static_cast<uint8_t>(u16) \
}
/**
* @brief Get initializer list for byte array with little-endian byte order from 16-bit value.
*
* @param u16 16-bit input value
* @return Initializer list for uint8_t[2]
*
* @ingroup staCoreEndian
*/
#define STA_UINT16_TO_BYTES_LE(u16) \
{ \
static_cast<uint8_t>(u16), \
static_cast<uint8_t>(u16 >> 8) \
}
{ \
static_cast<uint8_t>(u16), \
static_cast<uint8_t>(u16 >> 8) \
}
/**
* @brief Get initializer list for byte array with big-endian byte order from 32-bit value.
*
* @param u32 32-bit input value
* @return Initializer list for uint8_t[4]
*
* @ingroup staCoreEndian
*/
#define STA_UINT32_TO_BYTES_BE(u32) \
{ \
static_cast<uint8_t>(u32 >> 24), \
static_cast<uint8_t>(u32 >> 16), \
static_cast<uint8_t>(u32 >> 8), \
static_cast<uint8_t>(u32) \
}
{ \
static_cast<uint8_t>(u32 >> 24), \
static_cast<uint8_t>(u32 >> 16), \
static_cast<uint8_t>(u32 >> 8), \
static_cast<uint8_t>(u32) \
}
/**
* @brief Get initializer list for byte array with little-endian byte order from 32-bit value.
*
* @param u32 32-bit input value
* @return Initializer list for uint8_t[4]
*
* @ingroup staCoreEndian
*/
#define STA_UINT32_TO_BYTES_LE(u32) \
{ \
static_cast<uint8_t>(u32), \
static_cast<uint8_t>(u32 >> 8), \
static_cast<uint8_t>(u32 >> 16), \
static_cast<uint8_t>(u32 >> 24) \
}
{ \
static_cast<uint8_t>(u32), \
static_cast<uint8_t>(u32 >> 8), \
static_cast<uint8_t>(u32 >> 16), \
static_cast<uint8_t>(u32 >> 24) \
}
/**
* @defe STA_UINT16_TO_BE(u16)
* @def STA_UINT16_TO_BE(u16)
* @brief Convert 16-bit value to big-endian byte order.
*
* @param u16 16-bit input value
@@ -174,6 +165,9 @@
*/
/** @} */
#ifdef STA_MCU_LITTLE_ENDIAN
# define STA_UINT16_TO_BE(u16) STA_UINT16_SWAP_BYTE_ORDER(u16)
@@ -186,7 +180,7 @@
# define STA_UINT32_TO_BYTES(u32) STA_UINT32_TO_BYTES_LE(u32)
# define STA_UINT32_TO_BYTES_SWAP(u32) STA_UINT32_TO_BYTES_BE(u32)
#elif STA_MCU_BIG_ENDIAN
#else // STA_MCU_BIG_ENDIAN
# define STA_UINT16_TO_BE(u16) (u16)
# define STA_UINT16_TO_LE(u16) STA_UINT16_SWAP_BYTE_ORDER(u16)

270
include/sta/enum_flags.hpp
View File

@@ -10,143 +10,143 @@
namespace sta
{
/**
* @brief 32-bit flag register with enum type representing single flag bits.
*
* @tparam F Enum type used for flag bits
*
* @ingroup staCore
*/
template <typename F>
class EnumFlags
{
public:
using flag_type = F; /**< Enum type used for flag bits */
/**
* @brief 32-bit flag register with enum type representing single flag bits.
*
* @tparam F Enum type used for flag bits
*
* @ingroup sta_core
*/
template <typename F>
class EnumFlags
{
public:
using flag_type = F; /**< Enum type used for flag bits */
public:
/**
* @brief Default constructor.
*/
EnumFlags();
/**
* @brief Copy constructor.
*
* @param other Flags to copy
*/
EnumFlags(const EnumFlags & other);
/**
* @brief Construct from single flag.
*
* @param flag Single flag bit to set
*/
EnumFlags(flag_type flag);
public:
/**
* @brief Default constructor.
*/
EnumFlags();
/**
* @brief Copy constructor.
*
* @param other Flags to copy
*/
EnumFlags(const EnumFlags & other);
/**
* @brief Construct from single flag.
*
* @param flag Single flag bit to set
*/
EnumFlags(flag_type flag);
// Modification
//
// Modification
//
/**
* @brief Set bits from flags register.
*
* @param flags Flag bits to set
*/
void set(const EnumFlags & flags);
/**
* @brief Clear flag bits.
*
* @param flags Flag bits to clear
*/
void clear(const EnumFlags & flags);
/**
* @brief Clear all flag bits.
*/
void clear();
/**
* @brief Set bits from flags register.
*
* @param flags Flag bits to set
*/
void set(const EnumFlags & flags);
/**
* @brief Clear flag bits.
*
* @param flags Flag bits to clear
*/
void clear(const EnumFlags & flags);
/**
* @brief Clear all flag bits.
*/
void clear();
// Inspection
//
// Inspection
//
/**
* @brief Test if all flags are set.
*
* @param flags Flag bits to check
* @return True if all checked flag bits are set
*/
bool isSet(const EnumFlags & flags) const;
/**
* @brief Test if all flags are set.
*
* @param flags Flag bits to check
* @return True if all checked flag bits are set
*/
bool isSet(const EnumFlags & flags) const;
/**
* @brief Test if any flag is set.
*
* @param flags Flag bits to check
* @return True if any checked flag bit is set
*/
bool isAnySet(const EnumFlags & flags) const;
/**
* @brief Test if any flag is set.
*
* @param flags Flag bits to check
* @return True if any checked flag bit is set
*/
bool isAnySet(const EnumFlags & flags) const;
// Operator overloads
//
// Operator overloads
//
/**
* @brief Equal to operator.
*
* @param rhs Flags to compare
* @return True if flags are equal
*/
bool operator ==(const EnumFlags & rhs) const;
/**
* @brief Not equal to operator.
*
* @param rhs Flags to compare
* @return True if flags are not equal
*/
bool operator !=(const EnumFlags & rhs) const;
/**
* @brief Equal to operator.
*
* @param rhs Flags to compare
* @return True if flags are equal
*/
bool operator ==(const EnumFlags & rhs) const;
/**
* @brief Not equal to operator.
*
* @param rhs Flags to compare
* @return True if flags are not equal
*/
bool operator !=(const EnumFlags & rhs) const;
/**
* @brief Bitwise AND operator.
*
* @param rhs Other flags
* @return Result of bitwise AND
*/
EnumFlags operator &(const EnumFlags & rhs) const;
/**
* @brief Bitwise OR operator.
*
* @param rhs Other flags
* @return Result of bitwise OR
*/
EnumFlags operator |(const EnumFlags & rhs) const;
/**
* @brief Bitwise AND operator.
*
* @param rhs Other flags
* @return Result of bitwise AND
*/
EnumFlags operator &(const EnumFlags & rhs) const;
/**
* @brief Bitwise OR operator.
*
* @param rhs Other flags
* @return Result of bitwise OR
*/
EnumFlags operator |(const EnumFlags & rhs) const;
/**
* @brief Bitwise AND assignment operator.
*
* @param rhs Other flags
* @return Reference to this
*/
EnumFlags & operator &=(const EnumFlags & rhs);
/**
* @brief Bitwise OR assignment operator.
*
* @param rhs Other flags
* @return Reference to this
*/
EnumFlags & operator |=(const EnumFlags & rhs);
/**
* @brief Bitwise AND assignment operator.
*
* @param rhs Other flags
* @return Reference to this
*/
EnumFlags & operator &=(const EnumFlags & rhs);
/**
* @brief Bitwise OR assignment operator.
*
* @param rhs Other flags
* @return Reference to this
*/
EnumFlags & operator |=(const EnumFlags & rhs);
/**
* @brief Explicitly convert flags to uint32_t.
*/
explicit operator uint32_t();
/**
* @brief Explicitly convert flags to uint32_t.
*/
explicit operator uint32_t();
private:
/**
* @brief Construct from uint32_t flags.
*
* @param flags Flags
*/
EnumFlags(uint32_t flags);
private:
/**
* @brief Construct from uint32_t flags.
*
* @param flags Flags
*/
EnumFlags(uint32_t flags);
private:
uint32_t flags_; /**< Flags register */
};
private:
uint32_t flags_; /**< Flags register */
};
} // namespace sta
@@ -155,23 +155,23 @@ namespace sta
*
* @param enumType Enum type to overload
*
* @ingroup staCore
* @ingroup sta_core
*/
#define STA_ENUM_FLAGS_OVERLOAD(enumType) \
sta::EnumFlags<enumType> operator |(enumType lhs, enumType rhs) \
{ \
return sta::EnumFlags<enumType>{lhs} | rhs; \
}
sta::EnumFlags<enumType> operator |(enumType lhs, enumType rhs) \
{ \
return sta::EnumFlags<enumType>{lhs} | rhs; \
}
/**
* @brief Declare alias for sta::EnumFlags specialization.
*
* @param enumType Enum type for specialization
*
* @ingroup staCore
* @ingroup sta_core
*/
#define STA_ENUM_FLAGS_ALIAS(enumType) \
using enumType ## Flags = sta::EnumFlags<enumType>
using enumType ## Flags = sta::EnumFlags<enumType>
/**
* @brief Declare enum and create sta::EnumFlags alias and overloads.
@@ -180,15 +180,15 @@ namespace sta
* @param value1 First enum value
* @param ... Enum values 2 - 32
*
* @ingroup staCore
* @ingroup sta_core
*/
#define STA_ENUM_FLAGS_DECL(enumType, value1, ...) \
enum class enumType \
{ \
value1, ##__VA_ARGS__ \
}; \
STA_ENUM_FLAGS_ALIAS(enumType); \
STA_ENUM_FLAGS_OVERLOAD(enumType)
enum class enumType \
{ \
value1, ##__VA_ARGS__ \
}; \
STA_ENUM_FLAGS_ALIAS(enumType); \
STA_ENUM_FLAGS_OVERLOAD(enumType)
// Include template implementation

156
include/sta/enum_flags.tpp
View File

@@ -11,105 +11,105 @@
namespace sta
{
template <typename F>
EnumFlags<F>::EnumFlags()
: flags_{0}
{}
template <typename F>
EnumFlags<F>::EnumFlags()
: flags_{0}
{}
template <typename F>
EnumFlags<F>::EnumFlags(const EnumFlags & other)
: flags_{other.flags_}
{}
template <typename F>
EnumFlags<F>::EnumFlags(const EnumFlags & other)
: flags_{other.flags_}
{}
template <typename F>
EnumFlags<F>::EnumFlags(flag_type flag)
: flags_{1U << static_cast<uint8_t>(flag)}
{}
template <typename F>
EnumFlags<F>::EnumFlags(flag_type flag)
: flags_{1U << static_cast<uint8_t>(flag)}
{}
template <typename F>
EnumFlags<F>::EnumFlags(uint32_t flags)
: flags_{flags}
{}
template <typename F>
EnumFlags<F>::EnumFlags(uint32_t flags)
: flags_{flags}
{}
template <typename F>
void EnumFlags<F>::set(const EnumFlags & flags)
{
flags_ |= flags.flags_;
}
template <typename F>
void EnumFlags<F>::set(const EnumFlags & flags)
{
flags_ |= flags.flags_;
}
template <typename F>
void EnumFlags<F>::clear(const EnumFlags & flags)
{
flags_ &= ~(flags.flags_);
}
template <typename F>
void EnumFlags<F>::clear(const EnumFlags & flags)
{
flags_ &= ~(flags.flags_);
}
template <typename F>
void EnumFlags<F>::clear()
{
flags_ = 0;
}
template <typename F>
void EnumFlags<F>::clear()
{
flags_ = 0;
}
template <typename F>
bool EnumFlags<F>::isSet(const EnumFlags & flags) const
{
return (flags_ & flags.flags_) == flags.flags_;
}
template <typename F>
bool EnumFlags<F>::isSet(const EnumFlags & flags) const
{
return (flags_ & flags.flags_) == flags.flags_;
}
template <typename F>
bool EnumFlags<F>::isAnySet(const EnumFlags & flags) const
{
return (flags_ & flags.flags_) != 0;
}
template <typename F>
bool EnumFlags<F>::isAnySet(const EnumFlags & flags) const
{
return (flags_ & flags.flags_) != 0;
}
template <typename F>
bool EnumFlags<F>::operator ==(const EnumFlags<F> & rhs) const
{
return (flags_ == rhs.flags_);
}
template <typename F>
bool EnumFlags<F>::operator ==(const EnumFlags<F> & rhs) const
{
return (flags_ == rhs.flags_);
}
template <typename F>
bool EnumFlags<F>::operator !=(const EnumFlags<F> & rhs) const
{
return (flags_ != rhs.flags_);
}
template <typename F>
bool EnumFlags<F>::operator !=(const EnumFlags<F> & rhs) const
{
return (flags_ != rhs.flags_);
}
template <typename F>
EnumFlags<F> EnumFlags<F>::operator &(const EnumFlags<F> & rhs) const
{
return EnumFlags(flags_ & rhs.flags_);
}
template <typename F>
EnumFlags<F> EnumFlags<F>::operator &(const EnumFlags<F> & rhs) const
{
return EnumFlags(flags_ & rhs.flags_);
}
template <typename F>
EnumFlags<F> EnumFlags<F>::operator |(const EnumFlags<F> & rhs) const
{
return EnumFlags(flags_ | rhs.flags_);
}
template <typename F>
EnumFlags<F> EnumFlags<F>::operator |(const EnumFlags<F> & rhs) const
{
return EnumFlags(flags_ | rhs.flags_);
}
template <typename F>
EnumFlags<F> & EnumFlags<F>::operator &=(const EnumFlags<F> & rhs)
{
flags_ &= rhs.flags_;
return *this;
}
template <typename F>
EnumFlags<F> & EnumFlags<F>::operator &=(const EnumFlags<F> & rhs)
{
flags_ &= rhs.flags_;
return *this;
}
template <typename F>
EnumFlags<F> & EnumFlags<F>::operator |=(const EnumFlags<F> & rhs)
{
flags_ |= rhs.flags_;
return *this;
}
template <typename F>
EnumFlags<F> & EnumFlags<F>::operator |=(const EnumFlags<F> & rhs)
{
flags_ |= rhs.flags_;
return *this;
}
template <typename F>
EnumFlags<F>::operator uint32_t()
{
return flags_;
}
template <typename F>
EnumFlags<F>::operator uint32_t()
{
return flags_;
}
} // namespace sta

186
include/sta/fifo_buffer.hpp
View File

@@ -8,107 +8,107 @@
namespace sta
{
/**
* @brief FIFO buffer.
*
* @tparam Size Size type
* @tparam N Buffer size
*
* @ingroup staCore
*/
template <typename Size, Size N>
class FifoBuffer
{
public:
/**
* @brief FIFO size type.
*/
using size_type = Size;
/**
* @brief Max number of bytes in FIFO.
*/
static constexpr size_type MAX_SIZE = N;
/**
* @brief FIFO buffer.
*
* @tparam Size Size type
* @tparam N Buffer size
*
* @ingroup sta_core
*/
template <typename Size, Size N>
class FifoBuffer
{
public:
/**
* @brief FIFO size type.
*/
using size_type = Size;
/**
* @brief Max number of bytes in FIFO.
*/
static constexpr size_type MAX_SIZE = N;
public:
/**
* @brief Construct empty FIFO buffer.
*/
FifoBuffer();
/**
* @brief Construct FIFO buffer with initial data.
*
* @param buffer Source buffer
* @param size Buffer size
*/
FifoBuffer(const uint8_t * buffer, Size size);
public:
/**
* @brief Construct empty FIFO buffer.
*/
FifoBuffer();
/**
* @brief Construct FIFO buffer with initial data.
*
* @param buffer Source buffer
* @param size Buffer size
*/
FifoBuffer(const uint8_t * buffer, Size size);
/**
* @brief Clear buffer content.
*/
void clear();
/**
* @brief Clear buffer content.
*/
void clear();
/**
* @brief Set data in buffer.
*
* @param buffer Source buffer
* @param size Number of bytes to write
*/
void set(const uint8_t * buffer, size_type size);
/**
* @brief Set data in buffer.
*
* @param buffer Source buffer
* @param size Number of bytes to write
*/
void set(const uint8_t * buffer, size_type size);
/**
* @brief Append value to end of buffer.
*
* @param value Value
*/
void pushBack(uint8_t value);
/**
* @brief Append data to end of buffer.
*
* @param buffer Source buffer
* @param size Number of bytes to write
*/
void pushBack(const uint8_t * buffer, size_type size);
/**
* @brief Append value repeatedly to end of buffer.
*
* @param value Fill value
* @param count Repeat count
*/
void pushBack(uint8_t value, size_type count);
/**
* @brief Append value to end of buffer.
*
* @param value Value
*/
void pushBack(uint8_t value);
/**
* @brief Append data to end of buffer.
*
* @param buffer Source buffer
* @param size Number of bytes to write
*/
void pushBack(const uint8_t * buffer, size_type size);
/**
* @brief Append value repeatedly to end of buffer.
*
* @param value Fill value
* @param count Repeat count
*/
void pushBack(uint8_t value, size_type count);
/**
* @brief Take data from start of buffer.
*
* @param buffer Destination buffer
* @param size Number of bytes to read
*/
void popFront(uint8_t * buffer, size_type size);
/**
* @brief Take data from start of buffer.
*
* @param buffer Destination buffer
* @param size Number of bytes to read
*/
void popFront(uint8_t * buffer, size_type size);
/**
* @brief Get size of data in buffer.
*
* @return Data size
*/
size_type size() const;
/**
* @brief Get size of data in buffer.
*
* @return Data size
*/
size_type size() const;
/**
* @brief Check if buffer is full.
*
* @return True if buffer is full
*/
bool isFull() const;
/**
* @brief Check if buffer is empty.
*
* @return True if buffer is empty
*/
bool isEmpty() const;
/**
* @brief Check if buffer is full.
*
* @return True if buffer is full
*/
bool isFull() const;
/**
* @brief Check if buffer is empty.
*
* @return True if buffer is empty
*/
bool isEmpty() const;
private:
uint8_t * head_; /**< Read position */
uint8_t * tail_; /**< Write position */
uint8_t buffer_[N]; /**< Buffer data */
};
private:
uint8_t * head_; /**< Read position */
uint8_t * tail_; /**< Write position */
uint8_t buffer_[N]; /**< Buffer data */
};
} // namespace sta

134
include/sta/fifo_buffer.tpp
View File

@@ -10,93 +10,93 @@
namespace sta
{
template <typename Size, Size N>
FifoBuffer<Size, N>::FifoBuffer()
: head_{buffer_}, tail_{buffer_}
{}
template <typename Size, Size N>
FifoBuffer<Size, N>::FifoBuffer()
: head_{buffer_}, tail_{buffer_}
{}
template <typename Size, Size N>
FifoBuffer<Size, N>::FifoBuffer(const uint8_t * buffer, size_type size)
{
set(buffer, size);
}
template <typename Size, Size N>
FifoBuffer<Size, N>::FifoBuffer(const uint8_t * buffer, size_type size)
{
set(buffer, size);
}
template <typename Size, Size N>
void FifoBuffer<Size, N>::set(const uint8_t * buffer, size_type bsize)
{
STA_ASSERT(bsize <= sizeof(buffer_));
STA_ASSERT(buffer != nullptr);
template <typename Size, Size N>
void FifoBuffer<Size, N>::set(const uint8_t * buffer, size_type bsize)
{
STA_ASSERT(bsize <= sizeof(buffer_));
STA_ASSERT(buffer != nullptr);
head_ = buffer_;
tail_ = buffer_ + bsize;
memcpy(buffer_, buffer, bsize);
}
head_ = buffer_;
tail_ = buffer_ + bsize;
memcpy(buffer_, buffer, bsize);
}
template <typename Size, Size N>
void FifoBuffer<Size, N>::clear()
{
head_ = tail_ = buffer_;
}
template <typename Size, Size N>
void FifoBuffer<Size, N>::clear()
{
head_ = tail_ = buffer_;
}
template <typename Size, Size N>
void FifoBuffer<Size, N>::pushBack(uint8_t value)
{
STA_ASSERT_MSG(tail_ < buffer_ + sizeof(buffer_), "Buffer overflow");
template <typename Size, Size N>
void FifoBuffer<Size, N>::pushBack(uint8_t value)
{
STA_ASSERT_MSG(tail_ < buffer_ + sizeof(buffer_), "Buffer overflow");
*tail_++ = value;
}
*tail_++ = value;
}
template <typename Size, Size N>
void FifoBuffer<Size, N>::pushBack(const uint8_t * buffer, size_type bsize)
{
STA_ASSERT_MSG(size() + bsize <= sizeof(buffer_), "Buffer overflow");
STA_ASSERT(buffer != nullptr);
template <typename Size, Size N>
void FifoBuffer<Size, N>::pushBack(const uint8_t * buffer, size_type bsize)
{
STA_ASSERT_MSG(size() + bsize <= sizeof(buffer_), "Buffer overflow");
STA_ASSERT(buffer != nullptr);
memcpy(tail_, buffer, bsize);
tail_ += bsize;
}
memcpy(tail_, buffer, bsize);
tail_ += bsize;
}
template <typename Size, Size N>
void FifoBuffer<Size, N>::pushBack(uint8_t value, size_type count)
{
STA_ASSERT_MSG(size() + count <= sizeof(buffer_), "Buffer overflow");
template <typename Size, Size N>
void FifoBuffer<Size, N>::pushBack(uint8_t value, size_type count)
{
STA_ASSERT_MSG(size() + count <= sizeof(buffer_), "Buffer overflow");
memset(tail_, value, count);
tail_ += count;
}
memset(tail_, value, count);
tail_ += count;
}
template <typename Size, Size N>
void FifoBuffer<Size, N>::popFront(uint8_t * buffer, size_type bsize)
{
STA_ASSERT_MSG(size() >= bsize, "Not enough data");
STA_ASSERT(buffer != nullptr);
template <typename Size, Size N>
void FifoBuffer<Size, N>::popFront(uint8_t * buffer, size_type bsize)
{
STA_ASSERT_MSG(size() >= bsize, "Not enough data");
STA_ASSERT(buffer != nullptr);
memcpy(buffer, head_, bsize);
head_ += bsize;
}
memcpy(buffer, head_, bsize);
head_ += bsize;
}
template <typename Size, Size N>
typename FifoBuffer<Size, N>::size_type FifoBuffer<Size, N>::size() const
{
return (tail_ - head_);
}
template <typename Size, Size N>
typename FifoBuffer<Size, N>::size_type FifoBuffer<Size, N>::size() const
{
return (tail_ - head_);
}
template <typename Size, Size N>
bool FifoBuffer<Size, N>::isFull() const
{
return (tail_ == buffer_ + sizeof(buffer_));
}
template <typename Size, Size N>
bool FifoBuffer<Size, N>::isFull() const
{
return (tail_ == buffer_ + sizeof(buffer_));
}
template <typename Size, Size N>
bool FifoBuffer<Size, N>::isEmpty() const
{
return (head_ == tail_);
}
template <typename Size, Size N>
bool FifoBuffer<Size, N>::isEmpty() const
{
return (head_ == tail_);
}
} // namespace sta

53
include/sta/gpio_pin.hpp
View File

@@ -8,28 +8,39 @@
namespace sta
{
/**
* @brief GPIO pin state.
*/
enum class GpioPinState
{
LOW,
HIGH
};
/**
* @defgroup sta_core_gpio GPIO
* @ingroup sta_core
* @brief GPIO pins.
* @{
*/
/**
* @brief Interface for GPIO pins.
*/
class GpioPin
{
public:
/**
* @brief Set pin output state.
*
* @param state Output state
*/
virtual void setState(GpioPinState state) = 0;
};
/**
* @brief GPIO pin state.
*/
enum class GpioPinState
{
LOW,
HIGH
};
/**
* @brief Interface for GPIO pins.
*/
class GpioPin
{
public:
/**
* @brief Set pin output state.
*
* @param state Output state
*/
virtual void setState(GpioPinState state) = 0;
};
/** @} */
} // namespace sta

5
include/sta/lang.hpp
View File

@@ -5,9 +5,10 @@
#ifndef STA_CORE_LANG_HPP
#define STA_CORE_LANG_HPP
/**
* @defgroup staCoreLang Lang
* @ingroup staCore
* @defgroup sta_core_lang Lang
* @ingroup sta_core
* @brief Compiler instructions.
* @{
*/

34
include/sta/mutex.hpp
View File

@@ -8,23 +8,25 @@
namespace sta
{
/**
* @brief Interface for mutex objects.
*/
class Mutex
{
public:
/**
* @brief Block until mutex has been acquired.
*/
virtual void acquire() = 0;
/**
* @brief Release mutex.
*/
virtual void release() = 0;
/**
* @brief Interface for mutex objects.
*
* @ingroup sta_core
*/
class Mutex
{
public:
/**
* @brief Block until mutex has been acquired.
*/
virtual void acquire() = 0;
/**
* @brief Release mutex.
*/
virtual void release() = 0;
static Mutex * ALWAYS_FREE; /**< Fake mutex that can always be acquired */
};
static Mutex * ALWAYS_FREE; /**< Fake mutex that can always be acquired */
};
} // namespace sta

358
include/sta/printable_uart.hpp
View File

@@ -13,191 +13,191 @@
namespace sta
{
/**
* @brief Integer representation.
*
* @ingroup staCore
*/
enum class IntegerBase
{
DEC, /**< Decimal */
BIN, /**< Binary */
HEX /**< Hexadecimal */
};
/**
* @brief Integer representation.
*
* @ingroup sta_core
*/
enum class IntegerBase
{
DEC, /**< Decimal */
BIN, /**< Binary */
HEX /**< Hexadecimal */
};
/**
* @brief Printable interface for UART.
*
* @ingroup staCore
*/
class PrintableUART
{
public:
/**
* @param intf UART instance
*/
PrintableUART(UART * intf);
/**
* @brief Printable interface for UART.
*
* @ingroup sta_core
*/
class PrintableUART
{
public:
/**
* @param intf UART instance
*/
PrintableUART(UART * intf);
/**
* @brief Print single character.
*
* @param c Character to print
*/
void print(char c);
/**
* @brief Print boolean value.
*
* @param b Boolean value
*/
void print(bool b);
/**
* @brief Print floating point value.
*
* @param d Floating point value
*/
void print(double d);
/**
* @brief Print integer in selected base.
*
* @param num 8-bit unsigned integer
* @param base Integer base
*/
void print(uint8_t num, IntegerBase base = IntegerBase::DEC);
/**
* @brief Print integer in selected base.
*
* @param num 16-bit unsigned integer
* @param base Integer base
*/
void print(uint16_t num, IntegerBase base = IntegerBase::DEC);
/**
* @brief Print integer in selected base.
*
* @param num 32-bit unsigned integer
* @param base Integer base
*/
void print(uint32_t num, IntegerBase base = IntegerBase::DEC);
/**
* @brief Print integer in selected base.
*
* @param num Integer
* @param base Integer base
*/
void print(size_t num, IntegerBase base = IntegerBase::DEC);
/**
* @brief Print c-string.
*
* @param str Null terminated string
*/
void print(const char * str);
/**
* @brief Print string.
*
* @param str String buffer
* @param length String length
*/
void print(const char * str, size_t length);
/**
* @brief Print single character.
*
* @param c Character to print
*/
void print(char c);
/**
* @brief Print boolean value.
*
* @param b Boolean value
*/
void print(bool b);
/**
* @brief Print floating point value.
*
* @param d Floating point value
*/
void print(double d);
/**
* @brief Print integer in selected base.
*
* @param num 8-bit unsigned integer
* @param base Integer base
*/
void print(uint8_t num, IntegerBase base = IntegerBase::DEC);
/**
* @brief Print integer in selected base.
*
* @param num 16-bit unsigned integer
* @param base Integer base
*/
void print(uint16_t num, IntegerBase base = IntegerBase::DEC);
/**
* @brief Print integer in selected base.
*
* @param num 32-bit unsigned integer
* @param base Integer base
*/
void print(uint32_t num, IntegerBase base = IntegerBase::DEC);
/**
* @brief Print integer in selected base.
*
* @param num Integer
* @param base Integer base
*/
void print(size_t num, IntegerBase base = IntegerBase::DEC);
/**
* @brief Print c-string.
*
* @param str Null terminated string
*/
void print(const char * str);
/**
* @brief Print string.
*
* @param str String buffer
* @param length String length
*/
void print(const char * str, size_t length);
/**
* @brief Print new-line.
*/
void println();
/**
* @brief Print single character followed by a new-line.
*
* @param c Character to print
*/
void println(char c);
/**
* @brief Print boolean value followed by a new-line.
*
* @param b Boolean value
*/
void println(bool b);
/**
* @brief Print floating point value followed by a new-line.
*
* @param d Floating point value
*/
void println(double d);
/**
* @brief Print integer in selected base followed by a new-line.
*
* @param num 8-bit unsigned integer
* @param base Integer base
*/
void println(uint8_t num, IntegerBase base = IntegerBase::DEC);
/**
* @brief Print integer in selected base followed by a new-line.
*
* @param num 16-bit unsigned integer
* @param base Integer base
*/
void println(uint16_t num, IntegerBase base = IntegerBase::DEC);
/**
* @brief Print integer in selected base followed by a new-line.
*
* @param num 32-bit unsigned integer
* @param base Integer base
*/
void println(uint32_t num, IntegerBase base = IntegerBase::DEC);
/**
* @brief Print integer in selected base followed by a new-line.
*
* @param num Integer
* @param base Integer base
*/
void println(size_t num, IntegerBase base = IntegerBase::DEC);
/**
* @brief Print c-string followed by a new-line.
*
* @param str Null terminated string
*/
void println(const char * str);
/**
* @brief Print string followed by a new-line.
*
* @param str String buffer
* @param length String length
*/
void println(const char * str, size_t length);
/**
* @brief Print new-line.
*/
void println();
/**
* @brief Print single character followed by a new-line.
*
* @param c Character to print
*/
void println(char c);
/**
* @brief Print boolean value followed by a new-line.
*
* @param b Boolean value
*/
void println(bool b);
/**
* @brief Print floating point value followed by a new-line.
*
* @param d Floating point value
*/
void println(double d);
/**
* @brief Print integer in selected base followed by a new-line.
*
* @param num 8-bit unsigned integer
* @param base Integer base
*/
void println(uint8_t num, IntegerBase base = IntegerBase::DEC);
/**
* @brief Print integer in selected base followed by a new-line.
*
* @param num 16-bit unsigned integer
* @param base Integer base
*/
void println(uint16_t num, IntegerBase base = IntegerBase::DEC);
/**
* @brief Print integer in selected base followed by a new-line.
*
* @param num 32-bit unsigned integer
* @param base Integer base
*/
void println(uint32_t num, IntegerBase base = IntegerBase::DEC);
/**
* @brief Print integer in selected base followed by a new-line.
*
* @param num Integer
* @param base Integer base
*/
void println(size_t num, IntegerBase base = IntegerBase::DEC);
/**
* @brief Print c-string followed by a new-line.
*
* @param str Null terminated string
*/
void println(const char * str);
/**
* @brief Print string followed by a new-line.
*
* @param str String buffer
* @param length String length
*/
void println(const char * str, size_t length);
private:
/**
* @brief Print unsigned integer in selected base.
*
* @param value Unsigned integer value
* @param base Integer base
* @param fmt printf format string for base 10
* @param size Size of value in bytes
*/
void printBase(uintmax_t value, IntegerBase base, const char * fmt, size_t size);
/**
* @brief Print unsigned integer in base 10.
*
* @param value Unsigned integer value
* @param fmt printf format string
*/
void printDec(uintmax_t value, const char * fmt);
/**
* @brief Print unsigned integer in base 2.
*
* @param value Unsigned integer value
* @param digits Number of digits to print
*/
void printBin(uintmax_t value, size_t digits);
/**
* @brief Print unsigned integer in base 16.
*
* @param value Unsigned integer value
* @param digits Number of digits to print
*/
void printHex(uintmax_t value, size_t digits);
private:
/**
* @brief Print unsigned integer in selected base.
*
* @param value Unsigned integer value
* @param base Integer base
* @param fmt printf format string for base 10
* @param size Size of value in bytes
*/
void printBase(uintmax_t value, IntegerBase base, const char * fmt, size_t size);
/**
* @brief Print unsigned integer in base 10.
*
* @param value Unsigned integer value
* @param fmt printf format string
*/
void printDec(uintmax_t value, const char * fmt);
/**
* @brief Print unsigned integer in base 2.
*
* @param value Unsigned integer value
* @param digits Number of digits to print
*/
void printBin(uintmax_t value, size_t digits);
/**
* @brief Print unsigned integer in base 16.
*
* @param value Unsigned integer value
* @param digits Number of digits to print
*/
void printHex(uintmax_t value, size_t digits);
private:
UART * intf_;
};
private:
UART * intf_;
};
} // namespace sta

56
include/sta/signal.hpp
View File

@@ -8,33 +8,35 @@
namespace sta
{
/**
* @brief Interface for signal objects.
*/
class Signal
{
public:
/**
* @brief Enter signaled state.
*/
virtual void notify() = 0;
/**
* @brief Check signal state w/o changing it.
*
* @return True if in signaled state
*/
virtual bool peek() = 0;
/**
* @brief Check signal state.
*
* @return True if in signaled state
*/
virtual bool test() = 0;
/**
* @brief Wait until signaled state is entered.
*/
virtual void wait() = 0;
};
/**
* @brief Interface for signal objects.
*
* @ingroup sta_core
*/
class Signal
{
public:
/**
* @brief Enter signaled state.
*/
virtual void notify() = 0;
/**
* @brief Check signal state w/o changing it.
*
* @return True if in signaled state
*/
virtual bool peek() = 0;
/**
* @brief Check signal state.
*
* @return True if in signaled state
*/
virtual bool test() = 0;
/**
* @brief Wait until signaled state is entered.
*/
virtual void wait() = 0;
};
} // namespace sta

128
include/sta/stm32/can.hpp
View File

@@ -9,8 +9,8 @@
#define STA_CORE_STM32_CAN_HPP
/**
* @defgroup stm32CAN CAN
* @ingroup stm32
* @defgroup sta_core_stm32_can CAN
* @ingroup sta_core_stm32
* @brief STM32 CAN module.
*
* Check @ref stm32BuildConfig for configuration options.
@@ -33,84 +33,84 @@
namespace sta
{
/**
* @brief Implementation of CanController interface using HAL.
*
* @ingroup stm32CAN
*/
class STM32CanController : public CanController
{
public:
static constexpr uint8_t MAX_FILTER_COUNT = 14; /**< Max number of filters */
static constexpr uint8_t MAX_FIFO_COUNT = 2; /**< Max number of FIFOs */
static constexpr uint8_t MAX_PAYLOAD_SIZE = 8; /**< Maximum payload size */
/**
* @brief Implementation of CanController interface using HAL.
*
* @ingroup sta_core_stm32_can
*/
class STM32CanController : public CanController
{
public:
static constexpr uint8_t MAX_FILTER_COUNT = 14; /**< Max number of filters */
static constexpr uint8_t MAX_FIFO_COUNT = 2; /**< Max number of FIFOs */
static constexpr uint8_t MAX_PAYLOAD_SIZE = 8; /**< Maximum payload size */
public:
/**
* @param handle CAN handle
*/
STM32CanController(CAN_HandleTypeDef * handle);
public:
/**
* @param handle CAN handle
*/
STM32CanController(CAN_HandleTypeDef * handle);
/**
* @brief Enable RX pending interrupts.
*/
void enableRxInterrupts();
/**
* @brief Enable RX pending interrupts.
*/
void enableRxInterrupts();
/**
* @brief Start CAN controller.
*/
void start();
/**
* @brief Stop CAN controller.
*/
void stop();
/**
* @brief Start CAN controller.
*/
void start();
/**
* @brief Stop CAN controller.
*/
void stop();
// RX/TX
//
// RX/TX
//
bool sendFrame(const CanTxHeader & header, const uint8_t * payload) override;
bool receiveFrame(uint8_t fifo, CanRxHeader * header, uint8_t * payload) override;
bool sendFrame(const CanTxHeader & header, const uint8_t * payload) override;
bool receiveFrame(uint8_t fifo, CanRxHeader * header, uint8_t * payload) override;
uint32_t getRxFifoFlags() override;
uint32_t getRxFifoFlags() override;
// RX Filter
//
// RX Filter
//
void configureFilter(uint8_t idx, const CanFilter & filter, bool active = false) override;
void enableFilter(uint8_t idx) override;
void disableFilter(uint8_t idx) override;
void clearFilters() override;
void configureFilter(uint8_t idx, const CanFilter & filter, bool active = false) override;
void enableFilter(uint8_t idx) override;
void disableFilter(uint8_t idx) override;
void clearFilters() override;
private:
/**
* @brief Initialize filter settings.
*/
void initFilters();
private:
/**
* @brief Initialize filter settings.
*/
void initFilters();
private:
CAN_HandleTypeDef * handle_; /**< CAN handle */
CAN_FilterTypeDef filters_[MAX_FILTER_COUNT]; /**< Filter settings */
};
private:
CAN_HandleTypeDef * handle_; /**< CAN handle */
CAN_FilterTypeDef filters_[MAX_FILTER_COUNT]; /**< Filter settings */
};
#if defined(STA_STM32_CAN_GLOBAL) || DOXYGEN
/**
* @brief Global CAN instance.
*
* @ingroup stm32CAN
*/
extern STM32CanController CanBus;
/**
* @brief Global CAN instance.
*
* @ingroup sta_core_stm32_can
*/
extern STM32CanController CanBus;
/**
* @brief Interrupt handler for pending RX frames.
*
* May be implemented by application.
*
* @ingroup stm32CAN
*/
void CanBus_RxPendingCallback();
/**
* @brief Interrupt handler for pending RX frames.
*
* May be implemented by application.
*
* @ingroup sta_core_stm32_can
*/
void CanBus_RxPendingCallback();
#endif // STA_STM32_CAN_GLOBAL
} // namespace sta

37
include/sta/stm32/clocks.hpp
View File

@@ -5,30 +5,33 @@
#ifndef STA_CORE_STM32_CLOCKS_HPP
#define STA_CORE_STM32_CLOCKS_HPP
/**
* @defgroup stm32 STM32
* @brief Modules implemented for STM32 MCUs.
*/
// Only enable module on STM32 platform
#include <sta/config.hpp>
#if defined(STA_PLATFORM_STM32) || defined(DOXYGEN)
#include <sta/stm32/hal.hpp>
/**
* @defgroup stm32BuildConfig Build config
* @ingroup stm32
* @brief Build configuration options.
*/
/**
* @defgroup stm32Clocks Clocks
* @ingroup stm32
* @defgroup sta_core_stm32_clocks Clocks
* @ingroup sta_core_stm32
* @brief STM32 Clock queries.
* @{
*/
// Only enable module on STM32 platform
#include <sta/config.hpp>
#if defined(STA_PLATFORM_STM32) || defined(DOXYGEN)
#include <sta/stm32/hal.hpp>
namespace sta
{
/**
* @brief Get peripheral clock frequency.
*
* @return Clock frequency
*/
using PCLKFreqFn = uint32_t (*)();
} // namespace sta
/**

46
include/sta/stm32/delay.hpp
View File

@@ -11,14 +11,11 @@
#ifndef STA_CORE_STM32_DELAY_HPP
#define STA_CORE_STM32_DELAY_HPP
/**
* @defgroup stm32Delay Delay
* @ingroup stm32
* @brief STM32 Delay module.
*/
// Only enable module on STM32 platform
#include <sta/config.hpp>
#if defined(STA_PLATFORM_STM32) || defined(DOXYGEN)
#include <cstdint>
@@ -26,25 +23,32 @@
namespace sta
{
/**
* @brief Millisecond delay.
*
* @param ms Milliseconds
*
* @ingroup stm32Delay
*/
void delayMs(uint32_t ms);
/**
* @defgroup sta_core_stm32_delay Delay
* @ingroup sta_core_stm32
* @brief STM32 Delay module.
* @{
*/
/**
* @brief Millisecond delay.
*
* @param ms Milliseconds
*/
void delayMs(uint32_t ms);
#if defined(STA_STM32_DELAY_US_TIM) || defined(DOXYGEN)
/**
* @brief Microsecond delay.
*
* @param us Microseconds
*
* @ingroup stm32Delay
*/
void delayUs(uint32_t us);
/**
* @brief Microsecond delay.
*
* @param us Microseconds
*/
void delayUs(uint32_t us);
#endif // STA_STM32_DELAY_US_TIM
/** @} */
} // namespace sta

132
include/sta/stm32/gpio_pin.hpp
View File

@@ -5,11 +5,6 @@
#ifndef STA_CORE_STM32_GPIO_PIN_HPP
#define STA_CORE_STM32_GPIO_PIN_HPP
/**
* @defgroup stm32GPIO GPIO
* @ingroup stm32
* @brief STM32 GPIO module.
*/
// Only enable module on STM32 platform w/ HAL GPIO module enabled
#include <sta/config.hpp>
@@ -26,68 +21,81 @@
#include <sta/gpio_pin.hpp>
/**
* @defgroup sta_core_stm32_gpio GPIO
* @ingroup sta_core_stm32
* @brief STM32 GPIO module.
*/
namespace sta
{
/**
* @brief Container for STM GPIO Pin data.
*
* @ingroup stm32GPIO
*/
class STM32GpioPin : public GpioPin
{
public:
/**
* @param port GPIO port
* @param pin Pin index
*/
STM32GpioPin(GPIO_TypeDef * port, uint16_t pin);
void setState(GpioPinState state) override;
/**
* @brief Get GPIO port for pin.
*
* @return GPIO port
*/
GPIO_TypeDef * getPort() const;
/**
* @brief Get pin index for pin.
*
* @return Pin index
*/
uint16_t getPin() const;
/**
* @brief Get GPIO port index for pin.
*
* @return GPIO port index
*/
uint8_t getPortIndex() const;
private:
GPIO_TypeDef * port_; /**< GPIO port */
uint16_t pin_; /**< GPIO pin */
};
/**
* @ingroup sta_core_stm32_gpio
* @{
*/
/**
* @brief Interrupt trigger edge.
*/
enum class InterruptEdge
{
RISING, /**< Rising edge */
FALLING, /**< Falling edge */
BOTH /**< Rising and falling edge */
};
/**
* @brief Container for STM GPIO Pin data.
*/
class STM32GpioPin : public GpioPin
{
public:
/**
* @param port GPIO port
* @param pin Pin index
*/
STM32GpioPin(GPIO_TypeDef * port, uint16_t pin);
/**
* @brief Check pin EXIT pin configuration.
*
* @param pin GPIO pin
* @param edge Interrupt trigger edge
* @return True if EXIT pin and trigger edge matches
*/
bool isInterruptEdge(const STM32GpioPin & pin, InterruptEdge edge);
void setState(GpioPinState state) override;
/**
* @brief Get GPIO port for pin.
*
* @return GPIO port
*/
GPIO_TypeDef * getPort() const;
/**
* @brief Get pin index for pin.
*
* @return Pin index
*/
uint16_t getPin() const;
/**
* @brief Get GPIO port index for pin.
*
* @return GPIO port index
*/
uint8_t getPortIndex() const;
private:
GPIO_TypeDef * port_; /**< GPIO port */
uint16_t pin_; /**< GPIO pin */
};
/**
* @brief Interrupt trigger edge.
*/
enum class InterruptEdge
{
RISING, /**< Rising edge */
FALLING, /**< Falling edge */
BOTH /**< Rising and falling edge */
};
/**
* @brief Check pin EXIT pin configuration.
*
* @param pin GPIO pin
* @param edge Interrupt trigger edge
* @return True if EXIT pin and trigger edge matches
*/
bool isInterruptEdge(const STM32GpioPin & pin, InterruptEdge edge);
/** @} */
} // namespace sta
/**
@@ -95,7 +103,7 @@ namespace sta
*
* @param label Pin label
*
* @ingroup stm32GPIO
* @ingroup sta_core_stm32_gpio
*/
#define STA_STM32_GPIO_PIN(label) sta::STM32GpioPin{label##_GPIO_Port, label##_Pin}

7
include/sta/stm32/hal.hpp
View File

@@ -6,6 +6,13 @@
#define STA_CORE_STM32_HAL_HPP
/**
* @defgroup sta_core_stm32 STM32
* @ingroup sta_core_platforms
* @brief Modules implemented for the STM32 platform.
*/
// Include STM32 HAL headers
#include <main.h>

12
include/sta/stm32/init.hpp
View File

@@ -8,12 +8,12 @@
namespace sta
{
/**
* @brief Initialize global HAL objects.
*
* @ingroup stm32
*/
void initHAL();
/**
* @brief Initialize global HAL objects.
*
* @ingroup sta_core_stm32
*/
void initHAL();
} // namespace sta

45
include/sta/stm32/uart.hpp
View File

@@ -5,12 +5,6 @@
#ifndef STA_CORE_STM32_UART_HPP
#define STA_CORE_STM32_UART_HPP
/**
* @defgroup stm32UART UART
* @ingroup stm32
* @brief STM32 UART module.
*/
// Only enable module on STM32 platform w/ HAL UART module enabled
#include <sta/config.hpp>
@@ -27,26 +21,33 @@
#include <sta/uart.hpp>
/**
* @defgroup sta_core_stm32_uart UART
* @ingroup sta_core_stm32
* @brief STM32 UART module.
*/
namespace sta
{
/**
* @brief Implementation of UART interface using HAL.
*
* @ingroup stm32UART
*/
class STM32UART : public UART
{
public:
/**
* @param handle UART handle
*/
STM32UART(UART_HandleTypeDef * handle);
/**
* @brief Implementation of UART interface using HAL.
*
* @ingroup sta_core_stm32_uart
*/
class STM32UART : public UART
{
public:
/**
* @param handle STM32 HAL handle
*/
STM32UART(UART_HandleTypeDef * handle);
void write(const uint8_t * buffer, size_t size) override;
void write(const uint8_t * buffer, size_t size) override;
private:
UART_HandleTypeDef * handle_; /**< UART handle */
};
private:
UART_HandleTypeDef * handle_; /**< STM32 HAL handle */
};
} // namespace sta

24
include/sta/time.hpp
View File

@@ -10,18 +10,18 @@
namespace sta
{
/**
* @brief Signature for millisecond precision time.
*
* @return Time in milliseconds
*/
using TimeMsFn = uint32_t (*)();
/**
* @brief Signature for microseconds precision time.
*
* @return Time in microseconds
*/
using TimeUsFn = uint32_t (*)();
/**
* @brief Signature for millisecond precision time.
*
* @return Time in milliseconds
*/
using TimeMsFn = uint32_t (*)();
/**
* @brief Signature for microseconds precision time.
*
* @return Time in microseconds
*/
using TimeUsFn = uint32_t (*)();
} // namespace sta

73
include/sta/uart.hpp
View File

@@ -9,41 +9,50 @@
#include <cstdint>
/**
* @defgroup sta_core_uart UART
* @ingroup sta_core
* @brief UART interface.
*/
namespace sta
{
/**
* @brief Interface for %UART.
*/
class UART
{
public:
/**
* @brief Write buffer to %UART.
*
* @param buffer Source buffer
* @param size Number of bytes in buffer
*/
virtual void write(const uint8_t * buffer, size_t size) = 0;
/**
* @brief Interface for %UART.
*
* @ingroup sta_core_uart
*/
class UART
{
public:
/**
* @brief Write buffer to %UART.
*
* @param buffer Source buffer
* @param size Number of bytes in buffer
*/
virtual void write(const uint8_t * buffer, size_t size) = 0;
/**
* @brief Write unsigned integer to %UART.
*
* @param value Unsigned integer value
*/
void write(uint8_t value);
/**
* @brief Write unsigned integer to %UART.
*
* @param value Unsigned integer value
*/
void write(uint16_t value);
/**
* @brief Write unsigned integer to %UART.
*
* @param value Unsigned integer value
*/
void write(uint32_t value);
};
/**
* @brief Write unsigned integer to %UART.
*
* @param value Unsigned integer value
*/
void write(uint8_t value);
/**
* @brief Write unsigned integer to %UART.
*
* @param value Unsigned integer value
*/
void write(uint16_t value);
/**
* @brief Write unsigned integer to %UART.
*
* @param value Unsigned integer value
*/
void write(uint32_t value);
};
} // namespace sta