state_machine.h

Go to the documentation of this file.

/*
 * Licensed to Systerel under one or more contributor license
 * agreements. See the NOTICE file distributed with this work
 * for additional information regarding copyright ownership.
 * Systerel licenses this file to you under the Apache
 * License, Version 2.0 (the "License"); you may not use this
 * file except in compliance with the License. You may obtain
 * a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
 
#ifndef STATE_MACHINE_H_
#define STATE_MACHINE_H_
 
/* Machine static parameters, MonitoredItem parameters */
#define MONIT_TIMESTAMPS_TO_RETURN OpcUa_TimestampsToReturn_Both
#define MONIT_QSIZE 10
 
#include <stdbool.h>
 
/* The following includes are required to fetch the SOPC_LibSub_DataChangeCbk type */
#include "sopc_builtintypes.h"
#include "sopc_crypto_profiles.h"
#include "sopc_log_manager.h"
#include "sopc_types.h"
#include "sopc_user_app_itf.h"
#define SKIP_S2OPC_DEFINITIONS
#include "libs2opc_client.h"
#include "libs2opc_client_cmds.h"
 
/* Machine states */
typedef enum
{
    stError, /* stError is both error and closed state */
    stInit,
    stActivating,
    stActivated,
    stCreatingSubscr,
    stCreatingMonIt,
    stDeletingSubscr,
    stClosing
} SOPC_StaMac_State;
 
/* Request types */
typedef enum
{
    SOPC_REQUEST_TYPE_UNKNOWN = 0,            /* Unknown Request */
    SOPC_REQUEST_TYPE_USER,                   /* User Crafted Request */
    SOPC_REQUEST_TYPE_PUBLISH,                /* PublishRequest */
    SOPC_REQUEST_TYPE_CREATE_SUBSCRIPTION,    /* CreateSubscriptionRequest */
    SOPC_REQUEST_TYPE_CREATE_MONITORED_ITEMS, /* CreateMonitoredItemsRequest */
    SOPC_REQUEST_TYPE_DELETE_SUBSCRIPTION,    /* DeleteSubscriptionRequest */
    SOPC_REQUEST_TYPE_GET_ENDPOINTS           /* GetEndpointsRequest */
} SOPC_StaMac_RequestType;
 
/* Request scopes */
typedef enum
{
    SOPC_REQUEST_SCOPE_STATE_MACHINE, 
    SOPC_REQUEST_SCOPE_APPLICATION,   
    SOPC_REQUEST_SCOPE_DISCOVERY      
} SOPC_StaMac_RequestScope;
 
typedef struct
{
    uintptr_t appCtx;                      /* Application context, chosen outside of the state machine */
    SOPC_StaMac_RequestScope requestScope; /* Whether the request is started by the state machine or the applicative */
    SOPC_StaMac_RequestType requestType;   /* the type of request */
} SOPC_StaMac_ReqCtx;
 
/* Machine content is private to the implementation */
typedef struct SOPC_StaMac_Machine SOPC_StaMac_Machine;
 
/* Machine lifecycle */
 
SOPC_ReturnStatus SOPC_StaMac_Create(uint32_t iscConfig,
                                     SOPC_ReverseEndpointConfigIdx reverseConfigIdx,
                                     uint32_t iCliId,
                                     const char* szPolicyId,
                                     const char* szUsername,
                                     const char* szPassword,
                                     const char* szPath_cert_x509_token,
                                     const char* szPath_key_x509_token,
                                     SOPC_LibSub_DataChangeCbk* cbkLibSubDataChanged,
                                     double fPublishInterval,
                                     uint32_t iCntMaxKeepAlive,
                                     uint32_t iCntLifetime,
                                     uint32_t iTokenTarget,
                                     int64_t iTimeoutMs,
                                     SOPC_LibSub_EventCbk* cbkGenericEvent,
                                     uintptr_t userContext,
                                     SOPC_StaMac_Machine** ppSM);
 
/*
 * \brief Changes the callback for data change notifications on subscription
 */
SOPC_ReturnStatus SOPC_StaMac_ConfigureDataChangeCallback(SOPC_StaMac_Machine* pSM,
                                                          SOPC_ClientHelper_DataChangeCbk* pCbkClientHelper);
 
void SOPC_StaMac_Delete(SOPC_StaMac_Machine** ppSM);
 
SOPC_ReturnStatus SOPC_StaMac_StartSession(SOPC_StaMac_Machine* pSM);
 
SOPC_ReturnStatus SOPC_StaMac_StopSession(SOPC_StaMac_Machine* pSM);
 
SOPC_ReturnStatus SOPC_StaMac_SendRequest(SOPC_StaMac_Machine* pSM,
                                          void* requestStruct,
                                          uintptr_t appCtx,
                                          SOPC_StaMac_RequestScope requestScope,
                                          SOPC_StaMac_RequestType requestType);
 
/*
 * \brief Create subscription associated to the given state machine
 */
SOPC_ReturnStatus SOPC_StaMac_CreateSubscription(SOPC_StaMac_Machine* pSM);
 
SOPC_ReturnStatus SOPC_StaMac_DeleteSubscription(SOPC_StaMac_Machine* pSM);
 
typedef struct SOPC_CreateMonitoredItem_Ctx
{
    OpcUa_CreateMonitoredItemsResponse* Results; /* might be NULL if not necessary for application. */
    uintptr_t outCtxId; /* Contains unique identifier filled by ::SOPC_StaMac_CreateMonitoredItem */
} SOPC_CreateMonitoredItem_Ctx;
 
SOPC_ReturnStatus SOPC_StaMac_CreateMonitoredItem(SOPC_StaMac_Machine* pSM,
                                                  char const* const* lszNodeId,
                                                  const uint32_t* liAttrId,
                                                  int32_t nElems,
                                                  SOPC_CreateMonitoredItem_Ctx* pAppCtx,
                                                  uint32_t* lCliHndl);
 
bool SOPC_StaMac_IsConnectable(SOPC_StaMac_Machine* pSM);
 
bool SOPC_StaMac_IsConnected(SOPC_StaMac_Machine* pSM);
 
bool SOPC_StaMac_IsError(SOPC_StaMac_Machine* pSM);
 
void SOPC_StaMac_SetError(SOPC_StaMac_Machine* pSM);
 
bool SOPC_StaMac_HasSubscription(SOPC_StaMac_Machine* pSM);
 
bool SOPC_StaMac_HasMonItByAppCtx(SOPC_StaMac_Machine* pSM, SOPC_CreateMonitoredItem_Ctx* pAppCtx);
 
int64_t SOPC_StaMac_GetTimeout(SOPC_StaMac_Machine* pSM);
 
uintptr_t SOPC_StaMac_GetUserContext(SOPC_StaMac_Machine* pSM);
 
void SOPC_StaMac_SetUserContext(SOPC_StaMac_Machine* pSM, uintptr_t userContext);
 
bool SOPC_StaMac_EventDispatcher(SOPC_StaMac_Machine* pSM,
                                 uintptr_t* pAppCtx,
                                 SOPC_App_Com_Event event,
                                 uint32_t arg,
                                 void* pParam,
                                 uintptr_t appCtx);
 
#endif /* STATE_MACHINE_H_ */