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.

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.

After initializing the hardware by the begin() method, the bus can be read and written by beginTransaction(). Executing beginTransaction() selects the SPI select pin. Read/write is done with the transfer() function; SPI reads and writes at the same time.

beginTransaction()

void beginTransaction()
void beginTransaction(SPISettings settings)

Starts the use of the bus; sets the SPI select pin.

If called with the settings parameter given, the bus is set.

endTransaction()

void endTransaction()

Terminates the use of the bus; releases the SPI select pin.

transfer(), transfer16(), transfer32()

inline uint8_t transfer(uint8_t data)
inline uint16_t transfer16(uint16_t data)
inline uint32_t transfer32(uint32_t data)

Reads and writes the bus. transfer() transfers 8 bits, transfer16() transfers 16 bits, and transfer32() transfers 32 bits.

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.

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.)

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, 
        bool_t bPeriodic = true, 
        bool_t bRamOff = false, 
        uint8_t u8Device = TWENET::SLEEP_WAKETIMER_PRIMARY)

Put the module to sleep.

is_wokeup_by_dio()

bool is_wokeup_by_dio(uint8_t port)

Returns true if the return factor from sleep is the specified digital pin.

is_wokeup_by_wktimer()

bool is_wokeup_by_wktimer()

Returns true if the wake-up timer is the wake-up factor for returning from sleep.

reset_system()

inline void reset_system()

Resets the system. After reset, the process starts from setup().

stop_watchdog()

inline void stop_watchdog()

Stops the watchdog timer. Stop the timer if you are going to wait for polling for a long time.

restart_watchdog()

inline void restart_watchdog()

Restart the watchdog timer.

Behavior.

Three behaviors can be registered with the_twelite, and the following class objects are defined to store them.

• network : A behavior that implements a network. Normally, <NWK_SIMPLE> is registered.

• network2 : BEHAVIOR that implements networking. Use this behavior if you want another network BEHAVIOR to process packets which were not accepted by the first network due to the data structure of the payload or other reasons. (Reference: Using NWK_LAYERED and NWK_SIMPLE together)

• board: Behaviors for board support. Procedures for using each device on the board are added.

• app: Behaviors describing user applications. Behaviors can be written in terms of interrupts, events, and state transitions using state machines. It is also easy to define multiple application descriptions and select an application with completely different behavior at startup.

• settings: Behavior for performing configuration (interactive mode). Registers <STG_STD>.

use<B>()

// example
auto&& brd = the_twelite.board.use<PAL_AMB>();

Register behavior . Registration is done within setup(). The return value is a reference to the object corresponding to the registered behavior.

After registration, the object is retrieved in the same way as at the time of registration.

void loop() {
  auto&& nwk = the_twelite.network.use<NWK_SIMPLE>();
}

NWK_SIMPLE *pNwk = nullptr;

setup() {
  auto&& nwk = the_twelite.network.use<NWK_SIMPLE>();
	pNwk = &nwk;
}

void transmit() {
  if (auto&& pkt = pNwk->prepare_tx_packet()) {
    ...
  }
}

class object.

the_twelite defines the three class objects board, network, and app mentioned above, but also the following

tx_status

Notification of transmission completion status.

is_complete()

bool is_complete(uint8_t cbid)

Returns true when the packet with the specified ID has completed transmission.

is_success()

bool is_success(uint8_t cbid)

Returns true when the packet with the specified ID has completed transmission and has been successfully sent.

receiver

Retrieve incoming packets.

available()

bool available()

Returns true if there is an incoming packet that has not yet been read.

read()

packet_rx& read()

Read packets.

Reads and writes two-wire serial (I2C) master.

Alias Definition

using TwoWire = mwx::periph_twowire<MWX_TWOWIRE_RCVBUFF>;

The mwx::periph_wire<MWX_TWOWIRE_RCVBUFF> can be referred as TwoWire.

Type Definitions

The following definition types describe the types of arguments and return values.

typedef uint8_t size_type;
typedef uint8_t value_type;

hint style="warning %}

Initialization and termination

Wire Instance Creation

Instance creation and necessary initialization is done in the library. In user code, it is made available by calling Wire.begin().

When using the requestFrom() method, you can specify the size of the FIFO queue for temporary data storage. At compile time, compile the macro MWX_TWOWIRE_BUFF with the required number of bytes. The default is 32 bytes.

Example: -DMWX_TWOWIRE_BUFF=16

begin()

void begin(
    const size_type u8mode = WIRE_100KHZ,
    bool b_portalt = false)

Initialize hardware.

Example

void setup() {
    ...
    Wire.begin();
    ...
}

void wakeup() {
    ...
    Wire.begin();
    ...
}

Reading and Writing

There are two types of read/write procedures. Select and use one of them.

• Member function (input/output using the following member functions) requestFrom(), beginTransmission(), endTransmission(), write()

• Helper class (stream function available) reader, writer

Others

Probe（Determine presence of device)

bool probe(uint8_t address)

Checks if the device specified by address is responding. If the device exists, true is returned.

setClock()

void setClock(uint32_t speed)

The procedure is originally intended to change the bus frequency, but no action is taken.

The helper class version is a more abstract implementation. Creating objects reader, writer for reading and writing is the start of using the bus, and destroying the objects 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.

if (auto&& wrt = Wire.get_writer(...)) { // Object creation and device communication determination
   // Within this scope (wave brackets) is the validity period of wrt.
   wrt << 0x00; // Writes 0x00 with mwx::stream interface
} 
// wrt is discarded at the point where the if clause is exited, and the use of the bus is terminated

Also, read/write objects implement the mwx::stream interface, so you can use the << operator, etc.

• Aligning the start and end of bus usage with the validity period of objects improves the visibility of source code and prevents omissions of termination procedures.

• Unification of read/write procedures by mwx::stream interface

loading

Loading process and its termination procedure in scope if() { ... } in scope.

const uint8_t DEV_ADDR = 0x70;
uint8_t au8data[6];
if (auto&& rdr = Wire.get_reader(DEV_ADDR, 6)) {
		for (auto&& c: au8data) {
			c = rdr();
		}
}

// same above
uint16_t u16temp, u16humd;
uint8_t u8temp_csum, u8humd_csum;
if (auto&& rdr = Wire.get_reader(SHTC3_ADDRESS, 6)) {
		rdr >> u16temp;
		rdr >> u8temp_csum;
		rdr >> u16humd;
		rdr >> u8humd_csum;
}

The above reads one byte at a time using the rdr object generated by the get_readr() method. The parameter of the method is the two-line serial ID to be read. 1.

1. in if(...) Create a rdrobject in. (The type is resolved with the universal reference auto&& by type inference. 2.) The generated rdr object defines an operator bool (), which is used to evaluate the decision expression. If communication is possible with the specified ID, true is returned. 3. The rdr object defines an int operator () (void) operator, which is called to read one byte of data from the 2-wire serial bus. If the read fails, -1 is returned, and if it succeeds, the read byte value is returned. 4.

2. if() { ... } The destructor of rdr is called at the end of the scope to STOP the two-wire serial bus.

get_reader(addr, read_count=0)

periphe_wire::reader
get_reader(uint8_t addr, uint8_t read_count = 0)

I2C 読み出しに用いるワーカーオブジェクトを取得します。

write (writer)

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

const uint8_t DEV_ADDR = 0x70;
if (auto&& wrt = Wire.get_writer(DEV_ADDR)) {
	wrt(SHTC3_TRIG_H);
	wrt(SHTC3_TRIG_L);
}

// same above
if (auto&& wrt = Wire.get_writer(DEV_ADDR)) {
	wrt << SHTC3_TRIG_H; // int type is handled as uint8_t
	wrt << SHTC3_TRIG_L;
}

In the above, the wrt object generated by the get_writer() method is used to write one byte at a time. The method parameter is the two-line serial ID to be read.

1. if(...) Generate a wrtobject in. (The type name is resolved with auto' because it is long. 2.) The generated wrtobject defines anoperator bool (), which is used to evaluate the decision expression. If communication is possible with the specified ID, trueis returned. 3. Thewrtobject defines anint operator () (void)operator, which is called to write one byte of data to the 2-wire serial bus. If it fails,-1` is returned, and if it succeeds, the written byte value is returned. 4.

2. if() { ... } The destructor of wrt is called at the end of the scope to STOP the two-wire serial bus.

get_writer()

periph_wire::writer
get_writer(uint8_t addr)

Obtains the worker object used for I2C export.

Worker object (writer)

<< operator

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

The int and uint8_t types transfer 8 bits.

() operator

operator() (uint8_t val)
operator() (int val)

Write out 1 byte.

worker object (reader)

>> operator

operator >> (uint8_t& c)
operator >> (uint16_t& c)
operator >> (uint32_t& c)
operator >> (uint8_t(&c)[N]) // Fixed array of N bytes

Reads only the size of each data type.

() operator

int operator() (bool b_stop = false)

//Example
uint8_t dat[6];
if (auto&& rdr = Wire.get_reader(0x70)) {
  for(uint8_t& x : dat) {
    x = rdr();
  }
}

Reads 1 byte. Returns -1 if there is an error, returns the byte value read if normal.

If b_stop is set to true, the STOP bit is issued on that read.

Example

The following example shows a measurement example of the temperature/humidity sensor SHTC3 of the environmental sensor PAL.

Wire.begin();
// reset (may not necessary...)
if (auto&& wrt = Wire.get_writer(0x70)) {
	wrt << 0x80; // SHTC3_SOFT_RST_H
	wrt << 0x05; // SHTC3_SOFT_RST_L
}

delay(5); // wait some

// start read
if (auto&& wrt = Wire.get_writer(0x70)) {
	wrt << 0x60; // SHTC3_TRIG_H
	wrt << 0x9C; // SHTC3_TRIG_L
}

delay(10); // wait some

// read result
uint16_t u16temp, u16humd;
uint8_t u8temp_csum, u8humd_csum;
if (auto&& rdr = Wire.get_reader(0x70, 6)) {
	rdr >> u16temp;
	rdr >> u8temp_csum;
	rdr >> u16humd;
	rdr >> u8humd_csum;
}

// checksum 0x31, init=0xFF
if (CRC8_u8CalcU16(u16temp, 0xff) != u8temp_csum) {
	Serial << format("{SHTC3 T CKSUM %x}", u8temp_csum); }
if (CRC8_u8CalcU16(u16humd, 0xff) != u8humd_csum) {
	Serial << format("{SHTC3 H CKSUM %x}", u8humd_csum); }

// calc temp/humid (degC x 100, % x 100)
int16_t i16Temp = (int16_t)(-4500 + ((17500 * int32_t(u16temp)) >> 16));
int16_t i16Humd = (int16_t)((int32_t(u16humd) * 10000) >> 16);

Serial << "temp=" << int(i16Temp) 
	   << ",humid=" << int(i16Humd) << mwx::crlf;

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.

Implement mwx::stream and input/output with UART0 of TWELITE.

• The Serial object is initialized at system startup with UART0, 115200 bps, and the initialization process is performed in the library. On the user code, it is available from setup().

• The Serial1 object is provided in the library, but no initialization process is performed; to enable UART1, perform the necessary initialization procedures Serial1.setup(), Serial1.begin().

setup()

void setup(uint16_t buf_tx, uint16_t buf_rx)

Initialize objects.

• Allocate memory for FIFO buffers for TX/RX

• Allocating memory for TWE_tsFILE structure

begin()

void begin(unsigned long speed = 115200, uint8_t config = 0x06)

Initialize hardware.

end()

(Not implemented) Stop using hardware.

get_tsFile()

TWE_tsFILE* get_tsFile();

Get a structure in the TWE_tsFILE* format used in the C library.

The method using member functions has a relatively low level of abstraction and follows the general API system as provided by the C library. The procedures for operating the two-wire serial bus are more intuitive.

However, it is necessary to be explicitly aware of the start and end of bus usage.

Read

requestFrom()

size_type requestFrom(
    uint8_t u8address,
    size_type length,
    bool b_send_stop = true)

Reads the specified number of bytes at once. Since the result of reading is stored in a queue, call the .read() method immediately afterward until the queue is empty.

Code Example

int len = Wire.requestFrom(0x70, 6);
for (int i = 0; i < 6; i++) {
  if (Wire.available()) {
		  au8data[i] = Wire.read();
    Serial.print(buff[i], HEX);
  }
}
// skip the rest (just in case)
// while (Wire.available()) Wire.read(); // normally, not necessary.

Writing

Writing is performed by the write() method after executing beginTransmission(). Call endTranmission() after a series of writing is finished.

	#define DEV_ADDR (0x70)
	const uint8_t msg[2] = 
	  {SHTC3_SOFT_RST_H, SHTC3_SOFT_RST_L};

	Wire.beginTransmission(DEV_ADDR);
	Wire.write(msg, sizeof(msg));
	Wire.endTransmission();

beginTransmission()

void beginTransmission(uint8_t address)

Initialize the export transfer. Call endTransmission() as soon as the writing process is finished.

write(value)

size_type write(const value_type value)

Writes one byte.

write(*value, quantity)

size_type write(
  const value_type* value,
  size_type quantity)

Writes a byte sequence.

endTransmission()

uint8_t endTransmission(bool sendStop = true)

Processes the end of the export.

Reads and writes the SPI bus (as Controller).

Constants

Initialization and termination

The procedure for using the SPI bus depends on the begin() method.

Reads and writes the SPI bus (MASTER).

begin()

void begin(uint8_t slave_select, SPISettings settings)
SPISettings(uint32_t clock, uint8_t bitOrder, uint8_t dataMode)

Initialize hardware.

Example

void setup() {
  ...
  SPI.begin(0, SPISettings(2000000, SPI_CONF::MSBFIRST, SPI_CONF::SPI_MODE3));
  ...
}

void wakeip() {
  ...
  SPI.begin(0, SPISettings(2000000, SPI_CONF::MSBFIRST, SPI_CONF::SPI_MODE3));
  ...
}

end()

void end()

Terminate the use of SPI hardware.

Reading and Writing

There are two types of read/write procedures. Select and use one of them.

• Member function version (input/output using the following member functions) beginTransaction(), endTransaction(), transfer(), transfer16(), transfer32()

• Helper class version (stream function available) transceiver

The pulse counter is a circuit that reads and counts pulses even when the microcontroller CPU is not running. There are two systems of pulse counters: PC0 is assigned to PulseCounter0 and PC1 to PulseCounter1.

PC0 is assigned to PulseCounter0 and PC1 is assigned to PulseCounter1.

method

begin()

Initializes the object and starts counting. the first parameter refct is the count number on which interrupts and available decisions are based. When this number is exceeded, it is reported to the application. You can also set refct to 0. In this case, it is not a sleep wake-up factor.

The second parameter edge specifies whether the interrupt is rising (PIN_INT_MODE::RISING) or falling (PIN_INT_MODE::FALLING).

The third debounce takes the values 0, 1, 2, or 3. 1, 2, or 3 settings require the same consecutive value to detect a change in value to reduce the effect of noise.

end()

Discontinue detection.

available()

If the specified count (refct in begin()) is 0, true is returned when the count exceeds 1.

If the specified count (refct in begin()) is 1 or more, true is returned when the number of detections exceeds the specified count.

read()

Reads the count value. Resets the count value to 0 after reading.

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.

The timer has two functions: to generate a software interrupt at a specified period, and to output a PWM at a specified period. 5 timers in total are available in the TWELITE radio module, from 0...4.

The name of the built-in object is Timer0..4, but will be referred to as TimerX on this page.

Methods

setup()

void setup()

Initializes the timer. This call allocates the necessary memory space.

begin()

void begin(uint16_t u16Hz, bool b_sw_int = true, bool b_pwm_out = false)

Starts a timer; the first parameter is the period of the timer in Hz; setting the second parameter to true enables software interrupts; setting the third parameter to true true` enables PWM output.

end()

void end()

Stops the timer operation.

available()

inline bool available()

It becomes true at loop() immediately after a timer interrupt occurs, and becomes false when loop() ends.

change_duty()

void change_duty(uint16_t duty, uint16_t duty_max = 1024)

Set the duty ratio. the first parameter specifies the duty ratio (a small value makes the average of the waveform closer to the GND level, a large value makes it closer to the Vcc level). the second parameter specifies the maximum duty ratio value of the duty ratio.

change_hz()

void change_hz(uint16_t hz, uint16_t mil = 0) 

Sets the frequency of the timer; the second parameter is an integer with three decimal places for the frequency. For example, to set the frequency to 10.4 Hz, specify hz=10, mil=400.