aruna::comm Namespace Reference

Namespaces
	anonymous_namespace{comm.cpp}

Classes
struct	channel_t
	endpoint type of a comm channel More...
class	Link
struct	transmitpackage_t
	transmit ready package. More...

Typedefs
typedef uint8_t	port_t

Enumerations
enum	link_t { link_t::RADIO, link_t::WIRED, link_t::NONE }
enum	status_t { status_t::RUNNING, status_t::STOPPED, status_t::PAUSED }

Functions
err_t	start ()
	Start new communication. More...
err_t	start (Link *driver)
	Start new communication. More...
err_t	stop ()
	Stop the communication, free all queue's, channels and buffers. More...
err_t	pause ()
	pause all communication. More...
err_t	resume ()
	resume all communication. More...
err_t	register_channel (channel_t *channel)
	Register a new communication endpoint. More...
err_t	unregister_channel (channel_t &channel)
	unregister an endpoint More...
err_t	send (channel_t *channel, port_t to_port, uint8_t *data, size_t data_size, bool wait_for_ack=false)
	Send data. More...
bool	is_connected ()
	Get the status of the comm link. More...
status_t	get_status ()
	Get the running status of com. More...
err_t	get_channels (char *buffer)
	get all names of the channels currently registered More...
unsigned int	get_speed ()
	Get the speed of the link to the other hosts in bits per second. More...
err_t	incoming_connection (uint8_t *package, uint8_t package_size)
	Interrupt incomming connection handeler. More...
err_t	register_candidate_driver (Link *driver)
	register a driver to be a comm driver candidate. More...
err_t	unregister_candidate_driver (Link *driver)
	unregister a driver to be a comdiver candidate More...
link_t	get_link_type ()
	Get connection hardware type. More...
void	get_candidate_drivers (char *buffer[])
	get all the comm driver candidates More...

Variables
static constexpr size_t	MAX_DATA_SIZE = 150

Typedef Documentation

port_t

typedef uint8_t aruna::comm::port_t

Definition at line 30 of file commTypes.h.

Enumeration Type Documentation

link_t

enum aruna::comm::link_t

strong

Enumerator
RADIO
WIRED
NONE

Definition at line 17 of file commTypes.h.

                          {
            RADIO,
            WIRED,
            NONE
        };

status_t

enum aruna::comm::status_t

strong

Enumerator
RUNNING
STOPPED
PAUSED

Definition at line 24 of file commTypes.h.

                            {
            RUNNING,
            STOPPED,
            PAUSED
        };

Function Documentation

get_candidate_drivers()

void aruna::comm::get_candidate_drivers

(

char *

buffer[]

)

get all the comm driver candidates

get_channels()

err_t aruna::comm::get_channels

(

char *

buffer

)

get all names of the channels currently registered

Parameters

buffer

to write the names into.

Returns

err_t

• OK if it was a success
• BUFFER_OVERFLOW if the suplied buffer is to small,
• `INVALID_PARAMETERS if the parameters are incorrect,

Definition at line 444 of file comm.cpp.

                                     {
// TODO
        return err_t::OK;
    }

get_link_type()

link_t aruna::comm::get_link_type

(

)

Get connection hardware type.

Return values

link_t

get_speed()

unsigned int aruna::comm::get_speed

(

)

Get the speed of the link to the other hosts in bits per second.

Note

returns 0 if there is no connection.

Return values

int,speed

Definition at line 449 of file comm.cpp.

                             {
        return getDriver()->get_speed();
    }

Here is the call graph for this function:

get_status()

status_t aruna::comm::get_status

(

)

Get the running status of com.

Returns

status_t (RUNNING, PAUSED, STOPPED)

Definition at line 440 of file comm.cpp.

                          {
        return status;
    }

Here is the caller graph for this function:

incoming_connection()

err_t aruna::comm::incoming_connection	(	uint8_t *	package,
		uint8_t	package_size
	)

Interrupt incomming connection handeler.

Parameters

package

that needs to be handeled.

Return values

err_t

NOT_STARTED comm is not started OK handeled NO_CHANNEL there is no channel to handle it

Definition at line 453 of file comm.cpp.

                                                                      {
/*
 *    TODO O(N) is eigenlijk te langzaam.
 *    Als we het meteen kunnen opzoeken door ook nog een set te maken (of hashing table) van de namen
 *    scheelt dat ons heel veel tijd want dan is het O(1)!
 */
        transmitpackage_t tp;
        if (get_status() != status_t::RUNNING) return err_t::NOT_STARTED;
        log->verbose("incoming connection");

        if (!transmitpackage_t::binary_to_transmitpackage(package, tp))
            return err_t::INVALID_PARAMETERS;

        for (auto channel : channels) {
            if (channel->port == tp.to_port) {
                pthread_mutex_lock((pthread_mutex_t*)&channel->in_buffer_lock);
                channel->in_buffer.push(tp);
                pthread_mutex_unlock((pthread_mutex_t*)&channel->in_buffer_lock);
                pthread_cond_broadcast((pthread_cond_t*)&channel->in_buffer_not_empty);
                return err_t::OK;
            }
        }
        return err_t::NO_CHANNEL;

    }

Here is the call graph for this function:

Here is the caller graph for this function:

is_connected()

bool aruna::comm::is_connected

(

)

Get the status of the comm link.

Return values

1	is connected, 0 if not.

Definition at line 436 of file comm.cpp.

                        {
        return getDriver()->is_connected();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

pause()

err_t aruna::comm::pause

(

)

pause all communication.

buffers, channels and queue's will be saved

Returns

err_t

• OK if it was a success,
• NOT_STARTED if the comm was not started.

Definition at line 335 of file comm.cpp.

                  {
        switch (get_status()) {
            case status_t::STOPPED:
            case status_t::PAUSED:
                return err_t::NOT_STARTED;
            default:
                break;
        }
//        TODO suspend transmissionQueueHandeler_thread_handeler
        set_status(status_t::PAUSED);
        return err_t::OK;
    }

Here is the call graph for this function:

register_candidate_driver()

err_t aruna::comm::register_candidate_driver

(

Link *

driver

)

register a driver to be a comm driver candidate.

Parameters

driver

ComDriver object

Returns

err_t

• DRIVER_EXISTS if driver already exists.
• BUFFER_OVERFLOW driver buffer overflow
• OK all is well :).

Definition at line 479 of file comm.cpp.

                                                  {
//    comdriver moet eigenlijk een referentie zijn en niet een levend object.
        register_log();
        log->debug("registering driver");
        if (driverCandidates.find(driver) != driverCandidates.end()) {
            return err_t::DRIVER_EXISTS;
        }
        if (!driverCandidates.insert(driver).second)
            return err_t::BUFFER_OVERFLOW;
//    select new driver if comm is running
        if (get_status() == status_t::RUNNING) {
//        TODO its better to rate this new driver and compare its score to the current driver.
            selectDriverTask();
        }
        return err_t::OK;
    }

Here is the call graph for this function:

register_channel()

err_t aruna::comm::register_channel

(

channel_t *

channel

)

Register a new communication endpoint.

Parameters

channel

channel_t object

Return values

err_t

INVALID_PARAMETERS if parameters are invalid OK if it was succesfully added. CHANNEL_EXISTS if the channel already exists. BUFFER_OVERFLOW channel buffer overflow

Definition at line 362 of file comm.cpp.

                                               {
/*
 * TODO paramters should consist of the paramters of channel_t together with a handeler.
 * handeler can then later be used for sending and accessing Rx array
 */

//    TODO testen of deze check wel werkt.
        if (channels.find(channel) != channels.end())
            return err_t::CHANNEL_EXISTS;
        if (channels.insert(channel).second) {
            return err_t::OK;
        } else
            return err_t::BUFFER_OVERFLOW;
//    TODO handeler fixen.
    }

Here is the caller graph for this function:

resume()

err_t aruna::comm::resume

(

)

resume all communication.

Returns

err_t

• OK if it was a success,
• NOT_STARTED if the comm was not started.
• NOT_PAUSED if it was not paused.

Definition at line 348 of file comm.cpp.

                   {
        switch (get_status()) {
            case status_t::STOPPED:
                return err_t::NOT_STARTED;
            case status_t::RUNNING:
                return err_t::NOT_PAUSED;
            default:
                break;
        }
//        TODO continue transmissionQueueHandeler_thread_handeler
        set_status(status_t::RUNNING);
        return err_t::OK;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

send()

err_t aruna::comm::send	(	channel_t *	channel,
		port_t	to_port,
		uint8_t *	data,
		size_t	data_size,
		bool	wait_for_ack = false
	)

Send data.

Note

Parameters

channel	channel handler that is sending the data
to_port	to which port to send de data to.
data	Data to send.
data_size	length of the data
wait_for_ack	if set to thrue, thread will block until ack is received or until timeout is reached

Return values

err_t

INVALID_PARAMETERS if parameters are invalid OK if it was succesfully send. NO_CONNECTION if there is no connection, BUFFER_OVERFLOW if the data was not added to the bugger due an overflow, NO_CHANNEL if the channel does'nt exist. NO_RESPONSE if there was no response (only if wait_for_ack is true)

Definition at line 386 of file comm.cpp.

                                                                                                 {
        if (get_status() != status_t::RUNNING) return err_t::NOT_STARTED;
        if (channels.find(channel) == channels.end()) {
            return err_t::NO_CHANNEL;
        }
        uint16_t packages = ceil((double) data_size / (double) MAX_DATA_SIZE);
//  how many packages are we waiting for?
        uint8_t n_to_wait_for = 0;
        //        datasize length
        size_t ds_l;
        //        datasize pointer
        size_t ds_p = 0;

        if (!getDriver()->is_connected())
            return err_t::NO_CONNECTION;

//  TODO check if tp is allocated
        auto tp = (transmitpackage_t *) calloc(packages, sizeof(transmitpackage_t));

//    loop until all data in send
        while (data_size > 0) {
//      static data
            tp[n_to_wait_for].to_port = to_port;
            tp[n_to_wait_for].from_port = channel->port;
            tp[n_to_wait_for].n = 0;
            tp[n_to_wait_for].notify_on_ack = wait_for_ack;

            tp[n_to_wait_for].data_transmitting = &data[ds_p];

            ds_l = (data_size >= MAX_DATA_SIZE) ? MAX_DATA_SIZE : data_size;

            tp[n_to_wait_for].data_lenght = ds_l;
            tp[n_to_wait_for].size = ds_l + transmitpackage_t::HEADER_SIZE;

            ds_p += ds_l;
            data_size -= ds_l;
            log->verbose("sending from: %d to: %d", tp[n_to_wait_for].from_port,
                     tp[n_to_wait_for].to_port);
            log->dump(log::level_t::VERBOSE, tp[n_to_wait_for].data_transmitting, tp[n_to_wait_for].data_lenght);
            pthread_mutex_lock(&out_buffer_critical);
            out_buffer.push(tp[n_to_wait_for]);
            pthread_mutex_unlock(&out_buffer_critical);
            pthread_cond_broadcast(&out_buffer_not_empty);

            n_to_wait_for++;
        }
        free(tp);
        return err_t::OK;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

start() [1/2]

err_t aruna::comm::start

(

)

Start new communication.

start SIS report watcher thread

start reporter to report all SIS activiry to the watcher over comm channels

Using LINK_HARDWARE to define hardware

Return values

err_t

HARDWARE_ERROR if the hardware fails. OK great success!

Definition at line 251 of file comm.cpp.

                  {
//    pick a driver
        auto dr = pickDriver();
        if (std::get<1>(dr) == err_t::OK) {
//        if driver is found start comm with driver as paramter
            return start(std::get<0>(dr));
        }
//    return pickDriver error.
        return std::get<1>(dr);
    }

Here is the call graph for this function:

start() [2/2]

err_t aruna::comm::start

(

Link *

driver

)

Start new communication.

Using LINK_HARDWARE to define hardware

Parameters

driver

force to use specific driver.

Return values

err_t

HARDWARE_ERROR if the hardware fails. OK great success!

Definition at line 262 of file comm.cpp.

                              {
        switch (get_status()) {
            case status_t::RUNNING:
                return err_t::NOT_STOPPED;
            case status_t::PAUSED:
//            TODO is dit slim? kan ongwenst gedrag vertonen als je van driver wilt wisselen.
                return resume();
            default:
                break;
        }
        int err = 0;
//        register com channel
        register_log();
//    set the driver
        err_t driver_err;
        setDriver(*driver);
// TODO check if driver is not NULL
        driver_err = getDriver()->startup_error;
//        init pthread mutex and cond
        pthread_cond_init(&out_buffer_not_empty, NULL);
        pthread_mutex_init(&out_buffer_critical, NULL);
        if (driver_err != err_t::OK)
            return driver_err;

        err = pthread_create(&transmissionQueueHandeler_thread_handeler, NULL, transmissionQueueHandeler, NULL);
        if (err) {
            log->error("failed to start transmissionQueueHandeler: %i", err);
//        stop when task failes
//        TODO destroy driver object
//        TODO driver unsetten en destroyen.
            return err_t::TASK_FAILED;
        }
        err = pthread_create(&receiveHandeler_thread_handeler, NULL, receiveHandeler, NULL);
        if (err) {
            log->error("failed to start receiveHandeler: %i", err);
//        stop when task failes
//        TODO destroy driver object
//        TODO driver unsetten en destroyen.
            return err_t::TASK_FAILED;
        }
//    set status to running if all succeeded

        set_status(status_t::RUNNING);

        return err_t::OK;
    }

Here is the call graph for this function:

stop()

err_t aruna::comm::stop

(

)

Stop the communication, free all queue's, channels and buffers.

Return values

err_t

HARDWARE_ERROR if the hardware fails. OK great success! NOT_STARTED if the comm was not started.

Definition at line 309 of file comm.cpp.

                 {
        switch (get_status()) {
            case status_t::STOPPED:
                return err_t::NOT_STARTED;
            default:
                break;
        }
//    stop all
        err_t driver_err;
//        TODO destory driver object
        pthread_cancel(receiveHandeler_thread_handeler);
        pthread_cancel(transmissionQueueHandeler_thread_handeler);
        int pret = 0;
        pthread_cond_destroy(&out_buffer_not_empty);
        pthread_mutex_destroy(&out_buffer_critical);
        pthread_exit(&pret);
//        TODO is this code even reached is the thread is terminated?
        while(!out_buffer.empty())
            out_buffer.pop();
        set_status(status_t::STOPPED);

        if (driver_err != err_t::OK)
            return driver_err;
        return err_t::OK;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

unregister_candidate_driver()

err_t aruna::comm::unregister_candidate_driver

(

Link *

driver

)

unregister a driver to be a comdiver candidate

Parameters

driver

ComDriver to be deleted

Returns

err_t

• OK great success!
• NO_DRIVER driver does'nt exists.

Definition at line 497 of file comm.cpp.

                                                    {
        if (driverCandidates.erase(driver)) {
//        if we delete our own driver, search for a new one
            if (comm::driver == driver)
                selectDriverTask();
            return err_t::OK;
        } else
            return err_t::NO_DRIVER;
    }

Here is the call graph for this function:

unregister_channel()

err_t aruna::comm::unregister_channel

(

channel_t &

channel

)

unregister an endpoint

Parameters

channel

endpoint to be removed

Return values

err_t

OK if it was succesfully removed. NO_CHANNEL ain't got no channel, ain't got no knife.

Definition at line 378 of file comm.cpp.

                                                 {
        if (channels.erase(&channel))
            return err_t::OK;
        else
            return err_t::NO_CHANNEL;
    }

Here is the caller graph for this function:

Variable Documentation

MAX_DATA_SIZE

constexpr size_t aruna::comm::MAX_DATA_SIZE = 150

static

Definition at line 34 of file commTypes.h.