Wait for time by polling (specified in μsec).

Wait for a given period of time in microsec.

The time is measured by the TickTimer count. When waiting for a long time, the CPU clock is reduced and polling is performed.

Change the setting of the digital output pins.

static inline void digitalWrite(uint8_t u8pin, E_PIN_STATE ulVal)

The first parameter specifies the pin number to be set, and the second parameter specifies either HIGH or LOW.

Waiting for time by polling.

void delay(uint32_t ms)

The program waits for a given period of time in ms.

The time is measured by the TickTimer count. When waiting for a long period of time, the CPU clock is decreased and polling is performed.

Obtain the system time, [ms].

uint32_t millis()

The system tick time is updated by TickTimer interrupt.

Sets the DIO (general-purpose digital IO) pin.

void pinMode(uint8_t u8pin, E_PIN_MODE mode)

This function allows you to change the state of DIO0..19 and the pins DO0,1. The setting contents are described in the enumeration value of E_PIN_MODE, description of DIO and Description of DO.

Generates an random number.

uint32_t random(uint32_t maxval)
uint32_t random(uint32_t minval, uint32_t maxval)

The first line returns the value of 0.. (maxval-1) value is returned. Note that the value of maxval is not the maximum value.

The second line returns the value of minval..maxval-1.

The following functions are used for general-purpose digital IO (DIO) operations.

• pinMode()

• digitalWrite()

• digitalRead()

• attachIntDio()

• detachIntDio()

Constants

Pin name and number

Mode of pin（DIO0..19)

The following enumeration values are handled with the type name E_PIN_MODE.

Mode of the pin (DO0,1)

The following enumeration values are handled with the type name E_PIN_MODE.

pin_state

The following enumeration values are handled with the type name E_PIN_STATE.

Rising and falling edge of pin

The following enumeration values are handled with the type name E_PIN_INT_MODE.

Sets 1 at the specified bit position.

Parameters can be specified as a variable number of arguments, each parameter specifying a 0..31 integer that specifies a bit position. For example, specifying pack_bits(1,3,6) returns ((1UL<<1)|(1UL<<3)|(1UL<<6)).

Background

There are situations where values are referenced and set in various bitmaps, such as the status of IO ports (DI, DO), to simplify the description.

Unregisters the interrupt handler.

The mwx library uses an implementation of printf, which is commonly used in C, for formatting output. Function definitions for several functions are available.

mwx_printf() prints a printf output to the Serial object. It is the same process as Serial.printfmt().

mwx_snprintf()` prints a snprintf to a buffer.

Reads the values of all ports in the input settings at once.

The values are stored in the order of DIO0 ... DIO19 from the LSB side. DIO19 are stored in this order.

The pins on the HIGH side are set to 1 and the pins on the LOW side are set to 0.

Enables DIO interrupts.

For a preconfigured pin, the first parameter is the pin number for which you want to enable interrupts, the second is the interrupt direction (.

Example

Set up an interrupt to be generated when the DIO5 pin changes from HIGH to LOW.

myAppClass.hpp

Basic definition of the application behavior myAppClass. Details are omitted.

myAppClass.cpp

Description of the interrupt handler of the application behavior myAppClass, which inverts the output setting of DIO12 when an interrupt of DIO5 is generated and displays * on the serial port Serial for events occurring after the interrupt handler is finished.

Reads the value of the port of the input configuration.

static inline E_PIN_STATE digitalRead(uint8_t u8pin)

Get the input value of a pin that has been previously set as an input, either LOW or HIGH.

Obtains the value of a specified bit position from an integer and creates a bitmap of the specified order.

constexpr uint32_t collect_bits(uint32_t bm, ...)

The value corresponding to the bit position 0..31 specified by the subsequent variable number parameter is extracted from the value specified in the parameter bm. The extracted values are arranged in parameter order and returned as a bitmap.

The bitmap is ordered with the first parameter as the upper bit and the last parameter as bit 0.

uint32_t b1 = 0x12; // (b00010010)
uint32_t b2 = collect_bits(b1, 4, 2, 1, 0); 
  // bit4->1, bit2->0, bit1->1, bit0->0
  // b2=0x10 (b1010)

In the example, taking out bits 4,2,1,0 of b1 yields (1,0,1,0). This is calculated as 0x10 as b1010.

Background

There are situations where values are referenced and set in various bitmaps, such as the status of IO ports (DI, DO), in order to simplify the description.

Read

Get uint16_t, uint32_t values from the byte array as uint8_t, big-endian sequence.

	inline uint8_t G_BYTE(const uint8_t*& p) {
		return *(p)++; 
	}
	inline uint16_t G_WORD(const uint8_t*& p) {
		uint32_t r = *p++;
		r = (r << 8) + *p++;
		return r;
	}
	inline uint32_t G_DWORD(const uint8_t*& p) {
		uint32_t r = *p++;
		r = (r << 8) + *p++;
		r = (r << 8) + *p++;
		r = (r << 8) + *p++;
		return r;
	}

p is incremented by the number of bytes read.

Writing

Write uint8_t, big-endian uint16_t and uint32_t values to the byte array specified by pointer q.

	inline uint8_t& S_OCTET(uint8_t*& q, uint8_t c) {
		*q++ = c;
		return *q;
	}
	inline uint8_t& S_WORD(uint8_t*& q, uint16_t c) {
		*(q) = ((c) >> 8) & 0xff; (q)++;
		*(q) = ((c) & 0xff); (q)++;
		return *q;
	}
	inline uint8_t& S_DWORD(uint8_t*& q, uint32_t c) {
		*(q) = ((c) >> 24) & 0xff; (q)++;
		*(q) = ((c) >> 16) & 0xff; (q)++;
		*(q) = ((c) >>  8) & 0xff; (q)++;
		*(q) = ((c) & 0xff); (q)++;
		return *q;
	}

q is incremented by the number of bytes written.

Background

To simplify operations when generating and disassembling the data payload of wireless packets.

More simplified pack_bytes() and expand_bytes() are also available.

This value is often used in checksum calculations.

uint8_t CRC8_u8Calc(uint8_t *pu8Data, uint8_t size, uint8_t init=0)
uint8_t CRC8_u8CalcU32(uint32_t u32c, uint8_t init=0)
uint8_t CRC8_u8CalcU16(uint16_t u16c, uint8_t init=0)
uint8_t XOR_u8Calc(uint8_t *pu8Data, uint8_t size)
uint8_t LRC_u8Calc(uint8_t* pu8Data, uint8_t size)

CRC8, XOR, LRC(ASCII format) calculations.

CRC8_u8CalcU16(), CRC8_u8CalcU32() computes CRC8 using u16c, u32c as big-endian sequence.

Background

Added as a library procedure because it is used to check data strings in wireless packets, checksums (LRC) in ASCII format, and various sensors.

Decompose a sequence of bytes and store it in a variable.

const uint8_t* expand_bytes(
        const uint8_t* b, const uint8_t* e, ...)

The expand_bytes() parameter is a combination of iterators of type uint8_t*. This specifies the next iterator after the beginning and end of the parsed target. If the parsing proceeds to the e position, nullptr is returned.

If there is no error in expansion, the next iterator to be read is returned.

The variable number parameters can be the following

Example

auto&& rx = the_twelite.receiver.read();

char fourchars[5]{}; 
auto&& np = 
	expand_bytes(rx.get_payload().begin(), rx.get_payload().end()
		, make_pair((uint8_t*)fourchars, 4)
    );

// read rest of payload
uint8_t u8DI_BM_remote = 0xff;
uint16_t au16AI_remote[5];
expand_bytes(np, rx.get_payload().end()
	, u8DI_BM_remote
	, au16AI_remote[0]
	, au16AI_remote[1]
	, au16AI_remote[2]
	, au16AI_remote[3]
	, au16AI_remote[4]
);

In this example, a 4-byte string is read out first. Here, make_pair() is used to explicitly read 4 bytes of data.

The next data is read out based on the returned iterator np. The next data is of type uint8_t, followed by five more of type uint16_t.

Background

To simplify the description of byte arrays of type uint8_t used in generating data payloads and extracting data from non-volatile packets.

auto&& rx = the_twelite.receiver.read();
char fourchars[5]{}; 
uint8_t u8DI_BM_remote = 0xff;
uint16_t au16AI_remote[5];

uint8_t *p = rx.get_payload().begin();
fourchars[0] = p[0];
fourchars[1] = p[1];
fourchars[2] = p[2];
fourchars[3] = p[3];
fourchars[4] = 0;
p += 4;

u8DI_BM_remote = (p[0] << 8) + p[1]; p+=2;
au16AI_remote[0] = (p[0] << 8) + p[1]; p+=2;
...

The above is the simplest description, but it can be read from a byte array using Byte array utils as follows

auto&& rx = the_twelite.receiver.read();
char fourchars[5]{}; 
uint8_t u8DI_BM_remote = 0xff;
uint16_t au16AI_remote[5];

uint8_t *p = rx.get_payload().begin();
fourchars[0] = G_BYTE(p);
fourchars[1] = G_BYTE(p);
fourchars[2] = G_BYTE(p);
fourchars[3] = G_BYTE(p);
fourchars[4] = 0;

u8DI_BM_remote = G_WORD(p);
au16AI_remote[0] = G_WORD(p);
...

Generates a sequence of bytes by arranging element data.

uint8_t* pack_bytes(uint8_t* b, uint8_t* e, ...)

pack_bytes takes a begin(),end() iterator of the container class as a parameter and writes the data specified by the following parameters to the container as a sequence of bytes.

The data given for the variable argument parameters are as follows

smplbuf_u8& pack_bytes(smplbuf_u8& c, ...)

The pack_bytes takes a container object as a parameter and writes the data specified by the subsequent parameters as a sequence of bytes into the container. It is appended to the end by the container's .push_back() method.

The data given as variable argument parameters is shown below.

Example

auto&& rx = the_twelite.receiver.read();

smplbuf<uint8_t, 128> buf;
mwx::pack_bytes(buf
	, uint8_t(rx.get_addr_src_lid())	    // src addr (LID)
	, uint8_t(0xCC)							// cmd id (0xCC, fixed)
	, uint8_t(rx.get_psRxDataApp()->u8Seq)	// seqence number
	, uint32_t(rx.get_addr_src_long())		// src addr (long)
	, uint32_t(rx.get_addr_dst())			// dst addr
	, uint8_t(rx.get_lqi())					// LQI
	, uint16_t(rx.get_length())				// payload length
	, rx.get_payload() 						// payload
);

In this example, each attribute and payload of the received packet is re-stored in a separate buffer buf.

Background

To simplify the description of byte arrays of type uint8_t used in the generation of data payloads and extraction of data in non-volatile packets.

auto&& rx = the_twelite.receiver.read();

uint8_t data[128];
data[0] = rx.get_addr_src_lid();
data[1] = 0xCC;
data[2] = rx.get_psRxDataApp()->u8Seq;
data[4] = rx.get_addr_src_long() & 0x000000FF;
data[5] = (rx.get_addr_src_long() & 0x0000FF00) >> 8;
data[6] = (rx.get_addr_src_long() & 0x00FF0000) >> 16;
data[7] = (rx.get_addr_src_long() & 0xFF000000) >> 24;
...

The above is the simplest description, but byte arrays can be generated using Byte array utils as follows.

auto&& rx = the_twelite.receiver.read();

uint8_t data[128], *q = data;
S_OCTET(q, rx.get_addr_src_lid());
S_OCTET(q, 0xCC);
S_OCTET(q, rx.get_psRxDataApp()->u8Seq);
S_DWORD(q, rx.get_addr_src_long());
S_DWORD(q, rx.get_addr_dst());
S_OCTET(q, rx.get_lqi());
S_WORD(q, rx.get_length());
for (auto x : rx.get_payload()) {
  S_OCTET(q, x);
}

Simplifies the description of placement new (placement new).

For example, use the following Constructor arguments can also be given.

background

Since the constructor of the global object is not called due to compiler constraints, one way to initialize it is to use placement new. However, since the syntax of placement new (placement new) appears to be complicated.

Another method is to use std::unique_ptr (or eastl::unique_ptr).

The quotient divided by 10, 100 or 1000 and the remainder Calculate the quotient and remainder.

In some cases, such as sensor values, the value multiplied by 100 may be passed as a uint16_t type, but since calculation processing on a microcontroller without a division circuit takes a reasonable amount of time, the calculation is performed by approximate calculation and correction using addition, subtraction, multiplication and bit shift.

Pass val as the value to be calculated, rem as the variable to store the remainder, and neg as the variable to store the sign.

The return value is the quotient value (always positive), rem stores the remainder value (always positive), and neg is true if negative.

The constraints of the calculation algorithm (overflow) determine the range of possible values for div100() and div1000(). The div100() corresponds to values from -9999999 to 9999999, and the div1000() corresponds to values from -999999999 to 99999999.

Usage examples

Calculation speed

Approx. 10 times faster.

Output results

The div_result_i32 class, which stores the result of division, has a format() method to obtain a _div_chars class object. The _div_chars() class object contains a string buffer and has methods to access the string buffer as const char* type. It also implements the << operator for Serial objects.

The first parameter dig_quo of the format() method specifies the number of output digits (not including the sign part). If the number of output digits is not sufficient (hereafter referred to as missing digits), it is filled with blanks or 0. The second parameter opt specifies the format.

Example

Background

Since division is a costly operation in the TWELITE wireless microcontroller, we added a division algorithm with a limited purpose.

In the library, some sensor values such as temperature and humidity are expressed using 100 times the value (2512 for 25.12°C), so we defined a simple procedure to obtain the quotient divided by 100 and the remainder.

As for dev_result_i32::format(), it is to avoid complications when formatting output.

Scale (expand and contract) with 8-bit values (0..25, etc.) and user-friendly 0..1000 (thousandths, ‰) values. Approximate computation by multiplication and bit shift instead of division (x*1000/255) for low computational cost.

scale_1000_to_127u8()

Scale 0..1000 to 0..127. Approximate calculation using (16646*x+65000)>>17.

scale_127u8_to_1000()

Scale 0..127 to 0..1000. Approximate calculation using (2064000UL*x+131072)>>18.

scale_1000_to_255u8()

Scales 0..1000 to 0..255. Approximate calculation using (33423*x+65000)>>17.

scale_255u8_to_1000()

Scales 0..255 to 0..1000. Approximate calculation using (1028000UL*uint32_t(x)+131072)>>18.

scale_1000_to_256u8()

Scales 0..1000 to 0..256. Approximate calculation using (33554*x+66000) >> 17.

Note: x=999,1000 returns 255 as the range of uint8_t even though the calculated value is 256.

scale_256u16_to_1000()

Scale 0..256 to 0..1000. Approximate calculation using (1028000UL*uint32_t(x)+131072)>>18.

Background

Values to be set in hardware are often based on binary numbers such as 0...255, while numbers to be handled in user applications are easier to handle based on decimal numbers such as 0...1000. We defined an expression that does not perform division for these scale conversions.