CodeForge

			/*
 *  control.c
 *
 *  Copyright 2013 Michael Zillgith
 *
 *  This file is part of libIEC61850.
 *
 *  libIEC61850 is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  libIEC61850 is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libIEC61850.  If not, see <http://www.gnu.org/licenses/>.
 *
 *  See COPYING file for the complete license text.
 */

#include "control.h"
#include "mms_mapping.h"
#include "mms_mapping_internal.h"

#include "mms_client_connection.h"

#include "ied_server_private.h"

#include "mms_value_internal.h"

#if (CONFIG_IEC61850_CONTROL_SERVICE == 1)

#ifndef DEBUG_IED_SERVER
#define DEBUG_IED_SERVER 0
#endif

#define CONTROL_ERROR_NO_ERROR 0
#define CONTROL_ERROR_UNKOWN 1
#define CONTROL_ERROR_TIMEOUT_TEST 2
#define CONTROL_ERROR_OPERATOR_TEST 3

#define CONTROL_ADD_CAUSE_UNKNOWN 0
#define CONTROL_ADD_CAUSE_SELECT_FAILED 3
#define CONTROL_ADD_CAUSE_BLOCKED_BY_INTERLOCKING 10
#define CONTROL_ADD_CAUSE_BLOCKED_BY_SYNCHROCHECK 11
#define CONTROL_ADD_CAUSE_COMMAND_ALREADY_IN_EXECUTION 12
#define CONTROL_ADD_CAUSE_OBJECT_NOT_SELECTED 18
#define CONTROL_ADD_CAUSE_OBJECT_ALREADY_SELECTED 19
#define CONTROL_ADD_CAUSE_INCONSISTENT_PARAMETERS 26
#define CONTROL_ADD_CAUSE_LOCKED_BY_OTHER_CLIENT 27

#define STATE_UNSELECTED 0
#define STATE_READY 1
#define STATE_WAIT_FOR_ACTICATION_TIME 2
#define STATE_PERFORM_TEST 3
#define STATE_WAIT_FOR_EXECUTION 4
#define STATE_OPERATE 5

struct sControlObject
{

    MmsDomain* mmsDomain;
    IedServer iedServer;
    char* lnName;
    char* name;

    int state;
    Semaphore stateLock;

    MmsValue* mmsValue;
    MmsVariableSpecification* typeSpec;

    MmsValue* oper;
    MmsValue* sbo;
    MmsValue* sbow;
    MmsValue* cancel;

    MmsValue* ctlVal;
    MmsValue* ctlNum;
    MmsValue* origin;
    MmsValue* timestamp;

    char* ctlObjectName;

    /* for LastAppIError */
    MmsValue* error;
    MmsValue* addCause;

    bool selected;
    uint64_t selectTime;
    uint32_t selectTimeout;
    MmsValue* sboClass;
    MmsValue* sboTimeout;

    bool timeActivatedOperate;
    uint64_t operateTime;

    bool operateOnce;
    MmsServerConnection* clientConnection;

    MmsValue* emptyString;

    bool initialized;
    uint32_t ctlModel;

    bool testMode;
    bool interlockCheck;
    bool synchroCheck;

    uint32_t operateInvokeId;

    ControlHandler listener;
    void* listenerParameter;

    ControlPerformCheckHandler checkHandler;
    void* checkHandlerParameter;

    ControlWaitForExecutionHandler waitForExecutionHandler;
    void* waitForExecutionHandlerParameter;

};

void
ControlObject_sendLastApplError(ControlObject* self, MmsServerConnection* connection, char* ctlVariable, int error,
        int addCause, MmsValue* ctlNum, MmsValue* origin, bool handlerMode);

void
ControlObject_sendCommandTerminationReq(ControlObject* self, MmsServerConnection* connection);

MmsValue*
Control_readAccessControlObject(MmsMapping* self, MmsDomain* domain, char* variableIdOrig,
        MmsServerConnection* connection);

static void
setState(ControlObject* self, int newState)
{

    Semaphore_wait(self->stateLock);
    self->state = newState;
    Semaphore_post(self->stateLock);

}

static int
getState(ControlObject* self)
{

    int state;
    Semaphore_wait(self->stateLock);
    state = self->state;
    Semaphore_post(self->stateLock);

    return state;

}

static void
updateSboTimeoutValue(ControlObject* self)
{

    if (self->sboTimeout != NULL) {

        uint32_t sboTimeoutVal = MmsValue_toInt32(self->sboTimeout);

        if (DEBUG_IED_SERVER)
            printf("set timeout for %s to %u\n", self->ctlObjectName, sboTimeoutVal);

        self->selectTimeout = sboTimeoutVal;
    
}
    else
        self->selectTimeout = CONFIG_CONTROL_DEFAULT_SBO_TIMEOUT;

}

static void
initialize(ControlObject* self)
{

    if (!(self->initialized)) {


        MmsServer mmsServer = IedServer_getMmsServer(self->iedServer);

        self->emptyString = MmsValue_newVisibleString(NULL);

        char* ctlModelName = createString(4, self->lnName, "$CF$", self->name, "$ctlModel");

        if (DEBUG_IED_SERVER)
            printf("initialize control for %s\n", ctlModelName);

        MmsValue* ctlModel = MmsServer_getValueFromCache(mmsServer,
                self->mmsDomain, ctlModelName);

        if (ctlModel == NULL) {

            if (DEBUG_IED_SERVER)
                printf("No control model found for variable %s\n", ctlModelName);
        
}

        free(ctlModelName);

        char* sboClassName = createString(4, self->lnName, "$CF$", self->name, "$sboClass");

        self->sboClass = MmsServer_getValueFromCache(mmsServer, self->mmsDomain, sboClassName);

        free(sboClassName);

        self->ctlObjectName = (char*) malloc(130);

        createStringInBuffer(self->ctlObjectName, 5, MmsDomain_getName(self->mmsDomain), "/",
                self->lnName, "$CO$", self->name);

        self->error = MmsValue_newIntegerFromInt32(0);
        self->addCause = MmsValue_newIntegerFromInt32(0);

        if (ctlModel != NULL) {

            uint32_t ctlModelVal = MmsValue_toInt32(ctlModel);

            self->ctlModel = ctlModelVal;

            if (DEBUG_IED_SERVER)
                printf("  ctlModel: %i\n", ctlModelVal);

            if ((ctlModelVal == 2) || (ctlModelVal == 4)) {
 /* SBO */
                char* sboTimeoutName = createString(4, self->lnName, "$CF$", self->name, "$sboTimeout");

                char* controlObjectReference = createString(6, self->mmsDomain->domainName, "/", self->lnName, "$",
                        self->name, "$SBO");

                self->sbo = MmsValue_newVisibleString(controlObjectReference);

                self->sboTimeout = MmsServer_getValueFromCache(mmsServer,
                        self->mmsDomain, sboTimeoutName);

                updateSboTimeoutValue(self);

                setState(self, STATE_UNSELECTED);

                if (DEBUG_IED_SERVER)
                    printf("timeout for %s is %i\n", sboTimeoutName, self->selectTimeout);

                free(controlObjectReference);
                free(sboTimeoutName);
            
}
            else {

                self->sbo = MmsValue_newVisibleString(NULL);

                setState(self, STATE_READY);
            
}
        
}

        self->initialized = true;
    
}

}

static bool
isSboClassOperateOnce(ControlObject* self)
{

    if (self->sboClass != NULL) {

        if (MmsValue_toInt32(self->sboClass) == 1)
            return false;
        else
            return true;
    
}
    else
        return true; /* default is operate-once ! */

}

static void
abortControlOperation(ControlObject* self)
{

    if ((self->ctlModel == 2) || (self->ctlModel == 4)) {


        if (isSboClassOperateOnce(self))
            setState(self, STATE_UNSELECTED);
        else
            setState(self, STATE_READY);
    
}
    else
        setState(self, STATE_READY);

}

static MmsValue*
getOperParameterOperTime(MmsValue* operParameters)
{

    if (MmsValue_getType(operParameters) == MMS_STRUCTURE) {


        if (MmsValue_getArraySize(operParameters) == 7)
            return MmsValue_getElement(operParameters, 1);
    
}

    return NULL;

}

static void
controlOperateThread(ControlObject* self)
{

    bool checkOk = true;

    bool isTimeActivatedControl = false;

    ClientConnection iedClientConnection =
            private_IedServer_getClientConnectionByHandle(self->iedServer, self->clientConnection);

    if (iedClientConnection == NULL) return;

    private_ClientConnection_increaseTasksCount(iedClientConnection);

    if (getState(self) == STATE_WAIT_FOR_ACTICATION_TIME)
        isTimeActivatedControl = true;

    setState(self, STATE_WAIT_FOR_EXECUTION);

    if (self->waitForExecutionHandler != NULL) {

        checkOk = self->waitForExecutionHandler(self->waitForExecutionHandlerParameter, self->ctlVal,
                self->testMode, self->synchroCheck);
    
}

    if (!checkOk) {


        if (isTimeActivatedControl) {

            ControlObject_sendLastApplError(self, self->clientConnection, "Oper",
            CONTROL_ERROR_NO_ERROR, CONTROL_ADD_CAUSE_BLOCKED_BY_SYNCHROCHECK,
                    self->ctlNum, self->origin, false);
        
}
        else
            MmsServerConnection_sendWriteResponse(self->clientConnection, self->operateInvokeId,
                    DATA_ACCESS_ERROR_OBJECT_ACCESS_DENIED);

        abortControlOperation(self);

    
}
    else {

        if (isTimeActivatedControl) {

            ControlObject_sendCommandTerminationReq(self, self->clientConnection);

            MmsValue* operTm = getOperParameterOperTime(self->oper);

            MmsValue_setUtcTime(operTm, 0);

        
}
        else
            MmsServerConnection_sendWriteResponse(self->clientConnection, self->operateInvokeId,
                    DATA_ACCESS_ERROR_SUCCESS);

        uint64_t currentTime = Hal_getTimeInMs();

        setState(self, STATE_OPERATE);

        if (ControlObject_operate(self, self->ctlVal, currentTime, self->testMode)) {


            if ((self->ctlModel == 4) || (self->ctlModel == 3)) {

                ControlObject_sendCommandTerminationReq(self, self->clientConnection);
            
}
        
}
        else {


            if ((self->ctlModel == 4) || (self->ctlModel == 3)) {

                if (DEBUG_IED_SERVER)
                    printf("Oper: operate failed!\n");
                ControlObject_sendLastApplError(self, self->clientConnection, "Oper",
                CONTROL_ERROR_NO_ERROR, CONTROL_ADD_CAUSE_SELECT_FAILED,
                        self->ctlNum, self->origin, false);
            
}
        
}

        abortControlOperation(self);
    
}

    /* synchronize with connection management */
    private_ClientConnection_decreaseTasksCount(iedClientConnection);

}

static void
star
...
...
(Not finished, please download and read the complete file)