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; }