1 / 8

pktparser

pktparser(parser_packet) performs content interpretation on the byte sequence converted by serparser performs content interpretation on the byte sequence converted by serparser.

serparser_heap parser_ser;

void setup() {
    // init ser parser (heap alloc)
    parser_ser.begin(PARSER::ASCII, 256);
}

void loop() {
    int c;
    while ((c = Serial.read()) >= 0) {
        parser_ser.parse(c);
        if (parser_ser.available()) {
            // get buffer object
            auto&& payl = parser_ser.get_buf();
            // identify packet type
            auto&& typ = identify_packet_type(payl.begin(), payl.end());
            
            // if packet type is TWELITE standard 0x81 message
            if (typ == E_PKT::PKT_TWELITE) {
                pktparser pkt; // packet parser object
                // analyze packet data
                typ = pkt.parse<TwePacketTwelite>(payl.begin(), payl.end());
                
                if (typ != E_PKT::PKT_ERROR) { // success!
                    // get data object
                    auto&& atw = pkt.use<TwePacketTwelite>();
                    
                    // display packet inforamtion
                    Serial << crlf << format("TWELITE: SRC=%08X LQI=%03d "
                        , app.u32addr_src, app.u8lqi);
	                  Serial << " DI1..4="
	                      << atw.DI1 ? 'L' : 'H' << atw.DI2 ? 'L' : 'H' 
                        << atw.DI3 ? 'L' : 'H' << atw.DI4 ? 'L' : 'H';
                }
            }
        }
    }
}

The above example interprets standard application 0x81 message. parser_ser object converts the message input from Serial into a byte string. This byte string is first identified by identify_packet_type() to determine the type of the message E_PKT. Once the message type is determined, the message is parsed by .parse<TwePacketTwelite>(). The parsed result will be of type TwePacketTwelite, and .use<TwePacketTwelite>() is the procedure to extract this object. The TwePacketTwelite type is a class, but it refers to its member variables directly as a structure.

parse<T>

template <class T>
E_PKT parse(const uint8_t* p, const uint8_t* e)

Parses a sequence of bytes.

The T specifies the packet type to be parsed. For example, TwePacketTwelite is specified for 0x81 messages in standard applications.

p and e specify the next to the beginning and the end of the byte sequence.

The return value is of type E_PKT. In case of an error, E_PKT::PKT_ERROR is returned.

user<T>

template <class T> 
T& use()

Returns a reference to an object corresponding to the packet type of the interpreted byte sequence. It can be called if parse<T> was executed beforehand and there were no errors.

The T can be the same type as the one executed with parse<T>, or a TwePacket from which only basic information can be obtained.

E_PKT

packet type definition

Corresponds to the following packet

Corresponds to the ASCII format output by the Parent Node of App_Wings.

Name

Description

idenify_packet_type()

Determines the type of packet using the packet data byte sequence as input. The return value is E_PKT.

E_PKT identify_packet_type(uint8_t* p, uint8_t u8len)

If the packet cannot be interpreted as a specific packet, E_PKT::PKT_ERROR is returned.

TwePacket

It is a base class of packet type, but the member structure common contains address information and other common information.

class TwePacket {
	public:
		static const E_PKT _pkt_id = E_PKT::PKT_ERROR;
		
		struct {
			uint32_t tick; // system time at interpretation execution [ms]
			uint32_t src_addr; // source address (serial number)
			uint8_t src_lid; // source address (logical address)
			uint8_t lqi; // LQI
			uint16_t volt; // voltage[mV]
		} common;
};

This is used when you want to get minimum information such as address information when you want to store mixed types as pktparser type in arrays, etc.

TwePacketTwelite

The TwePacketTwelite class is a standard application 0x81 command of App_Twelite, which is an interpretation of the TwePacketTwelite class.

class TwePacketTwelite : public TwePacket, public DataTwelite { ... };

Various information in the packet data is stored in DataTwelite after parse<TwePacketTwelite>() is executed.

DataTwelite structure

struct DataTwelite {
		//Serial # of sender
		uint32_t u32addr_src;
		
		// Logical ID of the sender
		uint8_t u8addr_src;

		// Destination logical ID
		uint8_t u8addr_dst;

		// Timestamp at time of transmission
		uint16_t u16timestamp;

		// Flag for low latency transmission
		bool b_lowlatency_tx;

		// Number of repeat relays
		uint16_t u8rpt_cnt;

		// LQI
		uint16_t u8lqi;

		// DI status (true is active Lo,GND)
		bool DI1, DI2, DI3, DI4;
		// DI status bitmap (DI1,2,3,4 in order from LSB)
		uint8_t DI_mask;

		// true if DI active (has been active in the past)
		bool DI1_active, DI2_active, DI3_active, DI4_active;
		// Active bitmap of DI (DI1,2,3,4 in order from LSB)
		uint8_t DI_active_mask;

		// Supply voltage of the module [mV].
		uint16_t u16Volt;

		// AD value [mV]
		uint16_t u16Adc1, u16Adc2, u16Adc3, u16Adc4;
		// Bitmap that is set to 1 if AD is active (AD1,2,3,4 in order from LSB)
		uint8_t Adc_active_mask;
};

TwePacketIO

The TwePacketAppIO class interprets the standard app serial message (0x81) of App_IO The TwePacketAppIO class is the one that interprets the

class TwePacketAppIO : public TwePacket, public DataAppIO { ... };

Various information in the packet data is stored in DataTwelite after parse<TwePacketIO>() execution.

DataAppIO structure

struct DataAppIO {
		// Serial # of sender
		uint32_t u32addr_src;
		
		// Logical ID of the sender
		uint8_t u8addr_src;

		// Destination logical ID
		uint8_t u8addr_dst;

		// Timestamp at the time of transmission
		uint16_t u16timestamp;

		// Flag for low latency transmission
		bool b_lowlatency_tx;

		// Number of repeat relays
		uint16_t u8rpt_cnt;

		// LQI value
		uint16_t u8lqi;

		// DI status bitmap (DI1,2,3,4,...) in order from LSB
		uint8_t DI_mask;

		// Active (1 if used) bitmap of DI (DI1,2,3,4,...) in order from LSB
		uint8_t DI_active_mask;
		
		// Bitmap of whether DI is interrupt-derived or not (DI1,2,3,4,...) in order from LSB
		uint16_t DI_int_mask;
};

TwePacketUART

The TwePacketAppUart class is the format in which the extended format of the App_UART is received by the parent and repeater application App_Wings.

class TwePacketAppUART : public TwePacket, public DataAppUART

Various information in the packet data is stored in DataAppUART after parse<TwePacketUART>() execution.

The simple format cannot be interpreted. parse<TwePacketUART>() returns E_PKT::PKT_ERROR. To check the contents, refer to the original byte sequence directly.

DataAppUART structure

struct DataAppUART {
		/**
		 * source address (Serial ID)
		 */
		uint32_t u32addr_src;

		/**
		 * source address (Serial ID)
		 */
		uint32_t u32addr_dst;

		/**
		 * source address (logical ID)
		 */
		uint8_t u8addr_src;

		/**
		 * destination address (logical ID)
		 */
		uint8_t u8addr_dst;

		/**
		 * LQI value
		 */
		uint8_t u8lqi;

		/**
		 * Response ID
		 */
		uint8_t u8response_id;

		/**
		 * Payload length
		 */
		uint16_t u16paylen;

		/**
		 * payload
		 */
#if MWX_PARSER_PKT_APPUART_FIXED_BUF == 0
		mwx::smplbuf_u8_attach payload;
#else
		mwx::smplbuf_u8<MWX_PARSER_PKT_APPUART_FIXED_BUF> payload;
#endif
	};

The payload is the data part, but the method of data storage changes depending on the macro definition.

If MWX_PARSER_PKT_APPUART_FIXED_BUF is compiled with the value 0, payload refers directly to the byte sequence for packet analysis. If the value of the original byte sequence is changed, the data in payload will be destroyed.

If you define the value of MWX_PARSER_PKT_APPUART_FIXED_BUF to be greater than 0, the payload will allocate a buffer of that value (bytes). However, if the data of the serial message exceeds the buffer size, parse<TwePacketAppUART>() fails and returns E_PKT::PKT_ERROR.

TwePacketPAL

The TwePacketPal class interprets TWELITE PAL packet data. This class handles TWELITE PAL (sensor data and other upstream data) commonly.

class TwePacketPal : public TwePacket, public DataPal { ... };

PAL common data is defined in DataPal.

Generator functions are provided to retrieve data specific to each PAL sensor board.

DataPal structure

Although the packet data structure of PAL differs depending on the connected sensors, etc., DataPal holds the data structure of the common part.

struct DataPal {
	uint8_t u8lqi; // LQI value

	uint32_t u32addr_rpt; // address of the relay

	uint32_t u32addr_src; // source address
	uint8_t u8addr_src; // source logical address

	uint16_t u16seq; // sequence number

	E_PAL_PCB u8palpcb; // PAL board type
	uint8_t u8palpcb_rev; // Revision of PAL board
	uint8_t u8sensors; // Number of sensor data in the data (MSB=1 is an error)
	uint8_t u8snsdatalen; // sensor data length (in bytes)

	union {
		const uint8_t *au8snsdata; // reference to sensor data part
		uint8_t _pobj[MWX_PARSER_PKT_APPPAL_FIXED_BUF]; // each sensor object
	};
};

The PAL packet data structure consists of two blocks: the common part for all PALs and the individual data part. The individual data part does not interpret the packet, but stores it as is. To simplify handling, data exceeding 32 bytes is stored in dynamically allocated uptr_snsdata.

The individual data parts are stored in a structure whose base class is PalBase. This structure is generated by the generator function defined in TwePacketPal.

If the size fits in MWX_PARSER_PKT_APPPAL_FIXED_BUF when parse<TwePacketPAL>() is executed, a separate sensor object is generated.

If it does not fit, a reference to the byte sequence used for analysis is stored in au8snsdata. In this case, if the data in the byte string used for analysis is rewritten, sensor-specific objects cannot be generated.

PalBase

All data structures for each sensor in PAL inherit from PalBase. The sensor data storage status u32StoredMask is included.

	struct PalBase {
		uint32_t u32StoredMask; // Data acquisition flags used internally
	};

PalEvent

PAL events are information that is sent when certain conditions are met by processing sensor information, rather than directly from sensors. For example, when an acceleration sensor detects a certain level of acceleration from a stationary state.

	struct PalEvent {
		uint8_t b_stored; // true if stored
		uint8_t u8event_source; // spare
		uint8_t u8event_id; // event ID
		uint32_t u32event_param;// event parameter
	};

If event data exists, it can be determined by .is_PalEvent() of TwePacketPal being true, and .get_PalEvent() will yield a PalEvent data structure.

Generator functions

Generator functions are used to extract various types of data from sensor PAL.

void print_pal(pktparser& pkt) {
	auto&& pal = pkt.use<TwePacketPal>();
	if (pal.is_PalEvent()) {
		PalEvent obj = pal.get_PalEvent();
	} else
	switch(pal.u8palpcb) {
	case E_PAL_PCB::MAG:
	  {
		  // generate pal board specific data structure.
		  PalMag obj = pal.get_PalMag();
	  } break;
  case E_PAL_PCB::AMB:
	  {
		  // generate pal board specific data structure.
		  PalAmb obj = pal.get_PalAmb();
	  } break;
	  ...
	default: ;
	}
}

To use the generator function, first determine if pkt is an event (.is_PalEvent()). If it is an event, it has get_PalEvent(). Otherwise, it creates an object according to u8palpcb.

get_PalMag()

PalMag get_PalMag()

// MAG
struct PalMag : public PalBase {
    uint16_t u16Volt; // module voltage [mV]
    uint8_t u8MagStat; // state of magnetic switch [0:no magnet,1,2].
    uint8_t bRegularTransmit; // MSB flag of u8MagStat
};

If .u8palpcb==E_PAL_PCB::MAG, the data PalMag of the open/close sensor pal is taken.

get_PalAmb()

PalAmb get_PalAmb()

// AMB
struct PalAmb : public PalBase {
    uint16_t u16Volt; // module voltage [mV]
    int16_t i16Temp; // temperature (100x value)
    uint16_t u16Humd; // humidity (100x value)
    uint32_t u32Lumi; // illuminance (equivalent to Lux)
};

If .u8palpcb==E_PAL_PCB::AMB, the data PalAmb of the environmental sensor pal is taken.

get_PalMot()

PalMot get_PalMot()

// MOT
struct PalMot : public PalBase {
    uint16_t u16Volt; // module voltage [mV]
    uint8_t u8samples; // number of samples
    uint8_t u8sample_rate_code; // sample rate (0: 25Hz, 4:100Hz)
    int16_t i16X[16]; // X axis
    int16_t i16Y[16]; // Y axis
    int16_t i16Z[16]; // Z axis
};

If .u8palpcb==E_PAL_PCB::MOT, the data PalMot of the operating sensor pal is taken.

get_PalEvent()

PalEvent get_PalEvent()

// PAL event
struct PalEvent {
    uint8_t b_stored; // if true, event information is available
    uint8_t u8event_source; // event source
    uint8_t u8event_id; // event ID
    uint32_t u32event_param; // 24bit, event parameter
};

Extracts a PalEvent (PAL event) if .is_PalEvent() is true.