14067797526

Committed 25 Mar 2025 06:51PM CUT coverage: 90.526%. Remained the same

Build # 14067797526

Build Type

push

github

Committed by

web-flow

Commit Message

chore: Update `note-c` dependency (#140)

* chore: Improve version docs, bump version
* Remove `note-c` before re-add
* Squashed 'src/note-c/' content from commit c35ba60
    - git-subtree-dir: src/note-c
    - git-subtree-split: c35ba60e1
* Remove unneeded directories from `note-c`

Run Details

98 of 137 branches covered (71.53%)

Branch coverage included in aggregate %.

332 of 338 relevant lines covered (98.22%)

15.22 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

75.0

/src/NoteTxn_Arduino.cpp

#include "NoteTxn_Arduino.hpp"

#ifndef NOTE_MOCK
  #include <Arduino.h>
#else
  #include "mock/mock-arduino.hpp"
  #include "mock/mock-parameters.hpp"
#endif

// Singleton instance of the NoteTxn_Arduino class
namespace instance {
    inline NoteTxn* & note_txn (void) {
        static NoteTxn* note_txn = nullptr;
        return note_txn;
    }
};

NoteTxn *
make_note_txn (
    nullptr_t
) {
    NoteTxn* & note_txn = instance::note_txn();
    if (note_txn) {
        delete note_txn;
        note_txn = nullptr;
    }
    return note_txn;
}

template <typename T>
NoteTxn *
make_note_txn (
    T & txn_pins_
) {
    NoteTxn* & note_txn = instance::note_txn();

    if (txn_pins_[0] == txn_pins_[1]) {
        // Invalid tuple invokes deletion
        if (note_txn) {
            delete note_txn;
            note_txn = nullptr;
        }
    } else if (!note_txn) {
        note_txn = new NoteTxn_Arduino(txn_pins_[0], txn_pins_[1]);
    }

    return note_txn;
}

NoteTxn_Arduino::NoteTxn_Arduino
(
    uint8_t ctx_pin_,
    uint8_t rtx_pin_
) :
    _ctx_pin(ctx_pin_),
    _rtx_pin(rtx_pin_)
{
    // Float CTX/RTX to conserve energy
    ::pinMode(_ctx_pin, INPUT);
    ::pinMode(_rtx_pin, INPUT);
}

bool
NoteTxn_Arduino::start (
    uint32_t timeout_ms_
)
{
    bool result = false;

    // Signal Request To Transact
    ::pinMode(_rtx_pin, OUTPUT);
    ::digitalWrite(_rtx_pin, HIGH);

    // Await Clear To Transact Signal
    ::pinMode(_ctx_pin, INPUT_PULLUP);
    for (uint32_t timeout = (::millis() + timeout_ms_)
       ; ::millis() < timeout
       ; ::delay(1)
    ) {
        if (HIGH == ::digitalRead(_ctx_pin)) {
            result = true;
            break;
        }
    }

    // Float CTX to conserve energy
    ::pinMode(_ctx_pin, INPUT);

    // Abandon request on timeout
    if (!result) {
        stop();
    }

    return result;
}

void
NoteTxn_Arduino::stop (
    void
)
{
    // Float RTX pin
    ::pinMode(_rtx_pin, INPUT);
}

// Explicitly instantiate the template function for array types
template NoteTxn * make_note_txn<uint8_t[2]>(uint8_t(&)[2]);
template NoteTxn * make_note_txn<const uint8_t[2]>(const uint8_t(&)[2]);

1	#include "NoteTxn_Arduino.hpp"
2
3	#ifndef NOTE_MOCK
4	#include <Arduino.h>
5	#else
6	#include "mock/mock-arduino.hpp"
7	#include "mock/mock-parameters.hpp"
8	#endif
9
10	// Singleton instance of the NoteTxn_Arduino class
11	namespace instance {
12	inline NoteTxn* & note_txn (void) {	7✔
13	static NoteTxn* note_txn = nullptr;
14	return note_txn;	7✔
15	}
16	};
17
18	NoteTxn *
19	make_note_txn (	×
20	nullptr_t
21	) {
22	NoteTxn* & note_txn = instance::note_txn();	×
23	if (note_txn) {	×
24	delete note_txn;	×
25	note_txn = nullptr;	×
26	}
27	return note_txn;	×
28	}
29
30	template <typename T>
31	NoteTxn *
32	make_note_txn (	7✔
33	T & txn_pins_
34	) {
35	NoteTxn* & note_txn = instance::note_txn();	7✔
36
37	if (txn_pins_[0] == txn_pins_[1]) {	7✔
38	// Invalid tuple invokes deletion
39	if (note_txn) {	3!
40	delete note_txn;	3!
41	note_txn = nullptr;	3✔
42	}
43	} else if (!note_txn) {	4✔
44	note_txn = new NoteTxn_Arduino(txn_pins_[0], txn_pins_[1]);	3!
45	}
46
47	return note_txn;	7✔
48	}
49
50	NoteTxn_Arduino::NoteTxn_Arduino	16✔
51	(
52	uint8_t ctx_pin_,
53	uint8_t rtx_pin_
54	) :	16✔
55	_ctx_pin(ctx_pin_),	16✔
56	_rtx_pin(rtx_pin_)	16✔
57	{
58	// Float CTX/RTX to conserve energy
59	::pinMode(_ctx_pin, INPUT);	16!
60	::pinMode(_rtx_pin, INPUT);	16!
61	}	16✔
62
63	bool
64	NoteTxn_Arduino::start (	10✔
65	uint32_t timeout_ms_
66	)
67	{
68	bool result = false;	10✔
69
70	// Signal Request To Transact
71	::pinMode(_rtx_pin, OUTPUT);	10✔
72	::digitalWrite(_rtx_pin, HIGH);	10✔
73
74	// Await Clear To Transact Signal
75	::pinMode(_ctx_pin, INPUT_PULLUP);	10✔
76	for (uint32_t timeout = (::millis() + timeout_ms_)	10✔
77	; ::millis() < timeout	22✔
78	; ::delay(1)	12✔
79	) {
80	if (HIGH == ::digitalRead(_ctx_pin)) {	19✔
81	result = true;	7✔
82	break;	7✔
83	}
84	}
85
86	// Float CTX to conserve energy
87	::pinMode(_ctx_pin, INPUT);	10✔
88
89	// Abandon request on timeout
90	if (!result) {	10✔
91	stop();	3✔
92	}
93
94	return result;	10✔
95	}
96
97	void
98	NoteTxn_Arduino::stop (	4✔
99	void
100	)
101	{
102	// Float RTX pin
103	::pinMode(_rtx_pin, INPUT);	4✔
104	}	4✔
105
106	// Explicitly instantiate the template function for array types
107	template NoteTxn * make_note_txn<uint8_t[2]>(uint8_t(&)[2]);
108	template NoteTxn * make_note_txn<const uint8_t[2]>(const uint8_t(&)[2]);

blues / note-arduino / 14067797526

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous