static void
init (
)
{
pwr_sClass_ASup *asp;
pwr_sClass_DSup *dsp;
pwr_tStatus sts;
sAttribute *ap;
sObject *op;
sSupObject *sp;
pwr_tObjid oid;
ltp = tree_CreateTable(&sts, sizeof(pwr_tObjid), offsetof(sObject, oid),
sizeof(sObject), 200, tree_Comp_oid);
sts = gdh_GetClassList(pwr_cClass_ASup, &oid);
while (ODD(sts)) {
sts = gdh_ObjidToPointer(oid, (void **)&asp);
op = tree_Find(&sts, ltp, &asp->Attribute.Objid);
if (op == NULL) {
op = tree_Insert(&sts, ltp, &asp->Attribute.Objid);
LstIni(&op->attr_l);
}
ap = findAttribute(op, &asp->Attribute, pwr_cClass_ASup);
sp = calloc(1, sizeof(*sp));
(void)LstIns(LstEnd(&ap->sup_l), sp, sup_l);
sp->oid = oid;
sp->p = asp;
op->sup_c++;
ap->sup_c++;
sts = gdh_GetNextObject(oid, &oid);
}
sts = gdh_GetClassList(pwr_cClass_DSup, &oid);
while (ODD(sts)) {
sts = gdh_ObjidToPointer(oid, (void **)&dsp);
op = tree_Find(&sts, ltp, &dsp->Attribute.Objid);
if (op == NULL) {
op = tree_Insert(&sts, ltp, &dsp->Attribute.Objid);
LstIni(&op->attr_l);
}
ap = findAttribute(op, &dsp->Attribute, pwr_cClass_DSup);
sp = calloc(1, sizeof(*sp));
(void)LstIns(LstEnd(&ap->sup_l), sp, sup_l);
sp->oid = oid;
sp->p = dsp;
op->sup_c++;
ap->sup_c++;
sts = gdh_GetNextObject(oid, &oid);
}
}
//
// Set Scan filter
//
static pwr_tStatus SetScanFilter( xmenu_sMenuCall *ip)
{
pwr_tObjid child;
int sts;
pwr_tBoolean local;
pwr_tObjid io_handler;
pwr_sClass_IOHandler *io_handler_p;
pwr_sClass_windowplc *window_p;
pwr_tClassId classid;
int enable;
if ( !ip->Priv & pwr_mPrv_System)
return XNAV__INSENSITIVE;
if ( strcmp( "Enable", ip->ItemList[ip->ChosenItem].FilterArguments[0]) == 0)
enable = 1;
else if ( strcmp( "Disable", ip->ItemList[ip->ChosenItem].FilterArguments[0]) == 0)
enable = 0;
else
return XNAV__SUCCESS;
// Only on local objects
sts = gdh_GetObjectLocation( ip->Pointed.Objid, &local);
if ( EVEN(sts) || !local)
return XNAV__INSENSITIVE;
// Only if simulate
sts = gdh_GetClassList( pwr_cClass_IOHandler, &io_handler);
if ( EVEN(sts)) return sts;
sts = gdh_ObjidToPointer( io_handler, (void **) &io_handler_p);
if ( EVEN(sts)) return sts;
if ( !io_handler_p->IOSimulFlag)
return XNAV__INSENSITIVE;
sts = gdh_GetChild( ip->Pointed.Objid, &child);
while( ODD(sts)) {
sts = gdh_GetObjectClass( child, &classid);
if ( EVEN(sts)) return sts;
if ( classid == pwr_cClass_windowplc) {
sts = gdh_ObjidToPointer( child, (void **) &window_p);
if ( EVEN(sts)) return sts;
if ( (enable && window_p->ScanOff) ||
(!enable && !window_p->ScanOff))
return XNAV__SUCCESS;
else
return XNAV__INSENSITIVE;
}
}
return XNAV__INVISIBLE;
}
/* Supervise emon server process */
void
pwrs_Node_SupEmon (
)
{
int i = errh_eAnix_emon - 1;
pwr_tTime current_time;
pwr_tDeltaTime diff;
static float timeout = 3;
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->ProcStatus[i] != 0 && np->ProcStatus[i] != PWR__PTIMEOUT) {
time_GetTime( ¤t_time);
time_Adiff( &diff, ¤t_time, &np->ProcTimeStamp[i]);
if ( time_DToFloat( 0, &diff) > timeout) {
if ( errh_Severity( np->ProcStatus[i]) < errh_Severity(PWR__PTIMEOUT)) {
np->ProcStatus[i] = PWR__PTIMEOUT;
np->SystemStatus = PWR__PTIMEOUT;
}
}
}
}
static pwr_tStatus IoCardInit (
io_tCtx ctx,
io_sAgent *ap,
io_sRack *rp,
io_sCard *cp
)
{
pwr_sClass_Ssab_PIDuP *op;
io_sLocal *local;
pwr_tStatus sts;
op = (pwr_sClass_Ssab_PIDuP *) cp->op;
local = calloc( 1, sizeof(*local));
cp->Local = local;
local->Address = op->RegAddress;
local->Qbus_fp = ((io_sRackLocal *)(rp->Local))->Qbus_fp;
errh_Info( "Init of pid card '%s'", cp->Name);
sts = gdh_ObjidToPointer(op->PidXCon, (void *) &local->objP);
if ( EVEN(sts)) {
errh_Error( "PID-card not properly connected, %s", cp->Name);
return IO__ERRDEVICE;
}
/* Calculate indexes in I/O-area */
local->dyn_ind = ((char *) &local->Dyn - (char *) local) / 2;
local->par_ind = ((char *) &local->Par - (char *) local) / 2;
local->stat_ind = ((char *) &local->Stat - (char *) local) / 2;
local->ran_ind = ((char *) &local->AoRange - (char *) local) / 2;
return 1;
}
static void
create_thread (
plc_sThread *tp,
plc_sProctbl *ptp,
plc_sProcess *pp
)
{
pwr_tStatus sts;
long int phase;
tp->aref.Objid = ptp->thread;
tp->init = ptp->init;
tp->exec = ptp->exec;
tp->first_scan = 1;
tp->PlcThread = pwrb_PlcThread_Init(&sts, tp);
tp->csup_lh = csup_Init(&sts, ptp->thread, tp->f_scan_time);
tp->i_scan_time = tp->f_scan_time * 1000.0 + 0.5;
time_FloatToD(&tp->scan_time, tp->f_scan_time);
tp->pp = pp;
plc_inittimer(tp);
tp->exit = FALSE;
link_io_copy_areas(tp);
que_Create(&sts, &tp->q_in);
que_Create(&sts, &tp->q_out);
sts = gdh_ObjidToName(ptp->thread, tp->name, sizeof(tp->name), cdh_mNName);
if (EVEN(sts)) {
errh_Error("Get name of thread object %s, %m", cdh_ObjidToString(NULL, ptp->thread, 1), sts);
return;
}
sts = gdh_ObjidToPointer(ptp->thread, (void *)&tp->PlcThread);
if (EVEN(sts)) {
errh_Error("Direct link to thread object \"%s\", %m", tp->name, sts);
return;
}
#if defined OS_LYNX && USE_RT_TIMER
sem_init(&tp->ScanSem, 0, 0);
tp->ScanMultiple = tp->i_scan_time / (CLK_TCK/1000);
tp->IntervalCount = tp->ScanMultiple;
#endif
sts = thread_Create(&tp->tid, tp->name, (void *(*)())&plc_thread, tp);
if (EVEN(sts)) {
errh_Error("Creating thread \"%s\", %m", tp->name, sts);
return;
}
/* Wait for thread to initialize. */
phase = (long int)que_Get(&sts, &tp->q_out, NULL, NULL);
pwr_Assert(phase == 1);
}
int xnav_open_URL( pwr_tURL url)
{
char cmd[200];
int sts;
pwr_sClass_WebBrowserConfig *config_p = 0;
char browser[40] = "firefox";
pwr_tObjid config_objid;
sts = gdh_GetClassList( pwr_cClass_WebBrowserConfig, &config_objid);
if ( ODD(sts))
sts = gdh_ObjidToPointer( config_objid, (void **)&config_p);
if ( ODD(sts)) {
if ( strcmp( config_p->WebBrowser, "") != 0)
strcpy( browser, config_p->WebBrowser);
}
if ( strncmp( url, "$pwr_lang/", 10) == 0) {
// If file in $pwr_lang, check if file exist, else take en_us
if ( Lng::current() != lng_eLanguage_en_US) {
pwr_tURL testurl;
pwr_tTime t;
replace_symbol( url, testurl, config_p);
dcli_translate_filename( testurl, testurl);
sts = dcli_file_time( testurl, &t);
if ( EVEN(sts)) {
// Try en_us
strcpy( testurl, "$pwr_doc/en_us/");
strcat( testurl, &url[10]);
strcpy( url, testurl);
}
}
}
replace_symbol( url, url, config_p);
if ( strcmp( browser, "mozilla") == 0 ||
strcmp( browser, "rt_mozilla") == 0) {
// Try remote display first
sprintf( cmd, "%s -remote \"openurl(%s,new-window)\"", browser, url);
sts = system(cmd);
if ( sts) {
// Not started yet
sprintf( cmd, "%s %s &", browser, url);
system( cmd);
}
}
else {
sprintf( cmd, "%s %s &", browser, url);
system( cmd);
}
return XNAV__SUCCESS;
}
int print_data( pwr_sAttrRef *arp, FILE *fp)
{
int sts;
char *s;
pwr_tClassId classid;
char *object_p;
pwr_tAName dataname;
pwr_tAName objectname;
pwr_tAName attributename;
pwr_tObjid objid;
int object_backup;
int array_element = 0;
int index;
int nr;
sts = gdh_AttrrefToName( arp, dataname, sizeof(dataname), cdh_mNName);
if ( EVEN(sts)) return sts;
strcpy( objectname, dataname);
if ( (s = strchr( objectname, '.'))) {
*s = 0;
object_backup = 0;
strcpy( attributename, dataname);
if ( (s = strchr( dataname, '['))) {
array_element = 1;
nr = sscanf( s+1, "%d", &index);
if ( nr != 1) return 0;
}
}
else {
object_backup = 1;
}
sts = gdh_NameToObjid( objectname, &objid);
if ( EVEN(sts)) return sts;
sts = gdh_ObjidToPointer( objid, (void **)&object_p);
if ( EVEN(sts)) return sts;
sts = gdh_GetObjectClass( objid, &classid);
if ( EVEN(sts)) return sts;
if ( object_backup) {
print_object( objid, classid, object_p, 0, objectname, fp);
}
else {
print_attribute( objid, classid, object_p, attributename, array_element, index, fp);
}
return 1;
}
//
// Set scan
//
static pwr_tStatus SetScan( xmenu_sMenuCall *ip)
{
pwr_tObjid child;
int sts;
pwr_tBoolean local;
pwr_tObjid io_handler;
pwr_sClass_IOHandler *io_handler_p;
pwr_tBoolean value = 0;
pwr_tOName name;
pwr_tClassId classid;
if ( strcmp( "Enable", ip->ItemList[ip->ChosenItem].MethodArguments[0]) == 0)
value = 0;
else if ( strcmp( "Disable", ip->ItemList[ip->ChosenItem].MethodArguments[0]) == 0)
value = 1;
else
return XNAV__SUCCESS;
// Only on local objects
sts = gdh_GetObjectLocation( ip->Pointed.Objid, &local);
if ( EVEN(sts) || !local)
return 0;
// Only if simulate
sts = gdh_GetClassList( pwr_cClass_IOHandler, &io_handler);
if ( EVEN(sts)) return sts;
sts = gdh_ObjidToPointer( io_handler, (void **) &io_handler_p);
if ( EVEN(sts)) return sts;
if ( !io_handler_p->IOSimulFlag)
return 0;
sts = gdh_GetChild( ip->Pointed.Objid, &child);
while( ODD(sts)) {
sts = gdh_GetObjectClass( child, &classid);
if ( EVEN(sts)) return sts;
if ( classid == pwr_cClass_windowplc) {
sts = gdh_ObjidToName( child, name, sizeof(name),
cdh_mName_volumeStrict);
if ( EVEN(sts)) return sts;
strcat( name, ".ScanOff");
sts = gdh_SetObjectInfo( name, (void *) &value, sizeof( value));
if ( EVEN(sts)) return sts;
return XNAV__SUCCESS;
}
}
return 0;
}
static pwr_tStatus SimulateOn( xmenu_sMenuCall *ip)
{
int sts;
pwr_tObjid io_handler;
pwr_sClass_IOHandler *io_handler_p;
// Only if simulate
sts = gdh_GetClassList( pwr_cClass_IOHandler, &io_handler);
if ( EVEN(sts)) return XNAV__INVISIBLE;
sts = gdh_ObjidToPointer( io_handler, (void **) &io_handler_p);
if ( EVEN(sts)) return sts;
if ( !io_handler_p->IOSimulFlag)
return XNAV__INVISIBLE;
return XNAV__SUCCESS;
}
pwr_tStatus io_get_plhandler_object(pwr_sClass_EplHandler** o, pwr_tObjid* roid)
{
pwr_tStatus sts;
pwr_tObjid oid;
// Get EplHandler object
sts = gdh_GetClassList(pwr_cClass_EplHandler, &oid);
if (EVEN(sts))
return sts;
sts = gdh_ObjidToPointer(oid, (void*)o);
if (EVEN(sts))
return sts;
if (roid != NULL)
*roid = oid;
return IO__SUCCESS;
}
void rt_fast::open()
{
pwr_tStatus sts;
pwr_sAttrRef aref;
pwr_tObjid oid;
pwr_sClass_DsFastConf *conf_p;
// Open server configuration object DsFastConf
sts = gdh_GetClassList( pwr_cClass_DsFastConf, &oid);
if ( ODD(sts)) {
sts = gdh_ObjidToPointer( oid, (void **)&conf_p);
if ( EVEN(sts)) throw co_error( sts);
scan_time = 1.0 / conf_p->BaseFrequency;
}
else {
scan_time = 0.1;
errh_Info( "No fast configuration, using base frequency 10 Hz");
oid = pwr_cNObjid;
}
aproc_RegisterObject( oid);
// Open FastCurve object
for ( sts = gdh_GetClassListAttrRef( pwr_cClass_DsFastCurve, &aref);
ODD(sts);
sts = gdh_GetNextAttrRef( pwr_cClass_DsFastCurve, &aref, &aref)) {
fastobject *o = new fastobject( &aref);
objects.push_back( o);
try {
o->open( scan_time);
fast_cnt++;
}
catch ( co_error& e) {
delete o;
objects.pop_back();
errh_Error( "DsFastCurve configuration error: &s", (char *)e.what().c_str());
}
}
}
static void
init_grafcet ()
{
pwr_tStatus sts;
pwr_tObjid oid;
pwr_sClass_initstep *o;
sts = gdh_GetClassList(pwr_cClass_initstep, &oid);
while (ODD(sts)) {
sts = gdh_ObjidToPointer(oid, (void *)&o);
if (EVEN(sts)) {
errh_Error("Initialize all GRAFCET init steps, %m", sts);
return;
}
if (!o->StatusInit) {
/* This InitStep is not initialized. */
o->Status[0] = 1;
o->StatusInit = 1;
}
sts = gdh_GetNextObject(oid, &oid);
}
}
void EvEve::view_shift()
{
pwr_sClass_OpPlace *opp;
pwr_tStatus sts;
sts = gdh_ObjidToPointer( user, (pwr_tAddress *) &opp);
if ( EVEN(sts)) return;
if ( cdh_ObjidIsNull(ala->current_view)) {
set_view( opp->AlarmViews[0]);
}
else {
for ( unsigned int i = 0; i < sizeof(opp->AlarmViews)/sizeof(opp->AlarmViews[0]); i++) {
if ( cdh_ObjidIsEqual( ala->current_view, opp->AlarmViews[i])) {
if ( i == sizeof(opp->AlarmViews)/sizeof(opp->AlarmViews[0]) - 1)
set_view( pwr_cNObjid);
else
set_view( opp->AlarmViews[i+1]);
break;
}
}
}
}
void
pwrb_IOHandler_Exec (
void (* handler_event_cb)(int, int),
int swap
)
{
static pwr_tBoolean old_CardErrorSoftLimit = 0;
static pwr_tBoolean old_CardErrorHardLimit = 0;
if ( !iop || swap) {
pwr_tOid oid;
pwr_tStatus sts;
sts = gdh_GetClassList( pwr_cClass_IOHandler, &oid);
if ( ODD(sts))
gdh_ObjidToPointer( oid, (void **) &iop);
if ( EVEN(sts)) return;
}
if ( !iop)
return;
if ( handler_event_cb) {
if ( iop->CardErrorSoftLimit && !old_CardErrorSoftLimit)
(handler_event_cb)(pwr_eSystemEventTypeEnum_IOErrorSoftLimit, 1);
else if ( !iop->CardErrorSoftLimit && old_CardErrorSoftLimit)
(handler_event_cb)(pwr_eSystemEventTypeEnum_IOErrorSoftLimit, 0);
if ( iop->CardErrorHardLimit && !old_CardErrorHardLimit)
(handler_event_cb)(pwr_eSystemEventTypeEnum_IOErrorHardLimit, 1);
else if ( !iop->CardErrorHardLimit && old_CardErrorHardLimit)
(handler_event_cb)(pwr_eSystemEventTypeEnum_IOErrorHardLimit, 0);
}
old_CardErrorSoftLimit = iop->CardErrorSoftLimit;
old_CardErrorHardLimit = iop->CardErrorHardLimit;
}
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[])
{
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;
}
}
}
}
pwr_tUInt32 bck_WaitBackup (
void *context,
pwr_tBoolean timeout)
{
pwr_tUInt32 sts;
pwr_tObjid objid;
pwr_tInt32 c;
pwr_tTime t;
pwr_tVaxTime tmo;
pwr_tVaxTime tmptime;
pwr_sClass_Backup_Conf *backup_confp; /* Backup_Conf object pointer */
$DESCRIPTOR (timeunitdsc, "0 0:0:0.1"); /* 0.1 second units */
int cycletime;
#ifdef OS_ELN
pwr_tInt32 res;
pwr_tVaxTime *tmop;
#endif
#ifdef OS_VMS
$DESCRIPTOR (efcname, BCK_EFC_NAME);
#endif
/*
* Initialize
*/
#ifdef OS_ELN
if (!areas_mapped) {
BCK_MAP_AREAS;
areas_mapped = TRUE;
}
#endif
/*
* Find the local Backup_Conf object
*/
sts = gdh_GetClassList (pwr_cClass_Backup_Conf, &objid);
while (ODD (sts)) {
sts = gdh_ObjidToPointer (objid, (pwr_tAddress *)&backup_confp);
if (ODD (sts)) break;
sts = gdh_GetNextObject (objid, &objid);
}
if (EVEN (sts)) return sts; /* Something wrong, quit */
/*
* Pick up argument information
*/
if (context == NULL) time_GetTime(&t);
else {
t = *(pwr_tTime *)context;
free (context);
}
#ifdef OS_ELN
tmop = NULL;
#else
timed_out = FALSE;
sts = sys$ascefc (BCK_EFC, &efcname, 0, 0);
if (EVEN (sts)) lib$signal (sts); /* BUG */
#endif
if (timeout) {
cycletime = backup_confp->CycleSlow * 2;
if (cycletime == 0) cycletime = BCK_DEFAULT_SLOW * 2;
#ifdef OS_ELN
tmo = eln$time_value (&timeunitdsc);
#else
sts = sys$bintim (&timeunitdsc, &tmo);
if (EVEN (sts)) lib$signal (sts); /* BUG, should not happen */
#endif
lib$mult_delta_time (
&cycletime, /* multiplier */
&tmo); /* delta_time (modified) */
sys$gettim (&tmptime);
lib$add_times (&tmo, &tmptime, &tmo); /* Make absolute time */
#ifdef OS_ELN
tmop = &tmo;
#else
sts = sys$setimr (BCK_WRITE_DONE, &tmo, &astrtn, 4711, 0);
if (EVEN (sts)) lib$signal (sts); /* BUG */
#endif
}
/*
* Loop, and wait for things to happen
*/
while (TRUE) {
#ifdef OS_ELN
ker$clear_event (NULL, bck_write_done);
ker$wait_any (NULL, &res, tmop, bck_write_done);
/* Check for timeout */
if (res == 0) return SS$_TIMEOUT;
#else
sts = sys$clref (BCK_WRITE_DONE);
if (EVEN (sts)) lib$signal (sts); /* BUG */
sts = sys$waitfr (BCK_WRITE_DONE);
if (EVEN (sts)) lib$signal (sts); /* BUG */
/* Check for timeout */
if (timed_out) return SS$_TIMEOUT;
#endif
/* Check if both cycles done */
if (time_Acomp(&backup_confp->ObjTimeSlow, &t) < 0)
continue;
if (time_Acomp(&backup_confp->ObjTimeFast, &t) < 0)
continue;
break;
} /* Loop */
#ifdef OS_VMS
sys$cantim (4711, 0);
#endif
return 1; /* Done. */
} /* bck_WaitBackup */
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 XNav::getAllMenuItems( xmenu_sMenuCall *ip,
xmenu_sMenuItem **Item,
pwr_tObjid objid,
pwr_tUInt32 Level,
int *nItems,
int AddSeparator,
pwr_sAttrRef *CurrentObject)
{
int sts;
pwr_tCid classid;
pwr_tObjid child;
pwr_sMenuButton *mbp;
pwr_sMenuCascade *mcp;
pwr_sMenuRef *mrp;
pwr_tStatus (*filter)( xmenu_sMenuCall *);
int sensitive;
int i;
Level++;
memset(*Item, 0, sizeof(**Item));
if(AddSeparator) {
(*Item)->Level = Level;
(*Item)->Item = xmenu_eMenuItem_Separator;
(*Item)->MenuObject = pwr_cNObjid;
(*Item)++;
(*nItems)++;
}
else {
sts = gdh_GetObjectClass( objid, &classid);
if ( EVEN(sts)) return sts;
if ( classid == pwr_eClass_MenuButton) {
sts = gdh_ObjidToPointer( objid, (void **) &mbp);
if ( EVEN(sts)) return sts;
ip->ChosenItem = *nItems;
for ( i = 0; i < 5; i++) {
strcpy( (*Item)->FilterArguments[i], mbp->FilterArguments[i]);
}
// Call any filter method
(*Item)->CurrentObject = *CurrentObject;
sensitive = 1;
if ( strcmp( mbp->FilterName, "") != 0) {
sts = GetMethod( mbp->FilterName, &filter);
if ( ODD(sts)) {
sts = (filter) ( ip);
if ( sts == XNAV__INSENSITIVE)
sensitive = 0;
}
}
else
sts = XNAV__SUCCESS;
if ( ODD(sts)) {
(*Item)->Level = Level;
(*Item)->Item = xmenu_eMenuItem_Button;
(*Item)->MenuObject = objid;
(*Item)->Flags.f.Sensitive = sensitive;
if (strcmp( mbp->MethodName, "") == 0)
(*Item)->Flags.f.Sensitive = 0;
strcpy((*Item)->Name, mbp->ButtonName);
strcpy( (*Item)->Method, mbp->MethodName);
strcpy( (*Item)->Filter, mbp->FilterName);
for ( i = 0; i < 5; i++) {
strcpy( (*Item)->MethodArguments[i], mbp->MethodArguments[i]);
}
(*Item)++;
(*nItems)++;
}
}
else if ( classid == pwr_eClass_MenuSeparator) {
(*Item)->Level = Level;
(*Item)->Item = xmenu_eMenuItem_Separator;
(*Item)->MenuObject = objid;
(*Item)++;
(*nItems)++;
}
else if ( classid == pwr_eClass_MenuCascade) {
sts = gdh_ObjidToPointer( objid, (void **) &mcp);
if ( EVEN(sts)) return sts;
// Call any filter method
(*Item)->CurrentObject = *CurrentObject;
if ( strcmp( mcp->FilterName, "") != 0) {
sts = GetMethod( mcp->FilterName, &filter);
if ( ODD(sts)) {
sts = (filter) ( ip);
}
}
else
sts = XNAV__SUCCESS;
if ( ODD(sts)) {
(*Item)->Level = Level;
(*Item)->Item = xmenu_eMenuItem_Cascade;
(*Item)->Flags.f.Sensitive = 1;
strcpy((*Item)->Name, mcp->ButtonName);
(*Item)->MenuObject = objid;
(*Item)++;
(*nItems)++;
sts = gdh_GetChild( objid, &child);
while( ODD(sts)) {
sts = getAllMenuItems(ip, Item, child, Level, nItems, 0, CurrentObject);
if ( EVEN(sts)) return sts;
sts = gdh_GetNextSibling( child, &child);
}
}
}
else if ( classid == pwr_eClass_MenuRef &&
cdh_ObjidIsNull( CurrentObject->Objid)) {
pwr_tAName aname;
pwr_sAttrRef currentar;
pwr_tCid current_cid;
pwr_tTid a_tid;
pwr_tUInt32 a_size, a_offs, a_elem;
sts = gdh_ObjidToPointer( objid, (void **) &mrp);
if ( EVEN(sts)) return sts;
// Call any filter method
(*Item)->CurrentObject = *CurrentObject;
if ( strcmp( mrp->FilterName, "") != 0) {
sts = GetMethod( mrp->FilterName, &filter);
if ( ODD(sts)) {
sts = (filter) ( ip);
}
}
else
sts = XNAV__SUCCESS;
if ( ODD(sts)) {
int create_object_button = 0;
if ( strcmp( mrp->RefAttribute, "_SelfObject") == 0) {
// Object entry for attributes
char *s;
sts = gdh_AttrrefToName( &ip->Pointed, aname, sizeof(aname), cdh_mName_volumeStrict);
if ( EVEN(sts)) return sts;
if ( (s = strrchr( aname, '.')))
*s = 0;
sts = gdh_NameToAttrref( pwr_cNOid, aname, ¤tar);
if ( EVEN(sts)) return sts;
}
else {
sts = gdh_AttrrefToName( &ip->Pointed, aname, sizeof(aname), cdh_mName_volumeStrict);
if ( EVEN(sts)) return sts;
strcat( aname, ".");
strcat( aname, mrp->RefAttribute);
sts = gdh_GetAttributeCharacteristics( aname, &a_tid, &a_size,
&a_offs, &a_elem);
if ( ODD(sts)) {
switch ( a_tid) {
case pwr_eType_AttrRef:
sts = gdh_GetObjectInfo( aname, ¤tar, sizeof(currentar));
break;
case pwr_eType_Objid: {
pwr_tOid oid;
currentar = pwr_cNAttrRef;
sts = gdh_GetObjectInfo( aname, &oid, sizeof(oid));
currentar = cdh_ObjidToAref( oid);
break;
}
default:
sts = 0;
}
}
create_object_button = 0;
}
if ( ODD(sts) && cdh_ObjidIsNotNull( currentar.Objid)) {
(*Item)->Level = Level;
(*Item)->Item = xmenu_eMenuItem_Ref;
(*Item)->Flags.f.Sensitive = 1;
strcpy((*Item)->Name, mrp->ButtonName);
(*Item)->MenuObject = objid;
(*Item)++;
(*nItems)++;
// Create a label with current object name
sts = gdh_AttrrefToName( ¤tar, aname, sizeof(aname),
cdh_mNName);
if ( ODD(sts) && create_object_button) {
(*Item)->Level = Level;
(*Item)->Item = xmenu_eMenuItem_Button;
(*Item)->MenuObject = pwr_cNObjid;
strncpy((*Item)->Name, aname, sizeof((*Item)->Name));
(*Item)->Name[sizeof((*Item)->Name)-1] = 0;
(*Item)->MenuObject = pwr_cNObjid;
(*Item)->CurrentObject = currentar;
(*Item)->Flags.f.Sensitive = 1;
strcpy( (*Item)->Method, "$Object-OpenObject");
(*Item)++;
(*nItems)++;
}
sts = gdh_GetAttrRefTid( ¤tar, ¤t_cid);
if ( EVEN(sts)) return sts;
xmenu_eItemType item_type = ip->ItemType;
if ( currentar.Flags.b.Object)
ip->ItemType = xmenu_eItemType_Object;
else
ip->ItemType = xmenu_eItemType_AttrObject;
sts = GetObjectMenu(ip, current_cid, Item, Level, nItems, 0, ¤tar);
if ( EVEN(sts)) return sts;
ip->ItemType = item_type;
}
}
}
}
return XNAV__SUCCESS;
}
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)
{
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[])
{
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);
}
}
int Op::sup_init()
{
pwr_tOid node_oid;
pwr_tOid sup_oid;
pwr_tAName aname;
pwr_tStatus sts;
// Index 0 is current node
sts = gdh_GetNodeObject( 0, &node_oid);
if ( EVEN(sts)) return sts;
OpSup sup;
sup.node_oid = node_oid;
sts = gdh_ObjidToName( node_oid, sup.object_name, sizeof(sup.object_name), cdh_mName_volumeStrict);
if ( EVEN(sts)) return sts;
strcpy( aname, sup.object_name);
strcat( aname, ".SystemStatus");
sts = gdh_RefObjectInfo( aname, (void **)&sup.p, &sup.refid, sizeof(pwr_tStatus));
if ( EVEN(sts)) return sts;
syi_NodeName( &sts, sup.node_name, sizeof(sup.node_name));
sup_vect.push_back(sup);
// Add nodes in NodeLinkSup objects
for ( sts = gdh_GetClassList( pwr_cClass_NodeLinkSup, &sup_oid);
ODD(sts);
sts = gdh_GetNextObject( sup_oid, &sup_oid)) {
pwr_sClass_NodeLinkSup *sup_p;
qcom_sNode qnode;
pwr_tNid nid;
sts = gdh_ObjidToPointer( sup_oid, (void **)&sup_p);
OpSup nsup;
nsup.node_oid = sup_p->Node;
sts = gdh_ObjidToName( nsup.node_oid, nsup.object_name, sizeof(nsup.object_name),
cdh_mName_volumeStrict);
if ( EVEN(sts)) strcpy( nsup.object_name, "");
sts = gdh_ObjidToName( sup_oid, aname, sizeof(aname), cdh_mName_volumeStrict);
if ( EVEN(sts)) return sts;
strcat( aname, ".SystemStatus");
sts = gdh_RefObjectInfo( aname, (void **)&nsup.p, &sup.refid, sizeof(pwr_tStatus));
if ( EVEN(sts)) return sts;
int found = 0;
for (nid = qcom_cNNid; qcom_NextNode(&sts, &qnode, nid); nid = qnode.nid) {
if ( qnode.nid == nsup.node_oid.vid) {
strcpy( nsup.node_name, qnode.name);
found = 1;
break;
}
}
if ( !found)
strcpy( nsup.node_name, "Unknown");
sup_vect.push_back(nsup);
}
return 1;
}
/*
* Name:
* io_ConnectToDigSupLstSerial
*
*
* Function:
* Initialize list of DSup object for digitala in- och output signals.
* Description:
*
*/
pwr_tStatus io_ConnectToDigSupLstSerial (
pwr_tClassId Class,
pwr_tObjid ObjId,
pwr_tAddress ObjP /* Pointer to the object */
)
{
pwr_tStatus Sts;
pwr_sClass_DSup *DSupP;
pwr_sClass_Di *DiP;
pwr_sClass_Do *DoP;
pwr_sClass_Po *PoP;
pwr_tBoolean *BooleanP;
pwr_tObjid SupId;
pwr_tClassId ObjClass;
sDSupLstLink *DSupLstP;
sDSupLstLink *NextDSupLstP, *NextP;
switch (Class) {
case pwr_cClass_Di:
DiP = (pwr_sClass_Di *) ObjP;
BooleanP = gdh_TranslateRtdbPointer( (pwr_tUInt32)DiP->ActualValue );
break;
case pwr_cClass_Do:
DoP = (pwr_sClass_Do *) ObjP;
BooleanP = gdh_TranslateRtdbPointer( (pwr_tUInt32)DoP->ActualValue );
break;
case pwr_cClass_Po:
PoP = (pwr_sClass_Po *) ObjP;
BooleanP = gdh_TranslateRtdbPointer( (pwr_tUInt32)PoP->ActualValue );
break;
default:
return ( IO__SUCCESS );
break;
}
/* Get child with class DSup */
Sts = gdh_GetChild ( ObjId, &SupId);
while ( ODD(Sts)) {
Sts = gdh_GetObjectClass ( SupId, &ObjClass);
if ( EVEN(Sts)) return (Sts);
if ( ObjClass == pwr_cClass_DSup ) {
Sts = gdh_ObjidToPointer ( SupId, (pwr_tAddress *)&DSupP);
if (EVEN(Sts)) return ( Sts );
DSupLstP = (sDSupLstLink *) calloc( 1, sizeof(sDSupLstLink) );
DSupLstP->SupP = DSupP;
DSupLstP->ValueP = BooleanP;
if ( DSupDigSerialLstP == NULL ) {
DSupDigSerialLstP = DSupLstP;
}
else {
if ( DSupDigSerialLstP->NextP == NULL ) {
DSupDigSerialLstP->NextP = DSupLstP;
}
else {
NextP = DSupDigSerialLstP->NextP;
while ( NextP != NULL ) {
NextDSupLstP = NextP;
NextP = NextP->NextP;
}
NextDSupLstP->NextP = DSupLstP;
}
}
}
Sts = gdh_GetNextSibling ( SupId, &SupId);
}
return IO__SUCCESS;
} /* END io_ConnectToDigSupLstSerial */
/*
* Name:
* io_ConnectToAnaSupLstSerial
*
*
* Function:
* Initialize list of ASup object for serial connected analog in- och output
* signals.
* Description:
*
*/
pwr_tStatus io_ConnectToAnaSupLstSerial (
pwr_tClassId Class,
pwr_tObjid ObjId,
pwr_tAddress ObjP /* Pointer to the object */
)
{
pwr_tStatus Sts;
pwr_sClass_ASup *ASupP;
pwr_sClass_Ai *AiP;
pwr_sClass_Ao *AoP;
pwr_tFloat32 *Float32P;
pwr_tObjid SupId;
pwr_tClassId ObjClass;
sASupLstLink *ASupLstP;
sASupLstLink *NextASupLstP, *NextP;
switch (Class) {
case pwr_cClass_Ai:
AiP = (pwr_sClass_Ai *) ObjP;
Float32P = gdh_TranslateRtdbPointer( (pwr_tUInt32)AiP->ActualValue );
break;
case pwr_cClass_Ao:
AoP = (pwr_sClass_Ao *) ObjP;
Float32P = gdh_TranslateRtdbPointer( (pwr_tUInt32)AoP->ActualValue );
break;
default:
return ( IO__SUCCESS );
break;
}
/* Get child with class ASup */
Sts = gdh_GetChild ( ObjId, &SupId);
while ( ODD(Sts)) {
Sts = gdh_GetObjectClass ( SupId, &ObjClass);
if ( EVEN(Sts)) return (Sts);
if ( ObjClass == pwr_cClass_ASup ) {
Sts = gdh_ObjidToPointer ( SupId, (pwr_tAddress *)&ASupP);
if (EVEN(Sts)) return ( Sts );
ASupLstP = (sASupLstLink *) calloc( 1, sizeof(sASupLstLink) );
ASupLstP->SupP = ASupP;
ASupLstP->ValueP = Float32P;
if ( ASupAnaSerialLstP == NULL ) {
ASupAnaSerialLstP = ASupLstP;
}
else {
if ( ASupAnaSerialLstP->NextP == NULL ) {
ASupAnaSerialLstP->NextP = ASupLstP;
}
else {
NextP = ASupAnaSerialLstP->NextP;
while ( NextP != NULL ) {
NextASupLstP = NextP;
NextP = NextP->NextP;
}
NextASupLstP->NextP = ASupLstP;
}
}
}
Sts = gdh_GetNextSibling ( SupId, &SupId);
}
return IO__SUCCESS;
} /* END io_ConnectToAnaSupLstSerial */
/****************************************************************************
* Name: logg_loggconflist_add()
*
* Type pwr_tStatus
*
* Type Parameter IOGF Description
*
* Description:
* Add a conversion config object to the list.
*
**************************************************************************/
static pwr_tStatus logg_loggconflist_add(
logg_ctx loggctx,
pwr_tObjid objid,
logg_t_loggconf_list **loggconflist,
int *loggconflist_count)
{
logg_t_loggconf_list *loggconflist_ptr;
logg_t_loggconf_list *new_loggconflist;
pwr_sAttrRef attrref;
int i;
pwr_tStatus sts;
pwr_sClass_LoggConfig *loggconf;
/* Syntax check */
sts = gdh_ObjidToPointer ( objid, (pwr_tAddress *) &loggconf);
if ( EVEN(sts)) return sts;
/* Check that there is some filename */
if ( !strcmp( loggconf->LoggFile, ""))
return REM__LOGGFILE;
/* Check that identity is unique */
loggconflist_ptr = *loggconflist;
for ( i = 0; i < *loggconflist_count; i++)
{
if ( loggconflist_ptr->loggconf->Identity == loggconf->Identity)
return REM__DUPLIDENT;
loggconflist_ptr++;
}
if ( *loggconflist_count == 0)
{
*loggconflist = calloc( 1 , sizeof(logg_t_loggconf_list));
if ( *loggconflist == 0)
return REM__NOMEMORY;
}
else
{
new_loggconflist = calloc( *loggconflist_count + 1,
sizeof(logg_t_loggconf_list));
if ( new_loggconflist == 0)
return REM__NOMEMORY;
memcpy( new_loggconflist, *loggconflist,
*loggconflist_count * sizeof(logg_t_loggconf_list));
free( *loggconflist);
*loggconflist = new_loggconflist;
}
loggconflist_ptr = *loggconflist + *loggconflist_count;
loggconflist_ptr->objid = objid;
/* Direct link to the cell */
memset( &attrref, 0, sizeof(attrref));
attrref.Objid = objid;
sts = gdh_DLRefObjectInfoAttrref ( &attrref,
(pwr_tAddress *) &loggconflist_ptr->loggconf,
&loggconflist_ptr->subid);
if ( EVEN(sts)) return sts;
(*loggconflist_count)++;
return REM__SUCCESS;
}
void ini_StartApplications ()
{
pwr_tStatus sts;
pwr_sAppl *applp;
pwr_tObjid objid;
#ifdef OS_ELN
$DESCRIPTOR(prognamedsc, "");
$DESCRIPTOR(nulldsc, "");
$DESCRIPTOR(argdsc, "");
VARYING_STRING(255) filename;
VARYING_STRING(41) progname;
char tmpfilename[255],hostspec[20],*cp;
PORT jobport;
#endif
#ifdef OS_VMS
$DESCRIPTOR(prognamedsc, "");
$DESCRIPTOR(nulldsc, "");
$DESCRIPTOR(argdsc, "");
char spawnbuf [512] = "";
$DESCRIPTOR (SpawnCommand, "");
$DESCRIPTOR (SpawnPrcnam, "Appl Start");
pwr_tUInt32 Flags;
#endif
/* Find the $Appl objects on this particular node */
sts = gdh_GetClassList(pwr_eClass_Appl, &objid);
while (ODD(sts)) {
if (ODD(gdh_ObjidToPointer(objid, (pwr_tAddress *)&applp))) {
/* Found an object on this node, load the program */
#ifdef OS_ELN
if (strlen(applp->FileName) > 0) {
/* Check whether we booted from a local disk or not */
if (ini_LocalBoot()) {
/* Local boot */
/* Find the filename. Beyond the last ':' */
cp = strrchr(applp->FileName,':');
if ( cp )
*cp++;
else
cp = applp->FileName;
/* Build the application filename. */
sprintf(tmpfilename,"%s%s",ini_BootFilesLocation(),cp);
} else {
/* Remote boot */
/* Check if application name contains '::'. If not - add hostspec */
cp = strstr(applp->FileName,"::");
if (!cp ) {
ini_GetNodeInfo(NULL, NULL, NULL, hostspec, NULL, NULL);
sprintf(tmpfilename,"%s::%s",hostspec,applp->FileName);
} else {
strcpy(tmpfilename,applp->FileName);
}
}
errh_Info("Load program '%s'", tmpfilename);
CSTRING_TO_VARYING(tmpfilename, filename);
CSTRING_TO_VARYING(applp->ProgramName, progname);
eln$load_program(&filename, &progname, applp->KernelMode,
applp->StartWithDebug, FALSE, applp->KernelStackSize, 1,
10, applp->JobPriority, applp->ProcessPriority, &sts);
if (EVEN(sts)) errh_Error("eln$load_program '%s'\n%m", applp->ProgramName, sts);
}
if (ODD(sts)) {
/* Start it */
errh_Info("Start program '%s'", applp->ProgramName);
prognamedsc.dsc$a_pointer = applp->ProgramName;
prognamedsc.dsc$w_length = strlen(applp->ProgramName);
argdsc.dsc$a_pointer = applp->Arg;
argdsc.dsc$w_length = strlen (applp->Arg);
ker$create_job(&sts, &jobport, &prognamedsc, NULL, &nulldsc, &nulldsc, &nulldsc, &argdsc);
if (EVEN(sts)) errh_Error("ker$create_job '%s'\n%m", applp->ProgramName, sts);
}
#elif defined(OS_VMS)
sprintf(spawnbuf, "$ @pwr_exe:rt_ini_appl_start %s \"%s\" %d %d \"%s\"",
applp->FileName, applp->ProgramName,
applp->StartWithDebug, applp->JobPriority,
applp->Arg);
SpawnCommand.dsc$w_length = strlen(spawnbuf);
SpawnCommand.dsc$a_pointer = spawnbuf;
Flags = 1; /* Nowait and Notify */
errh_Info("Starting %s\nin process %s", applp->FileName, applp->ProgramName);
sts = lib$spawn(&SpawnCommand, NULL, NULL, &Flags);
if (EVEN(sts)) errh_Error("lib$spawn '%s'\n%m", spawnbuf, sts);
#elif defined(OS_LYNX) || defined(OS_LINUX)
errh_Error("NYI. start %s \"%s\" %d %d \"%s\"",
applp->FileName, applp->ProgramName,
applp->StartWithDebug, applp->JobPriority,
applp->Arg);
#endif
} /* Local appl object */
sts = gdh_GetNextObject (objid, &objid);
}
}
static void
load_backup ()
{
pwr_tObjid oid;
pwr_sClass_AvArea *avp;
pwr_sClass_DvArea *dvp;
pwr_sClass_IvArea *ivp;
pwr_sClass_InitArea *iavp;
pwr_sClass_InitArea *idvp;
pwr_sClass_InitArea *iivp;
pwr_tStatus sts;
int i;
pwr_sClass_IOHandler *iop;
pwr_sAttrRef aref;
sts = io_get_iohandler_object(&iop, NULL);
if (EVEN(sts)) {
errh_Error("io_get_iohandler_object, %m", sts);
return;
}
sts = gdh_NameToObjid("pwrNode-active-io-av", &oid);
if (EVEN(sts)) {
errh_Error("gdh_NameToObjid(pwrNode-active-io-av, &oid), %m", sts);
return;
}
sts = gdh_ObjidToPointer(oid, (void *) &avp);
if (EVEN(sts)) {
errh_Error("gdh_ObjidToPointer(oid, (void *) &avp), %m", sts);
return;
}
sts = gdh_NameToObjid("pwrNode-active-io-av_init", &oid);
if (EVEN(sts)) {
errh_Error("gdh_NameToObjid(pwrNode-active-io-av_init, &oid), %m", sts);
return;
}
sts = gdh_ObjidToPointer(oid, (void *) &iavp);
if (EVEN(sts)) {
errh_Error("gdh_ObjidToPointer(oid, (void *) &iavp), %m", sts);
return;
}
sts = gdh_NameToObjid("pwrNode-active-io-dv", &oid);
if (EVEN(sts)) {
errh_Error("gdh_NameToObjid(pwrNode-active-io-dv, &oid), %m", sts);
return;
}
sts = gdh_ObjidToPointer(oid, (void *) &dvp);
if (EVEN(sts)) {
errh_Error("gdh_ObjidToPointer(oid, (void *) &dvp), %m", sts);
return;
}
sts = gdh_NameToObjid("pwrNode-active-io-dv_init", &oid);
if (EVEN(sts)) {
errh_Error("gdh_NameToObjid(pwrNode-active-io-dv_init, &oid), %m", sts);
return;
}
sts = gdh_ObjidToPointer(oid, (void *) &idvp);
if (EVEN(sts)) {
errh_Error("gdh_ObjidToPointer(oid, (void *) &idvp), %m", sts);
return;
}
sts = gdh_NameToObjid("pwrNode-active-io-iv", &oid);
if (EVEN(sts)) {
errh_Error("gdh_NameToObjid(pwrNode-active-io-iv, &oid), %m", sts);
return;
}
sts = gdh_ObjidToPointer(oid, (void *) &ivp);
if (EVEN(sts)) {
errh_Error("gdh_ObjidToPointer(oid, (void *) &ivp), %m", sts);
return;
}
sts = gdh_NameToObjid("pwrNode-active-io-iv_init", &oid);
if (EVEN(sts)) {
errh_Error("gdh_NameToObjid(pwrNode-active-io-iv_init, &oid), %m", sts);
return;
}
sts = gdh_ObjidToPointer(oid, (void *) &iivp);
if (EVEN(sts)) {
errh_Error("gdh_ObjidToPointer(oid, (void *) &iivp), %m", sts);
return;
}
for (i = 0; i < iop->AvCount; i++) {
pwr_tFloat32 *ifp = gdh_TranslateRtdbPointer(iavp->Value[i]);
avp->Value[i]= *ifp;
}
for (i = 0; i < iop->DvCount; i++) {
pwr_tBoolean *ibp = gdh_TranslateRtdbPointer(idvp->Value[i]);
dvp->Value[i] = *ibp;
}
for (i = 0; i < iop->IvCount; i++) {
pwr_tInt32 *iip = gdh_TranslateRtdbPointer(iivp->Value[i]);
ivp->Value[i] = *iip;
}
typedef struct {
union {
pwr_tFloat32 *f;
pwr_tInt32 *i;
pwr_tBoolean *b;
} actval_p;
pwr_tUInt32 validx;
union {
pwr_sClass_Av *av;
pwr_sClass_Iv *iv;
pwr_sClass_Dv *dv;
pwr_sClass_Ai *ai;
pwr_sClass_Ao *ao;
pwr_sClass_Ii *ii;
pwr_sClass_Io *io;
pwr_sClass_Di *di;
pwr_sClass_Do *dox;
pwr_sClass_Co *co;
} op;
} ini_sRestoreSig;
// Store ActualValue pointers
ini_sRestoreSig *rsav = calloc( sizeof(ini_sRestoreSig), iop->AvCount);
i = 0;
for ( sts = gdh_GetClassListAttrRef(pwr_cClass_Av, &aref);
ODD(sts);
sts = gdh_GetNextAttrRef(pwr_cClass_Av, &aref, &aref)) {
if ( i >= iop->AvCount) break;
sts = gdh_AttrRefToPointer( &aref, (pwr_tAddress *)&rsav[i].op.av);
if ( EVEN(sts)) {
errh_Error("gdh_AttrRefToPointer Iv, %m", sts);
return;
}
rsav[i].actval_p.f = rsav[i].op.av->ActualValue;
rsav[i].validx = rsav[i].op.av->ValueIndex;
i++;
}
ini_sRestoreSig *rsdv = calloc( sizeof(ini_sRestoreSig), iop->DvCount);
i = 0;
for ( sts = gdh_GetClassListAttrRef(pwr_cClass_Dv, &aref);
ODD(sts);
sts = gdh_GetNextAttrRef(pwr_cClass_Dv, &aref, &aref)) {
if ( i >= iop->DvCount) break;
sts = gdh_AttrRefToPointer( &aref, (pwr_tAddress *)&rsdv[i].op.dv);
if ( EVEN(sts)) {
errh_Error("gdh_AttrRefToPointer Iv, %m", sts);
return;
}
rsdv[i].actval_p.b = rsdv[i].op.dv->ActualValue;
rsdv[i].validx = rsdv[i].op.dv->ValueIndex;
i++;
}
ini_sRestoreSig *rsiv = calloc( sizeof(ini_sRestoreSig), iop->IvCount);
i = 0;
for ( sts = gdh_GetClassListAttrRef(pwr_cClass_Iv, &aref);
ODD(sts);
sts = gdh_GetNextAttrRef(pwr_cClass_Iv, &aref, &aref)) {
if ( i >= iop->IvCount) break;
sts = gdh_AttrRefToPointer( &aref, (pwr_tAddress *)&rsiv[i].op.iv);
if ( EVEN(sts)) {
errh_Error("gdh_AttrRefToPointer Iv, %m", sts);
return;
}
rsiv[i].actval_p.i = rsiv[i].op.iv->ActualValue;
rsiv[i].validx = rsiv[i].op.iv->ValueIndex;
i++;
}
ini_sRestoreSig *rsai = calloc( sizeof(ini_sRestoreSig), iop->AiCount);
i = 0;
for ( sts = gdh_GetClassListAttrRef(pwr_cClass_Ai, &aref);
ODD(sts);
sts = gdh_GetNextAttrRef(pwr_cClass_Ai, &aref, &aref)) {
if ( i >= iop->AiCount) break;
sts = gdh_AttrRefToPointer( &aref, (pwr_tAddress *)&rsai[i].op.ai);
if ( EVEN(sts)) {
errh_Error("gdh_AttrRefToPointer Iv, %m", sts);
return;
}
rsai[i].actval_p.f = rsai[i].op.ai->ActualValue;
rsai[i].validx = rsai[i].op.ai->ValueIndex;
i++;
}
ini_sRestoreSig *rsao = calloc( sizeof(ini_sRestoreSig), iop->AoCount);
i = 0;
for ( sts = gdh_GetClassListAttrRef(pwr_cClass_Ao, &aref);
ODD(sts);
sts = gdh_GetNextAttrRef(pwr_cClass_Ao, &aref, &aref)) {
if ( i >= iop->AoCount) break;
sts = gdh_AttrRefToPointer( &aref, (pwr_tAddress *)&rsao[i].op.ao);
if ( EVEN(sts)) {
errh_Error("gdh_AttrRefToPointer Iv, %m", sts);
return;
}
rsao[i].actval_p.f = rsao[i].op.ao->ActualValue;
rsao[i].validx = rsao[i].op.ao->ValueIndex;
i++;
}
ini_sRestoreSig *rsii = calloc( sizeof(ini_sRestoreSig), iop->IiCount);
i = 0;
for ( sts = gdh_GetClassListAttrRef(pwr_cClass_Ii, &aref);
ODD(sts);
sts = gdh_GetNextAttrRef(pwr_cClass_Ii, &aref, &aref)) {
if ( i >= iop->IiCount) break;
sts = gdh_AttrRefToPointer( &aref, (pwr_tAddress *)&rsii[i].op.ii);
if ( EVEN(sts)) {
errh_Error("gdh_AttrRefToPointer Iv, %m", sts);
return;
}
rsii[i].actval_p.i = rsii[i].op.ii->ActualValue;
rsii[i].validx = rsii[i].op.ii->ValueIndex;
i++;
}
ini_sRestoreSig *rsio = calloc( sizeof(ini_sRestoreSig), iop->IoCount);
i = 0;
for ( sts = gdh_GetClassListAttrRef(pwr_cClass_Io, &aref);
ODD(sts);
sts = gdh_GetNextAttrRef(pwr_cClass_Io, &aref, &aref)) {
if ( i >= iop->IoCount) break;
sts = gdh_AttrRefToPointer( &aref, (pwr_tAddress *)&rsio[i].op.io);
if ( EVEN(sts)) {
errh_Error("gdh_AttrRefToPointer Iv, %m", sts);
return;
}
rsio[i].actval_p.i = rsio[i].op.io->ActualValue;
rsio[i].validx = rsio[i].op.io->ValueIndex;
i++;
}
ini_sRestoreSig *rsdi = calloc( sizeof(ini_sRestoreSig), iop->DiCount);
i = 0;
for ( sts = gdh_GetClassListAttrRef(pwr_cClass_Di, &aref);
ODD(sts);
sts = gdh_GetNextAttrRef(pwr_cClass_Di, &aref, &aref)) {
if ( i >= iop->DiCount) break;
sts = gdh_AttrRefToPointer( &aref, (pwr_tAddress *)&rsdi[i].op.di);
if ( EVEN(sts)) {
errh_Error("gdh_AttrRefToPointer Iv, %m", sts);
return;
}
rsdi[i].actval_p.b = rsdi[i].op.di->ActualValue;
rsdi[i].validx = rsdi[i].op.di->ValueIndex;
i++;
}
ini_sRestoreSig *rsdo = calloc( sizeof(ini_sRestoreSig), iop->DoCount);
i = 0;
for ( sts = gdh_GetClassListAttrRef(pwr_cClass_Do, &aref);
ODD(sts);
sts = gdh_GetNextAttrRef(pwr_cClass_Do, &aref, &aref)) {
if ( i >= iop->DoCount) break;
sts = gdh_AttrRefToPointer( &aref, (pwr_tAddress *)&rsdo[i].op.dox);
if ( EVEN(sts)) {
errh_Error("gdh_AttrRefToPointer Iv, %m", sts);
return;
}
rsdo[i].actval_p.b = rsdo[i].op.dox->ActualValue;
rsdo[i].validx = rsdo[i].op.dox->ValueIndex;
i++;
}
ini_sRestoreSig *rsco = calloc( sizeof(ini_sRestoreSig), iop->CoCount);
pwr_tInt32 **rscoa = calloc( sizeof(pwr_tInt32*), iop->CoCount);
i = 0;
for ( sts = gdh_GetClassListAttrRef(pwr_cClass_Co, &aref);
ODD(sts);
sts = gdh_GetNextAttrRef(pwr_cClass_Co, &aref, &aref)) {
if ( i >= iop->CoCount) break;
sts = gdh_AttrRefToPointer( &aref, (pwr_tAddress *)&rsco[i].op.co);
if ( EVEN(sts)) {
errh_Error("gdh_AttrRefToPointer Iv, %m", sts);
return;
}
rsco[i].actval_p.i = rsco[i].op.co->RawValue;
rsco[i].validx = rsco[i].op.co->ValueIndex;
rscoa[i] = rsco[i].op.co->AbsValue;
i++;
}
sts = bck_LoadBackup();
if (EVEN(sts)) {
errh_Error("bck_LoadBackup, %m", sts);
return;
}
// Set stored ActualValue pointers
for ( i = 0; i < iop->AvCount; i++) {
rsav[i].op.av->ActualValue = rsav[i].actval_p.f;
rsav[i].op.av->ValueIndex = rsav[i].validx;
}
free( rsav);
for ( i = 0; i < iop->DvCount; i++) {
rsdv[i].op.dv->ActualValue = rsdv[i].actval_p.b;
rsdv[i].op.dv->ValueIndex = rsdv[i].validx;
}
free( rsdv);
for ( i = 0; i < iop->IvCount; i++) {
rsiv[i].op.iv->ActualValue = rsiv[i].actval_p.i;
rsiv[i].op.iv->ValueIndex = rsiv[i].validx;
}
free( rsiv);
for ( i = 0; i < iop->AiCount; i++) {
rsai[i].op.ai->ActualValue = rsai[i].actval_p.f;
rsai[i].op.ai->ValueIndex = rsai[i].validx;
}
free( rsai);
for ( i = 0; i < iop->AoCount; i++) {
rsao[i].op.ao->ActualValue = rsao[i].actval_p.f;
rsao[i].op.ao->ValueIndex = rsao[i].validx;
}
free( rsao);
for ( i = 0; i < iop->IiCount; i++) {
rsii[i].op.ii->ActualValue = rsii[i].actval_p.i;
rsii[i].op.ii->ValueIndex = rsii[i].validx;
}
free( rsii);
for ( i = 0; i < iop->IoCount; i++) {
rsio[i].op.io->ActualValue = rsio[i].actval_p.i;
rsio[i].op.io->ValueIndex = rsio[i].validx;
}
free( rsio);
for ( i = 0; i < iop->DiCount; i++) {
rsdi[i].op.di->ActualValue = rsdi[i].actval_p.b;
rsdi[i].op.di->ValueIndex = rsdi[i].validx;
}
free( rsdi);
for ( i = 0; i < iop->DoCount; i++) {
rsdo[i].op.dox->ActualValue = rsdo[i].actval_p.b;
rsdo[i].op.dox->ValueIndex = rsdo[i].validx;
}
free( rsdo);
for ( i = 0; i < iop->CoCount; i++) {
rsco[i].op.co->RawValue = rsco[i].actval_p.i;
rsco[i].op.co->AbsValue = rscoa[i];
rsco[i].op.co->ValueIndex = rsco[i].validx;
}
free( rsco);
free( rscoa);
for (i = 0; i < iop->AvCount; i++) {
pwr_tFloat32 *ifp = gdh_TranslateRtdbPointer(iavp->Value[i]);
*ifp = avp->Value[i];
}
for (i = 0; i < iop->DvCount; i++) {
pwr_tBoolean *ibp = gdh_TranslateRtdbPointer(idvp->Value[i]);
*ibp = dvp->Value[i];
}
for (i = 0; i < iop->IvCount; i++) {
pwr_tInt32 *iip = gdh_TranslateRtdbPointer(iivp->Value[i]);
*iip = ivp->Value[i];
}
}
EvAlaGtk::EvAlaGtk( void *ev_parent_ctx,
GtkWidget *ev_parent_wid,
char *ala_name,
pwr_tObjid ev_user,
int ev_eventname_seg,
int ev_width,
int ev_height,
int ev_x,
int ev_y,
pwr_tObjid ev_view,
unsigned int ev_options,
void *widget,
pwr_tStatus *status) :
EvAla( ev_parent_ctx, ala_name, ev_user, ev_eventname_seg,
ev_width, ev_height, ev_x, ev_y, ev_view, ev_options, status),
parent_wid(ev_parent_wid), toplevel(0)
{
pwr_tStatus sts;
pwr_sClass_OpPlace *opp;
pwr_tFileName fname;
int ala_width = 700;
int ala_height = 300;
*status = 1;
if ( ev_width != 0 && ev_height != 0) {
ala_width = ev_width;
ala_height = ev_height;
}
// Check user object
if ( cdh_ObjidIsNull( user)) {
*status = XNAV__NOUSER;
return;
}
sts = gdh_ObjidToPointer( user, (pwr_tAddress *) &opp);
if ( EVEN(sts)) {
*status = XNAV__NOUSER;
return;
}
ala_size = opp->MaxNoOfAlarms;
// create_aliaslist( opp);
// Ala Window
if ( !(options & ev_mAlaOptions_Embedded)) {
toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW,
"default-height", ala_height,
"default-width", ala_width,
"title", CoWowGtk::translate_utf8(ala_name),
NULL);
parent_wid_ala = toplevel;
g_signal_connect( parent_wid_ala, "delete_event", G_CALLBACK(ala_delete_event), this);
g_signal_connect( parent_wid_ala, "destroy", G_CALLBACK(ala_destroy_event), this);
g_signal_connect( parent_wid_ala, "focus-in-event", G_CALLBACK(ala_action_inputfocus), this);
CoWowGtk::SetWindowIcon( parent_wid_ala);
}
else
parent_wid_ala = (GtkWidget *)widget;
ala_vbox = gtk_vbox_new( FALSE, 0);
// Menu
// Accelerators
GtkAccelGroup *accel_g = (GtkAccelGroup *) g_object_new(GTK_TYPE_ACCEL_GROUP, NULL);
gtk_window_add_accel_group(GTK_WINDOW(parent_wid_ala), accel_g);
GtkMenuBar *menu_bar = (GtkMenuBar *) g_object_new(GTK_TYPE_MENU_BAR, NULL);
// File entry
GtkWidget *file_print = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Print"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(file_print),
gtk_image_new_from_stock( "gtk-print", GTK_ICON_SIZE_MENU));
g_signal_connect(file_print, "activate", G_CALLBACK(ala_activate_print), this);
GtkWidget *file_close = gtk_image_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Close"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(file_close),
gtk_image_new_from_stock( "gtk-close", GTK_ICON_SIZE_MENU));
g_signal_connect(file_close, "activate", G_CALLBACK(ala_activate_exit), this);
gtk_widget_add_accelerator( file_close, "activate", accel_g,
'w', GdkModifierType(GDK_CONTROL_MASK), GTK_ACCEL_VISIBLE);
GtkMenu *file_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_print);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close);
GtkWidget *file = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_File"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu));
// Functions entry
GtkWidget *functions_ack_last = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_Acknowledge"));
g_signal_connect( functions_ack_last, "activate",
G_CALLBACK(ala_activate_ack_last), this);
gtk_widget_add_accelerator( functions_ack_last, "activate", accel_g,
'k', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *functions_ack_all = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("A_cknowledge All"));
g_signal_connect( functions_ack_all, "activate",
G_CALLBACK(ala_activate_ack_all), this);
GtkWidget *functions_open_plc = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("Open _Program"));
g_signal_connect( functions_open_plc, "activate",
G_CALLBACK(ala_activate_open_plc), this);
gtk_widget_add_accelerator( functions_open_plc, "activate", accel_g,
'l', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *functions_display_object = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_Display object in Navigator"));
g_signal_connect( functions_display_object, "activate",
G_CALLBACK(ala_activate_display_in_xnav), this);
gtk_widget_add_accelerator( functions_display_object, "activate", accel_g,
'd', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkMenu *func_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(func_menu), functions_ack_last);
gtk_menu_shell_append(GTK_MENU_SHELL(func_menu), functions_ack_all);
gtk_menu_shell_append(GTK_MENU_SHELL(func_menu), functions_open_plc);
gtk_menu_shell_append(GTK_MENU_SHELL(func_menu), functions_display_object);
GtkWidget *functions = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Functions"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), functions);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(functions), GTK_WIDGET(func_menu));
// View entry
GtkWidget *view_shift_view = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("S_hift View"));
g_signal_connect( view_shift_view, "activate",
G_CALLBACK(ala_activate_shift_view), this);
gtk_widget_add_accelerator( view_shift_view, "activate", accel_g,
'n', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *view_zoom_in = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("Zoom _In"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(view_zoom_in),
gtk_image_new_from_stock( "gtk-zoom-in", GTK_ICON_SIZE_MENU));
g_signal_connect( view_zoom_in, "activate",
G_CALLBACK(ala_activate_zoom_in), this);
gtk_widget_add_accelerator( view_zoom_in, "activate", accel_g,
'i', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *view_zoom_out = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("Zoom _Out"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(view_zoom_out),
gtk_image_new_from_stock( "gtk-zoom-out", GTK_ICON_SIZE_MENU));
g_signal_connect( view_zoom_out, "activate",
G_CALLBACK(ala_activate_zoom_out), this);
gtk_widget_add_accelerator( view_zoom_out, "activate", accel_g,
'o', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *view_zoom_reset = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("Zoom _Reset"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(view_zoom_reset),
gtk_image_new_from_stock( "gtk-zoom-100", GTK_ICON_SIZE_MENU));
g_signal_connect( view_zoom_reset, "activate",
G_CALLBACK(ala_activate_zoom_reset), this);
gtk_widget_add_accelerator( view_zoom_reset, "activate", accel_g,
'b', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *view_disp_hundredth = gtk_check_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_Display hundredth"));
g_signal_connect( view_disp_hundredth, "activate",
G_CALLBACK(ala_activate_disp_hundredth), this);
GtkWidget *view_hide_object = gtk_check_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_Hide Event Name"));
g_signal_connect( view_hide_object, "activate",
G_CALLBACK(ala_activate_hide_object), this);
GtkWidget *view_hide_text = gtk_check_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("Hide _Event Text"));
g_signal_connect( view_hide_text, "activate",
G_CALLBACK(ala_activate_hide_text), this);
// Submenu Select View
GtkWidget *view_select_flat = gtk_menu_item_new_with_mnemonic( "_Flat");
g_signal_connect( view_select_flat, "activate",
G_CALLBACK(ala_activate_select_flat), this);
GtkWidget *view_select = gtk_menu_item_new_with_mnemonic( "_Select View");
GtkMenu *view_select_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(view_select_menu), view_select_flat);
for ( unsigned int i = 0; i < sizeof(opp->AlarmViews)/sizeof(opp->AlarmViews[0]); i++) {
pwr_sClass_AlarmView *viewp;
if ( cdh_ObjidIsNull( opp->AlarmViews[i]))
break;
sts = gdh_ObjidToPointer( opp->AlarmViews[i], (void **)&viewp);
if ( ODD(sts)) {
alarm_views[i] = opp->AlarmViews[i];
GtkWidget *view_select_view = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8(viewp->Name));
switch ( i) {
case 0: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view1), this); break;
case 1: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view2), this); break;
case 2: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view3), this); break;
case 3: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view4), this); break;
case 4: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view5), this); break;
case 5: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view6), this); break;
case 6: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view7), this); break;
case 7: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view8), this); break;
case 8: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view9), this); break;
case 9: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view10), this); break;
case 10: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view11), this); break;
case 11: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view12), this); break;
case 12: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view13), this); break;
case 13: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view14), this); break;
case 14: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view15), this); break;
case 15: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view16), this); break;
case 16: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view17), this); break;
case 17: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view18), this); break;
case 18: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view19), this); break;
case 19: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view20), this); break;
case 20: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view21), this); break;
case 21: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view22), this); break;
case 22: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view23), this); break;
case 23: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view24), this); break;
case 24: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view25), this); break;
}
gtk_menu_shell_append(GTK_MENU_SHELL(view_select_menu), view_select_view);
}
}
gtk_menu_item_set_submenu(GTK_MENU_ITEM(view_select),
GTK_WIDGET(view_select_menu));
GtkMenu *view_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_shift_view);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_select);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_in);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_out);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_reset);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_disp_hundredth);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_hide_object);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_hide_text);
GtkWidget *view = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_View"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), view);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(view), GTK_WIDGET(view_menu));
// Help entry
GtkWidget *help_help = gtk_image_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_Help"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(help_help),
gtk_image_new_from_stock( "gtk-help", GTK_ICON_SIZE_MENU));
g_signal_connect(help_help, "activate", G_CALLBACK(ala_activate_help), this);
gtk_widget_add_accelerator( help_help, "activate", accel_g,
'h', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget *help_helpevent = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("Help Selected Event"));
g_signal_connect( help_helpevent, "activate",
G_CALLBACK(ala_activate_helpevent), this);
GtkMenu *help_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_help);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_helpevent);
GtkWidget *help = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Help"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), GTK_WIDGET(help_menu));
// Create ala evlist
ala = new EvListGtk( this, ala_vbox, ev_eType_AlarmList, ala_size, eventname_seg,
&ala_widget, ala_init_cb);
ala->start_trace_cb = &ala_start_trace_cb;
ala->display_in_xnav_cb =&ala_display_in_xnav_cb;
ala->name_to_alias_cb = &ala_name_to_alias_cb;
ala->popup_menu_cb = &ala_popup_menu_cb;
ala->sound_cb = &ala_sound_cb;
ala->help_event_cb = &help_event_cb;
ala->selection_changed_cb = &ala_selection_changed_cb;
// Toolbar
GtkToolbar *tools = (GtkToolbar *) g_object_new(GTK_TYPE_TOOLBAR, NULL);
GtkWidget *tools_ack = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_acknowledge.png");
gtk_container_add( GTK_CONTAINER( tools_ack), gtk_image_new_from_file( fname));
g_signal_connect(tools_ack, "clicked", G_CALLBACK(ala_activate_ack_last), this);
g_object_set( tools_ack, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_ack, CoWowGtk::translate_utf8("Acknowledge"), "");
GtkWidget *tools_zoom_in = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_in.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_in),
gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_in, "clicked", G_CALLBACK(ala_activate_zoom_in), this);
g_object_set( tools_zoom_in, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_zoom_in,CoWowGtk::translate_utf8("Zoom in"), "");
GtkWidget *tools_zoom_out = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_out.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_out),
gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_out, "clicked", G_CALLBACK(ala_activate_zoom_out), this);
g_object_set( tools_zoom_out, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_zoom_out,CoWowGtk::translate_utf8("Zoom out"), "");
GtkWidget *tools_zoom_reset = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_reset.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_reset),
gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_reset, "clicked", G_CALLBACK(ala_activate_zoom_reset), this);
g_object_set( tools_zoom_reset, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_zoom_reset,CoWowGtk::translate_utf8("Zoom reset"), "");
ala_methodtoolbar = new XttMethodToolbarGtk(0, 0, ~0, "");
GtkToolbar *tools_meth = (GtkToolbar *) ((XttMethodToolbarGtk *)ala_methodtoolbar)->build();
ala_methodtoolbar->m_xnav = (XNav *)((Ev *)parent_ctx)->parent_ctx;
ala_methodtoolbar->m_parent_ctx = ala;
ala_methodtoolbar->get_select_cb = ala->get_select;
ala_sup_methodtoolbar = new XttMethodToolbarGtk(0, 0, mt_mMethod_OpenPlc | mt_mMethod_RtNavigator,
" for supervisory object");
GtkToolbar *tools_sup = (GtkToolbar *) ((XttMethodToolbarGtk *)ala_sup_methodtoolbar)->build();
ala_sup_methodtoolbar->m_xnav = (XNav *)((Ev *)parent_ctx)->parent_ctx;
ala_sup_methodtoolbar->m_parent_ctx = ala;
ala_sup_methodtoolbar->get_select_cb = ala->get_select_supobject;
GtkWidget *ala_toolsbox = gtk_hbox_new( FALSE, 0);
gtk_box_pack_start( GTK_BOX(ala_toolsbox), GTK_WIDGET(tools), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(ala_toolsbox), GTK_WIDGET(gtk_separator_tool_item_new()), FALSE, FALSE, 4);
gtk_box_pack_start( GTK_BOX(ala_toolsbox), GTK_WIDGET(tools_sup), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(ala_toolsbox), GTK_WIDGET(gtk_separator_tool_item_new()), FALSE, FALSE, 4);
gtk_box_pack_start( GTK_BOX(ala_toolsbox), GTK_WIDGET(tools_meth), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(ala_vbox), GTK_WIDGET(menu_bar), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(ala_vbox), GTK_WIDGET(ala_toolsbox), FALSE, FALSE, 0);
gtk_box_pack_end( GTK_BOX(ala_vbox), GTK_WIDGET(ala_widget), TRUE, TRUE, 0);
if ( !(options & ev_mAlaOptions_Embedded)) {
gtk_container_add( GTK_CONTAINER(parent_wid_ala), ala_vbox);
}
// gtk_widget_show_all( parent_wid_ala);
ala_methodtoolbar->set_sensitive();
ala_sup_methodtoolbar->set_sensitive();
// }
if ( !(options & ev_mAlaOptions_Embedded)) {
gtk_widget_show_all( parent_wid_ala);
if ( !(x == 0 && y == 0)) {
// Set position
gtk_window_move( GTK_WINDOW(parent_wid_ala), x, y);
}
}
else
gtk_widget_set_size_request( ala_vbox, ala_width, ala_height);
ala_displayed = 1;
wow = new CoWowGtk( parent_wid_ala);
*status = 1;
}
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;
}
}