rt_mh_appl.c

Go to the documentation of this file.

/*
 * ProviewR   Open Source Process Control.
 * Copyright (C) 2005-2025 SSAB EMEA AB.
 *
 * This file is part of ProviewR.
 *
 * This program 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 2 of
 * the License, or (at your option) any later version.
 *
 * This program 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 ProviewR. If not, see <http://www.gnu.org/licenses/>
 *
 * Linking ProviewR statically or dynamically with other modules is
 * making a combined work based on ProviewR. Thus, the terms and
 * conditions of the GNU General Public License cover the whole
 * combination.
 *
 * In addition, as a special exception, the copyright holders of
 * ProviewR give you permission to, from the build function in the
 * ProviewR Configurator, combine ProviewR with modules generated by the
 * ProviewR PLC Editor to a PLC program, regardless of the license
 * terms of these modules. You may copy and distribute the resulting
 * combined work under the terms of your choice, provided that every
 * copy of the combined work is accompanied by a complete copy of
 * the source code of ProviewR (the version used to produce the
 * combined work), being distributed under the terms of the GNU
 * General Public License plus this exception.
 */
 
/* rt_mh_appl.c -- Runtime environment - Message Handler */
 
#include <stdio.h>
#include <string.h>
 
#include "co_time.h"
#include "rt_mh_def.h"
#include "rt_qcom_msg.h"
#include "rt_mh_util.h"
 
typedef struct {
  mh_sHead head;
  qcom_sQid handler;
  mh_eApplState state;
} sApplContext;
 
/* Local variables */
 
static sApplContext lAppl;
 
/* Local function prototypes */
 
static pwr_tStatus sendAndReceive(mh_eMsg, pwr_tUInt32, void*, mh_uApplReply*);
 
pwr_tStatus mh_ApplCancel(
    pwr_tUInt32 id, 
    pwr_tString80* cancelText 
    )
{
  pwr_tStatus sts;
  mh_sApplReturn cancel;
 
  /* Check parameters */
 
  if (cancelText == NULL)
    memset(&cancel.ReturnText, 0, sizeof(cancel.ReturnText));
  else
    strncpy(cancel.ReturnText, (char*)cancelText, sizeof(*cancelText));
 
  cancel.TargetIdx = id;
  cancel.ReturnType = mh_eEvent_Cancel;
 
  sts = sendAndReceive(mh_eMsg_ApplReturn, sizeof(cancel), &cancel, NULL);
 
  return sts;
}
 
/*
*@example mh_examples.c
*/
 
pwr_tStatus mh_ApplConnect(
    pwr_tObjid applObject, 
    mh_mApplFlags
        flags, 
    const pwr_tString80 abortEventName, 
    mh_eEvent abortEventType, 
    mh_eEventPrio abortEventPrio, 
    mh_mEventFlags abortEventFlags, 
    const pwr_tString80 abortEventText, 
    pwr_tUInt32* activeMessages 
    )
{
  pwr_tStatus sts;
  pwr_tClassId cid;
  mh_sApplConnect connect;
  mh_uApplReply reply;
  qcom_sQid qid = qcom_cNQid;
  char name[32];
  qcom_sNode myNode;
  qcom_sQattr qAttr;
 
  mh_UtilWaitForMh();
 
  sprintf(name, "MhAppl_%X", applObject.oix);
 
  if (!qcom_Init(&sts, NULL, name)) {
    errh_Error("Failed connecting application to QCOM\n%m", sts);
    return MH__QCOMCONAPPL;
  }
 
  qAttr.type = qcom_eQtype_private;
  qAttr.quota = 100;
  if (!qcom_CreateQ(&sts, &qid, &qAttr, name)) {
    errh_Error("Failed to create QCOM que\n%m", sts);
    return MH__QCOMCREQ;
  }
 
  qcom_MyNode(&sts, &myNode);
  lAppl.head.platform.os = myNode.os;
  lAppl.head.platform.hw = myNode.hw;
 
  /* Check Application object */
 
  if (applObject.vid
      != pwr_cNVolumeId) { /* Application object should exist in Rtdb */
    sts = gdh_GetObjectClass(applObject, &cid);
    if (EVEN(sts))
      return sts;
    switch (cid) {
    case pwr_eClass_Appl:
    case pwr_cClass_OpAppl:
    case pwr_cClass_Application:
      break;
    default:
      return MH__NOAPPL;
    }
  }
 
  lAppl.head.xdr = FALSE; /* To local handler only */
  lAppl.head.ver = mh_cVersion;
  lAppl.head.source = mh_eSource_Application;
  net_GetTime(&lAppl.head.birthTime);
  lAppl.head.qid = qid;
  lAppl.head.aid = applObject;
  lAppl.handler.nid = qid.nid;
  lAppl.handler.qix = mh_cProcHandler;
 
  connect.ApplObject = applObject;
  connect.Qid = qid;
  connect.Flags = flags;
  strncpy(
      connect.AbortEventName, abortEventName, sizeof(connect.AbortEventName));
  connect.AbortEventType = abortEventType;
  connect.AbortEventPrio = abortEventPrio;
  connect.AbortEventFlags = abortEventFlags;
  strncpy(
      connect.AbortEventText, abortEventText, sizeof(connect.AbortEventText));
 
  sts = sendAndReceive(mh_eMsg_ApplConnect, sizeof(connect), &connect, &reply);
  if (EVEN(sts))
    return sts;
 
  if (activeMessages != NULL)
    *activeMessages = reply.Connect.NoOfActMessages;
 
  lAppl.state = mh_eApplState_Connected;
  return sts;
}
 
pwr_tStatus mh_ApplDisconnect()
{
  pwr_tStatus sts;
 
  sts = sendAndReceive(mh_eMsg_ApplDisconnect, 0, NULL, NULL);
 
  lAppl.state = mh_eApplState_Disconnected;
 
  return MH__SUCCESS;
}
 
pwr_tStatus mh_ApplMessage(
    pwr_tUInt32* id, 
    mh_sApplMessage* message 
    )
{
  pwr_tStatus sts;
  mh_uApplReply reply;
 
  /* Check parameters */
 
  if (message == NULL)
    return MH__BADPARAM;
 
  sts = sendAndReceive(mh_eMsg_ApplMessage, sizeof(*message), message, &reply);
  if (EVEN(sts))
    return sts;
 
  message->Id = reply.Message.Idx;
  if (id != NULL)
    *id = reply.Message.Idx;
  return sts;
}
 
pwr_tStatus mh_ApplReturn(
    pwr_tUInt32 id, 
    pwr_tString80* returnText 
    )
{
  pwr_tStatus sts;
  mh_sApplReturn applReturn;
 
  /* Check parameters */
 
  if (returnText == NULL)
    memset(&applReturn.ReturnText, 0, sizeof(applReturn.ReturnText));
  else
    strncpy(applReturn.ReturnText, (char*)returnText, sizeof(*returnText));
 
  applReturn.TargetIdx = id;
  applReturn.ReturnType = mh_eEvent_Return;
 
  sts = sendAndReceive(
      mh_eMsg_ApplReturn, sizeof(applReturn), &applReturn, NULL);
 
  return sts;
}
 
pwr_tStatus mh_ApplGetMsgInfo(
    pwr_tUInt32
        id, 
    mh_sApplMessage* message 
    )
{
  pwr_tStatus sts;
  mh_uApplReply reply;
 
  /* Check parameters */
 
  if (message == NULL)
    return MH__BADPARAM;
 
  sts = sendAndReceive(mh_eMsg_ApplGetMsgInfo, sizeof(id), &id, &reply);
  if (EVEN(sts))
    return sts;
 
  memcpy(message, &reply.Info.Message, sizeof(*message));
 
  return MH__SUCCESS;
}
 
static pwr_tStatus sendAndReceive(
    mh_eMsg type, pwr_tUInt32 inSize, void* ip, mh_uApplReply* reply)
{
  pwr_tStatus sts;
  qcom_sPut put;
  qcom_sGet get;
  mh_sHead* hp;
  mh_uApplReply* rp;
  void* rvoid;
  pwr_tUInt32 size = sizeof(lAppl.head) + inSize;
 
  if ((put.data = qcom_Alloc(&sts, size)) == NULL) {
    errh_Error("mh_Appl, sendAndReceive, qcom_AllocMsg failed\n%m", sts);
    return MH__QCOMALLOCMSG;
  }
 
  memcpy(put.data, &lAppl.head, sizeof(lAppl.head));
  ((mh_sHead*)put.data)->type = type;
  if (inSize > 0)
    memcpy((char*)put.data + sizeof(lAppl.head), ip, inSize);
 
  put.type.b = mh_cMsgClass;
  put.type.s = 0;
  put.reply.qix = 0;
  put.reply.nid = 0;
  put.size = size;
  put.allocate = 0;
 
  get.data = NULL;
 
  rvoid = qcom_Request(
      &sts, &lAppl.handler, &put, &lAppl.head.qid, &get, 1000 * 3600, 0);
  if (EVEN(sts)) {
    errh_Error("mhAppl, sendAndReceive, qcom_Get failed\n%m", sts);
    qcom_Free(NULL, put.data);
    return MH__QCOMRCVMSG;
  }
 
  hp = (mh_sHead*)get.data;
  rp = (mh_uApplReply*)(hp + 1);
  sts = rp->Sts;
 
  if (ODD(sts) && reply != NULL)
    memcpy(reply, rp, sizeof(mh_uApplReply));
 
  qcom_Free(NULL, get.data);
 
  return sts;
}