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 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;
}
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;
}
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);
}
}
void rt_sysmon::scan()
{
pwr_tStatus osts, sts;
errh_eSeverity severity, oseverity;
aproc_TimeStamp( scantime(), 5);
// Find most severe status
sts = PWR__SRUN;
severity = errh_Severity( sts);
for ( int i = 0; i < (int) objects.size(); i++) {
objects[i]->scan();
osts = objects[i]->status();
oseverity = errh_Severity( osts);
if ( oseverity > severity) {
sts = osts;
severity = oseverity;
}
}
errh_SetStatus( sts);
}
/*
* 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;
}
/*
* Class: jpwr_rt_Qcom
* Method: getIniEvent
* Signature: (III)Ljpwr/rt/QcomrGetIniEvent;
*/
JNIEXPORT jobject JNICALL Java_jpwr_rt_Qcom_getIniEvent
(JNIEnv *env, jobject object, jint qix, jint nid, jint timeoutTime)
{
jclass qcomrGetIniEvent_id;
jmethodID qcomrGetIniEvent_cid;
jobject return_obj;
jint jsts;
jboolean jterminate = FALSE;
jboolean jswapInit = FALSE;
jboolean jswapDone = FALSE;
jboolean jtimeout = FALSE;
qcom_sQid qid;
int sts;
int tmo = timeoutTime;
pwr_tBoolean terminate = FALSE;
pwr_tBoolean swapInit = FALSE;
pwr_tBoolean swapDone = FALSE;
pwr_tBoolean timeout = FALSE;
char mp[2000];
qcom_sGet get;
ini_mEvent new_event;
qcom_sEvent *ep;
qcomrGetIniEvent_id = (*env)->FindClass( env, "jpwr/rt/QcomrGetIniEvent");
qcomrGetIniEvent_cid = (*env)->GetMethodID( env, qcomrGetIniEvent_id,
"<init>", "(ZZZZI)V");
qid.qix = qix;
qid.nid = nid;
get.maxSize = sizeof(mp);
get.data = mp;
qcom_Get( &sts, &qid, &get, tmo);
if (sts == QCOM__TMO || sts == QCOM__QEMPTY) {
timeout = TRUE;
}
else {
ep = (qcom_sEvent*) get.data;
new_event.m = ep->mask;
if (new_event.b.swapInit) {
errh_SetStatus( PWR__APPLRESTART);
swapInit = TRUE;
}
else if (new_event.b.swapDone) {
swapDone = TRUE;
errh_SetStatus( PWR__ARUN);
}
else if (new_event.b.terminate) {
terminate = TRUE;
}
}
jsts = (jint) 1;
jterminate = (jboolean) terminate;
jswapInit = (jboolean) swapInit;
jswapDone = (jboolean) swapDone;
jtimeout = (jboolean) timeout;
return_obj = (*env)->NewObject( env, qcomrGetIniEvent_id,
qcomrGetIniEvent_cid,
jterminate,
jswapInit,
jswapDone,
jtimeout,
jsts);
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 (
int argc,
char **argv
)
{
pwr_tStatus sts;
qcom_sGet get;
net_sNotify *notify;
net_sMessage *mp;
gdb_sNode *np;
qcom_sQid qid = qcom_cNQid;
errh_Init("pwr_nacp", errh_eAnix_neth_acp);
errh_SetStatus( PWR__SRVSTARTUP);
init(&qid);
errh_SetStatus( PWR__SRUN);
for (;;) {
mp = receive(&qid, &get);
np = node(mp);
if (np == NULL) {
errh_Error("sender %u.%u, type %u.%u, size %u, reply %u.%u",
get.sender.nid, get.sender.aix, get.type.b, get.type.s, get.size,
get.reply.nid, get.reply.qix);
continue;
}
switch (get.type.s) {
case net_eMsg_nodeUp:
nodeUp((net_sNodeUp *) mp);
break;
case net_eMsg_createObject:
gdb_ScopeLock {
subc_ActivateList(&gdbroot->no_node->subc_lh, pwr_cNObjid);
} gdb_ScopeUnlock;
break;
case net_eMsg_deleteObject:
notify = (net_sNotify *) mp;
gdb_ScopeLock {
subc_ActivateList(&np->subc_lh, notify->oid);
} gdb_ScopeUnlock;
break;
case net_eMsg_moveObject:
case net_eMsg_renameObject:
gdb_ScopeLock {
subc_ActivateList(&np->subc_lh, pwr_cNObjid);
subc_ActivateList(&gdbroot->no_node->subc_lh, pwr_cNObjid);
} gdb_ScopeUnlock;
break;
default:
errh_Error("Unexpected subtype %d received from %d.%d %X",
get.type.s, get.reply.qix, get.reply.nid, get.pid);
}
qcom_Free(&sts, mp);
}
}
void
Init ()
{
pwr_tUInt32 sts;
pwr_tInt32 ret;
char msg[80];
pwr_tObjid MHObjId;
pwr_sAttrRef AttrRef;
pwr_tDlid DLId;
pwr_sClass_MessageHandler *MH;
char fname[200];
dcli_translate_filename( fname, DATABASE);
dcli_translate_filename( info_fname, DATABASE_INFO);
sts = gdh_GetNodeIndex(&lHelCB.Nid);
If_Error_Log_Exit(sts, "gdh_GetNodeIndex");
sts = gdh_GetClassList(pwr_cClass_MessageHandler, &MHObjId);
If_Error_Log_Exit(sts, "Couldn't find message handler object");
AttrRef.Objid = MHObjId;
AttrRef.Body = 0;
AttrRef.Offset = 0;
AttrRef.Size = sizeof(pwr_sClass_MessageHandler);
AttrRef.Flags.m = 0;
sts = gdh_DLRefObjectInfoAttrref(&AttrRef, (pwr_tAddress *)&MH, &DLId);
If_Error_Log_Exit(sts,"Couldn't get direct link to message handler object");
if (MH->EventLogSize == 0) {
Log("EventLogSize = 0, no event logger will run on this node.");
errh_SetStatus( pwr_cNStatus);
exit(1);
}
lHelCB.MaxCardinality = MH->EventLogSize;
lHelCB.MaxStoreLSize = 1000; /*not used*/
lHelCB.ScanTime = 2000; /* 5 seconds */
/*create the database if it's not already created*/
if((ret = db_create(&dataBaseP, NULL, 0)) != 0)
{
/*error creating db-handle send the mess to errh, then exit*/
sprintf(msg, "db_create: %s, no eventlogger will run", db_strerror(ret));
errh_Error(msg);
exit(1);
}
/*open the database*/
#if (DB_VERSION_MAJOR > 3) && (DB_VERSION_MINOR > 0)
ret = dataBaseP->open(dataBaseP, NULL, fname, NULL, DATABASETYPE, DB_CREATE, 0664);
#else
ret = dataBaseP->open(dataBaseP, fname, NULL, DATABASETYPE, DB_CREATE, 0664);
#endif
if(ret != 0)
{
/*error opening/creating db send the mess to errh, then exit*/
sprintf(msg, "db_open: %s, no eventlogger will run", db_strerror(ret));
Log(msg);
exit(1);
}
newhead(&listhead);
}
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 (
int argc,
char *argv[]
)
{
pwr_tStatus sts;
int event;
plc_sProcess *pp;
uid_t ruid;
struct passwd *pwd;
/*
struct rlimit rlim;
int i;
*/
/* Set core dump file size limit to infinite */
/*
rlim.rlim_cur = RLIM_INFINITY;
rlim.rlim_max = RLIM_INFINITY;
sts = setrlimit(RLIMIT_CORE, &rlim);
printf("%d\n", sts);
i = 1/0;
printf("%d\n", i);
*/
pp = init_process();
qcom_WaitAnd(&sts, &pp->eventQ, &qcom_cQini, ini_mEvent_newPlcInit, qcom_cTmoEternal);
init_plc(pp);
create_threads(pp);
init_threads(pp);
/* Once threads has set their priority don't run as root */
#if 0
ruid = getuid();
if (ruid == 0) {
pwd = getpwnam("pwrp");
if (pwd != NULL) {
setreuid(pwd->pw_uid, pwd->pw_uid);
}
}
else
setreuid(ruid, ruid);
#endif
qcom_SignalOr(&sts, &qcom_cQini, ini_mEvent_newPlcInitDone);
qcom_WaitAnd(&sts, &pp->eventQ, &qcom_cQini, ini_mEvent_newPlcStart, qcom_cTmoEternal);
// proc_SetPriority(pp->PlcProcess->Prio);
set_values(pp);
start_threads(pp);
run_threads(pp);
time_Uptime(&sts, &pp->PlcProcess->StartTime, NULL);
qcom_SignalOr(&sts, &qcom_cQini, ini_mEvent_newPlcStartDone);
#if 0
/* Force the backup to take care initialized backup objects. */
bck_ForceBackup(NULL);
#endif
errh_SetStatus( PWR__SRUN);
qcom_WaitOr(&sts, &pp->eventQ, &qcom_cQini, ini_mEvent_terminate | ini_mEvent_oldPlcStop, qcom_cTmoEternal, &event);
switch ( event) {
case ini_mEvent_terminate:
errh_SetStatus( PWR__SRVTERM);
stop_threads(pp);
clean_all(pp);
nmps_delete_lock( &sts);
break;
case ini_mEvent_oldPlcStop:
errh_SetStatus( PWR__SRVTERM);
time_Uptime(&sts, &pp->PlcProcess->StopTime, NULL);
stop_threads(pp);
save_values(pp);
qcom_SignalOr(&sts, &qcom_cQini, ini_mEvent_oldPlcStopDone);
#if defined OS_ELN
sts = proc_SetPriority(31);
#endif
clean_all(pp);
break;
default: ;
}
exit(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[])
{
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;
}
}
}
void rt_post::open()
{
pwr_tStatus sts;
pwr_tObjid oid;
pwr_tFileName filename;
// Open server configuration object PostConfig
sts = gdh_GetClassList( pwr_cClass_PostConfig, &oid);
if ( ODD(sts)) {
sts = gdh_ObjidToPointer( oid, (void **)&conf);
if ( EVEN(sts)) throw co_error( sts);
aproc_RegisterObject( oid);
}
else {
errh_Info( "No Post configuration");
errh_SetStatus( 0);
exit(0);
}
conf->Status = PWR__SRVSTARTUP;
// Connect to mh
mh_UtilWaitForMh();
sts = mh_OutunitConnect(
oid,
mh_eOutunitType_Post,
0,
mh_ack_bc,
mh_alarm_bc,
mh_block_bc,
mh_cancel_bc,
mh_clear_alarmlist_bc,
mh_clear_blocklist_bc,
mh_info_bc,
mh_return_bc,
NULL
);
if ( EVEN(sts)) {
errh_Error( "Post terminated: %m", sts);
conf->Status = sts;
exit(0);
}
// Load user database
sts = gdh_GetObjectInfo( "pwrNode-System.SystemGroup", &systemgroup,
sizeof(systemgroup));
if ( EVEN(sts)) {
errh_Error( "Post terminated: %m", sts);
conf->Status = sts;
exit(0);
}
udb = new GeUser();
sts = dcli_get_defaultfilename( user_cFilename, filename, "");
udb->load( filename);
conf->Status = PWR__SRUN;
}
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);
}
}
}
}
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[])
{
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);
}
}
void CreateSocket()
{
int sts;
unsigned char badr[4];
unsigned int iadr[4] = {-1, -1, -1, -1};
struct hostent *he;
struct sockaddr_in address;
socklen_t address_len = sizeof(struct sockaddr_in);
/* Create a socket for UDP */
my_socket = socket(AF_INET, SOCK_DGRAM, 0);
if (my_socket < 0) {
errh_Error("Socket, %d", my_socket);
errh_SetStatus(PWR__SRVTERM);
exit(0);
}
if (rn_udp->LocalPort != 0) {
/* Set local port */
my_addr.sin_family = AF_INET;
my_addr.sin_port = htons(rn_udp->LocalPort);
/* Bind the created socket */
sts = bind(my_socket, (struct sockaddr *) &my_addr, sizeof(my_addr));
if (sts != 0) {
errh_Error("Bind, %d", sts);
errh_SetStatus(PWR__SRVTERM);
exit(0);
}
}
else {
getsockname(my_socket, (struct sockaddr *) &address, &address_len);
rn_udp->LocalPort = ntohs(address.sin_port);
}
/*
problem, you have to be root user to do this!!
sts = setsockopt(my_socket, SOL_SOCKET, SO_BINDTODEVICE, rn_udp->DevName, strlen(en_udp->DevName));
printf("Setsockopt, %d\n", sts);
if (sts != 0) errh_Error("Setsockopt bindtodevice, %d", sts);
*/
/* Initialize remote address structure */
their_addr.sin_family = AF_INET;
their_addr.sin_port = htons(rn_udp->RemotePort);
sscanf((char *) &(rn_udp->RemoteAddress), "%d.%d.%d.%d",
&iadr[0], &iadr[1], &iadr[2], &iadr[3]);
/* If none or invalid ip-address is given, use hostname to get hostent struct,
otherwise use the given ip address directly */
if ((iadr[0] < 0 || iadr[0] > 255) ||
(iadr[0] < 0 || iadr[0] > 255) ||
(iadr[0] < 0 || iadr[0] > 255) ||
(iadr[0] < 0 || iadr[0] > 255)) {
he = gethostbyname(rn_udp->RemoteHostname);
if (he) {
memcpy(&their_addr.sin_addr, he->h_addr, 4);
sprintf(rn_udp->RemoteAddress, "%s", inet_ntoa(their_addr.sin_addr));
}
else {
errh_Error("Unknown host, %s", rn_udp->RemoteHostname);
errh_SetStatus(PWR__SRVTERM);
exit(0);
}
}
else {
badr[0] = (unsigned char) iadr[0];
badr[1] = (unsigned char) iadr[1];
badr[2] = (unsigned char) iadr[2];
badr[3] = (unsigned char) iadr[3];
memcpy(&their_addr.sin_addr, &badr, 4);
}
/* If there is a multicast address configured, create a socket for a dual remote node */
if (rn.multicast) {
dual_addr.sin_family = AF_INET;
dual_addr.sin_port = htons(rn_udp->RemotePort);
badr[0] = (unsigned char) rn.multicast->Address[0];
badr[1] = (unsigned char) rn.multicast->Address[1];
badr[2] = (unsigned char) rn.multicast->Address[2];
badr[3] = (unsigned char) rn.multicast->Address[3];
memcpy(&dual_addr.sin_addr, &badr, 4);
}
rn_udp->LinkUp = 0;
rn_udp->KeepaliveDiff = 0;
time_since_scan = 0;
time_since_rcv = 0;
time_since_keepalive = 0;
}
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);
}
}
}
int main (int argc, char **argv)
{
pwr_tStatus sts = 1;
io_tCtx io_ctx;
io_tCtx io_ctx_swap;
pwr_sClass_IOHandler *ihp;
int swap_io;
int close_io;
int init_io;
qcom_sQid qid = qcom_cNQid;
int tmo;
char mp[2000];
qcom_sGet get;
pwr_tTime now;
pwr_tTime next;
pwr_tTime after;
pwr_tDeltaTime cycle;
lst_sEntry *csup_lh;
int delay_action = 0;
pwr_sNode *nodep;
pwr_tBoolean old_emergency_break = 0;
if ( argc > 1) {
if ( strcmp( argv[1], "-m") == 0) {
io_methods_print();
exit(0);
}
if ( strcmp( argv[1], "-h") == 0) {
usage();
exit(0);
}
}
ihp = init(&qid, &csup_lh, &nodep);
plc_UtlWaitForPlc();
/* Prepare the swap context */
sts = io_init_swap(io_mProcess_IoComm, pwr_cNObjid, &io_ctx_swap, 1, ihp->CycleTimeBus);
for (close_io = swap_io = 0, init_io = 1;;) {
if (init_io) {
double f;
sts = io_init(io_mProcess_IoComm, pwr_cNObjid, &io_ctx, 1, ihp->CycleTimeBus);
if ( ODD(sts))
errh_SetStatus( PWR__SRUN);
#if defined(OS_ELN)
ker$clear_event( &sts, io_comm_terminate);
io_dioc_init();
io_dioc_start();
#endif
init_io = 0;
tmo = ihp->CycleTimeBus * 1000.;
f = floor(ihp->CycleTimeBus);
cycle.tv_sec = f;
cycle.tv_nsec = (ihp->CycleTimeBus - f) * 1.0e9;
cycle.tv_nsec++;
time_GetTimeMonotonic(&next);
time_Aadd(NULL, &next, &cycle);
}
get.maxSize = sizeof(mp);
get.data = mp;
qcom_Get(&sts,&qid, &get, tmo);
if (sts == QCOM__TMO || sts == QCOM__QEMPTY) {
if ( nodep->EmergBreakTrue && !old_emergency_break)
sts = io_swap(io_ctx_swap, io_eEvent_IoCommEmergencyBreak);
sts = io_read(io_ctx);
if (EVEN(sts)) {
ihp->IOReadWriteFlag = FALSE;
errh_Error("IO read, %m", sts);
}
sts = io_write(io_ctx);
if (EVEN(sts)) {
ihp->IOReadWriteFlag = FALSE;
errh_Error("IO write, %m", sts);
}
if ( nodep->EmergBreakTrue && !old_emergency_break)
sts = io_swap(io_ctx, io_eEvent_EmergencyBreak);
old_emergency_break = nodep->EmergBreakTrue;
if (swap_io)
{
sts = io_swap(io_ctx_swap, io_eEvent_IoCommSwap);
}
io_ScanSupLst( io_ctx->SupCtx);
time_GetTime(&now);
time_GetTimeMonotonic(&after);
next = after;
time_Aadd(NULL, &next, &cycle);
delay_action = csup_Exec(&sts, csup_lh, (pwr_tDeltaTime *) &next,
(pwr_tDeltaTime *) &after, &now);
if (delay_action == 2)
ihp->IOReadWriteFlag = FALSE;
aproc_TimeStamp(ihp->CycleTimeBus, 5);
} else {
ini_mEvent new_event;
qcom_sEvent *ep = (qcom_sEvent*) get.data;
new_event.m = ep->mask;
if (new_event.b.oldPlcStop && !swap_io) {
swap_io = 1;
close_io = 1;
errh_SetStatus(PWR__SRVRESTART);
} else if (new_event.b.swapDone && swap_io) {
swap_io = 0;
init_io = 1;
} else if (new_event.b.terminate) {
exit(0);
}
if (close_io) {
io_close(io_ctx);
#if defined(OS_ELN)
ker$signal( &sts, io_comm_terminate);
#endif
close_io = 0;
}
}
}
}
JNIEXPORT void JNICALL Java_jpwr_rt_Errh_setStatus
(JNIEnv *env, jobject object, jint jsts)
{
int sts = jsts;
errh_SetStatus( sts);
}
static pwr_tStatus InitTrendList( trend_tCtx ctx)
{
pwr_tStatus sts;
pwr_tUInt32 dummy;
pwr_tTypeId type;
int tix;
pwr_tAttrRef aref;
pwr_tAttrRef oaref;
pwr_tAName name;
pwr_tDisableAttr disabled;
/* Init DsTrend objects */
/* Scan through typelist and insert valid objects in list and initiate */
/* the DsTrend objects. */
for ( sts = gdh_GetClassListAttrRef(pwr_cClass_DsTrend, &aref);
ODD(sts);
sts = gdh_GetNextAttrRef( pwr_cClass_DsTrend, &aref, &aref) ) {
trend_sListEntry *ep;
pwr_sClass_DsTrend *o;
sts = gdh_AttrrefToName( &aref, name, sizeof(name), cdh_mNName);
if (EVEN(sts))
continue;
/* Check if parent object is disabled */
sts = gdh_AttrArefToObjectAref( &aref, &oaref);
if ( ODD(sts)) {
sts = gdh_ArefDisabled( &oaref, &disabled);
if ( ODD(sts) && disabled)
continue;
}
ep = calloc(1, sizeof(*ep));
if (ep == NULL) {
errh_CErrLog(DS__ERRALLOC, NULL);
errh_SetStatus( PWR__SRVTERM);
exit(DS__ERRALLOC);
}
sts = gdh_RefObjectInfo(name, (pwr_tAddress *)&ep->o,
&ep->o_subid, sizeof(*ep->o));
if (EVEN(sts)) {
errh_Error("Couldn't get subscription for '%s'\n%m", name, sts);
free(ep);
continue;
}
o = ep->o;
/* Set init values */
o->BufferStatus[0] = 1;
o->BufferStatus[1] = 1;
o->NoOfBuffers = 2;
o->NoOfBufElement = 239;
/* Initiate DsTrend object, sampled attribute must be on local node */
sts = gdh_DLRefObjectInfoAttrref((pwr_sAttrRef *)&o->DataName,
(pwr_tAddress *)&o->DataPointer, &o->DataSubId);
if (EVEN(sts)) {
if ( sts == GDH__RTDBNULL && IsDisabled( &o->DataName))
continue;
errh_Error("Couldn't get direct link to %s's attribute DataName\n%m", name, sts);
gdh_UnrefObjectInfo(ep->o_subid);
free(ep);
continue;
}
sts = gdh_GetAttributeCharAttrref((pwr_sAttrRef *)&o->DataName,
&type, &dummy, &dummy, &dummy);
if (EVEN(sts)) {
errh_Error("Couldn't get datatype for %s's attribute DataName\n%m", name, sts);
gdh_UnrefObjectInfo(ep->o_subid);
free(ep);
continue;
}
tix = cdh_TypeIdToIndex(type);
if (!IsValidType(tix)) {
errh_Error("No valid datatype for %s's attribute DataName\n%m", name, DS__ERRTYPE);
gdh_UnrefObjectInfo(ep->o_subid);
free(ep);
continue;
}
o->DataType = tix;
if ( o->Multiple == 0)
o->Multiple = 1;
o->NoOfSample = (o->StorageTime * ctx->scantime) / o->Multiple;
if(o->NoOfSample > o->NoOfBufElement)
o->NoOfSample = o->NoOfBufElement;
o->ScanTime = ctx->scantime;
ep->next = ctx->o_list;
ctx->o_list = ep;
}
/* Init DsTrendCurve objects */
/* Scan through typelist and insert valid objects in list and initiate
the DsTrend objects. */
for (sts = gdh_GetClassListAttrRef(pwr_cClass_DsTrendCurve, &aref);
ODD(sts);
sts = gdh_GetNextAttrRef( pwr_cClass_DsTrendCurve, &aref, &aref) ) {
trend_sListEntryTC *ep;
pwr_sClass_DsTrendCurve *o;
int i;
int found;
sts = gdh_AttrrefToName( &aref, name, sizeof(name), cdh_mNName);
if (EVEN(sts))
continue;
/* Check if parent object is disabled */
sts = gdh_AttrArefToObjectAref( &aref, &oaref);
if ( ODD(sts)) {
sts = gdh_ArefDisabled( &oaref, &disabled);
if ( ODD(sts) && disabled)
continue;
}
ep = calloc(1, sizeof(*ep));
if (ep == NULL) {
errh_CErrLog(DS__ERRALLOC, NULL);
errh_SetStatus( PWR__SRVTERM);
exit(DS__ERRALLOC);
}
ep->first_scan = 1;
sts = gdh_RefObjectInfo(name, (pwr_tAddress *)&ep->o,
&ep->o_subid, sizeof(*ep->o));
if (EVEN(sts)) {
errh_Error("Couldn't get subscription for '%s'\n%m", name, sts);
free(ep);
continue;
}
o = ep->o;
if ( o->Function & 1) {
/* Data stored by user */
gdh_UnrefObjectInfo(ep->o_subid);
free(ep);
continue;
}
ep->multiple = (int) (o->ScanTime / ctx->scantime_tc + 0.5);
o->NoOfSample = (int) (o->StorageTime / ctx->scantime_tc * ep->multiple + 0.5);
/* Initiate DsTrendCuve object, sampled attribute must be on local node */
found = 0;
for ( i = 0; i < 10; i++) {
if ( cdh_ObjidIsNull( o->Attribute[i].Objid))
continue;
/* Link to attribute */
sts = gdh_DLRefObjectInfoAttrref((pwr_sAttrRef *)&o->Attribute[i],
(pwr_tAddress *)&ep->datap[i], &ep->data_subid[i]);
if (EVEN(sts)) {
if ( sts == GDH__RTDBNULL && IsDisabled( &o->Attribute[i]))
continue;
errh_Error("Couldn't get direct link to %s's attribute %d, %m", name, i+1, sts);
ep->datap[i] = 0;
continue;
}
sts = gdh_GetAttributeCharAttrref((pwr_sAttrRef *)&o->Attribute[i],
&type, &dummy, &dummy, &dummy);
if (EVEN(sts)) {
errh_Error("Couldn't get datatype for %s's attribute DataName\n%m", name, sts);
gdh_UnrefObjectInfo(ep->data_subid[i]);
ep->datap[i] = 0;
continue;
}
tix = cdh_TypeIdToIndex(type);
ep->data_size[i] = cdh_TypeToSize( type);
if (!IsValidType(tix)) {
errh_Error("No valid datatype for %s's attribute DataName\n%m", name, DS__ERRTYPE);
gdh_UnrefObjectInfo(ep->data_subid[i]);
ep->datap[i] = 0;
continue;
}
o->AttributeType[i] = type;
/* Link to buffer */
sts = gdh_DLRefObjectInfoAttrref((pwr_sAttrRef *)&o->Buffers[i],
(pwr_tAddress *)&ep->buffheadp[i], &ep->buff_subid[i]);
if (EVEN(sts)) {
errh_Error("Couldn't get direct link to %s's buffer %d, %m", name, i+1, sts);
gdh_UnrefObjectInfo(ep->data_subid[i]);
ep->datap[i] = 0;
continue;
}
ep->buffp[i] = (char *)ep->buffheadp[i] + pwr_AlignLW(sizeof(pwr_sClass_CircBuffHeader));
/* Get buffer size */
sts = gdh_GetAttributeCharAttrref( &o->Buffers[i], 0, &ep->buff_size[i], 0, 0);
if ( EVEN(sts)) return sts;
ep->buff_size[i] -= pwr_AlignLW(sizeof(pwr_sClass_CircBuffHeader));
found = 1;
}
if ( !found) {
errh_Error("No valid attributes for %s", name);
gdh_UnrefObjectInfo(ep->o_subid);
free(ep);
continue;
}
/* Link to time buffer */
if ( cdh_ObjidIsNotNull( o->TimeBuffer.Objid)) {
sts = gdh_DLRefObjectInfoAttrref((pwr_sAttrRef *)&o->TimeBuffer,
(pwr_tAddress *)&ep->timeheadp, &ep->timebuff_subid);
if (EVEN(sts)) {
errh_Error("Couldn't get direct link to %s's time buffer, %m", name, sts);
ep->timeheadp = 0;
ep->timebuffp = 0;
}
else
ep->timebuffp = (char *)ep->timeheadp + pwr_AlignLW(sizeof(pwr_sClass_CircBuffHeader));
if ( o->TimeResolution == pwr_eTimeResolutionEnum_Nanosecond)
ep->time_size = 8;
else
ep->time_size = 4;
/* Get buffer size */
sts = gdh_GetAttributeCharAttrref( &o->TimeBuffer, 0, &ep->timebuff_size, 0, 0);
if ( EVEN(sts)) return sts;
ep->timebuff_size -= pwr_AlignLW(sizeof(pwr_sClass_CircBuffHeader));
}
/* Calculate number of samples */
for ( i = 0; i < 10; i++) {
if ( !ep->datap[i])
continue;
if ( o->NoOfSample > ep->buff_size[i] / ep->data_size[i])
o->NoOfSample = ep->buff_size[i] / ep->data_size[i];
}
if ( ep->timebuffp) {
if ( o->NoOfSample > ep->timebuff_size / ep->time_size)
o->NoOfSample = ep->timebuff_size / ep->time_size;
}
for ( i = 0; i < 10; i++) {
if ( !ep->datap[i])
continue;
ep->buffheadp[i]->Size = o->NoOfSample;
ep->buffheadp[i]->ElementSize = ep->data_size[i];
}
if ( ep->timebuffp) {
ep->timeheadp->Size = o->NoOfSample;
ep->timeheadp->ElementSize = ep->time_size;
}
ep->next = ctx->o_list_tc;
ctx->o_list_tc = ep;
}
if ( ctx->o_list == NULL && ctx->o_list_tc == NULL)
return DS__NOOBJECT;
else
return DS__SUCCESS;
}
/*----------------------------------------------------------------------------*\
Read method for the Powerlink master
\*----------------------------------------------------------------------------*/
static pwr_tStatus IoAgentRead( io_tCtx ctx, io_sAgent *ap) {
io_sLocalEpl_MN *local = (io_sLocalEpl_MN *)ap->Local;
io_sLocalEpl_CN *local1;
pwr_sClass_Epl_MN *op = (pwr_sClass_Epl_MN *)ap->op;
io_sRack *rp;
io_sCard *cp;
pwr_tUInt32 error_count = 0;
int ret = IO__SUCCESS;
if(!ap->Local)
return ret;
// Remeber the time when this functions was called the first time
if( local->init == 0) {
clock_gettime(CLOCK_REALTIME, &local->boot);
local->init = 1;
}
// Time now (tps = time when bad state occurred)
clock_gettime(CLOCK_REALTIME, &local->tpe);
error_count = op->ErrorCount;
// Add to error count if agent changed from good to bad state and setup is complete
if( local->prevState == pwr_eEplNmtState_EplNmtMsOperational && op->NmtState != pwr_eEplNmtState_EplNmtMsOperational && ( (local->tpe).tv_sec - (local->boot).tv_sec) >= op->StartupTimeout)
op->ErrorCount++;
// Copy Powerlink process image to temp memory (only if stallaction=resetinputs else tmp_area=input_area)
if( local->inputResetEnabled)
memcpy( local->tmp_area , local->input_area, local->input_area_size);
// If no bad state and were still in startup there can be no error (else remember when error occurred)
if( op->NmtState == pwr_eEplNmtState_EplNmtMsOperational || ( (local->tpe).tv_sec - (local->boot).tv_sec) < op->StartupTimeout) {
(local->tps).tv_sec = 0;
local->timeoutStatus = 0;
}
else if( (local->tps).tv_sec == 0) {
clock_gettime(CLOCK_REALTIME, &local->tps);
}
// Agent error soft limit reached, tell log (once)
if ( op->ErrorCount >= op->ErrorSoftLimit && error_count < op->ErrorSoftLimit) {
errh_Warning( "IO Agent ErrorSoftLimit reached, '%s'", ap->Name);
}
// Agent error hard limit reached, tell log (once)
if ( op->ErrorCount >= op->ErrorHardLimit && error_count < op->ErrorHardLimit) {
if( op->StallAction == pwr_eStallActionEnum_EmergencyBreak) {
errh_Error( "IO Agent ErrorHardLimit reached '%s', IO stopped", ap->Name);
}
else
errh_Error( "IO Agent ErrorHardLimit reached '%s'", ap->Name);
}
// Agent timeout has elapsed, tell log (once)
if( ( (local->tpe).tv_sec - (local->tps).tv_sec) >= op->Timeout && local->timeoutStatus == 0 && (local->tps).tv_sec != 0) {
local->timeoutStatus = 1;
if( op->StallAction == pwr_eStallActionEnum_EmergencyBreak) {
errh_Error( "IO Agent timeout time elapsed '%s', IO stopped", ap->Name);
}
else if( op->StallAction == pwr_eStallActionEnum_ResetInputs) {
errh_Error( "IO Agent timeout time elapsed '%s', IO input area reset", ap->Name);
}
else
errh_Error( "IO Agent timeout time elapsed '%s'", ap->Name);
}
// Agent error hard limit reached, take action (always)
if ( op->ErrorCount >= op->ErrorHardLimit) {
if( op->StallAction == pwr_eStallActionEnum_EmergencyBreak) {
ctx->Node->EmergBreakTrue = 1;
errh_SetStatus(PWR__SRVFATAL);
IoAgentClose(ctx, ap);
}
ret = IO__ERRDEVICE;
}
// Agent timeout time elapsed, take action (always)
if ( ( (local->tpe).tv_sec - (local->tps).tv_sec) >= op->Timeout && (local->tps).tv_sec != 0) {
if( op->StallAction == pwr_eStallActionEnum_EmergencyBreak) {
ctx->Node->EmergBreakTrue = 1;
errh_SetStatus(PWR__SRVFATAL);
IoAgentClose(ctx, ap);
}
else if( op->StallAction == pwr_eStallActionEnum_ResetInputs) {
memset( local->tmp_area, 0, local->input_area_size);
}
ret = IO__ERRDEVICE;
}
// Remember agent state til next scan
local->prevState = op->NmtState;
// Loop through all slaves
for ( rp = ap->racklist; rp; rp = rp->next) {
((pwr_sClass_Epl_CN *)rp->op)->Status = ((pwr_sClass_Epl_CN *)rp->op)->NmtState == pwr_eEplNmtState_EplNmtCsOperational ? IOM__EPL_OPER : IOM__EPL_NOOPER;
local1 = (io_sLocalEpl_CN *)rp->Local;
// Time now (tps = time when bad state occurred)
clock_gettime(CLOCK_REALTIME, &local1->tpe);
error_count = ((pwr_sClass_Epl_CN *)rp->op)->ErrorCount;
// Add to error count if slave changed from good to bad state and setup is complete
if( local1->prevState == pwr_eEplNmtState_EplNmtCsOperational && ((pwr_sClass_Epl_CN *)rp->op)->NmtState != pwr_eEplNmtState_EplNmtCsOperational && ( (local1->tpe).tv_sec - (local->boot).tv_sec) >= op->StartupTimeout)
((pwr_sClass_Epl_CN *)rp->op)->ErrorCount++;
// Save time when bad state occurs
if( ( (pwr_sClass_Epl_CN *)rp->op)->NmtState == pwr_eEplNmtState_EplNmtCsOperational || ( (local1->tpe).tv_sec - (local->boot).tv_sec) < op->StartupTimeout) {
(local1->tps).tv_sec = 0;
local1->timeoutStatus = 0;
}
else if( (local1->tps).tv_sec == 0)
clock_gettime(CLOCK_REALTIME, &local1->tps);
// Slave error soft limit reached, tell log (once)
if ( ((pwr_sClass_Epl_CN *)rp->op)->ErrorCount >= ((pwr_sClass_Epl_CN *)rp->op)->ErrorSoftLimit && error_count < ((pwr_sClass_Epl_CN *)rp->op)->ErrorSoftLimit) {
errh_Warning( "IO Rack ErrorSoftLimit reached, '%s'", rp->Name);
}
// Slave error hard limit reached, tell log (once)
if ( ((pwr_sClass_Epl_CN *)rp->op)->ErrorCount >= ((pwr_sClass_Epl_CN *)rp->op)->ErrorHardLimit && error_count < ((pwr_sClass_Epl_CN *)rp->op)->ErrorHardLimit) {
if( ((pwr_sClass_Epl_CN *)rp->op)->StallAction == pwr_eStallActionEnum_EmergencyBreak) {
errh_Error( "IO Rack ErrorHardLimit reached '%s', IO stopped", rp->Name);
}
else
errh_Error( "IO Rack ErrorHardLimit reached '%s'", rp->Name);
}
// Slave timeout has elapsed, tell log (once)
if( ( (local1->tpe).tv_sec - (local1->tps).tv_sec) >= ((pwr_sClass_Epl_CN *)rp->op)->Timeout && local1->timeoutStatus == 0 && (local1->tps).tv_sec != 0) {
local1->timeoutStatus = 1;
if( ((pwr_sClass_Epl_CN *)rp->op)->StallAction == pwr_eStallActionEnum_EmergencyBreak) {
errh_Error( "Rack timeout time elapsed '%s', IO stopped", rp->Name);
}
else if( ((pwr_sClass_Epl_CN *)rp->op)->StallAction == pwr_eStallActionEnum_ResetInputs) {
errh_Error( "Rack timeout time elapsed '%s', IO input area reset", rp->Name);
}
else
errh_Error( "Rack timeout time elapsed '%s'", rp->Name);
}
// Slave error hard limit reached, take action (always)
if ( ((pwr_sClass_Epl_CN *)rp->op)->ErrorCount >= ((pwr_sClass_Epl_CN *)rp->op)->ErrorHardLimit) {
if( ((pwr_sClass_Epl_CN *)rp->op)->StallAction == pwr_eStallActionEnum_EmergencyBreak) {
ctx->Node->EmergBreakTrue = 1;
errh_SetStatus(PWR__SRVFATAL);
IoAgentClose(ctx, ap);
}
ret = IO__ERRDEVICE;
}
// Slave timeout elapsed, take action (always)
if( ( (local1->tpe).tv_sec - (local1->tps).tv_sec) >= ((pwr_sClass_Epl_CN *)rp->op)->Timeout && (local1->tps).tv_sec != 0) {
if( ((pwr_sClass_Epl_CN *)rp->op)->StallAction == pwr_eStallActionEnum_EmergencyBreak) {
ctx->Node->EmergBreakTrue = 1;
errh_SetStatus(PWR__SRVFATAL);
IoAgentClose(ctx, ap);
}
else if( ((pwr_sClass_Epl_CN *)rp->op)->StallAction == pwr_eStallActionEnum_ResetInputs) {
memset( local->tmp_area + ((pwr_sClass_Epl_CN *)rp->op)->InputAreaOffset, 0, ((pwr_sClass_Epl_CN *)rp->op)->InputAreaSize);
}
ret = IO__ERRDEVICE;
}
// Remeber slave state til next scan
local1->prevState = ((pwr_sClass_Epl_CN *)rp->op)->NmtState;
// Update Proview chan-objects with data from Powerlink process image
for ( cp = rp->cardlist; cp; cp = cp->next) {
io_bus_card_read( ctx, rp, cp, local->tmp_area, 0, ((io_sLocalEpl_CN *)rp->Local)->byte_ordering, pwr_eFloatRepEnum_FloatIEEE);
}
}
return ret;
}
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;
}
}
}
}
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;
}
}
static pwr_tStatus
start (
ini_sContext *cp
)
{
pwr_tStatus sts;
char console[80];
#if defined OS_POSIX
int fd;
if ( strcmp( cp->console, "") == 0)
strcpy( console, "/dev/console");
else
strcpy( console, cp->console);
if ((fd = open(console, O_APPEND | O_WRONLY)) == -1)
errl_Init(NULL, ini_errl_cb, cp);
else {
close(fd);
errl_Init(console, ini_errl_cb, cp);
}
#else
errl_Init("CONSOLE:", ini_errl_cb, cp);
#endif
errh_Init("pwr_ini", errh_eAnix_ini);
if ( cp->flags.b.interactive)
errh_Interactive();
mh_UtilCreateEvent();
ini_CheckContext(&sts, cp);
ini_ReadBootFile(&sts, cp);
ini_ReadNodeFile(&sts, cp);
ini_CheckNode(&sts, cp);
cp->me = tree_Find(&sts, cp->nid_t, &cp->node.nid);
if (cp->me == NULL) {
errh_LogFatal(&cp->log, "Cannot find my own node in %s\n", cp->nodefile.name);
exit(QCOM__WEIRD);
}
if (!checkErrors(cp))
exit(0);
if (cp->flags.b.verbose)
logCardinality(cp);
ini_CreateDb(&sts, cp);
ini_LoadNode(&sts, cp);
ini_BuildNode(&sts, cp);
if (cp->np != NULL) {
if (cp->np->ErrLogTerm[0] != '\0') {
errh_LogInfo(&cp->log, "Setting log terminal to: %s", cp->np->ErrLogTerm);
errl_SetTerm(cp->np->ErrLogTerm);
}
/* Logfile is always $pwrp_log/pwr.log from V4.0.0 and handled by Linux log rotation */
char fname[256];
sprintf(fname, "$pwrp_log/pwr_%s.log", cp->nodename);
dcli_translate_filename(fname, fname);
errl_SetFile(fname);
errh_LogInfo(&cp->log, "Setting log file to: %s", fname);
/*
if (cp->np->ErrLogFile[0] != '\0') {
struct tm *tp;
char fname[256];
time_t t;
time(&t);
tp = localtime(&t);
strftime(fname, sizeof(fname), cp->np->ErrLogFile, tp );
dcli_translate_filename( fname, fname);
errl_SetFile(fname);
errh_LogInfo(&cp->log, "Setting log file to: %s", cp->np->ErrLogFile);
}
*/
}
ini_SetSystemStatus( cp, PWR__STARTUP);
errh_SetStatus( PWR__STARTUP);
sts = ini_RcReadAndSet(cp->dir, cp->nodename, cp->busid);
if (EVEN(sts))
errh_LogError(&cp->log, "ini_RcReadAndSet, %m", sts);
sts = ini_SetAttribute(cp->aliasfile.name, cp->nodename, 0);
if (EVEN(sts) && sts != INI__FILE)
errh_LogError(&cp->log, "ini_SetAttribute, %m", sts);
qini_BuildDb(&sts, cp->nid_t, cp->me, NULL, cp->busid);
io_init_signals();
load_backup();
#if defined OS_ELN
ker$initialization_done(NULL);
#endif
ini_ProcTable(&sts, cp);
ini_ProcIter(&sts, cp, proc_mProcess_system, 0, ini_ProcLoad);
ini_ProcIter(&sts, cp, proc_mProcess_system, 0, ini_ProcStart);
ini_ProcIter(&sts, cp, proc_mProcess_system, 0, ini_ProcPrio);
net_Connect(&sts, &gdbroot->my_aid, &gdbroot->my_qid, NULL, "pwr_ini");
/*if (!qcom_Init(&sts, 0)) {*/
if (EVEN(sts)) {
errh_LogFatal(&cp->log, "net_Connect, %m", sts);
exit(sts);
}
qcom_SignalOr(&sts, &qcom_cQini, ini_mEvent_newPlcInit | ini_mEvent_newPlcStart);
ini_ProcIter(&sts, cp, proc_mProcess_user, 0, ini_ProcLoad);
ini_ProcIter(&sts, cp, proc_mProcess_user, 0, ini_ProcStart);
ini_ProcIter(&sts, cp, proc_mProcess_user, 0, ini_ProcPrio);
qcom_CreateQ(&sts, &cp->eventQ, NULL, "iniEvent");
if (EVEN(sts)) {
errh_LogFatal(&cp->log, "qcom_CreateQ, %m", sts);
exit(sts);
}
qcom_WaitAnd(&sts, &cp->eventQ, &qcom_cQini, ini_mEvent_newPlcStartDone | cp->plc_sigmask, qcom_cTmoEternal);
sts = ini_SetAttributeAfterPlc(cp->aliasfile.name, cp->nodename, 0);
if (EVEN(sts) && sts != INI__FILE)
errh_LogError(&cp->log, "ini_SetAttributeAfterPlc, %m", sts);
ini_SetSystemStatus( cp, PWR__RUNNING);
errh_SetStatus( PWR__SRUN);
return sts;
}
static pwr_tStatus start( ini_sContext *cp)
{
pwr_tStatus sts;
char console[80];
qini_sNode *nep;
qcom_sAid aid;
int fd;
if ( strcmp( cp->console, "") == 0)
strcpy( console, "/dev/console");
else
strcpy( console, cp->console);
if ((fd = open(console, O_APPEND | O_WRONLY)) == -1)
errl_Init(NULL, ini_errl_cb, cp);
else {
close(fd);
errl_Init(console, ini_errl_cb, cp);
}
errh_Init("pwr_ini", errh_eAnix_ini);
if ( cp->flags.b.interactive)
errh_Interactive();
ini_CheckContext(&sts, cp);
ini_ReadBootFile(&sts, cp);
ini_ReadNodeFile(&sts, cp);
for (nep = tree_Minimum(&sts, cp->nid_t); nep != NULL; nep = tree_Successor(&sts, cp->nid_t, nep)) {
if ( strcmp( cp->nodename, nep->name) == 0) {
cp->me = nep;
break;
}
}
if (cp->me == NULL) {
errh_LogFatal(&cp->log, "Cannot find my own node in %s\n", cp->nodefile.name);
exit(QCOM__WEIRD);
}
if (!checkErrors(cp))
exit(0);
/* Logfile is always $pwrp_log/pwr.log from V4.0.0 and handled by Linux log rotation */
char fname[256];
sprintf(fname, "$pwrp_log/pwr_%s.log", cp->nodename);
dcli_translate_filename(fname, fname);
errl_SetFile(fname);
errh_LogInfo(&cp->log, "Setting log file to: %s", fname);
// ini_SetSystemStatus( cp, PWR__STARTUP);
errh_SetStatus( PWR__STARTUP);
qini_BuildDb(&sts, cp->nid_t, cp->me, NULL, cp->busid);
ini_ProcTable(&sts, cp);
ini_ProcIter(&sts, cp, proc_mProcess_system, ini_ProcStart);
ini_ProcIter(&sts, cp, proc_mProcess_system, ini_ProcPrio);
ini_ProcIter(&sts, cp, proc_mProcess_user, ini_ProcStart);
ini_ProcIter(&sts, cp, proc_mProcess_user, ini_ProcPrio);
qcom_Init(&sts, &aid, "pwr_sev_init");
if (EVEN(sts)) {
errh_LogFatal(&cp->log, "qcom_Init, %m", sts);
exit(sts);
}
qcom_CreateQ(&sts, &cp->eventQ, NULL, "iniEvent");
if (EVEN(sts)) {
errh_LogFatal(&cp->log, "qcom_CreateQ, %m", sts);
exit(sts);
}
// ini_SetSystemStatus( cp, PWR__RUNNING);
errh_SetStatus( PWR__SRUN);
return sts;
}
