hoo2/tbx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

WIP: ATmodem (renamed after BG95_base) and sequencer

Browse Source
This commit is contained in:
Christos Choutouridis 2021-09-27 17:04:46 +03:00
parent ca38dfa2f1
commit f7c904e9c2
5 changed files with 205 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
include/utils/sequencer.h → include/com/sequencer.h
View File

@ -1,7 +1,7 @@
/*! /*!
* \file utils/sequencer.h * \file com/sequencer.h
* \brief * \brief
* A terminal-like device communication automation tool * A script based automation tool for send/receive communications
* *
* \copyright Copyright (C) 2021 Christos Choutouridis <christos@choutouridis.net> * \copyright Copyright (C) 2021 Christos Choutouridis <christos@choutouridis.net>
* *
@ -28,8 +28,8 @@
* </dd></dl> * </dd></dl>
*/ */
#ifndef TBX_UTILS_SEQUENCER_H_ #ifndef TBX_COM_SEQUENCER_H_
#define TBX_UTILS_SEQUENCER_H_ #define TBX_COM_SEQUENCER_H_
#include <core/core.h> #include <core/core.h>
@ -147,14 +147,19 @@ class sequencer {
size_t value; //!< Used by \c GOTO to indicate the next sequencer's step. size_t value; //!< Used by \c GOTO to indicate the next sequencer's step.
}; };
//! A no_action action_t
static constexpr action_t no_action = {action_t::NO, 0}; static constexpr action_t no_action = {action_t::NO, 0};
//! A next action_t
static constexpr action_t next = {action_t::NEXT, 0}; static constexpr action_t next = {action_t::NEXT, 0};
//! A goto action_t template
template <size_t GOTO> template <size_t GOTO>
static constexpr action_t go_to = {action_t::GOTO, static_cast<size_t>(GOTO)}; static constexpr action_t go_to = {action_t::GOTO, static_cast<size_t>(GOTO)};
//! An exit ok action_t
static constexpr action_t exit_ok = {action_t::EXIT, 0}; static constexpr action_t exit_ok = {action_t::EXIT, 0};
//! An exit error action_t
static constexpr action_t exit_error = {action_t::EXIT, static_cast<size_t>(-1)}; static constexpr action_t exit_error = {action_t::EXIT, static_cast<size_t>(-1)};
//! A generic exit action_t template
template <size_t Status> template <size_t Status>
static constexpr action_t exit = {action_t::EXIT, static_cast<size_t>(Status)}; static constexpr action_t exit = {action_t::EXIT, static_cast<size_t>(Status)};
@ -421,6 +426,8 @@ class sequencer {
clock_t mark = clock_(); clock_t mark = clock_();
seq_status_t status{seq_status_t::CONTINUE}; do { seq_status_t status{seq_status_t::CONTINUE}; do {
if (step >= Steps)
return exit_error.value;
const record_t& record = script[step]; // get reference ot current line const record_t& record = script[step]; // get reference ot current line
if (step != p_step) { // renew time marker in each step if (step != p_step) { // renew time marker in each step
@ -452,7 +459,7 @@ class sequencer {
std::tie(step, status) = action_ (script, s); std::tie(step, status) = action_ (script, s);
break; break;
} }
} while (script[++s].control == control_t::OR_EXPECT); } while ((++s < Steps) && (script[s].control == control_t::OR_EXPECT));
} }
if (record.timeout && (clock_() - mark) >= record.timeout) if (record.timeout && (clock_() - mark) >= record.timeout)
return exit_error.value; return exit_error.value;
@ -468,7 +475,7 @@ class sequencer {
std::tie(step, status) = action_ (script, s); std::tie(step, status) = action_ (script, s);
break; break;
} }
} while (script[++s].control == control_t::OR_DETECT); } while ((++s < Steps) && (script[s].control == control_t::OR_DETECT));
} }
if (record.timeout && (clock_() - mark) >= record.timeout) if (record.timeout && (clock_() - mark) >= record.timeout)
return exit_error.value; return exit_error.value;
@ -484,4 +491,4 @@ class sequencer {
} }
#endif /* TBX_UTILS_SEQUENCER_H_ */ #endif /* TBX_COM_SEQUENCER_H_ */

79
include/drv/BG95_base.h → include/drv/ATmodem.h
View File

@ -1,7 +1,7 @@
/*! /*!
* \file cont/BG95_base.h * \file drv/ATmodem.h
* \brief * \brief
* BG95 driver functionality as CRTP base class * ATmodem driver functionality as CRTP base class
* *
* \copyright Copyright (C) 2021 Christos Choutouridis <christos@choutouridis.net> * \copyright Copyright (C) 2021 Christos Choutouridis <christos@choutouridis.net>
* *
@ -28,8 +28,8 @@
* </dd></dl> * </dd></dl>
*/ */
#ifndef TBX_DRV_BG95_base_H_ #ifndef TBX_DRV_ATmodem_H_
#define TBX_DRV_BG95_base_H_ #define TBX_DRV_ATmodem_H_
#define __cplusplus 201703L #define __cplusplus 201703L
@ -37,7 +37,7 @@
#include <core/crtp.h> #include <core/crtp.h>
#include <cont/equeue.h> #include <cont/equeue.h>
#include <cont/range.h> #include <cont/range.h>
#include <utils/sequencer.h> #include <com/sequencer.h>
#include <cstring> #include <cstring>
#include <cstdlib> #include <cstdlib>
@ -63,12 +63,12 @@ namespace tbx {
* \tparam Delimiter * \tparam Delimiter
*/ */
template<typename Impl_t, size_t N, char Delimiter ='\n'> template<typename Impl_t, size_t N, char Delimiter ='\n'>
class BG95_base class ATmodem
: public sequencer<BG95_base<Impl_t, N, Delimiter>, char, N>{ : public sequencer<ATmodem<Impl_t, N, Delimiter>, char, N>{
_CRTP_IMPL(Impl_t); _CRTP_IMPL(Impl_t);
// local type dispatch // local type dispatch
using base_type = sequencer<BG95_base, char, N>; using base_type = sequencer<ATmodem, char, N>;
//! \name Public types //! \name Public types
//! @{ //! @{
@ -106,10 +106,10 @@ class BG95_base
//!@{ //!@{
protected: protected:
//!< \brief A default constructor from derived only //!< \brief A default constructor from derived only
BG95_base() = default; ATmodem() noexcept = default;
~BG95_base () = default; //!< \brief Allow destructor from derived only ~ATmodem () = default; //!< \brief Allow destructor from derived only
BG95_base(const BG95_base&) = delete; //!< No copies ATmodem(const ATmodem&) = delete; //!< No copies
BG95_base& operator= (const BG95_base&) = delete; //!< No copy assignments ATmodem& operator= (const ATmodem&) = delete; //!< No copy assignments
//!@} //!@}
//! \name Sequencer interface requirements //! \name Sequencer interface requirements
@ -139,6 +139,28 @@ class BG95_base
//! \name Private functionality //! \name Private functionality
//! @{ //! @{
private: private:
template <typename... Ts>
struct typelist {
using type = typelist; //!< act as identity
};
template <typename L>
struct front_impl {
using type = void;
};
template <typename Head, typename... Tail>
struct front_impl<typelist<Head, Tail...>> {
using type = Head;
};
//! Return the first element in \c meta::typelist \c List.
//!
//! Complexity \f$ O(1) \f$.
template <typename List>
using front = typename front_impl<List>::type;
template<typename T> template<typename T>
void extract (const char* str, T* value) { void extract (const char* str, T* value) {
static_assert ( static_assert (
@ -154,6 +176,9 @@ class BG95_base
std::strcpy(value, str); std::strcpy(value, str);
} }
} }
void extract (const char* str, void* value) {
(void)*str; (void)value;
}
template <char Marker = '%'> template <char Marker = '%'>
std::pair<size_t, bool> parse (const char* expected, const string_view buffer, char* token) { std::pair<size_t, bool> parse (const char* expected, const string_view buffer, char* token) {
@ -253,29 +278,45 @@ class BG95_base
* if (done && status == 1) * if (done && status == 1)
* std::cout << "Connected to home network\n" * std::cout << "Connected to home network\n"
* \endcode * \endcode
* element_type (&arr)[N]
*/ */
template <typename T, char Marker = '%'> template<char Marker = '%', typename ...Ts>
bool command (const string_view cmd, const string_view expected, T* value, clock_t timeout =0) { bool command (const string_view cmd, const string_view expected, clock_t timeout, Ts* ...values) {
char buffer[N];
char token[N]; constexpr size_t Nr = sizeof...(Ts);
front<typelist<Ts...>>* vargs[Nr] = {values...};
if constexpr (Nr == 0) { (void)vargs; }
char buffer[N], token[N];
size_t v =0;
transmit(cmd.data()); // send command transmit(cmd.data()); // send command
for (auto ex = expected.begin() ; ex != expected.end() ; ) { for (auto ex = expected.begin() ; ex != expected.end() ; ) {
clock_t mark = clock(); // load the answer with timeout clock_t mark = clock(); // load the answer with timeout
size_t sz =0; size_t sz =0;
bool redo = false; do {
do { do {
sz = receive(buffer); sz = receive(buffer);
if ((timeout != 0 )&& ((clock() - mark) >= timeout)) if ((timeout != 0 )&& ((clock() - mark) >= timeout))
return false; return false;
} while (!sz); } while (!sz);
redo = false; // have faith to parse successfully
for (size_t i=0 ; i<sz ; ) { // parse buffer based on expected for (size_t i=0 ; i<sz ; ) { // parse buffer based on expected
auto [step, marker] = parse<Marker> (ex++, {&buffer[i], sz-i}, token); auto [step, marker] = parse<Marker> (ex++, {&buffer[i], sz-i}, token);
if (!step) return false; if (!step) {
if (marker) extract(token, value); redo = true; // fail to parse, reload and retry
break;
}
if constexpr (Nr > 0) {
if (marker && v< Nr)
extract(token, vargs[v++]);
}
i += step; i += step;
} }
} while (redo);
} }
return true; return true;
} }
@ -324,4 +365,4 @@ class BG95_base
} // namespace tbx; } // namespace tbx;
#endif /* TBX_DRV_BG95_base_H_ */ #endif /* #ifndef TBX_DRV_ATmodem_H_ */

154
test/tests/BG95_base.cpp → test/tests/ATmodem.cpp
View File

@ -1,5 +1,5 @@
/*! /*!
* \file sequencer.cpp * \file ATmodem.cpp
* *
* \copyright Copyright (C) 2020 Christos Choutouridis <christos@choutouridis.net> * \copyright Copyright (C) 2020 Christos Choutouridis <christos@choutouridis.net>
* *
@ -26,15 +26,14 @@
* </dd></dl> * </dd></dl>
* *
*/ */
#include <drv/BG95_base.h> #include <drv/ATmodem.h>
#include <gtest/gtest.h> #include <gtest/gtest.h>
#include <cont/equeue.h>
//#include <map>
//#include <iostream> #include <cont/equeue.h>
#include <cstring> #include <cstring>
#include <utility> #include <utility>
#include <type_traits>
#ifndef WIN_TRHEADS #ifndef WIN_TRHEADS
#include <mutex> #include <mutex>
#include <thread> #include <thread>
@ -43,17 +42,18 @@
#include <mingw.mutex.h> #include <mingw.mutex.h>
#endif #endif
namespace test_bg95_base { namespace test_ATmodem {
using namespace tbx; using namespace tbx;
// test settings
constexpr size_t Size = 128;
using data_type = char;
// BG95 implementer mock // BG95 implementer mock
template<size_t N> template<size_t N>
class BG95 : public BG95_base<BG95<N>, N> { class BG95 : public ATmodem<BG95<N>, N> {
using base_type = ATmodem<BG95<N>, N>;
using Q = equeue<char, N, true>; using Queue = equeue<typename base_type::value_type, N, true>;
using base_type = BG95_base<BG95<N>, N>;
public: public:
enum class event { enum class event {
@ -114,15 +114,13 @@ namespace test_bg95_base {
} }
// data // data
Q rx_q{}; Queue rx_q{};
std::atomic<size_t> lines{}; std::atomic<size_t> lines{};
public:
using range_t = typename Q::range_t;
public: public:
// BG95_base driver requirements // ATmodem driver requirements
BG95() : BG95() noexcept :
rx_q(Q::data_match::MATCH_PUSH, base_type::delimiter, [&](){ rx_q(Queue::data_match::MATCH_PUSH, base_type::delimiter, [&](){
lines.fetch_add(1, std::memory_order_acq_rel); lines.fetch_add(1, std::memory_order_acq_rel);
}), lines(0) { } }), lines(0) { }
@ -146,7 +144,6 @@ namespace test_bg95_base {
return nullpos - data; return nullpos - data;
} }
size_t put (const char* data, size_t n) { size_t put (const char* data, size_t n) {
std::cerr << " ";
const char* reply = cmd_responce (data); const char* reply = cmd_responce (data);
while (*reply) while (*reply)
rx_q << *reply++; rx_q << *reply++;
@ -168,28 +165,43 @@ namespace test_bg95_base {
void handler (const char* data, size_t n) { void handler (const char* data, size_t n) {
(void)*data; (void)*data;
(void)n; (void)n;
// std::cout << "* handler called\n";
handler_flag = true; handler_flag = true;
} }
void clear_flag () { void clear_flag () {
handler_flag = false; handler_flag = false;
} }
TEST(TATmodem, traits) {
EXPECT_EQ ( std::is_default_constructible<BG95<Size>>::value, true);
EXPECT_EQ ( std::is_nothrow_default_constructible<BG95<Size>>::value, true);
EXPECT_EQ (!std::is_copy_constructible<BG95<Size>>::value, true);
EXPECT_EQ (!std::is_copy_assignable<BG95<Size>>::value, true);
EXPECT_EQ ((std::is_same_v<BG95<Size>::value_type, data_type>), true);
EXPECT_EQ ((std::is_same_v<BG95<Size>::pointer_type, data_type*>), true);
EXPECT_EQ ((std::is_same_v<BG95<Size>::size_type, size_t>), true);
EXPECT_EQ ((std::is_same_v<BG95<Size>::string_view, std::basic_string_view<data_type>>), true);
BG95<Size> m;
EXPECT_EQ (m.size(), Size);
}
/* /*
* Test inetd in non blocking mode * Test inetd in non blocking mode
*/ */
TEST(TBG95_base, inetd_non_blocking) { TEST(TATmodem, inetd_non_blocking) {
BG95<256> modem; BG95<Size> modem;
char buffer[256]; char buffer[Size];
const BG95<256>::inetd_handlers<2> async = {{ const BG95<Size>::inetd_handlers<2> async = {{
{"+QMTOPEN:", BG95<256>::starts_with, handler}, {"+QMTSTAT:", BG95<Size>::starts_with, handler},
{"+QMT", BG95<256>::starts_with, handler}, {"+QMTRECV", BG95<Size>::contains, handler},
}}; }};
clear_flag(); clear_flag();
modem.inetd(false, &async); modem.inetd(false, &async);
EXPECT_EQ (handler_flag, false); EXPECT_EQ (handler_flag, false);
modem.async(BG95<256>::event::MQTT_DISCONNECT); modem.async(BG95<Size>::event::MQTT_DISCONNECT);
modem.inetd(false, &async); // parse "\r\n" modem.inetd(false, &async); // parse "\r\n"
EXPECT_EQ (handler_flag, false); EXPECT_EQ (handler_flag, false);
modem.inetd(false, &async); // parse "+QMT*\r\n" and dispatch to handler() modem.inetd(false, &async); // parse "+QMT*\r\n" and dispatch to handler()
@ -225,41 +237,17 @@ namespace test_bg95_base {
EXPECT_EQ (modem.receive(buffer), 0UL); EXPECT_EQ (modem.receive(buffer), 0UL);
} }
// TEST(TBG95_base, run) { TEST(TATmodem, run) {
// BG95<256> modem; BG95<Size> modem;
//
// using Control = BG95<256>::control_t;
// using Action = BG95<256>::action_t;
//
// const BG95<256>::inetd_handlers<2> async = {{
// {"+QMTOPEN:", BG95<256>::starts_with, handler},
// {"+QMT", BG95<256>::starts_with, handler},
// }};
// const BG95<256>::script_t<7> script = {{
// {Control::NOP, "", BG95<256>::nil, BG95<256>::nil, {Action::GOTO, 1}, 1000},
// {Control::SEND, "ATE0\r\n", BG95<256>::nil, BG95<256>::nil, {Action::NEXT, 0}, 0},
// {Control::EXPECT, "OK\r\n", BG95<256>::ends_with, BG95<256>::nil, {Action::NEXT, 0}, 1000},
// {Control::OR_EXPECT,"ERROR", BG95<256>::contains, BG95<256>::nil, {Action::EXIT_ERROR, 0}, 0},
// {Control::SEND, "AT+CSQ\r\n",BG95<256>::nil, BG95<256>::nil, {Action::NEXT, 0}, 0},
// {Control::EXPECT, "OK\r\n", BG95<256>::ends_with, BG95<256>::nil, {Action::EXIT_OK, 0}, 1000},
// {Control::OR_EXPECT,"ERROR", BG95<256>::contains, BG95<256>::nil, {Action::EXIT_ERROR, 0}, 0},
// }};
//
// std::mutex m;
// m.lock();
// std::thread th1 ([&](){
// do
// modem.inetd(false, &async);
// while (!m.try_lock());
// m.unlock();
// });
// EXPECT_EQ (modem.run(script), true);
// m.unlock(); // stop and join inetd
// th1.join();
// }
TEST(TBG95_base, command) { using Control = BG95<Size>::control_t;
BG95<256> modem;
const BG95<Size>::script_t<4> script = {{
{Control::NOP, "", BG95<Size>::nil, BG95<Size>::nil, BG95<Size>::go_to<1>, 1000},
{Control::SEND, "ATE0\r\n", BG95<Size>::nil, BG95<Size>::nil, BG95<Size>::next, 0},
{Control::EXPECT, "OK\r\n", BG95<Size>::ends_with, BG95<Size>::nil, BG95<Size>::exit_ok, 1000},
{Control::OR_EXPECT,"ERROR", BG95<Size>::contains, BG95<Size>::nil, BG95<Size>::exit_error, 0}
}};
std::mutex m; std::mutex m;
m.lock(); m.lock();
@ -269,13 +257,45 @@ namespace test_bg95_base {
while (!m.try_lock()); while (!m.try_lock());
m.unlock(); m.unlock();
}); });
int status; EXPECT_EQ (modem.run(script), BG95<Size>::exit_ok.value);
EXPECT_EQ (modem.command("AT+CREG?\r\n", "\r\n+CREG: 0,%\r\n\r\nOK\r\n", &status), true); m.unlock(); // stop and join inetd
EXPECT_EQ (status, 5); th1.join();
}
char substr[32]; TEST(TATmodem, transmit) {
EXPECT_EQ (modem.command("AT+CREG?\r\n", "\r\n%\r\n\r\nOK\r\n", substr), true);
EXPECT_EQ (strcmp("+CREG: 0,5", substr), 0); }
TEST(TATmodem, command) {
BG95<Size> modem;
std::mutex m;
m.lock();
std::thread th1 ([&](){
do
modem.inetd(false);
while (!m.try_lock());
m.unlock();
});
EXPECT_EQ (modem.command("AT\r\n", "Something else", 1000), false);
EXPECT_EQ (modem.command("AT\r\n", "\r\nOK\r\n", 1000), true);
EXPECT_EQ (modem.command("AT\r\n", "%OK\r\n", 1000), true);
EXPECT_EQ (modem.command("AT+CREG?\r\n", "%OK\r\n", 1000), false);
EXPECT_EQ (modem.command("AT+CREG?\r\n", "%%%OK\r\n", 1000), true);
int status1, status2;
EXPECT_EQ (modem.command("AT+CREG?\r\n", "\r\n+CREG: 0,%\r\n\r\nOK\r\n", 1000, &status1), true);
EXPECT_EQ (status1, 5);
EXPECT_EQ (modem.command("AT+CREG?\r\n", "\r\n+CREG: %,%\r\n\r\nOK\r\n", 1000, &status1, &status2), true);
EXPECT_EQ (status1, 0);
EXPECT_EQ (status2, 5);
char substr1[32], substr2[32];
EXPECT_EQ (modem.command("AT+CREG?\r\n", "\r\n%\r\n\r\n%\r\n", 1000, substr1, substr2), true);
EXPECT_EQ (strcmp("+CREG: 0,5", substr1), 0);
EXPECT_EQ (strcmp("OK", substr2), 0);
m.unlock(); // stop and join inetd m.unlock(); // stop and join inetd
th1.join(); th1.join();

5
test/tests/deque.cpp
View File

@ -62,6 +62,11 @@ namespace Tdeque {
TEST(Tdeque, concept) { TEST(Tdeque, concept) {
using deque_t = deque<int, 8>; using deque_t = deque<int, 8>;
EXPECT_EQ ( std::is_default_constructible<deque_t>::value, true);
EXPECT_EQ ( std::is_nothrow_default_constructible<deque_t>::value, true);
EXPECT_EQ (!std::is_copy_constructible<deque_t>::value, true);
EXPECT_EQ (!std::is_copy_assignable<deque_t>::value, true);
EXPECT_EQ (true, !is_span<deque_t>::value); EXPECT_EQ (true, !is_span<deque_t>::value);
EXPECT_EQ (true, !is_std_array<deque_t>::value); EXPECT_EQ (true, !is_std_array<deque_t>::value);
EXPECT_EQ (true, !std::is_array<deque_t>::value); EXPECT_EQ (true, !std::is_array<deque_t>::value);

28
test/tests/sequencer.cpp
View File

@ -26,7 +26,7 @@
* </dd></dl> * </dd></dl>
* *
*/ */
#include <utils/sequencer.h> #include <com/sequencer.h>
#include <gtest/gtest.h> #include <gtest/gtest.h>
#include <type_traits> #include <type_traits>
@ -422,4 +422,30 @@ namespace test_sequencer {
EXPECT_EQ (s.run(script4), Seq::exit_ok.value); EXPECT_EQ (s.run(script4), Seq::exit_ok.value);
EXPECT_EQ (handler_flag, true); EXPECT_EQ (handler_flag, true);
} }
TEST(Tsequencer, run_boundaries) {
Seq s;
const Seq::script_t<1> script1 = {{
{Seq::control_t::NOP, "", Seq::nil, Seq::nil, Seq::next, 0},
}};
EXPECT_EQ (s.run(script1), Seq::exit_error.value);
const Seq::script_t<1> script2 = {{
{Seq::control_t::NOP, "", Seq::nil, Seq::nil, Seq::go_to<1>, 0},
}};
EXPECT_EQ (s.run(script2), Seq::exit_error.value);
const Seq::script_t<1> script3 = {{
{Seq::control_t::NOP, "", Seq::nil, Seq::nil, Seq::go_to<(size_t)-1>, 0},
}};
EXPECT_EQ (s.run(script3), Seq::exit_error.value);
const Seq::script_t<1> script4 = {{
{Seq::control_t::EXPECT, "abc", Seq::nil, Seq::nil, Seq::next, 1000},
}};
s.clear_clock();
EXPECT_EQ (s.run(script4), Seq::exit_error.value);
EXPECT_GT (s.clock(), (clock_t)1000);
}
} }