Detects changes in digital inputs. This class detects changes when the same detected value is obtained multiple times. This is useful for reducing the effect of chattering on mechanical buttons.

Methods

setup()

void setup(uint8_t max_history);

The parameter max_history is the maximum number of references that can be set with begin(). Memory is allocated and initialized here.

begin()

void begin(uint32_t bmPortMask,
				   uint8_t u8HistoryCount,
				   uint16_t tick_delta);

Starts the Buttons operation, the first parameter bmPortMask specifies the bitmap of digital inputs to be monitored. bit 0 corresponds to DIO 0, ... , bit N corresponds to DIO N. More than one can be specified: the second u8HistoryCount is the number of times required to confirm the value; the third tick_delta specifies the interval in ms between value checks; the fourth u8HistoryCount is the number of times to confirm the value.

It will take u8HistoryCount*tick_delta[ms] to confirm the value. For example, if u8HistoryCount=5 and tick_delta=4, it will take at least 20ms to confirm the state.

The confirmation is done in the TickTimer event handler. Since it is not an interrupt handler, it is affected by delays in processing, etc., but it is sufficient to suppress chattering of mechanical buttons, etc.

end()

void end()

Terminates the Buttons operation.

available()

inline bool available()

Returns true when a change is detected. It is cleared when read() is executed.

read()

bool read(uint32_t& u32port, uint32_t& u32changed)

Called when u32port becomes available. u32portis the bitmap of the current input DIO andu32changed` is the bitmap of the DIO where the change was detected.

Returns false if Buttons is not working.

About operation

Initial value determination

When Buttons starts to operate, the input status of DIO is not yet determined. When the value is determined, it becomes available. At this time, the MSB (bit31) of the bitmap read by read() is set to 1.

Since this function requires the operation to be determined, it cannot be used to monitor ports whose input values change constantly.

Sleep

If Buttons is in operation before Sleep, it will resume after it is restored. After resumption, initial determination is performed.

Analogue performs ADC and acquires values. It can continuously acquire multiple channels at a time, and can do so sequentially according to a timer or other cycle.

Constant.

Pin Definition.

pinMode(PIN_DIGITAL::DIO0, PIN_MODE::INPUT); 
pinMode(PIN_DIGITAL::DIO1, PIN_MODE::INPUT);

method.

setup()

void setup(
        bool bWaitInit = false,
        uint8_t kick_ev = E_AHI_DEVICE_TICK_TIMER,
        void (*fp_on_finish)() = nullptr) 

Initializes ADCs. setup() starts the regulator inside the semiconductor, specifies the timer device for periodic execution, and specifies the callback function to be called when all ADCs on the specified channel have completed.

begin()

void begin(uint8_t bmPorts, uint8_t capt_tick = 1)

The first parameter specifies the port where the ADC is to be made. The port specification is a bitmap with the bits set corresponding to the port numbers mentioned in the pin definition.For example, if you want to get the values of two pins PIN_ANALOGUE::A2 and PIN_ANALOGUE::VCC, specify (1 <<PIN_ANALOGUE::A1 | 1<<PIN_ANALOGUE::VCC ). You can also use pack_bits and write pack_bits(PIN_ANALOGUE::A1,PIN_ANALOGUE::VCC).

After calling begin(), the first ADC processing starts immediately, and the processing of the next pin starts from its end interrupt. When all processing is finished (if specified), the callback function is called. It waits until the next timer interrupt occurs before starting a new ADC process.

The second parameter specifies the number of timer interrupts before AC starts. For example, TickTimer is called every 1 ms, but if you specify 16 for the parameter, it will be processed every 16 ms.

void begin()

Starts ADC processing with default ADC pins (PIN_ANALOGUE::A1, PIN_ANALOGUE::A2). end() resumes the interrupted ADC processing.

end()

void end()

ADC processing is terminated and the regulator inside the semiconductor is stopped.

available()

inline bool available()

The value of the ADC is set to true after the acquisition. After confirmation by this function, it is false until the next ADC completion.

read(), read_raw()

inline int16_t read(uint8_t s)
inline int16_t read_raw(uint8_t s)

Reads ADC values. The parameter specifies the ADC pin to be read. read() returns the read value converted to mV and read_raw() returns the ADC value (0..1023).

ADC interrupt handler.

The ADC interrupt handler is set to periph_analogue::ADC_handler() when setup() is called.

If a different handler is specified by the semiconductor peripheral library, it will not work properly.

Sleep behavior

If the ADC is in cyclic execution state by begin(), ADC processing is resumed after returning from sleep.

For definitions commonly loaded in the library, cite the definition content.

mwx_common.h

#include <cstdint> // for type name
typedef char char_t;
typedef uint8_t byte;
typedef uint8_t boolean;

#ifndef NULL
#define NULL nullptr
#endif

Class objects are predefined objects in the MWX library, such as the_twelite, which handles TWENET, and objects for using peripherals.

Each object must be initialized by calling the .setup() or .begin() method. (Only Serial objects that use UART0 do not require initialization.)

This built-in class is defined as a built-in object, intended to be used for format input via serial port.

It is defined as a mwx::serial_parser<mwx::alloc_heap<uint8_t>> type that allocates buffer space for internal use from the heap at initialization (begin()).

For details, see class serparser for details.

TWELITE Reads and writes to the built-in EEPROM of the wireless microcontroller.

The built-in EEPROM has 3480 bytes available from address 0x000 to 0xEFF.

The first part is Settings (Interactive settings mode), so it is recommended to use the second half of the address when used together. The amount of space consumed by the settings (Interactive settings mode) depends on its implementation. Even with minimal settings, up to 256 bytes are used from the beginning, so use of the later addresses is recommended.

Methods

read()

uint8_t read(uint16_t address)

Read the data corresponding to address from EEPROM.

write()

void write(uint16_t address, uint8_t value)

Write value from EEPROM to address.

update()

void update(uint16_t address, uint8_t value)

This function is used when you want to reduce the number of rewrites in consideration of the rewrite life of EEPROM.

get_stream_helper()

auto&& get_stream_helper()
// The return type is abbreviated as auto&& due to its length.

Obtain a helper object to read and write using mwx::stream described below.

mwx::streamインタフェースを用いた入出力

stream_helper helper object mwx::stream operators and methods. Using mwx::stream, you can read and write integer types such as uint16_t and uint32_t types, read and write fixed-length array types such as uint8_t, and format them using format() objects.

auto&& strm = EEPROM.get_stream_helper();
// Helper object type names are resolved by auto&& due to their length.

Interfaces defined in mwx::stream, such as the << operator, can be used on this object.

strm.seek(1024); // Move to 1024th byte

strm << format("%08x", 12345678); // Record 12345678 as 8 characters in hexadecimal
strm << uint32_t(0x12ab34cd);     // Record 4 bytes of 0x12ab34cd
uint8_t msg_hello[16] = "HELLO WORLD!";
strm << msg_hello;                // Record "HELLO WORLD!" byte sequence (unterminated)

// result
// 0400: 30 30 62 63 36 31 34 65 12 ab 34 cd 48 45 4c 4c
//        0  0  b  c  6  1  4  e  0x12ab34cd  H  E  L  L
// 0410: 4f 20 57 4f 52 4c 44 21 00 00 00 00 ff ff ff ff
//        O SP  W  O  R  L  D  ! 

.seek() is used to move the EEPROM address to 1024.

The above writes an 8-byte string (00bc614e), a 4-byte integer (0x12ab34cd), a 16-byte byte string (HELLO WORLD!.... ), and a 1-byte terminating character.

strm.seek(1024);

uint8_t msg1[8];
strm >> msg1;
Serial << crlf << "MSG1=" << msg1;
// MSG1=00bc614e

uint32_t var1;
strm >> var1;
Serial << crlf << "VAR1=" << format("%08x", var1);
// VAR1=12ab34cd

uint8_t msg2[16]; // "HELLO WORLD!"の文字数
strm >> msg2;
Serial << crlf << "MSG2=" << msg2;
// MSG2=HELLO WORLD!

Move the EEPROM address to 1024 using .seek().

Reads the data sequence written out earlier. In order, 8-byte characters, 4-byte integers, and 16-byte strings are read out using the >> operator.

TickTimer is used for internal control of TWENET and is implicitly executed. The period of the timer is 1ms. Only the available() method is defined in loop() for the purpose of describing processing every 1ms by the TickTimer event.

void loop() {
  if (TickTimer.available()) {
    if ((millis() & 0x3FF) == 0) { // This may not be processed (could be skipped)
      Serial << '*';
    }
  }
}

Methods

available()

inline bool available()

It is set after the TickTimer interrupt occurs and becomes true in the loop() immediately following it. It is cleared after loop() ends.

The helper class version is a more abstract implementation. Creating a transceiver object for reading and writing is the start of using the bus, and destroying the object is the end of using the bus.

By creating the object in the decision expression of the if statement, the validity period of the object is limited to the scope of the if clause, and the object is destroyed when it exits the if clause, at which point the bus usage termination procedure is performed.

uint8_t c;
if (auto&& trs = SPI.get_rwer()) { // Object creation and device communication determination
   // Within this scope (wave brackets) is the validity period of trs.
   trs << 0x00; // Writes 0x00 with mwx::stream interface
   trs >> c;    // Store the read data in c.
} 
// wrt is discarded at the point where the if clause is exited, and the use of the bus is terminated

In addition, read/write objects implement the mwx::stream interface, allowing the use of the << operator, etc.

• The start and end of bus usage is aligned with the validity period of the object to improve the visibility of the source code and to prevent omissions in the termination procedure, etc.

• Unify read/write procedures with the mwx::stream interface

read/write

Reading process and its termination procedure in scope if() { ... } to do the reading with a helper class.

inline uint8_t _spi_single_op(uint8_t cmd, uint8_t arg) {
    uint8_t d0, d1;
    if (auto&& x = SPI.get_rwer()) {
        d0 = x.transfer(cmd); (void)d0;
        d1 = x.transfer(arg);
        // (x << (cmd)) >> d0;
        // (x << (arg)) >> d1;
    }

    return d1;
}

In the above, the x object created by the get_rwer() method is used to read and write one byte at a time. 1.

1. create x object in if(...) Generate the x object in the get_rwer() method. At the same time, set the select pin of the SPI bus. (The type is resolved with the universal reference auto&& by type inference. 2.)

2. the generated x object has a operator bool () defined, which is used to evaluate the decision expression, which is always true for the SPI bus.

3. x object defines uint8_t transfer(uint8_t) method, which is called to perform 8bit read/write transfer to SPI. 4. 4.if() { ... } Destructor of x is called at the end of the scope to release the select pin of the SPI bus.

get_rwer()

periph_spi::transceiver get_rwer()

Obtains the worker object used to read/write the SPI bus.

worker object

transfer() transfer16() transfer32()

uint8_t transfer(uint8_t val)
uint16_t transfer16(uint16_t val)
uint32_t transfer32(uint32_t val)

Each transfers 8-bit, 16-bit, and 32-bit data, and returns the read result with the same data width as the written data width.

<< operator

operator << (int c)
operator << (uint8_t c)
operator << (uint16_t c) 
operator << (uint32_t c)

The int and uint8_t types perform 8-bit transfer.

Types uint16_t and uint32_t perform 16-bit and 32-bit transfers, respectively.

The transfer result is stored in an internal FIFO queue of up to 16 bytes and read by the >> operator. Since the buffer is not large, it is assumed to be read out after each transfer.

>> operator

operator >> (uint8_t& c)
operator >> (uint16_t& c)
operator >> (uint32_t& c)

null_stream(size_t i = 1)
operator >> (null_stream&& p)

Specify a variable with the same data width as the previous transfer.

If the result of the read is not needed, use the null_stream() object; it skips reading by the data byte specified by i. If the result of the read is not needed, use the null_stream() object.

The the_twelite object summarizes the procedures for using TWENET and includes procedures for operating the wireless microcontroller, such as basic wireless settings, sleep, and other procedures.

summary.

the_twelite is set up in the setup() function, which also calls the_twelite.begin() to start the process. It is not possible to set up the_twelite except in setup().

void setup() {
  ...
 	the_twelite
		<< TWENET::appid(APP_ID)    
		<< TWENET::channel(CHANNEL) 
		<< TWENET::rx_when_idle();  
  ...
  the_twelite.begin();
}

In the above example, the application ID is set, the communication channel is set, and the receiving circuit is set.

Various procedures are included.

// Get a serial number
uint32_t u32hwser = the_twelite.get_hw_serial();

// Set channel to 11
the_twelite.change_channel(11);

// Sleep for 1 second.
the_twelite.sleep(1000);

// Perform a reset
the_twelite.reset_system();

It is also possible to register classes that handle wireless networks, classes that summarize board support, and classes that perform event-driven processing described by the user. By registering these classes, dedicated functions can be easily used. These classes are referred to as "behaviors" in this explanation.

void setup() {
	/*** SETUP section */
	// use PAL_AMB board support.
	auto&& brd = the_twelite.board.use<PAL_AMB>();
	
	...
	
	// Register Network
	auto&& nwk = the_twelite.network.use<NWK_SIMPLE>();
	nwk << NWK_SIMPLE::logical_id(u8ID);

In the above example, two types of behaviors are registered: environmental sensor pal behavior <PAL_AMB> and simple relay network <NWK_SIMPLE>. By registering these, hardware such as sensors on the environmental sensor pal can be easily handled. In addition, the complicated handling of wireless packets can be implicitly provided with functions such as relay processing and automatic discarding of duplicate packet arrivals.

Methods

<<operator (setting)

The << operator is used to initialize the object the_twelite.

The following configuration class objects are used as input, and default values are applied if no configuration is made.

TWENET::appid(uint32_t id)

Set the parameter id to the specified application ID. This is a required specification.

Reading the settings is done with uint32_t the_twelite.get_appid().

TWENET::channel(uint8_t ch)

Set the specified channel number (11..26) in parameter ch.

Reading the settings is done with uint8_t the_twelite.get_channel().

TWENET::tx_power(uint8_t pw)

Parameter pw is set to (0. 3) for the radio output. The default is (3: no output attenuation).

Reading the settings is done with uint8_t the_twelite.get_tx_power().

TWENET::rx_when_idle(uint8_t bEnable)

If the parameter bEnable is 1, the receiver circuit is always activated and can receive radio packets from others. The default is 0, which is dedicated to transmission only.

Reading the settings is done with uint8_t the_twelite.get_rx_when_idle().

TWENET::chmgr(uint8_t ch1 = 18, uint8_t ch2 = 0, uint8_t ch3 = 0)

Enables the channel manager. If multiple channels are specified, sending/receiving is performed on multiple channels; if 0 is specified for ch2 and ch3, the specification is disabled.

STG_STD

Reflects the setting values in interactive mode.

auto&& set = the_twelite.settings.use<STG_STD>();
...
set.reload();       // Load settings
the_twelite << set; // Reflects interactive mode settings

The items that will be reflected are as follows

• app_id

• channel

• tx_power

• Number of retransmissions when MAC ack is used

begin()

void begin()

It is executed after preconfiguration (see << operator) and registration of the behavior. It is usually placed at the end of the setup() function.

• the_twelite finished setting up

• Behavior initialization

例

void setup() {
	// use PAL_AMB board support.
	auto&& brd = the_twelite.board.use<PAL_AMB>();
	
	// settings
 	the_twelite
		<< TWENET::appid(APP_ID)    
		<< TWENET::channel(CHANNEL) 
		<< TWENET::rx_when_idle();  
	
	// Register Network
	auto&& nwk = the_twelite.network.use<NWK_SIMPLE>();
	nwk << NWK_SIMPLE::logical_id(u8ID);
	
	// somo others
	
	// begin the TWENET!
	the_twelite.begin();
}

change_channel()

inline bool change_channel(uint8_t u8Channel)

Changes channel settings. On failure, the channel is not changed and false is returned.

get_channel_phys()

uint8_t get_channel_phys()

Obtains the currently set channel number (11..26) from the MAC layer API.

get_hw_serial()

inline uint32_t get_hw_serial()

Get the module serial number.

sleep()

inline void sleep(
        uint32_t u32Periodms,