AresFrame Class Reference

#include <ares_frame.hpp>

Classes
struct	Setting
struct	Start
struct	LoraConfig
struct	Led
struct	Heartbeat
struct	Claim
struct	Log
struct	LogAck
struct	Version
struct	Dbg
struct	PktRx
struct	PktTx
struct	Decoded

Public Types
enum	AresFrameType : unsigned int {   SETTING = 0 , START = 1 , LORA_CONFIG = 2 , LED = 3 ,   HEARTBEAT = 4 , CLAIM = 5 , LOG = 6 , LOG_ACK = 7 ,   VERSION = 8 , ACK = 9 , FRAMING_ERROR = 10 , DBG = 11 ,   PKT_RX = 12 , PKT_TX = 13 , UNKNOWN }
enum	FramingError : uint8_t { BAD_FRAME = 0 , BAD_TYPE = 1 , NOT_IMPLEMENTED = 2 }
using	AckErrorCode = int32_t
using	TxTypes
using	RxTypes
using	ResponseTypes

Public Member Functions
	AresFrame (AresFrameType type, TxTypes payload)
	AresFrame (const std::vector< uint8_t > &bytearray)
	AresFrame ()
	AresFrame (const AresFrame &other)
	~AresFrame ()=default
void	serialize (std::vector< uint8_t > &bytearray)
void	parse (const uint8_t *serial_data, size_t start_index, size_t len)
void	parse (const std::vector< uint8_t > &bytearray, size_t start_index)
Decoded	get_parsed_frame () const
bool	frame_available () const
size_t	total_frames () const

Static Public Member Functions
static std::tuple< ssize_t, ssize_t, ssize_t >	frame_present (const uint8_t *serial_data, size_t len, bool error_no_footer=true)
static std::tuple< ssize_t, ssize_t, ssize_t >	frame_present (const std::vector< uint8_t > &bytearray, bool error_no_footer=true)

Detailed Description

Framing class for Ares frames. These frames are used for communication with the Ares LoRa platform.

Member Typedef Documentation

AckErrorCode

using AresFrame::AckErrorCode = int32_t

Data for AresFrame::ACK frames.

ResponseTypes

using AresFrame::ResponseTypes

Initial value:

 std::variant<std::monostate, Setting, AckErrorCode,
                                       FramingError, Led, Version>

A variant representing all the response frame types.

RxTypes

using AresFrame::RxTypes

Initial value:

 std::variant<std::monostate, Setting, Start, AckErrorCode,
                                 FramingError, Led, Heartbeat, Claim, Log,
                                 Version, LogAck, Dbg, PktRx, PktTx>

A variant representing all the reception frame types.

TxTypes

using AresFrame::TxTypes

Initial value:

 std::variant<std::monostate, Setting, Start, LoraConfig,
                                 Led, Heartbeat, Claim, Log, Version>

A variant representing all the transmission frame types.

Member Enumeration Documentation

AresFrameType

enum AresFrame::AresFrameType : unsigned int

Frame types for communication with the LoRa module.

Enumerator
SETTING	Setting get/set (TX/RX).
START	Start time (TX/RX).
LORA_CONFIG	LoRa modem configuration (TX).
LED	LED state get/set (TX/RX).
HEARTBEAT	Send heartbeat (TX/RX).
CLAIM	Master claim (TX/RX).
LOG	Log message (TX/RX).
LOG_ACK	Log acknowledge (RX).
VERSION	Firmware version (TX/RX).
ACK	Command acknowledge (RX).
FRAMING_ERROR	Framing error (RX).
DBG	Debug message (RX).
PKT_RX	Packet Received (RX).
PKT_TX	Packet transmitted (RX).
UNKNOWN	Unknown frame.

FramingError

enum AresFrame::FramingError : uint8_t

Data for AresFrame::FRAMING_ERROR frames.

Enumerator
BAD_FRAME	Bad frame.
BAD_TYPE	Bad frame type.
NOT_IMPLEMENTED	Frame type not implemented.

Constructor & Destructor Documentation

AresFrame() [1/4]

AresFrame::AresFrame ( AresFrameType type, TxTypes payload )

explicit

Constructs a frame object from deserialized data.

Parameters

type	The type of the frame.
payload	The payload for the frame.

AresFrame() [2/4]

AresFrame::AresFrame ( const std::vector< uint8_t > & bytearray )

explicit

Constructs a frame object from serial data.

Parameters

bytearray

The serial data.

Exceptions

AresFrameError

if frame is not found in buffer.

AresFrame() [3/4]

AresFrame::AresFrame

(

)

Default constructor.

AresFrame() [4/4]

AresFrame::AresFrame

(

const AresFrame &

other

)

Copy constructor.

Parameters

other

Other object to copy.

~AresFrame()

AresFrame::~AresFrame ( )

default

Destructor.

Member Function Documentation

frame_available()

bool AresFrame::frame_available ( ) const

nodiscard

Check if a new frame is available for serialization. Useful for messages split into multiple frames.

Returns

true if a new frame is available for serialization. false otherwise.

frame_present() [1/2]

std::tuple< ssize_t, ssize_t, ssize_t > AresFrame::frame_present ( const std::vector< uint8_t > & bytearray, bool error_no_footer = true )

static

Checks if there is a frame present in the given buffer.

Parameters

bytearray	The buffer to check.
error_no_footer	Return an error if there is no footer.

Returns

std::tuple<header index, frame size, bytes left> if frame found.

std::tuple<-1, -1, -1> on no frame found.

frame_present() [2/2]

std::tuple< ssize_t, ssize_t, ssize_t > AresFrame::frame_present ( const uint8_t * serial_data, size_t len, bool error_no_footer = true )

static

Checks if there is a frame present in the given buffer.

Parameters

serial_data	The serial data buffer to check.
len	The length of the serial data buffer.
error_no_footer	Return an error if there is no footer.

Returns

std::tuple<header index, frame size, bytes left> if frame found.

std::tuple<-1, -1, -1> on no frame found.

get_parsed_frame()

Decoded AresFrame::get_parsed_frame ( ) const

nodiscard

Retrieve the parsed frame.

Returns

The decoded or parsed frame.

Note

AresFrame::parse must be called first.

parse() [1/2]

void AresFrame::parse	(	const std::vector< uint8_t > &	bytearray,
		size_t	start_index )

Parse a frame from the given buffer.

Parameters

bytearray	The buffer to parse a frame from
start_index	The start index of the frame.

Exceptions

AresFrameError

if frame type cannot be parsed (meant for transmission only).

parse() [2/2]

void AresFrame::parse	(	const uint8_t *	serial_data,
		size_t	start_index,
		size_t	len )

Parse a frame from the given buffer.

Parameters

serial_data	The buffer to parse a frame from.
start_index	The start index of the frame.
len	The length of the buffer.

Exceptions

AresFrameError

if frame type cannot be parsed (meant for transmission only).

serialize()

void AresFrame::serialize

(

std::vector< uint8_t > &

bytearray

)

Serialize the frame into a buffer. If a frame is split into chunks, then places the next frame into the buffer.

Parameters

bytearray

The buffer to store the serialized frame in.

Exceptions

AresFrameError	if frame type cannot be serialized (meant for reception only).
AresFrameError	if log message is empty.
AresFrameError	if log message is too long.
AresFrameError	if frame payload length cannot be calculated.

total_frames()

size_t AresFrame::total_frames ( ) const

nodiscard

Retrieve the number of frames a message is split up into.

Returns

The number of frames that can be serialized and sent.

Note

AresFrame::serialize must be called first.

---

The documentation for this class was generated from the following file:

• serial-driver/core/include/ares-lora-serial/ares_frame.hpp