370 lines
14 KiB
C++
370 lines
14 KiB
C++
/*!
|
|
* \file cont/BG95_base.h
|
|
* \brief
|
|
* BG95 driver functionality as CRTP base class
|
|
*
|
|
* \copyright Copyright (C) 2021 Christos Choutouridis <christos@choutouridis.net>
|
|
*
|
|
* <dl class=\"section copyright\"><dt>License</dt><dd>
|
|
* The MIT License (MIT)
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
* </dd></dl>
|
|
*/
|
|
|
|
#ifndef TBX_DRV_BG95_base_H_
|
|
#define TBX_DRV_BG95_base_H_
|
|
|
|
#define __cplusplus 201703L
|
|
|
|
#include <core/core.h>
|
|
#include <core/crtp.h>
|
|
#include <cont/equeue.h>
|
|
#include <cont/range.h>
|
|
#include <utils/sequencer.h>
|
|
|
|
#include <cstring>
|
|
#include <cstdlib>
|
|
#include <algorithm>
|
|
|
|
#include <utility>
|
|
#include <atomic>
|
|
|
|
namespace tbx {
|
|
|
|
/*!
|
|
* \class BG95_base
|
|
* \brief
|
|
*
|
|
* \example implementation example
|
|
* \code
|
|
* using Queue = equeue<char, 512, true>;
|
|
*
|
|
* class BG95 :
|
|
* public BG95_base<BG95, Queue, 256> {
|
|
* using base_type = BG95_base<BG95, Queue, 256>;
|
|
* using range_t = typename Queue::range_t;
|
|
* private: // data
|
|
* Queue rx_q{};
|
|
* std::atomic<size_t> lines{};
|
|
* public:
|
|
* BG95() :
|
|
* rx_q(equeue<char, 512, true>::data_match::MATCH_PUSH, base_type::delimiter, [&](){
|
|
* lines.fetch_add(1, std::memory_order_acq_rel);
|
|
* }), lines(0) {
|
|
* // init code here ...
|
|
* }
|
|
* // ISR handler
|
|
* void usart_isr_ (void) {
|
|
* rx_q << // char from ISR
|
|
* }
|
|
* // CRTP requirements
|
|
* size_t get(char* data, bool wait =false) {
|
|
* do {
|
|
* if (lines.load(std::memory_order_acquire)) {
|
|
* size_t n =0;
|
|
* do{
|
|
* *data << rx_q;
|
|
* ++n;
|
|
* } while (*data++ != base_type::delimiter);
|
|
* lines.fetch_sub(1, std::memory_order_acq_rel);
|
|
* return n;
|
|
* }
|
|
* } while (wait);
|
|
* return 0;
|
|
* }
|
|
* size_t put (const char* data, size_t n) {
|
|
* // send data to UART
|
|
* return n;
|
|
* }
|
|
* const range_t contents() const { return range_t {rx_q.begin(), rx_q.end()}; }
|
|
* clock_t clock() { } // return systems CPU time
|
|
* };
|
|
* \endcode
|
|
*
|
|
* \tparam Impl_t
|
|
* \tparam Cont_t
|
|
* \tparam N
|
|
* \tparam Delimiter
|
|
*/
|
|
template<typename Impl_t, typename Cont_t, size_t N, char Delimiter ='\n'>
|
|
class BG95_base
|
|
: public sequencer<BG95_base<Impl_t, Cont_t, N, Delimiter>, Cont_t, char, N>{
|
|
_CRTP_IMPL(Impl_t);
|
|
|
|
static_assert(
|
|
std::is_same_v<typename Cont_t::value_type, char>,
|
|
"Cont_t must be a container of type char"
|
|
);
|
|
|
|
// local type dispatch
|
|
using base_type = sequencer<BG95_base, Cont_t, char, N>;
|
|
using str_view_t = typename base_type::str_view_t;
|
|
using range_t = typename Cont_t::range_t;
|
|
|
|
//! \name Public types
|
|
//! @{
|
|
public:
|
|
using action_t = typename base_type::action_t;
|
|
using control_t = typename base_type::control_t;
|
|
using match_t = typename base_type::match_t;
|
|
using handler_ft = typename base_type::handler_ft;
|
|
template<size_t Nm>
|
|
using script_t = typename base_type::template script_t<Nm>;
|
|
|
|
//! Publish delimiter
|
|
constexpr static char delimiter = Delimiter;
|
|
|
|
//! Required types for inetd async handler operation
|
|
//! @{
|
|
struct inetd_handler_t {
|
|
str_view_t token;
|
|
match_t match;
|
|
handler_ft handler;
|
|
};
|
|
template <size_t Nm>
|
|
using inetd_handlers = std::array<inetd_handler_t, Nm>;
|
|
//! @}
|
|
//! @}
|
|
|
|
//! \name Constructor / Destructor
|
|
//!@{
|
|
protected:
|
|
//!< \brief A default constructor from derived only
|
|
BG95_base() = default;
|
|
~BG95_base () = default; //!< \brief Allow destructor from derived only
|
|
BG95_base(const BG95_base&) = delete; //!< No copies
|
|
BG95_base& operator= (const BG95_base&) = delete; //!< No copy assignments
|
|
//!@}
|
|
|
|
//! \name Sequencer interface requirements
|
|
//! Forwarded to implementer the calls and cascade the the incoming channel
|
|
//! sequencer::get --resolved--> this->receive() --calls--> impl().get()
|
|
//! @{
|
|
friend base_type;
|
|
|
|
private:
|
|
size_t get_ (char* data) {
|
|
return impl().get (data);
|
|
}
|
|
size_t get (char* data) {
|
|
return receive (data);
|
|
}
|
|
size_t put (const char* data, size_t n) {
|
|
return impl().put (data, n);
|
|
}
|
|
const range_t contents () const {
|
|
return impl().contents();
|
|
}
|
|
clock_t clock () {
|
|
return impl().clock();
|
|
}
|
|
//! @}
|
|
|
|
//! \name Private functionality
|
|
//! @{
|
|
private:
|
|
template<typename T>
|
|
void extract (const char* str, T* value) {
|
|
static_assert (
|
|
std::is_same_v<std::remove_cv_t<T>, int>
|
|
|| std::is_same_v<std::remove_cv_t<T>, double>
|
|
|| std::is_same_v<std::remove_cv_t<T>, char>,
|
|
"Not supported conversion type.");
|
|
if constexpr (std::is_same_v<std::remove_cv_t<T>, int>) {
|
|
*value = std::atoi(str);
|
|
} else if (std::is_same_v<std::remove_cv_t<T>, double>) {
|
|
*value = std::atof(str);
|
|
} else if (std::is_same_v<std::remove_cv_t<T>, char>) {
|
|
std::strcpy(value, str);
|
|
}
|
|
}
|
|
|
|
template <char Marker = '%'>
|
|
std::pair<size_t, bool> parse (const char* expected, const str_view_t buffer, char* token) {
|
|
if (*expected == Marker) {
|
|
// We have Marker. Copy to token the next part of buffer, from begin up to expected[1] where
|
|
// the expected[1] character is and return the size of that part.
|
|
auto next = std::find(buffer.begin(), buffer.end(), expected[1]);
|
|
if (next == buffer.end()) {
|
|
*token =0;
|
|
return std::make_pair(0, false);
|
|
}
|
|
char* nullpos = std::copy(buffer.begin(), next, token);
|
|
*nullpos =0;
|
|
return std::make_pair(next - buffer.begin(), true);
|
|
}
|
|
else if (*expected == buffer.front()) {
|
|
// We have character match, copy the character to token and return 1 (the char size)
|
|
*token++ = buffer.front();
|
|
*token =0;
|
|
return std::make_pair(1, false);
|
|
}
|
|
else {
|
|
// Discrepancy. Return 0 (none parsed)
|
|
*token =0;
|
|
return std::make_pair(0, false);
|
|
}
|
|
}
|
|
|
|
//! @}
|
|
|
|
//! \name public functionality
|
|
//! @{
|
|
public:
|
|
|
|
/*!
|
|
* \brief
|
|
* Transmit data to modem
|
|
* \param data Pointer to data to send
|
|
* \param n The size of data buffer
|
|
* \return The number of transmitted chars
|
|
*/
|
|
size_t transmit (const char* data, size_t n) {
|
|
return put (data, n);
|
|
}
|
|
|
|
size_t transmit (const char* data) {
|
|
return put (data, strlen(data));
|
|
}
|
|
|
|
/*!
|
|
* \brief
|
|
* Try to receive data from modem. If there are data copy them to \c data pointer and retur
|
|
* the size. Otherwise return zero. In the case \c wait is true block until there are data to get.
|
|
*
|
|
* \param data Pointer to data buffer to write
|
|
* \param wait Flag to select blocking / non-blocking functionality
|
|
* \return The number of copied data.
|
|
*/
|
|
size_t receive (char* data, bool wait =false) {
|
|
do {
|
|
if (streams_.load(std::memory_order_acquire)) {
|
|
size_t n =0;
|
|
do {
|
|
*data << rx_q;
|
|
++n;
|
|
} while (*data++ != delimiter);
|
|
*data =0;
|
|
streams_.fetch_sub(1, std::memory_order_acq_rel);
|
|
return n;
|
|
}
|
|
} while (wait); // on wait flag we block until available stream
|
|
return 0;
|
|
}
|
|
|
|
/*!
|
|
* \brief
|
|
* Send a command to modem and check if the response matches to
|
|
* \c expected. If so read any token inside response marked with
|
|
* \c Marker, convert the value into type \c T and write it to \c t
|
|
*
|
|
* \param cmd The comand to send (null terminated)
|
|
* \param expected The expected response
|
|
* \param t The value to return
|
|
* \param timeout The timeout in CPU time (leave it for 0 - no timeout)
|
|
*
|
|
* \tparam T The type of the value to read from response marked with \c Marker
|
|
* \tparam Marker The marker character
|
|
* \return True on success
|
|
*
|
|
* example
|
|
* \code
|
|
* BG95<256> modem;
|
|
* std::thread th1 ([&](){
|
|
* modem.inetd(false);
|
|
* });
|
|
* int status;
|
|
* bool done = modem.command("AT+CREG?\r\n", "\r\n+CREG: 0,%\r\n\r\nOK\r\n", status);
|
|
* if (done && status == 1)
|
|
* std::cout << "Connected to home network\n"
|
|
* \endcode
|
|
*/
|
|
template <typename T, char Marker = '%'>
|
|
bool command (const str_view_t cmd, const str_view_t expected, T* value, clock_t timeout =0) {
|
|
char buffer[N];
|
|
char token[N];
|
|
|
|
transmit(cmd.data()); // send command
|
|
|
|
for (auto ex = expected.begin() ; ex != expected.end() ; ) {
|
|
clock_t mark = clock(); // load the answer with timeout
|
|
size_t sz =0;
|
|
do {
|
|
sz = receive(buffer);
|
|
if ((timeout != 0 )&& ((clock() - mark) >= timeout))
|
|
return false;
|
|
} while (!sz);
|
|
|
|
for (size_t i=0 ; i<sz ; ) { // parse buffer based on expected
|
|
auto [step, marker] = parse<Marker> (ex++, {&buffer[i], sz-i}, token);
|
|
if (!step) return false;
|
|
if (marker) extract(token, value);
|
|
i += step;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*!
|
|
* \brief
|
|
* inetd daemon functionality provided as member function of the driver. This should be running
|
|
* in the background either as consecutive calls from an periodic ISR with \c loop = false, or
|
|
* as a thread in an RTOS environment with \c loop = true.
|
|
*
|
|
* \tparam Nm The number of handler array entries
|
|
*
|
|
* \param async_handles Reference to asynchronous handler array
|
|
* \param loop Flag to indicate blocking mode. If true blocking.
|
|
*/
|
|
template <size_t Nm =0>
|
|
void inetd (bool loop =true, const inetd_handlers<Nm>* inetd_handlers =nullptr) {
|
|
std::array<char, N> buffer;
|
|
size_t resp_size;
|
|
do {
|
|
if ((resp_size = get_(buffer.data())) != 0) {
|
|
// on data check for async handlers
|
|
bool match = false;
|
|
if (inetd_handlers != nullptr) {
|
|
for (auto& h : *inetd_handlers)
|
|
match |= base_type::check_handle(h.token, h.match, h.handler, {buffer.data(), resp_size});
|
|
}
|
|
// if no match forward data to receive channel.
|
|
if (!match) {
|
|
char* it = buffer.data();
|
|
do {
|
|
rx_q << *it;
|
|
} while (*it++ != delimiter);
|
|
streams_.fetch_add(1, std::memory_order_acq_rel);
|
|
}
|
|
}
|
|
} while (loop);
|
|
}
|
|
|
|
//! @}
|
|
|
|
private:
|
|
equeue<char, N, true> rx_q{};
|
|
std::atomic<size_t> streams_{};
|
|
};
|
|
|
|
} // namespace tbx;
|
|
|
|
#endif /* TBX_DRV_BG95_base_H_ */
|