EPSIAE » eneraptor

        <name nam="Termometer server room"></name>

    <device id="thermometer_02">

        <name nam="Termometer pisarna"></name>

        <read_interval rditv="10"/>

        <action act="testAction_1"></action>

        <param par="testParam_1"></param>

    </device>

  <scenario id="scenario_01" name="Klima v server roomu">

    <check_idle val="30" />

    <check_active val="3" />

    <alpha val="0.7"/>

    <inDevAalues minval="20" maxval="25" optval="20" tolerance="0.5"/>

    <conditions/>

  </scenario>

  <scenario id="scenario_02" name="Klima v pisarni">

    <inDevice id="thermometer_02" />

    <outDevice id="air_cond_02" />

    <reaction func="linear" />

    <check_idle val="600" />

    <check_active val="30" />

    <alpha val="0.8"/>

    <params val="--lazy=true" />

    <inDevAalues minval="20" maxval="26" optval="23" tolerance="0.5"/>

    <action act="testAction_2"/>

    <param par="testParam_3"/>

          <less inDeviceId="time" val="1600" />

          <greater inDeviceId="time" val="700" />

  <scenario id="scenario_03" name="Okna v pisarni">

    <inDevice id="hygrometer_01" />

    <outDevice id="window_01" />

    <check_active val="10" />

    <alpha val="0.9"/>

    <inDevAalues minval="20" maxval="28" optval="28" tolerance="0.5"/>

    <action act="testAction_2"/>

    <param par="testParam_3"/>

        <greater inDeviceId="time" val="1600" />

        <less inDeviceId="time" val="700" />

int evalOperators(int opr, int a, int b);

#include <stdio.h>

int evaluateAdditionalConditions(cond_lst *cl, device *dev)

    int result = -1;

    int local_result = -1;

    cond_lst *leaf;

    device *testDev;

    //printf("dev %s\n",dev->id);

    if(cl->OPERATOR_TYPE == TOP_NODE)

        if(!cl->sub_lst) // no additional conditions

            return 1;

        else{}

    //printf("Evaluating operator %d\n", cl->OPERATOR_TYPE);

    while(cl->sub_lst)

        if(!cl->sub_lst->sub_lst) //leaf

            //printf("Found leaf with opr %d\n", cl->sub_lst->OPERATOR_TYPE);

            //todo glej cez cel sub - nivo

            if(result==-1) //got first leaf element

            {

                //printf("got FIRST LEAF element with opr %d and device name %s\n", cl->sub_lst->OPERATOR_TYPE, cl->sub_lst->dev);

                if(0==strcmp(cl->sub_lst->dev,"time"))

                    result = evalOperators(cl->sub_lst->OPERATOR_TYPE, getLocalFormattedTime(), cl->sub_lst->value);

                else

                    result = evalOperators(cl->sub_lst->OPERATOR_TYPE, (*getDevice(dev, cl->sub_lst->dev)).buf, cl->sub_lst->value);

            }

            else

            {

                //printf("got LEAF element with opr %d\n", cl->sub_lst->OPERATOR_TYPE);

                if(0==strcmp(cl->sub_lst->dev,"time"))

                    local_result = evalOperators(cl->sub_lst->OPERATOR_TYPE, getLocalFormattedTime(), cl->sub_lst->value);

                else

                    local_result = evalOperators(cl->sub_lst->OPERATOR_TYPE, (*getDevice(dev, cl->sub_lst->dev)).buf, cl->sub_lst->value);

                result = evalOperators(cl->OPERATOR_TYPE, result, local_result);

            }

        else //not leaf

        {

            //printf("Found child with opr %d\n", cl->sub_lst->OPERATOR_TYPE);

            if(result==-1) //got first child element

            {

                //printf("got FIRST CHILD element with opr %d\n", cl->sub_lst->OPERATOR_TYPE);

                result = evaluateAdditionalConditions(cl->sub_lst, dev);

            }

            else

            {

                //printf("got CHILD element with opr %d\n", cl->sub_lst->OPERATOR_TYPE);

                result = evaluateAdditionalConditions(cl->sub_lst, dev);

                result = evalOperators(cl->OPERATOR_TYPE, result, local_result);

            }

        }

        cl->sub_lst=cl->sub_lst->nxt_lst;

    return result;

// TODO check this one again

float getNewWeightedMeasurement(float oldval, float newval, float alpha)

{

    printf("getNewWeightedMeasurement(float oldval, float newval, float alpha)\n");

    printf("=== buffer %f, device buffer %f, alpha %f\n", oldval, newval, alpha);

    printf("%f\n",oldval*alpha+newval*(1-alpha));

    return oldval*alpha+newval*(1-alpha);

}

int   evaluateAdditionalConditions(cond_lst *cl, device *dev);

//int   evaluateAdditionalConditions(cond_lst *cl);

float getNewWeightedMeasurement(float oldval, float newval, float alpha);

#include <stdio.h>

int evalOperators(int opr, int a, int b)

    switch(opr)

    {

        case AND:

            //printf("\t--- Evaluating a %d && b %d = %d\n",a,b,a&&b);

            return a&&b;

        case NOT_AND:

            //printf("\t--- Evaluating !(a %d && b %d) = %d\n",a,b, !(a&&b));

            return !(a&&b);

        case OR:

            //printf("\t--- Evaluating a %d || b %d = %d\n",a,b, a||b);

            return a||b;

        case XOR:

            //printf("\t--- Evaluating (!a %d && b %d )||(a %d && !b %d)= %d\n",a,b,a,b,(!a&&b)||(a&&!b));

            return (!a&&b)||(a&&!b);

        case GREATER:

            //printf("\t--- Evaluating a %d > b %d = %d\n",a,b, a>b);

            return a>b;

        case GREATER_OR_EQUAL:

            //printf("\t--- Evaluating a %d >= b %d = %d\n",a,b, a>=b);

            return a>=b;

        case LESS:

            //printf("\t--- Evaluating a %d < b %d = %d\n",a,b, a<b);

            return a<b;

        case LESS_OR_EQUAL:

            //printf("\t--- Evaluating a %d <= b %d = %d\n",a,b, a<=b);

            return a<=b;

        default:

            printf("Evaluation gone wrong!\n");

            return NULL;

    }

    return NULL;

//#include "../logics/device_threads.h"

//#include "../logics/scenario_threads.h"

static device   *hDevice;   //device list

static scenario *hScenario; //scenario list

//extern scenario *test;   //device list

void *randomValThread_routine(void *dummy);

void *scenarioThread_routine(void *dummy);

    printf("-- decisionMakingThread_routine started --\n");

// scenario thread routine

    device   *inDev;

    int      active = 0;

    float    scen_main_buff;

    //float    alpha = 0.7f; //TODO put this in xml also

    //printf("alpha %.2f\n", alpha);

    /*load scenario*/

    // TODO add pointer to this device (all of them actually) to scenario structure - problems with segfault

    inDev = getDevice(hDevice, scen->inDevice_id);

    scen_main_buff=inDev->buf;

    printf("Scenario %s buffer updated to %.2f!\n", scen->scen_id, scen_main_buff);

    //*

        /// main scenario loop

        //printf("inDev->buf %.2f\n", 1.0f*inDev->buf);

        if(active)

            sleep(scen->actvChkItv);

        else

            sleep(scen->idleChkItv);

        //checking primary condition

        if(scen_main_buff) // is not null

        {

            scen_main_buff = scen_main_buff*scen->alpha+inDev->buf*(1-scen->alpha);

            printf("Scenario %s buffer updated to %f, alpha: %.2f!\n", scen->scen_id, scen_main_buff, scen->alpha);

            active = 1;

            if((scen_main_buff > scen->optval + scen->tolval) ||

               (scen_main_buff < scen->optval - scen->tolval))

            {

                if(evaluateAdditionalConditions(scen->cond_l, hDevice))

                    printf("Scenario %s updated!\n", scen->scen_id);

                    /*TODO calcualte parameters with given function*/

                    /*TODO execute action with parameter(s)*/

                else

                    printf("Scenario %s not updated!\n", scen->scen_id);

            }

            else

                active = 0;

        }

        if(active)

            printf("%s main buffer %.2f, sleeping %d\n",scen->scen_id, scen_main_buff, scen->actvChkItv);

        else

            printf("%s main buffer %.2f, sleeping %d\n",scen->scen_id, scen_main_buff, scen->idleChkItv);

    /**/

        //printf("device %s buf = %d\n", dev->id, dev->buf);

#include "devicelist.h"

    device  *dev;

    float   alpha;

    char    *params_val;    // TODO kaj je to?

    struct  condition_list *cond_l;

    // control variables and pointers

#include <time.h>

        curr->buf = 0;

device *getDevice1(char *devName)

{

    return NULL;

}

device *getDevice2(device *dev)

{

    return NULL;

}

            //printf("activating device %s with status %d\n", dev->id, dev->running);

int getLocalFormattedTime()

{

    // desired format hhmm, 4 digit int; 1430 = 14:30

    time_t epoch_time;

    struct tm *tm_p;

    int wntForm=0;

    epoch_time = time( NULL );

    tm_p = localtime( &epoch_time );

    return tm_p->tm_hour*100+tm_p->tm_min;

}

#include "devicelist.h"

//extern device *hDevice;   //device list

        //** //possible BUG, random pointer values (uncomment this block)

            if(mxmlElementGetAttr(node_t, "inDeviceId"))

            {

                cl->dev = (char *)malloc(sizeof(node_t->value.element.attrs->value)*strlen(mxmlElementGetAttr(node_t, "inDeviceId")));

                cl->dev = mxmlElementGetAttr(node_t, "inDeviceId");

                (*cl).value = atoi(mxmlElementGetAttr(node_t, "val"));

            }

        curr->actvChkItv = atoi(mxmlElementGetAttr(mxml_scenarioNode, "val"));

        //printf("actvChkItv:\t %d s\n", curr->actvChkItv );

        /// float   alpha;

        curr->alpha = atof(mxmlElementGetAttr(mxml_scenarioNode, "val"));

            mxml_scenarioNode= mxml_scenarioNode->next;

        //printf("actvChkItv:\t %f s\n", curr->alpha );

int     setNewDeviceList(); // ony called on startup

int     getNumberOfDevices();

device *getDevice1(char *devName);

device *getDevice2(device *dev);

int     getLocalFormattedTime();