static pwr_sClass_IOHandler *
init (qcom_sQid *qid, lst_sEntry **csup_lh)
{
pwr_tStatus sts = 1;
pwr_sClass_IOHandler *ihp;
qcom_sQattr qAttr;
qcom_sQid qini;
pwr_tObjid oid;
errh_Init("pwr_io", errh_eAnix_io);
#if defined(OS_ELN)
/* Event to kill dioc */
ker$create_event(&sts, &io_comm_terminate, EVENT$CLEARED);
#endif
if (!qcom_Init(&sts, 0, "pwr_io")) {
errh_Fatal("qcom_Init, %m", sts);
exit(sts);
}
qAttr.type = qcom_eQtype_private;
qAttr.quota = 100;
if (!qcom_CreateQ(&sts, qid, &qAttr, "events")) {
errh_Fatal("qcom_CreateQ, %m", sts);
exit(sts);
}
qini = qcom_cQini;
if (!qcom_Bind(&sts, qid, &qini)) {
errh_Fatal("qcom_Bind(Qini), %m", sts);
exit(-1);
}
sts = gdh_Init("pwr_io");
if (EVEN(sts)) {
errh_Fatal("rt_io_comm aborted\n%m", sts);
exit(sts);
}
sts = io_get_iohandler_object(&ihp, &oid);
if (EVEN(sts)) {
errh_Fatal("rt_io_comm aborted, no IoHandler object found\n%m", sts);
exit(sts);
}
aproc_RegisterObject( oid);
*csup_lh = csup_Init(&sts, oid, ihp->CycleTimeBus);
return ihp;
}
static void delete_locks()
{
pwr_tStatus sts;
lck_Delete(&sts, lck_eLock_Time);
if (EVEN(sts))
errh_Fatal("lock delete time, %m", sts);
lck_Delete(&sts, lck_eLock_Str);
if (EVEN(sts))
errh_Fatal("lock delete str, %m", sts);
lck_Delete(&sts, lck_eLock_NMps);
if (EVEN(sts))
errh_Fatal("lock delete NMps, %m", sts);
}
static plc_sProcess *
init_process ()
{
plc_sProcess *pp;
pwr_tStatus sts = PLC__SUCCESS;
#if 0
thread_SetPrio(NULL, 15);
#endif
errh_Init("pwr_plc", errh_eAnix_plc);
errh_SetStatus( PWR__SRVSTARTUP);
pp = (plc_sProcess *) calloc(1, sizeof(*pp));
if (pp == NULL) {
errh_Fatal("Out of virtual memory");
exit(0);
}
sts = gdh_Init("pwr_plc");
if (EVEN(sts)) {
errh_Fatal("gdh_Init, %m", sts);
errh_SetStatus( PWR__SRVTERM);
exit(sts);
}
#if defined OS_VMS
qdb->thread_lock.isThreaded = 1;
qdb->thread_lock.cond_signal = thread_CondSignal;
qdb->thread_lock.cond_wait = thread_CondWait;
#endif
qcom_CreateQ(&sts, &pp->eventQ, NULL, "plcEvent");
if (EVEN(sts)) {
errh_Fatal("qcom_CreateQ(eventQ), %m", sts);
errh_SetStatus( PWR__SRVTERM);
exit(sts);
}
sts = thread_MutexInit(&pp->io_copy_mutex);
if (EVEN(sts)) {
errh_Fatal("thread_MutexInit(io_copy_mutex), %m", sts);
errh_SetStatus( PWR__SRVTERM);
exit(sts);
}
return pp;
}
int main()
{
pwr_tStatus sts;
rt_sysmon sysmon;
int tmo;
char mp[2000];
qcom_sQid qid = qcom_cNQid;
qcom_sGet get;
int swap = 0;
bool first_scan = true;
init( &qid);
try {
sysmon.open();
}
catch ( co_error& e) {
errh_Error( (char *)e.what().c_str());
errh_Fatal( "rt_sysmon aborting");
errh_SetStatus( PWR__SRVTERM);
exit(0);
}
aproc_TimeStamp( sysmon.scantime(), 5);
errh_SetStatus( PWR__SRUN);
first_scan = true;
for (;;) {
if ( first_scan) {
tmo = (int) (sysmon.scantime() * 1000 - 1);
}
get.maxSize = sizeof(mp);
get.data = mp;
qcom_Get( &sts, &qid, &get, tmo);
if (sts == QCOM__TMO || sts == QCOM__QEMPTY) {
if ( !swap)
sysmon.scan();
}
else {
ini_mEvent new_event;
qcom_sEvent *ep = (qcom_sEvent*) get.data;
new_event.m = ep->mask;
if (new_event.b.oldPlcStop && !swap) {
errh_SetStatus( PWR__SRVRESTART);
swap = 1;
sysmon.close();
} else if (new_event.b.swapDone && swap) {
swap = 0;
sysmon.open();
errh_SetStatus( PWR__SRUN);
} else if (new_event.b.terminate) {
exit(0);
}
}
first_scan = false;
}
}
static void init(qcom_sQid* myQid)
{
pwr_tStatus sts;
sts = gdh_Init("pwr_nacp");
if (EVEN(sts)) {
errh_Fatal("gdh_Init, %m", sts);
errh_SetStatus(PWR__SRVTERM);
exit(sts);
}
#if defined OS_CYGWIN
qcom_sQattr qAttr;
qcom_sQid qid = qcom_cQnacp;
qAttr.type = qcom_eQtype_private;
qAttr.quota = 100;
if (!qcom_CreateQ(&sts, &qid, &qAttr, "nacp")) {
errh_Error("Failed to create QCOM que\n%m", sts);
errh_SetStatus(PWR__SRVTERM);
exit(sts);
}
#else
if (!qcom_AttachQ(&sts, &qcom_cQnacp)) {
errh_Fatal("qcom_AttachQ, %m", sts);
errh_SetStatus(PWR__SRVTERM);
exit(sts);
}
#endif
*myQid = qcom_cQnacp;
if (!qcom_Bind(&sts, myQid, &qcom_cQini)) {
errh_Fatal("qcom_Bind, %m", sts);
errh_SetStatus(PWR__SRVTERM);
exit(-1);
}
/* Activate all subscriptions that were requested before we started! */
gdb_ScopeLock
{
gdbroot->db->neth_acp = *myQid;
subc_ActivateList(&gdbroot->my_node->subc_lh, pwr_cNObjid);
subc_ActivateList(&gdbroot->no_node->subc_lh, pwr_cNObjid);
}
gdb_ScopeUnlock;
}
JNIEXPORT void JNICALL Java_jpwr_rt_Errh_fatal
(JNIEnv *env, jobject object, jstring jmsg)
{
char *cstr;
const char *msg;
msg = (*env)->GetStringUTFChars( env, jmsg, 0);
cstr = (char *)msg;
errh_Fatal( cstr);
(*env)->ReleaseStringUTFChars( env, jmsg, cstr);
}
unsigned int wmq_connectandopen()
{
MQLONG CompCode;
MQLONG Reason;
MQCONN(mgr_name, &Hconn, &CompCode, &Reason);
if ((CompCode != MQCC_OK) | (Reason != MQRC_NONE)) {
// errh_Fatal("MQCONN failed, queue mgr: %s, Code: %d, Reason: %d", mgr_name, CompCode, Reason);
// errh_SetStatus(PWR__SRVTERM);
if (!((CompCode == MQCC_WARNING) && (Reason == MQRC_ALREADY_CONNECTED)))
return 0;
}
/* Open queue for receiving messages */
MQOPEN(Hconn, &RcvObjDesc, RcvOpenOptions, &RcvHobj, &CompCode, &Reason);
if ((CompCode != MQCC_OK) | (Reason != MQRC_NONE)) {
errh_Fatal("MQOPEN failed, queue: %s, Code: %d, Reason: %d", rcv_que_name, CompCode, Reason);
errh_SetStatus(PWR__SRVTERM);
exit(0);
}
/* Open queue for sending messages */
MQOPEN(Hconn, &SndObjDesc, SndOpenOptions, &SndHobj, &CompCode, &Reason);
if ((CompCode != MQCC_OK) | (Reason != MQRC_NONE)) {
errh_Fatal("MQOPEN failed, queue: %s, Code: %d, Reason: %d", snd_que_name, CompCode, Reason);
errh_SetStatus(PWR__SRVTERM);
exit(0);
}
connected = 1;
return 1;
}
static void
init (
qcom_sQid *myQid
)
{
pwr_tStatus sts;
sts = gdh_Init("pwr_nacp");
if (EVEN(sts)) {
errh_Fatal("gdh_Init, %m", sts);
errh_SetStatus( PWR__SRVTERM);
exit(sts);
}
if (!qcom_AttachQ(&sts, &qcom_cQnacp)) {
errh_Fatal("qcom_AttachQ, %m", sts);
errh_SetStatus( PWR__SRVTERM);
exit(sts);
}
*myQid = qcom_cQnacp;
if (!qcom_Bind(&sts, myQid, &qcom_cQini)) {
errh_Fatal("qcom_Bind, %m", sts);
errh_SetStatus( PWR__SRVTERM);
exit(-1);
}
/* Activate all subscriptions that were requested before we started! */
gdb_ScopeLock {
gdbroot->db->neth_acp = *myQid;
subc_ActivateList(&gdbroot->my_node->subc_lh, pwr_cNObjid);
subc_ActivateList(&gdbroot->no_node->subc_lh, pwr_cNObjid);
} gdb_ScopeUnlock;
}
void init( qcom_sQid *qid)
{
qcom_sQid qini;
qcom_sQattr qAttr;
pwr_tStatus sts;
sts = gdh_Init("rt_sysmon");
if ( EVEN(sts)) {
errh_Fatal( "gdh_Init, %m", sts);
exit(sts);
}
errh_Init("pwr_sysmon", errh_eAnix_sysmon);
errh_SetStatus( PWR__SRVSTARTUP);
if (!qcom_Init(&sts, 0, "pwr_sysmon")) {
errh_Fatal("qcom_Init, %m", sts);
errh_SetStatus( PWR__SRVTERM);
exit(sts);
}
qAttr.type = qcom_eQtype_private;
qAttr.quota = 100;
if (!qcom_CreateQ(&sts, qid, &qAttr, "events")) {
errh_Fatal("qcom_CreateQ, %m", sts);
errh_SetStatus( PWR__SRVTERM);
exit(sts);
}
qini = qcom_cQini;
if (!qcom_Bind(&sts, qid, &qini)) {
errh_Fatal("qcom_Bind(Qini), %m", sts);
errh_SetStatus( PWR__SRVTERM);
exit(-1);
}
}
int main(int argc, char *argv[])
{
unsigned int sts; /* Status from function calls etc. */
unsigned char id[32];
unsigned char pname[32];
remtrans_item *remtrans;
int i;
/* Read arg number 2, should be id for this instance */
if (argc >= 2)
strcpy((char *)id, argv[1]);
else
strcpy((char *)id, "0");
/* Build process name with id */
sprintf((char *) pname, "rs_remser_%s", id);
/* Init of errh */
errh_Init((char *) pname, errh_eAnix_remote);
errh_SetStatus(PWR__SRVSTARTUP);
/* Set debug mode if arg number 4 is "debug" (started manually) */
debug = 0;
if (argc >= 4) {
if (!strncmp(argv[3],"debug",5)) debug = 1;
}
if (debug) printf("debugmode valt\n");
/* Init of gdh */
sts = gdh_Init((char *) pname);
if ( EVEN(sts)) {
errh_Error("gdh_Init, %m", sts);
errh_SetStatus(PWR__SRVTERM);
exit(sts);
}
/* Arg number 3 should be my remnodes objid in string representation,
read it, convert to real objid and store in remnode_item */
sts = 0;
if (argc >= 3) sts = cdh_StringToObjid(argv[2], &rn.objid);
if ( EVEN(sts)) {
errh_Error("cdh_StringToObjid, %m", sts);
errh_SetStatus(PWR__SRVTERM);
exit(sts);
}
/* Get pointer to RemnodeSerial object and store locally */
sts = gdh_ObjidToPointer(rn.objid, (pwr_tAddress *) &rn_serial);
if ( EVEN(sts)) {
errh_Error("cdh_ObjidToPointer, %m", sts);
errh_SetStatus(PWR__SRVTERM);
exit(sts);
}
/* Initialize some internal data and make standard remtrans init */
rn.next = NULL;
rn.local = NULL; // We dont use local structure since we only have one remnode
rn.retransmit_time = 10.0; // Not used, but initialize anyway
rn_serial->ErrCount = 0;
sts = RemTrans_Init(&rn);
if ( EVEN(sts)) {
errh_Error("RemTrans_Init, %m", sts);
errh_SetStatus(PWR__SRVTERM);
exit(sts);
}
time_since_scan = 0;
time_since_rcv = 0;
/* Store remtrans objects objid in remnode_serial object */
remtrans = rn.remtrans;
i = 0;
while(remtrans) {
rn_serial->RemTransObjects[i++] = remtrans->objid;
if ( i >= (int)(sizeof(rn_serial->RemTransObjects)/sizeof(rn_serial->RemTransObjects[0])))
break;
remtrans = (remtrans_item *) remtrans->next;
}
/* Initialize device */
ser_fd = RemUtils_InitSerialDev(rn_serial->DevName,
rn_serial->Speed,
rn_serial->DataBits,
rn_serial->StopBits,
rn_serial->Parity);
if (!ser_fd) {
errh_Error("InitDev, %d", ser_fd);
errh_SetStatus(PWR__SRVTERM);
exit(0);
}
/* Loop forever */
while (1)
{
if (rn_serial->Disable == 1) {
errh_Fatal("Disabled, exiting");
errh_SetStatus(PWR__SRVTERM);
exit(0);
}
sts = Receive();
sts = RemTrans_Cyclic(&rn, &remnode_send);
}
}
/*
* Class: jpwr_rt_Qcom
* Method: createIniEventQ
* Signature: ()Ljpwr/rt/QcomrCreateQ;
*/
JNIEXPORT jobject JNICALL Java_jpwr_rt_Qcom_createIniEventQ
(JNIEnv *env, jobject object, jstring jname)
{
jclass qcomrCreateQ_id;
jmethodID qcomrCreateQ_cid;
jobject return_obj;
jint jsts;
qcom_sQid qid = qcom_cNQid;
qcom_sQattr qAttr;
qcom_sQid qini;
int sts;
char *cstr;
const char *name;
qcomrCreateQ_id = (*env)->FindClass( env, "jpwr/rt/QcomrCreateQ");
qcomrCreateQ_cid = (*env)->GetMethodID( env, qcomrCreateQ_id,
"<init>", "(III)V");
name = (*env)->GetStringUTFChars( env, jname, 0);
cstr = (char *)name;
//printf("%s\n", cstr);
// Create a queue to receive stop and restart events
if (!qcom_Init(&sts, 0, cstr)) {
errh_Fatal("qcom_Init, %m", sts);
errh_SetStatus( PWR__APPLTERM);
exit(sts);
}
qAttr.type = qcom_eQtype_private;
qAttr.quota = 100;
if (!qcom_CreateQ(&sts, &qid, &qAttr, cstr)) {
errh_Fatal("qcom_CreateQ, %m", sts);
errh_SetStatus( PWR__APPLTERM);
exit(sts);
}
(*env)->ReleaseStringUTFChars( env, jname, cstr);
//printf( "Create que, qix %d, nid %d, sts %d\n", qid.qix, qid.nid, sts);
jsts = (jint) sts;
return_obj = (*env)->NewObject( env, qcomrCreateQ_id,
qcomrCreateQ_cid, qid.qix, qid.nid, jsts);
qini = qcom_cQini;
if (!qcom_Bind(&sts, &qid, &qini)) {
errh_Fatal("qcom_Bind(Qini), %m", sts);
errh_SetStatus( PWR__APPLTERM);
exit(-1);
}
return return_obj;
}
int main (int argc, char ** argv)
{
pwr_tStatus sts;
qcom_sQid my_q = qcom_cNQid;
qcom_sGet get;
errh_Init("pwr_linksup", errh_eAnix_linksup);
errh_SetStatus( PWR__SRVSTARTUP);
if (!qcom_Init(&sts, NULL, "pwr_linksup")) {
errh_Error("qcom_Init, %m", sts);
errh_SetStatus( PWR__SRVTERM);
exit(sts);
}
sts = gdh_Init("pwr_linksup");
if (EVEN(sts)) {
errh_Fatal("gdh_Init, %m", sts);
errh_SetStatus( PWR__SRVTERM);
exit(sts);
}
if (!qcom_CreateQ(&sts, &my_q, NULL, "events")) {
errh_Fatal("qcom_CreateQ, %m", sts);
errh_SetStatus( PWR__SRVTERM);
exit(sts);
}
if (!qcom_Bind(&sts, &my_q, &qcom_cQini)) {
errh_Fatal("qcom_Bind(Qini), %m", sts);
errh_SetStatus( PWR__SRVTERM);
exit(-1);
}
/* Wait for local nethandler to start */
while (EVEN(gdh_NethandlerRunning()))
sleep(1);
plc_UtlWaitForPlc();
LstIni(&node_l);
LstIni(&timer_l);
init_nodes();
if (!LstEmp(&node_l)) {
list_state = eListState_Scan;
} else {
errh_Info("No nodes to supervise, exiting");
errh_SetStatus( pwr_cNStatus);
exit(0);
}
errh_SetStatus( PWR__SRUN);
for (;;) {
scan_timers();
scan_nodes();
get.data = NULL;
if (qcom_Get(&sts, &my_q, &get, cTimerTimeScan) != NULL) {
if (get.type.b == qcom_eBtype_event) {
event(&get);
} else {
errh_Info("unexpected message type, type: %d", get.type.b);
}
qcom_Free(&sts, get.data);
}
aproc_TimeStamp(((float)cTimerTimeScan)/1000, 5);
}
}
int
main ()
{
pwr_tStatus sts;
pwr_tObjid oid;
qcom_sQid my_q = qcom_cNQid;
qcom_sGet get;
pwr_tBoolean firstTime = TRUE;
pwr_tUInt32 nrOfEvents = 0;
pwr_tUInt32 nrOfKeys = 0;
errh_Init("pwr_elog", errh_eAnix_elog);
errh_SetStatus( PWR__SRVSTARTUP);
memset(&lHelCB, 0, sizeof(lHelCB));
/* Declare process */
sts = gdh_Init("pwr_elog");
If_Error_Log_Exit(sts, "gdh_Init");
Init();
/* Create queue for receival of events */
if (!qcom_CreateQ(&sts, &my_q, NULL, "events")) {
errh_Fatal("qcom_CreateQ, %m", sts);
errh_SetStatus( PWR__APPLTERM);
exit(sts);
}
if (!qcom_Bind(&sts, &my_q, &qcom_cQini)) {
errh_Fatal("qcom_Bind(Qini), %m", sts);
errh_SetStatus( PWR__APPLTERM);
exit(-1);
}
oid.vid = lHelCB.Nid;
oid.oix = pwr_cNVolumeId;
sts = mh_OutunitConnect(
oid,
mh_eOutunitType_Logger,
mh_mOutunitFlags_ReadWait,
(mh_cbOutunitAck)Insert,
(mh_cbOutunitAlarm)Insert,
(mh_cbOutunitBlock)Insert,
(mh_cbOutunitCancel)Insert,
NULL,
NULL,
(mh_cbOutunitInfo)Insert,
(mh_cbOutunitReturn)Insert,
NULL
);
If_Error_Log_Exit(sts, "mh_OutunitConnect");
sts = mh_OutunitSetTimeout(lHelCB.ScanTime);
errh_SetStatus( PWR__SRUN);
for (;;) {
sts = mh_OutunitReceive();
if (EVEN(sts) && sts != MH__TMO)
Log_Error(sts, "mh_OutunitReceive");
Store(&firstTime, &nrOfEvents, &nrOfKeys);
get.data = NULL;
qcom_Get(&sts, &my_q, &get, 0);
if (sts != QCOM__TMO && sts != QCOM__QEMPTY) {
if (get.type.b == qcom_eBtype_event) {
qcom_sEvent *ep = (qcom_sEvent*) get.data;
ini_mEvent new_event;
if (get.type.s == qcom_cIini) {
new_event.m = ep->mask;
if (new_event.b.terminate) {
errh_SetStatus( PWR__APPLTERM);
exit(0);
}
}
}
qcom_Free(&sts, get.data);
}
aproc_TimeStamp( lHelCB.ScanTime/1000, 5.0);
}
}
int main(int argc, char *argv[])
{
remtrans_item *remtrans;
unsigned char id[32];
unsigned char pname[32];
pwr_tStatus sts;
struct timeval tv;
int i;
/* Read arg number 2, should be id for this instance */
if (argc >= 2)
strcpy((char *)id, argv[1]);
else
strcpy((char *)id, "0");
/* Build process name with id */
sprintf((char *) pname, "rs_remudp_%s", id);
/* Init of errh */
errh_Init((char *) pname, errh_eAnix_remote);
errh_SetStatus(PWR__SRVSTARTUP);
/* Init of gdh */
sts = gdh_Init((char *) pname);
if ( EVEN(sts)) {
errh_Error("gdh_Init, %m", sts);
errh_SetStatus(PWR__SRVTERM);
exit(sts);
}
/* Arg number 3 should be my remnodes objid in string representation,
read it, convert to real objid and store in remnode_item */
sts = 0;
if (argc >= 3) sts = cdh_StringToObjid(argv[2], &rn.objid);
if ( EVEN(sts)) {
errh_Error("cdh_StringToObjid, %m", sts);
errh_SetStatus(PWR__SRVTERM);
exit(sts);
}
/* Get pointer to RemnodeUDP object and store locally */
sts = gdh_ObjidToPointer(rn.objid, (pwr_tAddress *) &rn_udp);
if ( EVEN(sts)) {
errh_Error("cdh_ObjidToPointer, %m", sts);
errh_SetStatus(PWR__SRVTERM);
exit(sts);
}
/* Initialize some internal data and make standard remtrans init */
rn.next = NULL;
rn.local = NULL; // We dont use local structure since we only have one remnode
rn.retransmit_time = rn_udp->RetransmitTime;
rn_udp->ErrCount = 0;
sts = RemTrans_Init(&rn);
/* Log that we will multicast */
if (rn.multicast) {
errh_Info("Will send to dual address: %d.%d.%d.%d",
rn.multicast->Address[0],
rn.multicast->Address[1],
rn.multicast->Address[2],
rn.multicast->Address[3]);
}
if ( EVEN(sts)) {
errh_Error("RemTrans_Init, %m", sts);
errh_SetStatus(PWR__SRVTERM);
exit(sts);
}
/* Store remtrans objects objid in remnode_udp object */
remtrans = rn.remtrans;
i = 0;
while(remtrans) {
rn_udp->RemTransObjects[i++] = remtrans->objid;
if ( i >= (int)(sizeof(rn_udp->RemTransObjects)/sizeof(rn_udp->RemTransObjects[0])))
break;
remtrans = (remtrans_item *) remtrans->next;
}
/* Initialize no timeout value (poll) for select call */
tv.tv_sec = 0;
tv.tv_usec = 0;
/* Create UDP socket and init adress structures */
CreateSocket();
/* Wait for one cycle */
RemoteSleep(rn_udp->ScanTime);
/* Set running status */
errh_SetStatus(PWR__SRUN);
/* Set (re)start time in remnode object */
time_GetTime(&rn_udp->RestartTime);
/* Loop forever */
while (!doomsday)
{
/* Check disable flag */
if (rn_udp->Disable == 1) {
errh_Fatal("Disabled, exiting");
errh_SetStatus(PWR__SRVTERM);
exit(0);
}
/* Timestamp */
aproc_TimeStamp(TIME_INCR, 5);
RemoteSleep(TIME_INCR);
/* Increase time counters in local remnode and prevent big counters */
time_since_scan += TIME_INCR;
time_since_keepalive += TIME_INCR;
time_since_rcv += TIME_INCR;
time_since_scan = min(time_since_scan, rn_udp->ScanTime + 1.0);
time_since_keepalive = min(time_since_keepalive, rn_udp->KeepaliveTime + 1.0);
time_since_rcv = min(time_since_rcv, rn_udp->LinkTimeout + 1.0);
/* Update retransmit time, could have been changed */
rn.retransmit_time = rn_udp->RetransmitTime;
remtrans = rn.remtrans;
while(remtrans) {
remtrans->time_since_send += TIME_INCR;
/* Prevent big counter */
remtrans->time_since_send = min(remtrans->time_since_send, rn.retransmit_time + 1.0);
remtrans = (remtrans_item *) remtrans->next;
}
tv.tv_sec = 0;
tv.tv_usec = 0;
FD_ZERO(&fds);
FD_SET(my_socket, &fds);
sts = select(32, &fds, NULL, NULL, &tv);
if (sts > 0) Receive();
if (sts < 0) {
errh_Error("Select, %d", sts);
errh_SetStatus(PWR__SRVTERM);
exit(0);
}
if (time_since_scan >= rn_udp->ScanTime) {
if (!rn_udp->Disable) RemTrans_Cyclic(&rn, &RemnodeSend);
time_since_scan = 0;
}
if (time_since_keepalive >= rn_udp->KeepaliveTime) {
if (!rn_udp->Disable && rn_udp->UseKeepalive) SendKeepalive();
time_since_keepalive = 0;
}
if (time_since_rcv >= rn_udp->LinkTimeout && rn_udp->LinkTimeout > 0) {
if (rn_udp->LinkUp) {
errh_Info("UDP link down %s", rn_udp->RemoteHostname);
rn_udp->LinkUp = 0;
}
}
}
}
static pwr_tStatus
init_plc (
plc_sProcess *pp
)
{
pwr_tStatus sts = PLC__SUCCESS;
pwr_tObjid oid;
pwr_tObjid pp_oid;
pwr_tObjid io_oid;
pwr_tObjid thread_oid;
int sec;
int msec;
int i;
pwr_tCid cid;
sts = gdh_GetNodeObject(0, &oid);
if (EVEN(sts)) {
errh_Fatal("gdh_GetNodeObject, %m", sts);
exit(sts);
}
sts = gdh_ObjidToPointer(oid, (void *)&pp->Node);
if (EVEN(sts)) return sts;
sts = gdh_GetClassList(pwr_cClass_PlcProcess, &pp_oid);
if (EVEN(sts)) {
errh_Error("Found no PlcProcess-object\n%m", sts);
return sts;
}
sts = gdh_ObjidToPointer(pp_oid, (void *)&pp->PlcProcess);
if (EVEN(sts)) return sts;
i = 0;
sts = gdh_GetChild( pp_oid, &thread_oid);
while ( ODD(sts)) {
sts = gdh_GetObjectClass( thread_oid, &cid);
if ( EVEN(sts)) return sts;
if ( cid == pwr_cClass_PlcThread)
pp->PlcProcess->PlcThreadObjects[i++] = thread_oid;
sts = gdh_GetNextSibling( thread_oid, &thread_oid);
}
for ( ; i > sizeof(pp->PlcProcess->PlcThreadObjects)/sizeof(pp->PlcProcess->PlcThreadObjects[0]); i++)
pp->PlcProcess->PlcThreadObjects[i] = pwr_cNObjid;
aproc_RegisterObject( pp_oid);
sts = gdh_GetClassList(pwr_cClass_IOHandler, &io_oid);
if (EVEN(sts)) {
errh_Error("Found no IOHandler-object\n%m", sts);
return sts;
}
sts = gdh_ObjidToPointer(io_oid, (void *)&pp->IOHandler);
if (EVEN(sts)) return sts;
/* Set subscription defaults for PLC job */
sts = gdh_SetSubscriptionDefaults(
(pwr_tInt32)(pp->PlcProcess->SubscriptionInterval * 1000.), 10000);
sec = pp->PlcProcess->SubscriptionInterval;
msec = (int)((pp->PlcProcess->SubscriptionInterval - sec) * 1000.);
errh_Info("Setting subscription defaults to %d.%03d seconds", sec, msec);
sts = gdh_ObjidToName(oid, pp->nodeName, sizeof(pp->nodeName), cdh_mNName);
if (EVEN(sts)) return sts;
init_grafcet(pp);
link_io_base_areas(pp);
return sts;
}
int main(int argc, char* argv[])
{
remtrans_item* remtrans;
unsigned char id[32];
unsigned char pname[32];
pwr_tStatus sts;
int i;
float time_since_scan = 0.0;
/* Read arg number 2, should be id for this instance and id is our queue
* number */
if (argc >= 2)
strcpy((char*)id, argv[1]);
else
strcpy((char*)id, "0");
/* Build process name with id */
sprintf((char*)pname, "rs_remrabbitmq_%s", id);
/* Init of errh */
errh_Init((char*)pname, errh_eAnix_remote);
errh_SetStatus(PWR__SRVSTARTUP);
/* Init of gdh */
if (debug)
printf("Before gdh_init\n");
sts = gdh_Init((char*)pname);
if (EVEN(sts)) {
errh_Fatal("gdh_Init, %m", sts);
errh_SetStatus(PWR__SRVTERM);
exit(sts);
}
/* Arg number 3 should be my remnodes objid in string representation,
read it, convert to real objid and store in remnode_item */
sts = 0;
if (argc >= 3)
sts = cdh_StringToObjid(argv[2], &rn.objid);
if (EVEN(sts)) {
errh_Fatal("cdh_StringToObjid, %m", sts);
errh_SetStatus(PWR__SRVTERM);
exit(sts);
}
/* Get pointer to RemnodeRabbitMQ object and store locally */
sts = gdh_ObjidToPointer(rn.objid, (pwr_tAddress*)&rn_rmq);
if (EVEN(sts)) {
errh_Fatal("cdh_ObjidToPointer, %m", sts);
errh_SetStatus(PWR__SRVTERM);
exit(sts);
}
if (streq(rn_rmq->ReceiveQueue, "")
&& streq(rn_rmq->SendQueue, "")) {
errh_Fatal(
"Process terminated, neither send or receive queue configured, %s", id);
errh_SetStatus(PWR__SRVTERM);
exit(sts);
}
/* Create context */
ctx = calloc(1, sizeof(*ctx));
ctx->op = rn_rmq;
if (!streq(rn_rmq->ReceiveQueue, ""))
ctx->is_consumer = 1;
if (!streq(rn_rmq->SendQueue, ""))
ctx->is_producer = 1;
/* Initialize some internal data and make standard remtrans init */
rn.next = NULL;
rn.local = NULL; // We dont use local structure since we only have one remnode
rn_rmq->ErrCount = 0;
if (debug)
printf("Before remtrans_init\n");
sts = RemTrans_Init(&rn);
if (EVEN(sts)) {
errh_Fatal("RemTrans_Init, %m", sts);
errh_SetStatus(PWR__SRVTERM);
exit(sts);
}
/* Store remtrans objects objid in remnode_qcom object */
remtrans = rn.remtrans;
i = 0;
while (remtrans) {
rn_rmq->RemTransObjects[i++] = remtrans->objid;
if (i >= (int)(sizeof(rn_rmq->RemTransObjects)
/ sizeof(rn_rmq->RemTransObjects[0])))
break;
remtrans = (remtrans_item*)remtrans->next;
}
/* Connect to rabbitmq broker */
sts = rmq_connect();
if (EVEN(sts)) {
rmq_close(1);
errh_Fatal("Process terminated, unable to connect to RabbitMQ, %s", id);
errh_SetStatus(PWR__SRVTERM);
exit(sts);
}
/* Set running status */
errh_SetStatus(PWR__SRUN);
/* Set (re)start time in remnode object */
time_GetTime(&rn_rmq->RestartTime);
/* Loop forever */
while (!doomsday) {
if (rn_rmq->Disable == 1) {
errh_Fatal("Disabled, exiting");
errh_SetStatus(PWR__SRVTERM);
exit(0);
}
aproc_TimeStamp(TIME_INCR, 5);
if (ctx->is_consumer)
sts = rmq_receive();
else
RemoteSleep(TIME_INCR);
time_since_scan += TIME_INCR;
if (time_since_scan >= rn_rmq->ScanTime) {
if (ctx->is_producer)
sts = RemTrans_Cyclic(&rn, &rmq_send);
time_since_scan = 0.0;
}
}
}
int main(int argc, char *argv[])
{
remtrans_item *remtrans;
unsigned char id[32];
unsigned char pname[32];
pwr_tStatus sts;
int i;
float time_since_scan = 0.0;
/* Read arg number 2, should be id for this instance and id is our queue number */
if (argc >= 2)
strcpy((char *)id, argv[1]);
else
strcpy((char *)id, "0");
/* Build process name with id */
sprintf((char *) pname, "rs_remwmq_%s", id);
/* Init of errh */
errh_Init((char *) pname, errh_eAnix_remote);
errh_SetStatus(PWR__SRVSTARTUP);
/* Init of gdh */
if (debug) printf("Before gdh_init\n");
sts = gdh_Init((char *) pname);
if ( EVEN(sts)) {
errh_Fatal("gdh_Init, %m", sts);
errh_SetStatus(PWR__SRVTERM);
exit(sts);
}
/* Arg number 3 should be my remnodes objid in string representation,
read it, convert to real objid and store in remnode_item */
sts = 0;
if (argc >= 3) sts = cdh_StringToObjid(argv[2], &rn.objid);
if ( EVEN(sts)) {
errh_Fatal("cdh_StringToObjid, %m", sts);
errh_SetStatus(PWR__SRVTERM);
exit(sts);
}
/* Get pointer to RemnodeWMQ object and store locally */
sts = gdh_ObjidToPointer(rn.objid, (pwr_tAddress *) &rn_wmq);
if ( EVEN(sts)) {
errh_Fatal("cdh_ObjidToPointer, %m", sts);
errh_SetStatus(PWR__SRVTERM);
exit(sts);
}
/* Initialize some internal data and make standard remtrans init */
rn.next = NULL;
rn.local = NULL; // We dont use local structure since we only have one remnode
rn_wmq->ErrCount = 0;
if (debug) printf("Before remtrans_init\n");
sts = RemTrans_Init(&rn);
if ( EVEN(sts)) {
errh_Fatal("RemTrans_Init, %m", sts);
errh_SetStatus(PWR__SRVTERM);
exit(sts);
}
/* Store remtrans objects objid in remnode_mq object */
remtrans = rn.remtrans;
i = 0;
while(remtrans) {
rn_wmq->RemTransObjects[i++] = remtrans->objid;
if ( i >= (int)(sizeof(rn_wmq->RemTransObjects) / sizeof(rn_wmq->RemTransObjects[0])))
break;
remtrans = (remtrans_item *) remtrans->next;
}
/* Variables for MQ calls */
strncpy(mgr_name, rn_wmq->QueueManager, MQ_Q_MGR_NAME_LENGTH);
// strncpy(mgr_name, "hejsanqqq", sizeof(MQ_Q_MGR_NAME_LENGTH));
/* Open queue for receiving messages */
strncpy(rcv_que_name, rn_wmq->RcvQueue, MQ_Q_NAME_LENGTH);
// strncpy(rcv_que_name, "hejsanqqq", sizeof(MQ_Q_NAME_LENGTH));
/* Initialize object descriptor control block */
strncpy(RcvObjDesc.ObjectName, rcv_que_name, MQ_Q_NAME_LENGTH);
/* open queue for input but not if MQM stopping */
RcvOpenOptions = MQOO_INPUT_AS_Q_DEF | MQOO_FAIL_IF_QUIESCING;
/* Open queue for sending messages */
strncpy(snd_que_name, rn_wmq->SndQueue, MQ_Q_NAME_LENGTH);
// strncpy(snd_que_name, "hejsanqqq", sizeof(MQ_Q_NAME_LENGTH));
/* Initialize object descriptor control block */
strncpy(SndObjDesc.ObjectName, snd_que_name, MQ_Q_NAME_LENGTH);
/* open queue for output but not if MQM stopping */
SndOpenOptions = MQOO_OUTPUT | MQOO_FAIL_IF_QUIESCING;
errh_SetStatus(PWR__SRUN);
/* Connect and open */
sts = wmq_connectandopen();
/* Set (re)start time in remnode object */
time_GetTime(&rn_wmq->RestartTime);
/* Loop forever */
while (!doomsday) {
if (rn_wmq->Disable == 1) {
errh_Fatal("Disabled, exiting");
errh_SetStatus(PWR__SRVTERM);
exit(0);
}
aproc_TimeStamp(TIME_INCR, 5);
RemoteSleep(TIME_INCR);
time_since_scan += TIME_INCR;
if (!connected)
sts = wmq_connectandopen();
if (connected) {
sts = wmq_receive();
if (time_since_scan >= rn_wmq->ScanTime) {
sts = RemTrans_Cyclic(&rn, &wmq_send);
time_since_scan = 0.0;
}
}
}
}
int main(int argc, char** argv)
{
pwr_tStatus sts;
io_tCtx io_ctx;
float ctime = 1;
pwr_sClass_EplHandler* plhp;
pwr_tOid oid;
int tmo;
char mp[2000];
qcom_sGet get;
qcom_sQattr qAttr;
qcom_sQid qini;
qcom_sQid qid = qcom_cNQid;
if (argc > 1) {
if (streq(argv[1], "-m")) {
io_methods_print();
exit(0);
}
if (streq(argv[1], "-h")) {
usage();
exit(0);
}
}
// Make connection to error handler
errh_Init("pwr_powerlink", errh_eAnix_powerlink);
errh_SetStatus(PWR__SRVSTARTUP);
if (!qcom_Init(&sts, 0, "pwr_powerlink")) {
errh_Fatal("qcom_Init, %m", sts);
exit(sts);
}
qAttr.type = qcom_eQtype_private;
qAttr.quota = 100;
if (!qcom_CreateQ(&sts, &qid, &qAttr, "events")) {
errh_Fatal("qcom_CreateQ, %m", sts);
exit(sts);
}
qini = qcom_cQini;
if (!qcom_Bind(&sts, &qid, &qini)) {
errh_Fatal("qcom_Bind(Qini), %m", sts);
exit(-1);
}
// Make connection to realtime database
sts = gdh_Init("rt_powerlink");
if (EVEN(sts)) {
errh_Fatal("rt_powerlink aborted, gdh_Init failed\n%m", sts);
errh_SetStatus(PWR__SRVTERM);
exit(sts);
}
sts = gdh_GetClassList(pwr_cClass_Epl_CNServer, &oid);
if (ODD(sts)) {
system("rt_powerlink_cn &");
exit(0);
}
// Get Powerlink handler object
sts = io_get_plhandler_object(&plhp, &oid);
if (EVEN(sts)) {
errh_SetStatus(0);
errh_Info("rt_powerlink terminated, no EplHandler object found");
exit(sts);
}
// Create context and call init functions of all agent,
// rack and cardobjects
sts = io_init(io_mProcess_Powerlink, pwr_cNObjid, &io_ctx, 1, ctime);
if (EVEN(sts)) {
errh_SetStatus(PWR__SRVTERM);
errh_Fatal("rt_powerlink aborted, io_init() failed\n%m", sts);
exit(sts);
}
tmo = (plhp->CycleTime) * 1000;
aproc_TimeStamp(plhp->CycleTime, 5.0);
errh_SetStatus(PWR__SRUN);
aproc_RegisterObject(oid);
// Call IoAgentRead() IoAgentWrite() IoCardRead() IoCardWrite()
// IoModuleRead() IoModuleWrite() forever
for (;;) {
get.maxSize = sizeof(mp);
get.data = mp;
qcom_Get(&sts, &qid, &get, tmo);
if (sts == QCOM__TMO || sts == QCOM__QEMPTY) {
sts = io_read(io_ctx);
sts = io_write(io_ctx);
aproc_TimeStamp(plhp->CycleTime, 5.0);
} else {
ini_mEvent new_event;
qcom_sEvent* ep = (qcom_sEvent*)get.data;
new_event.m = ep->mask;
if (new_event.b.oldPlcStop) {
// TODO
} else if (new_event.b.swapDone) {
// TODO
} else if (new_event.b.terminate) {
// io_close(io_ctx);
exit(0);
}
}
}
}
void
pwrs_Node_Exec (
)
{
int i;
pwr_tTime current_time;
pwr_tDeltaTime diff;
errh_eSeverity severity;
errh_eSeverity system_severity;
errh_eSeverity plc_severity;
int new_idx = -1;
static int supervise[80] = {
0,0,0,0,1,1,1,0,1,1,
1,1,1,0,0,1,0,1,1,1,
1,1,1,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,
1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1};
static int reboot_done = 0;
if ( !np) {
pwr_tOid oid;
pwr_tStatus sts;
sts = gdh_GetNodeObject( 0, &oid);
if ( ODD(sts))
gdh_ObjidToPointer( oid, (void **) &np);
if ( EVEN(sts)) return;
}
if ( !np)
return;
if ( np->EmergBreakTrue) {
switch ( np->EmergBreakSelect) {
case 1: {
/* Reboot */
int sts;
if ( !reboot_done) {
errh_Fatal( "Emergency break action: reboot");
sts = system("rt_prio --reboot");
if ( sts != 0)
errh_Fatal("Unable to reboot, sts %d", sts);
reboot_done = 1;
}
break;
}
default: ;
}
}
else
reboot_done = 0;
/* Calculate plc status */
new_idx = -1;
plc_severity = errh_Severity( np->ProcStatus[errh_eAnix_plc-1]);
for ( i = errh_eAnix_plc1 - 1; i < errh_eAnix_plc1 - 1 + errh_cAnix_PlcSize; i++) {
severity = errh_Severity( np->ProcStatus[i]);
if ( np->ProcStatus[i] != 0 && EVEN(np->ProcStatus[i])) {
if ( severity >= plc_severity) {
new_idx = i;
plc_severity = severity;
}
}
}
if ( new_idx != -1)
np->ProcStatus[errh_eAnix_plc-1] = np->ProcStatus[new_idx];
else if ( EVEN(np->ProcStatus[errh_eAnix_plc-1]))
np->ProcStatus[errh_eAnix_plc-1] = PWR__SRUN;
/* Calculate system status and check timestamp */
new_idx = -1;
system_severity = errh_Severity( np->SystemStatus);
time_GetTime( ¤t_time);
for ( i = 0; i < sizeof(np->ProcStatus)/sizeof(np->ProcStatus[0]); i++) {
if ( np->ProcStatus[i] != 0 && supervise[i]) {
time_Adiff( &diff, &np->ProcTimeStamp[i], ¤t_time);
if ( time_Dcomp( &diff, 0) < 0) {
if ( errh_Severity( np->ProcStatus[i]) < errh_Severity(PWR__PTIMEOUT))
np->ProcStatus[i] = PWR__PTIMEOUT;
}
else if ( np->ProcStatus[i] == PWR__PTIMEOUT) {
np->ProcStatus[i] = (i < errh_cAnix_SrvSize) ? PWR__SRUN : PWR__ARUN;
}
}
severity = errh_Severity( np->ProcStatus[i]);
if ( np->ProcStatus[i] != 0 && EVEN(np->ProcStatus[i])) {
if ( severity >= system_severity) {
new_idx = i;
system_severity = severity;
}
}
}
if ( new_idx != -1)
np->SystemStatus = np->ProcStatus[new_idx];
else if ( EVEN(np->SystemStatus))
np->SystemStatus = PWR__RUNNING;
}
int main(int argc, char *argv[]) /*argv[2]=remnode name*/
{
unsigned int sts; /* Status from function calls etc. */
unsigned char id[32];
unsigned char pname[32];
remtrans_item *remtrans;
int i;
char first;
pssupd_buffer_vnet buff; /* Buffer for 'hello' */
pssupd_order_header *header; /* Header for 'hello' */
char name[80];
/* Read arg number 2, should be id for this instance */
if (argc >= 2)
strcpy((char *) id, argv[1]);
else
strcpy((char *) id, "0");
/* Build process name with id */
sprintf((char *) pname, "rs_rem3964r_%s", id);
/* Init of errh */
errh_Init((char *) pname, errh_eAnix_remote);
errh_SetStatus(PWR__SRVSTARTUP);
/* Init of gdh */
sts = gdh_Init((char *) pname);
if ( EVEN(sts)) {
errh_Error("gdh_Init, %m", sts);
errh_SetStatus(PWR__SRVTERM);
exit(sts);
}
/* Arg number 3 should be my remnodes objid in string representation,
read it, convert to real objid and store in remnode_item */
sts = 0;
if (argc >= 3) sts = cdh_StringToObjid(argv[2], &rn.objid);
if ( EVEN(sts)) {
errh_Error("cdh_StringToObjid, %m", sts);
errh_SetStatus(PWR__SRVTERM);
exit(sts);
}
/* Get pointer to Remnode3964R object and store locally */
sts = gdh_ObjidToPointer(rn.objid, (pwr_tAddress *) &rn_3964R);
if ( EVEN(sts)) {
errh_Error("cdh_ObjidToPointer, %m", sts);
errh_SetStatus(PWR__SRVTERM);
exit(sts);
}
/* Get name of object to use in sending poll */
sts = gdh_ObjidToName(rn.objid, name, sizeof(name), cdh_mName_object);
name[3] = 'P';
name[4] = 'S';
name[5] = 'S';
name[6] = 0;
RemUtils_AsciiToR50((char *) &name, (short *) &poll_id);
if (debug) printf("%s, %d %d\n", name, poll_id[0], poll_id[1]);
/* Initialize some internal data and make standard remtrans init */
rn.next = NULL;
rn.local = NULL; // We dont use local structure since we only have one remnode
rn.retransmit_time = 10.0; // Not used, but initialize anyway
rn_3964R->ErrCount = 0;
sts = RemTrans_Init(&rn);
if ( EVEN(sts)) {
errh_Error("RemTrans_Init, %m", sts);
errh_SetStatus(PWR__SRVTERM);
exit(sts);
}
sts = RemIO_Init_3964R(&rn);
if ( EVEN(sts)) {
errh_Error("RemIO_Init, %m", sts);
errh_SetStatus(PWR__SRVTERM);
exit(sts);
}
if (rn.remio_data == NULL)
use_remote_io = 0;
else
use_remote_io = 1;
time_since_poll = 0.0;
time_since_io = 0.0;
time_since_scan = 0.0;
/* Store remtrans objects objid in remnode_3964R object */
remtrans = rn.remtrans;
i = 0;
while(remtrans) {
rn_3964R->RemTransObjects[i++] = remtrans->objid;
if ( i >= (int)(sizeof(rn_3964R->RemTransObjects)/sizeof(rn_3964R->RemTransObjects[0])))
break;
remtrans = (remtrans_item *) remtrans->next;
}
/* Initialize device */
ser_fd = RemUtils_InitSerialDev(rn_3964R->DevName,
rn_3964R->Speed,
rn_3964R->DataBits,
rn_3964R->StopBits,
rn_3964R->Parity);
if (!ser_fd) {
errh_Error("InitDev, %d", ser_fd);
errh_SetStatus(PWR__SRVTERM);
exit(0);
}
first = TRUE;
rn_3964R->LinkUp = 1;
/* Loop forever */
while (1)
{
if (rn_3964R->Disable == 1) {
errh_Fatal("Disabled, exiting");
errh_SetStatus(PWR__SRVTERM);
exit(0);
}
// Wait micro time
// Wait cycle time
// timer = (int) (rn_3964R->ScanTime * 1000000.0);
usleep(30000);
Receive();
// time_since_poll += rn_3964R->ScanTime;
// time_since_io += rn_3964R->ScanTime;
time_since_poll += 0.03;
time_since_io += 0.03;
time_since_scan += 0.03;
if (first && use_remote_io) {
/* Send Hello to subsystem if we have poll */
header = (pssupd_order_header *) &buff.data;
header->type = PSS_Switch_Done;
header->size = 0;
header->signal = 0;
buff.no_of_updates = 1;
buff.length = (sizeof(pssupd_buffer_vnet) -
MAX_ORDER_BUFFERSIZE_VNET + sizeof(pssupd_order_header) + 1) / 2;
send_pollbuff(&rn, &buff);
}
// if (debug) printf("Remtrans Cyclic\n");
if (time_since_scan >= rn_3964R->ScanTime) {
if (debug) printf("Remtrans Cyclic\n");
RemTrans_Cyclic(&rn, &remnode_send);
time_since_scan = 0.0;
}
if (use_remote_io) {
if ((rn_3964R->LinkUp && time_since_poll >= rn_3964R->ScanTime*2.0) ||
(!rn_3964R->LinkUp && time_since_poll >= rn_3964R->ScanTime*10.0))
{
if (debug) printf("RemIO Cyclic\n");
sts = RemIO_Cyclic_3964R(&rn, &send_pollbuff);
time_since_poll = 0.0;
}
if (time_since_io >= rn_3964R->LinkTimeout && rn_3964R->LinkTimeout > 0) {
if (debug) printf("RemIO Stall\n");
sts = RemIO_Stall_3964R(&rn, stall_action);
}
}
first = FALSE;
}
}
int main (int argc, char **argv)
{
pwr_tStatus sts;
pwr_tObjid ObjId;
pwr_sClass_DsTrendConf *TConfP;
pwr_tBoolean InitOK;
pwr_tTime CurrentTime, LastScan, NextScan;
pwr_tDeltaTime ScanDeltaTime, WaitTime;
qcom_sQid qini;
qcom_sQattr qAttr;
int tmo;
char mp[2000];
qcom_sQid qid = qcom_cNQid;
qcom_sGet get;
int swap = 0;
trend_tCtx ctx;
errh_Init("pwr_trend", errh_eAnix_trend);
errh_SetStatus( PWR__SRVSTARTUP);
sts = gdh_Init("ds_trend");
If_Error_Log_Exit(sts, "gdh_Init");
if (!qcom_Init(&sts, 0, "pwr_trend")) {
errh_Fatal("qcom_Init, %m", sts);
exit(sts);
}
qAttr.type = qcom_eQtype_private;
qAttr.quota = 100;
if (!qcom_CreateQ(&sts, &qid, &qAttr, "events")) {
errh_Fatal("qcom_CreateQ, %m", sts);
exit(sts);
}
qini = qcom_cQini;
if (!qcom_Bind(&sts, &qid, &qini)) {
errh_Fatal("qcom_Bind(Qini), %m", sts);
exit(-1);
}
ctx = (trend_tCtx) calloc( 1, sizeof(trend_sCtx));
/* Wait until local nethandler has started */
while(EVEN(gdh_NethandlerRunning()))
sleep(1);
/* Fetch ScanTime */
sts = gdh_GetClassList(pwr_cClass_DsTrendConf, &ObjId);
if (EVEN(sts)) {
errh_Info("Couldn't get the DsTrendConf object. Used ScanTime = 1 s");
ctx->scantime = 1;
ctx->scantime_tc = 1.0;
}
else {
gdh_ObjidToPointer(ObjId, (pwr_tAddress *)&TConfP);
ctx->scantime = TConfP->ScanTime;
if ( ctx->scantime > 3600)
ctx->scantime = 3600;
else if ( ctx->scantime < 1)
ctx->scantime = 1;
ctx->scantime_tc = TConfP->ScanTime;
if ( ctx->scantime_tc > 3600)
ctx->scantime_tc = 3600;
}
ctx->dstrend_multiple = (int) (ctx->scantime / ctx->scantime_tc + 0.5);
aproc_RegisterObject( ObjId);
InitOK = FALSE;
sts = InitTrendList( ctx);
if ( EVEN(sts)) {
/* This should be removed when we can wait for init messages. */
errh_SetStatus(0);
errh_Info("No DsTrend objects configured");
exit(0);
}
/* If even sts, just wait for init message */
time_GetTimeMonotonic(&LastScan);
time_FloatToD( &ScanDeltaTime, ctx->scantime_tc);
aproc_TimeStamp( ctx->scantime, 5.0);
errh_SetStatus( PWR__SRUN);
for (;;) {
time_GetTimeMonotonic(&CurrentTime);
time_Aadd(&NextScan, &LastScan, &ScanDeltaTime);
if (time_Acomp(&CurrentTime, &NextScan) < 0) {
time_Adiff(&WaitTime, &NextScan, &CurrentTime);
tmo = 1000 * time_DToFloat( 0, &WaitTime);
get.maxSize = sizeof(mp);
get.data = mp;
qcom_Get( &sts, &qid, &get, tmo);
if (sts == QCOM__TMO || sts == QCOM__QEMPTY) {
if ( !swap)
StoreData( ctx);
}
else {
ini_mEvent new_event;
qcom_sEvent *ep = (qcom_sEvent*) get.data;
new_event.m = ep->mask;
if (new_event.b.oldPlcStop && !swap) {
swap = 1;
errh_SetStatus( PWR__SRVRESTART);
CloseTrendList( ctx);
}
else if (new_event.b.swapDone && swap) {
swap = 0;
sts = InitTrendList( ctx);
errh_SetStatus( PWR__SRUN);
errh_Info("Warm restart completed");
}
else if (new_event.b.terminate) {
exit(0);
}
}
}
else if ( !swap)
StoreData( ctx);
LastScan = NextScan;
aproc_TimeStamp( ctx->scantime, 5.0);
}
return 1;
}
int main()
{
logg_ctx loggctx;
pwr_tStatus sts;
pwr_tUInt32 ident;
char *msg;
logg_t_loggconf_list *conflist_ptr;
int i;
#if defined OS_LYNX || defined OS_LINUX
/* Exit handler */
atexit(&exit_hdlr);
signal(SIGINT, interrupt_hdlr);
#endif
sts = gdh_Init("rs_remote_logg");
if (EVEN(sts)) LogAndExit(sts);
/* Errh init */
errh_Init("rs_remote_logg", 0);
/* Initialize qcom que attributes */
remlogg_qattr.type = qcom_eQtype_private;
remlogg_qattr.quota = 100;
/* Delete the queue if it exists */
qcom_DeleteQ(&sts, &remlogg_qid);
/* Create the remlogg queue */
if (!qcom_CreateQ(&sts, &remlogg_qid, &remlogg_qattr, "Logg")) {
LogAndExit(sts);
}
/* Bind it to rt_ini event-queue */
if (!qcom_Bind(&sts, &remlogg_qid, &qcom_cQini)) {
errh_Fatal("qcom_Bind, %m", sts);
// errh_SetStatus( PWR__SRVTERM);
exit(-1);
}
loggctx = calloc( 1 , sizeof( *loggctx));
if ( loggctx == 0 ) LogAndExit( REM__NOMEMORY);
sts = logg_init( loggctx);
if ( EVEN(sts)) LogAndExit(sts);
for (;;)
{
/* Get logg message */
sts = logg_get_message( loggctx, &ident, &msg);
if ( EVEN(sts))
{
Log( REM__LOGGRCV, sts);
}
else if ( sts != REM__TIMEOUT)
{
logg_print( loggctx, ident, msg);
sts = logg_free_message();
}
/* Check if its time to open any file... */
conflist_ptr = loggctx->loggconflist;
for ( i = 0; i < loggctx->loggconf_count; i++)
{
if ( conflist_ptr->loggconf->NewVersion)
{
conflist_ptr->loggconf->NewVersion = 0;
if ( conflist_ptr->file_open)
{
fclose( conflist_ptr->outfile);
conflist_ptr->file_open = 0;
sts = logg_open_file( conflist_ptr, 1);
}
}
else if ( !conflist_ptr->file_open)
{
sts = logg_open_file( conflist_ptr, 0);
}
conflist_ptr++;
}
}
}
int main (int argc, char **argv)
{
pwr_tStatus sts;
unsigned int size;
qcom_sQid myQId;
alimsrv_sSupDataBuf *bp;
qcom_sGet get;
qcom_sPut put;
alimsrv_sRequest request;
XDR xdrs;
qcom_sQattr qAttr;
errh_Init("pwr_alim", errh_eAnix_alim);
errh_SetStatus( PWR__SRVSTARTUP);
if (!qcom_Init(&sts, 0, "pwr_alim")) {
errh_Fatal("qcom_Init, %m", sts);
exit(-1);
}
myQId.qix = alimsrv_cQix;
myQId.nid = 0;
qAttr.type = qcom_eQtype_private;
qAttr.quota = 100;
if (!qcom_CreateQ(&sts, &myQId, &qAttr, "pwr_alim")) {
errh_Fatal("qcom_CreateQ, %m", sts);
errh_SetStatus( PWR__SRVTERM);
exit(-1);
}
if (!qcom_Bind(&sts, &myQId, &qcom_cQini)) {
errh_Fatal("qcom_Bind, %m", sts);
errh_SetStatus( PWR__SRVTERM);
exit(-1);
}
sts = gdh_Init("pwr_alim");
if (EVEN(sts)) {
errh_Fatal("gdh_Init, %m", sts);
errh_SetStatus( PWR__SRVTERM);
exit(-1);
}
init();
errh_SetStatus( PWR__SRUN);
/* Loop forever and receive objid's */
for (;;) {
do {
get.maxSize = sizeof(request);
get.data = (char *)&request;
qcom_Get(&sts, &myQId, &get, qcom_cTmoEternal);
if (sts != QCOM__TMO && sts != QCOM__QEMPTY) {
if (get.type.b == qcom_eBtype_event) {
event(&get);
}
}
} while (ODD(sts) && get.type.s != alimsrv_eSubType_Request && get.type.b != alimsrv_cMsgType);
if (EVEN(sts)) {
errh_Error("qcom_Get, %m",sts);
continue;
}
if (request.Xdr) {
xdrmem_create(&xdrs, (char *)&request, sizeof(request), XDR_DECODE);
if (!xdr_alimsrv_sRequest(&xdrs, &request)) {
errh_Error("XDR Decode failed");
continue;
}
}
bp = buildBuffer(&request, &size);
if (ODD(sts)) {
bp->Xdr = TRUE;
xdrmem_create(&xdrs, (char *)bp, size, XDR_ENCODE);
if (!xdr_alimsrv_sSupDataBuf(&xdrs, bp)) {
errh_Error("XDR Encode failed");
} else {
put.type.b = alimsrv_cMsgType;
put.type.s = alimsrv_eSubType_Answer;
put.reply = myQId;
put.data = (char *) bp;
put.size = size;
if (!qcom_Reply(&sts, &get, &put))
errh_Error("qcom_Respond, %m", sts);
}
free(bp);
}
}
}
//---------------------------------------------------------------------------
//
// Function: AppCbEvent
//
// Description: event callback function called by EPL API layer within
// user part (low priority).
//
// Parameters: EventType_p = event type
// pEventArg_p = pointer to union, which describes
// the event in detail
// pUserArg_p = user specific argument
//
// Returns: tEplKernel = error code,
// kEplSuccessful = no error
// kEplReject = reject further processing
// otherwise = post error event to API layer
//
// State:
//
//---------------------------------------------------------------------------
tEplKernel PUBLIC AppCbEvent (
tEplApiEventType EventType_p, // IN: event type (enum)
tEplApiEventArg* pEventArg_p, // IN: event argument (union)
io_sAgent* pUserArg_p
)
{
UINT uiVarLen;
tEplKernel EplRet = kEplSuccessful;
pwr_sClass_Epl_MN *op = (pwr_sClass_Epl_MN *)pUserArg_p->op;
io_sRack *rp;
// check if NMT_GS_OFF is reached
switch (EventType_p) {
case kEplApiEventNmtStateChange: {
op->NmtState = pEventArg_p->m_NmtStateChange.m_NewNmtState;
op->Status = op->NmtState == pwr_eEplNmtState_EplNmtMsOperational ? IOM__EPL_OPER : IOM__EPL_NOOPER;
switch (pEventArg_p->m_NmtStateChange.m_NewNmtState) {
case kEplNmtGsOff: {
// NMT state machine was shut down,
// because of user signal (CTRL-C) or critical EPL stack error
// -> also shut down EplApiProcess() and main()
EplRet = kEplShutdown;
errh_Fatal("Event:kEplNmtGsOff originating event = 0x%X (%s)", pEventArg_p->m_NmtStateChange.m_NmtEvent,
EplGetNmtEventStr(pEventArg_p->m_NmtStateChange.m_NmtEvent));
break;
}
case kEplNmtGsResetCommunication: {
break;
}
case kEplNmtGsResetConfiguration: {
if (uiCycleLen_g != 0) {
EplRet = EplApiWriteLocalObject(0x1006, 0x00, &uiCycleLen_g, sizeof (uiCycleLen_g));
uiCurCycleLen_g = uiCycleLen_g;
}
else {
uiVarLen = sizeof(uiCurCycleLen_g);
EplApiReadLocalObject(0x1006, 0x00, &uiCurCycleLen_g, &uiVarLen);
}
break;
}
case kEplNmtCsPreOperational1:
case kEplNmtMsPreOperational1: {
errh_Info("AppCbEvent(0x%X) originating event = 0x%X (%s)", pEventArg_p->m_NmtStateChange.m_NewNmtState, pEventArg_p->m_NmtStateChange.m_NmtEvent, EplGetNmtEventStr(pEventArg_p->m_NmtStateChange.m_NmtEvent));
break;
}
case kEplNmtCsPreOperational2:
case kEplNmtMsPreOperational2: {
break;
}
case kEplNmtCsReadyToOperate:
case kEplNmtMsReadyToOperate: {
break;
}
case kEplNmtGsInitialising: {
break;
}
case kEplNmtGsResetApplication: {
break;
}
case kEplNmtMsNotActive:
case kEplNmtCsNotActive: {
break;
}
case kEplNmtCsOperational:
case kEplNmtMsOperational: {
break;
}
case kEplNmtCsBasicEthernet:
case kEplNmtMsBasicEthernet: {
break;
}
default: {
}
}
break;
}
case kEplApiEventCriticalError:
case kEplApiEventWarning: {
// error or warning occurred within the stack or the application
// on error the API layer stops the NMT state machine
errh_Error( "%s(Err/Warn): Source = %s (%02X) EplError = %s (0x%03X)",
__func__,
EplGetEventSourceStr(pEventArg_p->m_InternalError.m_EventSource),
pEventArg_p->m_InternalError.m_EventSource,
EplGetEplKernelStr(pEventArg_p->m_InternalError.m_EplError),
pEventArg_p->m_InternalError.m_EplError);
// check additional argument
switch (pEventArg_p->m_InternalError.m_EventSource) {
case kEplEventSourceEventk:
case kEplEventSourceEventu: {
// error occurred within event processing
// either in kernel or in user part
errh_Error(" OrgSource = %s %02X", EplGetEventSourceStr(pEventArg_p->m_InternalError.m_Arg.m_EventSource),
pEventArg_p->m_InternalError.m_Arg.m_EventSource);
break;
}
case kEplEventSourceDllk: {
// error occurred within the data link layer (e.g. interrupt processing)
// the DWORD argument contains the DLL state and the NMT event
errh_Error(" val = %X", pEventArg_p->m_InternalError.m_Arg.m_dwArg);
break;
}
default: {
break;
}
}
break;
}
case kEplApiEventHistoryEntry: {
// new history entry
errh_Info("%s(HistoryEntry): Type=0x%04X Code=0x%04X (0x%02X %02X %02X %02X %02X %02X %02X %02X)",
__func__,
pEventArg_p->m_ErrHistoryEntry.m_wEntryType,
pEventArg_p->m_ErrHistoryEntry.m_wErrorCode,
(WORD) pEventArg_p->m_ErrHistoryEntry.m_abAddInfo[0],
(WORD) pEventArg_p->m_ErrHistoryEntry.m_abAddInfo[1],
(WORD) pEventArg_p->m_ErrHistoryEntry.m_abAddInfo[2],
(WORD) pEventArg_p->m_ErrHistoryEntry.m_abAddInfo[3],
(WORD) pEventArg_p->m_ErrHistoryEntry.m_abAddInfo[4],
(WORD) pEventArg_p->m_ErrHistoryEntry.m_abAddInfo[5],
(WORD) pEventArg_p->m_ErrHistoryEntry.m_abAddInfo[6],
(WORD) pEventArg_p->m_ErrHistoryEntry.m_abAddInfo[7]);
break;
}
case kEplApiEventNode: {
switch (pEventArg_p->m_Node.m_NodeEvent) {
case kEplNmtNodeEventCheckConf: {
errh_Info("%s(Node=0x%X, CheckConf)", __func__, pEventArg_p->m_Node.m_uiNodeId);
break;
}
case kEplNmtNodeEventUpdateConf: {
errh_Info("%s(Node=0x%X, UpdateConf)", __func__, pEventArg_p->m_Node.m_uiNodeId);
break;
}
case kEplNmtNodeEventFound: {
break;
}
case kEplNmtNodeEventNmtState: {
for ( rp = pUserArg_p->racklist; rp; rp = rp->next)
if(((pwr_sClass_Epl_CN *)rp->op)->NodeId == pEventArg_p->m_Node.m_uiNodeId) {
((pwr_sClass_Epl_CN *)rp->op)->NmtState = pEventArg_p->m_Node.m_NmtState;
}
switch (pEventArg_p->m_Node.m_NmtState) {
case kEplNmtGsOff:
case kEplNmtGsInitialising:
case kEplNmtGsResetApplication:
case kEplNmtGsResetCommunication:
case kEplNmtGsResetConfiguration:
case kEplNmtCsNotActive: {
break;
}
case kEplNmtCsPreOperational1:
case kEplNmtCsPreOperational2:
case kEplNmtCsReadyToOperate: {
break;
}
case kEplNmtCsOperational: {
break;
}
case kEplNmtCsBasicEthernet:
case kEplNmtCsStopped:
default: {
break;
}
}
break;
}
case kEplNmtNodeEventError: {
errh_Error("AppCbEvent (Node=0x%X): Error = %s (0x%.4X)",
pEventArg_p->m_Node.m_uiNodeId,
EplGetEmergErrCodeStr(pEventArg_p->m_Node.m_wErrorCode),
pEventArg_p->m_Node.m_wErrorCode);
break;
}
default: {
break;
}
}
break;
}
case kEplApiEventCfmProgress: {
errh_Info("%s(Node=0x%X, CFM-Progress: Object 0x%X/%u, %lu/%lu Bytes", __func__, pEventArg_p->m_CfmProgress.m_uiNodeId, pEventArg_p->m_CfmProgress.m_uiObjectIndex, pEventArg_p->m_CfmProgress.m_uiObjectSubIndex, (ULONG) pEventArg_p->m_CfmProgress.m_dwBytesDownloaded, (ULONG) pEventArg_p->m_CfmProgress.m_dwTotalNumberOfBytes);
if ((pEventArg_p->m_CfmProgress.m_dwSdoAbortCode != 0)
|| (pEventArg_p->m_CfmProgress.m_EplError != kEplSuccessful)) {
errh_Error(" -> SDO Abort=0x%lX, Error=0x%X)", (unsigned long) pEventArg_p->m_CfmProgress.m_dwSdoAbortCode,
pEventArg_p->m_CfmProgress.m_EplError);
}
else {
}
break;
}
case kEplApiEventCfmResult: {
switch (pEventArg_p->m_CfmResult.m_NodeCommand) {
case kEplNmtNodeCommandConfOk: {
errh_Info("%s(Node=0x%X, ConfOk)", __func__, pEventArg_p->m_CfmResult.m_uiNodeId);
break;
}
case kEplNmtNodeCommandConfErr: {
errh_Info("%s(Node=0x%X, ConfErr)", __func__, pEventArg_p->m_CfmResult.m_uiNodeId);
break;
}
case kEplNmtNodeCommandConfReset: {
errh_Info("%s(Node=0x%X, ConfReset)", __func__, pEventArg_p->m_CfmResult.m_uiNodeId);
break;
}
case kEplNmtNodeCommandConfRestored: {
errh_Info("%s(Node=0x%X, ConfRestored)", __func__, pEventArg_p->m_CfmResult.m_uiNodeId);
break;
}
default: {
errh_Info("%s(Node=0x%X, CfmResult=0x%X)", __func__, pEventArg_p->m_CfmResult.m_uiNodeId, pEventArg_p->m_CfmResult.m_NodeCommand);
break;
}
}
break;
}
default:
break;
}
return EplRet;
}
