aruna::sis::watcher Namespace Reference

Functions
err_t	start ()
	start SIS report watcher thread More...
void *	watch (void *)
	Watch SIS reports task. More...
void	set_level (type_t type, level_t new_level)
	set level of alert on SIS level. More...

Variables
static const comm::port_t	port = 2

Function Documentation

set_level()

void aruna::sis::watcher::set_level	(	type_t	type,
		level_t	new_level
	)

set level of alert on SIS level.

Definition at line 74 of file watcher.cpp.

                                                         {
    level[(uint8_t) type] = new_level;
}

start()

err_t aruna::sis::watcher::start

(

)

start SIS report watcher thread

Returns

comm error

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!

start SIS report watcher thread

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

Returns

status_t, returns current status of the modulke

• RUNNING if it is running,
• STOPPED is it us currenty stopped.

Definition at line 19 of file watcher.cpp.

                        {
    comm_channel = new comm::channel_t(port);
//    TODO error check
    log_channel = new log::channel_t("SIS watcher");
    for (auto &i : level) {
        i = level_t::WARNING;
    }
    pthread_create(&watcher_thread, NULL, watch, NULL);
    return comm_channel->register_err;
}

Here is the call graph for this function:

Here is the caller graph for this function:

watch()

void * aruna::sis::watcher::watch

(

void *

)

Watch SIS reports task.

Definition at line 30 of file watcher.cpp.

                              {
    comm::transmitpackage_t tp;
    sis::status_t *status_buffer;
    sis::type_t received_type;
    while (1) {
        comm_channel->receive(&tp);
        if (tp.from_port != sis::reporter::port) {
            comm_channel->receive_clear();
            log_channel->warning("Port: %i sending us packages, dropping:", tp.from_port);
            log_channel->dump(log::level_t::WARNING, tp.data_received, tp.data_lenght);
            continue;
        }
        received_type = (sis::type_t) tp.data_received[0];

//        TODO this feels off, is there any better way of handling this?
        switch (received_type) {
            case type_t::WATER:
                status_buffer = reinterpret_cast<status_t *>(new sensor::water_status_t());
                break;
            case type_t::UNKNOWN:
            case type_t::MAX:
            default:
                received_type = type_t::UNKNOWN;
            case sis::type_t::DEFAULT:
                status_buffer = new sis::status_t(received_type);
                break;
        }

        status_buffer->decode(tp.data_received);
        if ((uint8_t) level[(uint8_t) received_type] <= (uint8_t) status_buffer->level) {
//            TODO error on critical and warning on warning.
//            TODO better log containing type and level.
//            TODO water type specific handler
            log_channel->error(status_buffer->description);
//            TODO log NOTIFY after >WARNING
        } else {
//            TODO log in verbose
        }
        delete status_buffer;
        comm_channel->receive_clear();
    }
    return nullptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

port

const comm::port_t aruna::sis::watcher::port = 2

static

Definition at line 16 of file watcher.h.