transmit ready package. More...

#include <commTypes.h>

Static Public Member Functions
static void	transmitpackage_to_binary (transmitpackage_t transp, uint8_t *bin)
	Get binary array of transmitpackage, for sending over a link. More...

static bool	binary_to_transmitpackage (uint8_t *bin, transmitpackage_t &transp)
	get tansmitpackage of binary array. More...

Public Attributes
port_t	from_port
	channel who is sending the data. More...

port_t	to_port
	to whom to send it to. More...

uint8_t	n

uint8_t *	data_transmitting
	Data to be transmitted. More...

uint8_t *	data_received
	pointer to where incoming data must be stored. More...

uint8_t	data_lenght
	size of the data More...

uint8_t	size
	total size of package (+ the size of the size variable) More...

bool	notify_on_ack = false
	notify the task on ack/no ack More...

bool	resend = false
	is the package being resend? More...

Static Public Attributes
static constexpr uint8_t	HEADER_SIZE = 4

Detailed Description

transmit ready package.

Definition at line 39 of file commTypes.h.

Member Function Documentation

◆ binary_to_transmitpackage()

static bool aruna::comm::transmitpackage_t::binary_to_transmitpackage	(	uint8_t *	bin,
		transmitpackage_t &	transp
	)

inlinestatic

get tansmitpackage of binary array.

Parameters

bin	array that stores the info
transp	transmitpackage that the data need to go to.

Returns: true if succeeded, false if not

Definition at line 125 of file commTypes.h.

                                                                                            {
                 //      check for complete header
                 const static int header_length = (sizeof(transp.size) + sizeof(transp.n) + sizeof(transp.from_port) +
                                                   sizeof(transp.to_port));
                 if (bin[0] < header_length)
                     return 0;
 
                 int dataLength = bin[0] - header_length;
                 transp.data_received = (uint8_t *) malloc(dataLength);
                 memcpy(&transp.size, &bin[0], (sizeof(transp.size)));
                 memcpy(&transp.n, &bin[sizeof(transp.size)], (sizeof(transp.n)));
                 memcpy(&transp.from_port, &bin[sizeof(transp.size) + sizeof(transp.n)], (sizeof(transp.from_port)));
                 memcpy(&transp.to_port, &bin[sizeof(transp.size) + sizeof(transp.n) + sizeof(transp.from_port)],
                        (sizeof(transp.to_port)));
                 memcpy(transp.data_received,
                        &bin[sizeof(transp.size) + sizeof(transp.n) + sizeof(transp.from_port) + sizeof(transp.to_port)],
                        dataLength);
                 transp.data_lenght = dataLength;
                 return 1;
             }

Here is the caller graph for this function:

◆ transmitpackage_to_binary()

static void aruna::comm::transmitpackage_t::transmitpackage_to_binary	(	transmitpackage_t	transp,
		uint8_t *	bin
	)

inlinestatic

Get binary array of transmitpackage, for sending over a link.

bin arrangement: size, n, from_port, to_port, data

Parameters

transp	package to make a binary from.
bin	to store the data to.

Definition at line 95 of file commTypes.h.

                                                                                           {
 
                 //      bit 0: size
                 memcpy(&bin[0],
                        &transp.size,
                        (sizeof(transp.size)));
                 //      bit 1: N
                 memcpy(&bin[sizeof(transp.size)],
                        &transp.n,
                        (sizeof(transp.n)));
                 //      bit 2: from port
                 memcpy(&bin[sizeof(transp.size) + sizeof(transp.n)],
                        &transp.from_port,
                        (sizeof(transp.from_port)));
                 //      bit 3: to port
                 memcpy(&bin[sizeof(transp.size) + sizeof(transp.n) + sizeof(transp.from_port)],
                        &transp.to_port,
                        sizeof(transp.to_port));
                 //      bit 4: data
                 memcpy(&bin[sizeof(transp.size) + sizeof(transp.n) + sizeof(transp.from_port) + sizeof(transp.to_port)],
                        transp.data_transmitting,
                        transp.data_lenght);
             }

Here is the caller graph for this function:

Member Data Documentation

◆ data_lenght

uint8_t aruna::comm::transmitpackage_t::data_lenght

size of the data

Definition at line 70 of file commTypes.h.

◆ data_received

uint8_t* aruna::comm::transmitpackage_t::data_received

pointer to where incoming data must be stored.

Definition at line 65 of file commTypes.h.

◆ data_transmitting

uint8_t* aruna::comm::transmitpackage_t::data_transmitting

Data to be transmitted.

Definition at line 60 of file commTypes.h.

◆ from_port

port_t aruna::comm::transmitpackage_t::from_port

channel who is sending the data.

Definition at line 44 of file commTypes.h.

◆ HEADER_SIZE

constexpr uint8_t aruna::comm::transmitpackage_t::HEADER_SIZE = 4

static

Definition at line 40 of file commTypes.h.

◆ n

uint8_t aruna::comm::transmitpackage_t::n

Definition at line 54 of file commTypes.h.

◆ notify_on_ack

bool aruna::comm::transmitpackage_t::notify_on_ack = false

notify the task on ack/no ack

Definition at line 81 of file commTypes.h.

◆ resend

bool aruna::comm::transmitpackage_t::resend = false

is the package being resend?

Definition at line 86 of file commTypes.h.

◆ size

uint8_t aruna::comm::transmitpackage_t::size

total size of package (+ the size of the size variable)

Definition at line 75 of file commTypes.h.

◆ to_port

port_t aruna::comm::transmitpackage_t::to_port

to whom to send it to.

Definition at line 49 of file commTypes.h.

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

include/aruna/comm/commTypes.h

Static Public Member Functions

Public Attributes

Static Public Attributes