static pwr_tStatus AoRangeToCoef(
io_sChannel *chanp)
{
pwr_sClass_ChanAo *cop;
char buf[120];
pwr_tStatus sts;
int i;
pwr_tFloat32 PolyCoef1;
pwr_tFloat32 PolyCoef0;
cop = chanp->cop;
if ( cop)
{
cop->CalculateNewCoef = 0;
/* Coef for ActualValue to RawValue conversion */
if ( cop->ActValRangeHigh != cop->ActValRangeLow)
{
cop->SigValPolyCoef1 = (cop->SensorSigValRangeHigh - cop->SensorSigValRangeLow)/
(cop->ActValRangeHigh - cop->ActValRangeLow);
cop->SigValPolyCoef0 = cop->SensorSigValRangeHigh - cop->ActValRangeHigh *
cop->SigValPolyCoef1;
}
else
{
sts = gdh_ObjidToName( chanp->ChanObjid, buf, sizeof(buf),
cdh_mName_volumeStrict);
if ( EVEN(sts)) return sts;
errh_Error( "Invalid ActValueRange in Ao channel %s", buf);
return IO__CHANRANGE;
}
/* Coef for ActualValue to SignalValue conversion */
if ( cop->ChannelSigValRangeHigh != 0)
{
PolyCoef0 = 0;
PolyCoef1 = 2047. / cop->ChannelSigValRangeHigh;
cop->OutPolyCoef1 = cop->SigValPolyCoef1 * PolyCoef1;
cop->OutPolyCoef0 = PolyCoef0 + PolyCoef1*
cop->SigValPolyCoef0;
}
else
{
sts = gdh_ObjidToName( chanp->ChanObjid, buf, sizeof(buf),
cdh_mName_volumeStrict);
if ( EVEN(sts)) return sts;
errh_Error( "Invalid SigValueRange in Ao channel %s", buf);
return IO__CHANRANGE;
}
}
return IO__SUCCESS;
}
static void pwrsrv_WriteAttribute( rpvd_sMsgWriteAttribute *msg)
{
rpvd_sMsgAny rmsg;
pwr_tAName name;
pwr_tUInt32 asize, aoffs, aelem;
pwr_tTypeId atid;
pwr_tStatus sts;
rmsg.Type = rpvd_eMsg_Status;
rmsg.Id = msg->Id;
sts = gdh_ObjidToName( msg->Oid, name, sizeof(name), cdh_mName_volumeStrict);
if ( EVEN(sts)) {
rmsg.Status = sts;
udp_Send( (char *)&rmsg, sizeof(rmsg));
return;
}
strcat( name, ".");
strcat( name, msg->Attribute);
sts = gdh_GetAttributeCharacteristics( name, &atid, &asize, &aoffs, &aelem);
if ( EVEN(sts)) {
rmsg.Status = sts;
udp_Send( (char *)&rmsg, sizeof(rmsg));
return;
}
sts = gdh_SetObjectInfo( name, &msg->Value, msg->Size);
rmsg.Status = sts;
udp_Send( (char *)&rmsg, sizeof(rmsg));
}
/*------------------------------------------------------------------------------
*/
static char *FormatOperator(
pwr_tObjid Outunit
)
{
pwr_tStatus sts;
static char Text[100];
pwr_tClassId Class;
pwr_sClass_User Operator;
pwr_tFullName FullName;
strcpy(Text,"--");
sts = gdh_GetObjectClass(Outunit, &Class);
if (ODD(sts)) {
if (Class == pwr_cClass_User) {
sts = gdh_ObjidToName(Outunit, FullName, sizeof(FullName), cdh_mNName);
if (ODD(sts)) {
sts = gdh_GetObjectInfo(FullName, &Operator, sizeof(pwr_sClass_User));
if (ODD(sts)) {
sprintf(Text, "%s %d %s %s", _OPPLACE, Operator.OpNumber,
_OPERATOR, Operator.UserName
);
}
}
}
}
return Text;
}
int rtt_crossref_channel(unsigned long ctx, pwr_tObjid objid, void* arg1,
void* arg2, void* arg3, void* arg4)
{
pwr_tAName hiername;
int sts;
pwr_sAttrRef signal_aref;
sts = gdh_ObjidToName(objid, hiername, sizeof(hiername), cdh_mNName);
if (EVEN(sts)) {
rtt_message('E', "Cross reference not defined");
return RTT__NOPICTURE;
}
strcat(hiername, ".SigChanCon");
sts = gdh_GetObjectInfo(
hiername, (pwr_tAddress)&signal_aref, sizeof(signal_aref));
if (EVEN(sts))
return sts;
sts = gdh_AttrrefToName(&signal_aref, hiername, sizeof(hiername), cdh_mNName);
if (EVEN(sts)) {
rtt_message('E', "Cross reference not defined");
return RTT__NOPICTURE;
}
sts = rtt_crr_signal(NULL, hiername);
return sts;
}
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);
}
//
// Set attribute value
//
int XAttNav::set_attr_value( brow_tObject node, char *name, char *value_str)
{
Item *base_item;
int sts;
char buff[1024];
pwr_tAName attr_str;
// Check authorization
if ( is_authorized_cb) {
if ( !(is_authorized_cb( parent_ctx,
pwr_mAccess_RtWrite | pwr_mAccess_System))) {
message( 'E', "Not authorized for this operation");
return XATT__NOTAUTHORIZED;
}
}
// Check that object still exist
if ( !object_exist( node))
return XATT__DISAPPEARD;
brow_GetUserData( node, (void **)&base_item);
switch( base_item->type) {
case xnav_eItemType_AttrArrayElem:
case xnav_eItemType_Attr:
case xnav_eItemType_Collect:
{
ItemAttr *item = (ItemAttr *)base_item;
// Check that objid is still the same
if ( strcmp(item->attr, name) != 0)
return XATT__DISAPPEARD;
sts = gdh_ObjidToName( item->objid,
attr_str, sizeof(attr_str), cdh_mName_volumeStrict);
if ( EVEN(sts)) return sts;
strcat( attr_str, ".");
strcat( attr_str, item->attr);
sts = XNav::attr_string_to_value( item->type_id,
value_str, buff, sizeof(buff), item->size);
if ( EVEN(sts))
message( 'E', "Input syntax error");
else
{
sts = gdh_SetObjectInfo( attr_str, buff, item->size);
if ( EVEN(sts)) return sts;
}
return sts;
}
default:
;
}
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;
}
int rtt_crossref_signal(unsigned long ctx, pwr_tObjid objid, void* arg1,
void* arg2, void* arg3, void* arg4)
{
pwr_tOName hiername;
int sts;
sts = gdh_ObjidToName(objid, hiername, sizeof(hiername), cdh_mNName);
if (EVEN(sts)) {
rtt_message('E', "Cross reference not defined");
return RTT__NOPICTURE;
}
sts = rtt_crr_signal(NULL, hiername);
return sts;
}
void disksup_object::exec()
{
#if defined OS_LINUX
struct statfs buf;
int sts;
pwr_sClass_DiskSup *o = (pwr_sClass_DiskSup *)p;
sts = statfs( o->DiskName, &buf);
if ( sts != 0) {
sts = errno_GetStatus();
if ( o->Status != sts) {
o->Status = sts;
printf( "Can't find disk\n");
}
return;
}
o->CurrentUse = 100.0 - 100.0 * buf.f_bfree / buf.f_blocks;
// Check if limit is exceeded
if ( !(o->CurrentUse < o->UsedMaxLimit)) {
if ( o->Status != SMON__DISKHIGHLIMIT) {
o->Status = SMON__DISKHIGHLIMIT;
if ( o->Action & pwr_mDiskSupActionMask_Alarm) {
pwr_tOName name;
sts = gdh_ObjidToName( aref.Objid, name, sizeof(name), cdh_mNName);
rt_sysmon::alarm_send( aref.Objid, o->DetectText, name, o->EventPriority);
}
if ( o->Action & pwr_mDiskSupActionMask_Command) {
if ( strcmp( o->Command, "") != 0) {
char msg[200];
system( o->Command);
sprintf( msg, "Command %s: %s", o->DiskName, o->Command);
errh_Info( msg);
}
}
}
}
else
o->Status = SMON__SUCCESS;
#endif
}
static pwr_tStatus AiRangeToCoef(
io_sChannel *chanp)
{
pwr_sClass_ChanAi *cop;
char buf[120];
pwr_tStatus sts;
pwr_tFloat32 PolyCoef1;
pwr_tFloat32 PolyCoef0;
cop = chanp->cop;
if ( cop)
{
cop->CalculateNewCoef = 0;
/* Coef for RawValue to SignalValue conversion */
cop->SigValPolyCoef0 = 0;
cop->SigValPolyCoef1 = cop->ChannelSigValRangeHigh / 30000;
/* Coef for SignalValue to ActualValue conversion */
if ( chanp->ChanClass != pwr_cClass_ChanAit && cop->SensorPolyType == 1)
{
if ( cop->SensorSigValRangeHigh != cop->SensorSigValRangeLow)
{
PolyCoef1 = (cop->ActValRangeHigh - cop->ActValRangeLow)/
(cop->SensorSigValRangeHigh - cop->SensorSigValRangeLow);
PolyCoef0 = cop->ActValRangeHigh - cop->SensorSigValRangeHigh *
PolyCoef1;
cop->SensorPolyCoef1 = cop->SigValPolyCoef1 * PolyCoef1;
cop->SensorPolyCoef0 = PolyCoef0 + PolyCoef1*
cop->SigValPolyCoef0;
}
else
{
sts = gdh_ObjidToName( chanp->ChanAref.Objid, buf, sizeof(buf),
cdh_mName_volumeStrict);
if ( EVEN(sts)) return sts;
errh_Error( "Invalid SigValueRange in Ai channel %s", buf);
return IO__CHANRANGE;
}
}
}
return IO__SUCCESS;
}
// Open trace
static pwr_tStatus OpenTrace( xmenu_sMenuCall *ip)
{
pwr_tOName name;
pwr_tCmd cmd;
int sts;
printf( "OpenProgram method called\n");
//foe_Open (ip->EditorContext, ip->WindowContext, ip->PointedSession,
// ip->Pointed.Objid);
sts = gdh_ObjidToName( ip->Pointed.Objid, name, sizeof(name),
cdh_mName_volumeStrict);
if ( EVEN(sts)) return sts;
sprintf( cmd, "open trace/name=%s", name);
((XNav *)ip->EditorContext)->command( cmd);
return 1;
}
static void pwrsrv_ObjectName( rpvd_sMsgObjectName *msg)
{
rpvd_sMsgOid m;
pwr_tStatus sts;
char name[256];
/* Simulate an oid request */
m.Type = rpvd_eMsg_Oid;
m.Id = msg->Id;
if ( msg->POid.oix) {
sts = gdh_ObjidToName( msg->POid, name, sizeof(name), cdh_mName_volumeStrict);
if ( EVEN(sts)) {
rpvd_sMsgObject rmsg;
rmsg.Type = rpvd_eMsg_Object;
rmsg.Id = msg->Id;
rmsg.Status = sts;
udp_Send( (char *)&rmsg, sizeof(rmsg));
return;
}
strcat( name, "-");
strcat( name, msg->Name);
}
else
strncpy( name, msg->Name, sizeof(name));
sts = gdh_NameToObjid( name, &m.Oid);
if ( EVEN(sts)) {
rpvd_sMsgObject rmsg;
rmsg.Type = rpvd_eMsg_Object;
rmsg.Id = msg->Id;
rmsg.Status = sts;
udp_Send( (char *)&rmsg, sizeof(rmsg));
return;
}
pwrsrv_Oid( &m);
}
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;
}
static pwr_tStatus IoRackInit (
io_tCtx ctx,
io_sAgent *ap,
io_sRack *rp
)
{
io_sCardLocal *local_card;
io_sCard *cardp;
io_sRackLocal *local;
int no_di;
int no_do;
pwr_sClass_Modbus_RTU_Slave *op;
char name[196];
pwr_tStatus sts;
pwr_tCid cid;
io_sChannel *chanp;
int i;
sts = gdh_ObjidToName(rp->Objid, (char *) &name, sizeof(name), cdh_mNName);
errh_Info( "Init of Modbus TCP Slave and Modules %s", name);
op = (pwr_sClass_Modbus_RTU_Slave *) rp->op;
rp->Local = calloc(1, sizeof(io_sRackLocal));
local = rp->Local;
op->Status = MB__NORMAL;
/* Do configuration check and initialize modules. */
cardp = rp->cardlist;
unsigned int prev_input_area_offset = 0;
unsigned int prev_output_area_offset = 0;
unsigned int input_area_offset = 0;
unsigned int output_area_offset = 0;
unsigned int input_area_chansize = 0;
unsigned int output_area_chansize = 0;
while(cardp) {
local_card = calloc(1, sizeof(*local_card));
cid = cardp->Class;
/* Find the super class */
while ( ODD( gdh_GetSuperClass( cid, &cid, cardp->Objid))) ;
switch (cid) {
case pwr_cClass_Modbus_RTU_Module: {
pwr_sClass_Modbus_RTU_Module *modulep;
cardp->Local = local_card;
no_di = 0;
no_do = 0;
local_card->msg[0].input_area = (void *) &(op->Inputs) + input_area_offset +
input_area_chansize;
local_card->msg[0].output_area = (void *) &(op->Outputs) + output_area_offset +
output_area_chansize;
modulep = (pwr_sClass_Modbus_RTU_Module *) cardp->op;
modulep->Status = pwr_eModbusModule_StatusEnum_StatusUnknown;
io_bus_card_init( ctx, cardp, &input_area_offset, &input_area_chansize,
&output_area_offset, &output_area_chansize,
pwr_eByteOrderingEnum_BigEndian, io_eAlignment_Packed);
/* Count number of di and do */
for (i = 0; i < cardp->ChanListSize; i++) {
chanp = &cardp->chanlist[i];
switch (chanp->ChanClass) {
case pwr_cClass_ChanDi:
no_di++;
break;
case pwr_cClass_ChanDo:
no_do++;
break;
}
}
local_card->msg[0].input_size = input_area_offset + input_area_chansize -
prev_input_area_offset;
local_card->msg[0].output_size = output_area_offset + output_area_chansize -
prev_output_area_offset;
local_card->msg[0].no_di = no_di;
local_card->msg[0].no_do = no_do;
break;
}
} /* End - switch ... */
prev_input_area_offset = input_area_offset + input_area_chansize;
prev_output_area_offset = output_area_offset + output_area_chansize;
cardp = cardp->next;
}
local->input_size = input_area_offset + input_area_chansize;
local->output_size = output_area_offset + output_area_chansize;
return IO__SUCCESS;
}
RtTraceGtk::RtTraceGtk( void *tr_parent_ctx, GtkWidget *tr_parent_wid, pwr_tObjid tr_objid,
pwr_tStatus *status) :
RtTrace( tr_parent_ctx, tr_objid, status), parent_wid(tr_parent_wid), toplevel(0), nav_shell(0)
{
const int window_width = 900;
const int window_height = 800;
const int nav_width = 180;
pwr_tStatus sts;
pwr_tObjid window_objid;
pwr_tClassId cid;
char title[220];
pwr_tOName hostname;
pwr_tOName plcconnect;
pwr_tFileName fname;
sts = gdh_ObjidToName( tr_objid, name, sizeof(name), cdh_mNName);
if (EVEN(sts)) {
*status = sts;
return;
}
strcpy( title, "Trace ");
strcat( title, name);
/* Find plcwindow */
sts = gdh_GetObjectClass( tr_objid, &cid);
if ( EVEN(sts)) {
*status = sts;
return;
}
if ( !(cid == pwr_cClass_windowplc ||
cid == pwr_cClass_windowcond ||
cid == pwr_cClass_windoworderact ||
cid == pwr_cClass_windowsubstep )) {
sts = gdh_GetChild( tr_objid, &window_objid);
if ( EVEN(sts)) {
*status = sts;
return;
}
}
else
window_objid = tr_objid;
sts = gdh_GetObjectClass( window_objid, &cid);
if ( EVEN(sts)) {
*status = sts;
return;
}
if ( !(cid == pwr_cClass_windowplc ||
cid == pwr_cClass_windowcond ||
cid == pwr_cClass_windoworderact ||
cid == pwr_cClass_windowsubstep )) {
*status = 0;
return;
}
sts = get_filename( window_objid, filename, &m_has_host, hostname,
plcconnect);
if ( EVEN(sts)) {
*status = sts;
return;
}
/* Create object context */
objid = window_objid;
if ( m_has_host) {
strcpy( m_hostname, hostname);
strcpy( m_plcconnect, plcconnect);
}
char *titleutf8 = g_convert( title, -1, "UTF-8", "ISO8859-1", NULL, NULL, NULL);
// Gtk
toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW,
"default-height", window_height,
"default-width", window_width,
"title", titleutf8,
NULL);
g_free( titleutf8);
g_signal_connect( toplevel, "delete_event", G_CALLBACK(delete_event), this);
g_signal_connect( toplevel, "destroy", G_CALLBACK(destroy_event), this);
CoWowGtk::SetWindowIcon( toplevel);
GtkAccelGroup *accel_g = (GtkAccelGroup *) g_object_new(GTK_TYPE_ACCEL_GROUP, NULL);
gtk_window_add_accel_group(GTK_WINDOW(toplevel), accel_g);
GtkMenuBar *menu_bar = (GtkMenuBar *) g_object_new(GTK_TYPE_MENU_BAR, NULL);
// File Entry
// Submenu Print
GtkWidget *file_print = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Print"));
g_signal_connect( file_print, "activate",
G_CALLBACK(activate_print), this);
GtkWidget *file_print_select = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("Print _Selected Documents"));
g_signal_connect( file_print_select, "activate",
G_CALLBACK(activate_printselect), this);
GtkWidget *file_savetrace = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("Save _Trace"));
g_signal_connect( file_savetrace, "activate",
G_CALLBACK(activate_savetrace), this);
GtkWidget *file_restoretrace = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Restore Trace"));
g_signal_connect( file_restoretrace, "activate",
G_CALLBACK(activate_restoretrace), this);
GtkWidget *file_cleartrace = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("C_lear Trace"));
g_signal_connect( file_cleartrace, "activate",
G_CALLBACK(activate_cleartrace), this);
GtkWidget *file_close = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g);
g_signal_connect(file_close, "activate", G_CALLBACK(activate_close), this);
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_print_select);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_savetrace);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_restoretrace);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_cleartrace);
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_open_object = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Open Object"));
g_signal_connect( functions_open_object, "activate",
G_CALLBACK(activate_open_object), this);
gtk_widget_add_accelerator( functions_open_object, "activate", accel_g,
'a', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *functions_open_subwindow = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("Open S_ubwindow"));
g_signal_connect( functions_open_subwindow, "activate",
G_CALLBACK(activate_open_subwindow), this);
gtk_widget_add_accelerator( functions_open_subwindow, "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(activate_display_object), this);
gtk_widget_add_accelerator( functions_display_object, "activate", accel_g,
'd', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *functions_show_cross = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Show Crossreferences"));
g_signal_connect( functions_show_cross, "activate",
G_CALLBACK(activate_show_cross), this);
gtk_widget_add_accelerator( functions_show_cross, "activate", accel_g,
'r', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *functions_open_classgraph = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Open ObjectGraph"));
g_signal_connect( functions_open_classgraph, "activate",
G_CALLBACK(activate_open_classgraph), this);
gtk_widget_add_accelerator( functions_open_classgraph, "activate", accel_g,
'g', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *functions_collect_insert = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Collect Insert"));
g_signal_connect( functions_collect_insert, "activate",
G_CALLBACK(activate_collect_insert), this);
gtk_widget_add_accelerator( functions_collect_insert, "activate", accel_g,
'v', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkMenu *functions_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_open_object);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_open_subwindow);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_display_object);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_show_cross);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_open_classgraph);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_collect_insert);
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(functions_menu));
// View Entry
GtkWidget *view_zoom_in = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_IN, NULL);
g_signal_connect( view_zoom_in, "activate",
G_CALLBACK(activate_zoomin), 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_from_stock(GTK_STOCK_ZOOM_OUT, NULL);
g_signal_connect( view_zoom_out, "activate",
G_CALLBACK(activate_zoomout), 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_from_stock(GTK_STOCK_ZOOM_100, NULL);
g_signal_connect( view_zoom_reset, "activate",
G_CALLBACK(activate_zoomreset), this);
gtk_widget_add_accelerator( view_zoom_reset, "activate", accel_g,
'b', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
// Submenu ScanTime
GSList *view_sc_group = NULL;
GtkWidget *view_scantime1 = gtk_radio_menu_item_new_with_mnemonic( view_sc_group,
"0.50 s");
view_sc_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(view_scantime1));
g_signal_connect( view_scantime1, "activate",
G_CALLBACK(activate_scantime1), this);
GtkWidget *view_scantime2 = gtk_radio_menu_item_new_with_mnemonic( view_sc_group,
"0.20 s");
view_sc_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(view_scantime1));
g_signal_connect( view_scantime2, "activate",
G_CALLBACK(activate_scantime2), this);
GtkWidget *view_scantime3 = gtk_radio_menu_item_new_with_mnemonic( view_sc_group,
"0.10 s");
view_sc_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(view_scantime1));
g_signal_connect( view_scantime3, "activate",
G_CALLBACK(activate_scantime3), this);
GtkWidget *view_scantime4 = gtk_radio_menu_item_new_with_mnemonic( view_sc_group,
"0.05 s");
view_sc_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(view_scantime1));
g_signal_connect( view_scantime4, "activate",
G_CALLBACK(activate_scantime4), this);
GtkWidget *view_scantime5 = gtk_radio_menu_item_new_with_mnemonic( view_sc_group,
"0.02 s");
g_signal_connect( view_scantime5, "activate",
G_CALLBACK(activate_scantime5), this);
GtkWidget *view_sc = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_ScanTime"));
GtkMenu *view_sc_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(view_sc_menu), view_scantime1);
gtk_menu_shell_append(GTK_MENU_SHELL(view_sc_menu), view_scantime2);
gtk_menu_shell_append(GTK_MENU_SHELL(view_sc_menu), view_scantime3);
gtk_menu_shell_append(GTK_MENU_SHELL(view_sc_menu), view_scantime4);
gtk_menu_shell_append(GTK_MENU_SHELL(view_sc_menu), view_scantime5);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(view_sc),
GTK_WIDGET(view_sc_menu));
GtkMenu *view_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
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_sc);
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));
// Mode entry
GSList *mode_group = NULL;
GtkWidget *mode_view = gtk_radio_menu_item_new_with_mnemonic( mode_group, CoWowGtk::translate_utf8("V_iew"));
mode_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(mode_view));
g_signal_connect( mode_view, "activate",
G_CALLBACK(activate_view), this);
GtkWidget *mode_trace = gtk_radio_menu_item_new_with_mnemonic( mode_group, CoWowGtk::translate_utf8("_Trace"));
mode_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(mode_trace));
g_signal_connect( mode_trace, "activate",
G_CALLBACK(activate_trace), this);
GtkWidget *mode_simulate = gtk_radio_menu_item_new_with_mnemonic( mode_group, CoWowGtk::translate_utf8("_Simulate"));
gtk_widget_add_accelerator( mode_simulate, "activate", accel_g,
's', GdkModifierType(GDK_CONTROL_MASK | GDK_SHIFT_MASK),
GTK_ACCEL_VISIBLE);
g_signal_connect( mode_simulate, "activate",
G_CALLBACK(activate_simulate), this);
GtkMenu *mode_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(mode_menu), mode_view);
gtk_menu_shell_append(GTK_MENU_SHELL(mode_menu), mode_trace);
gtk_menu_shell_append(GTK_MENU_SHELL(mode_menu), mode_simulate);
GtkWidget *mode = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Mode"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), mode);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(mode), GTK_WIDGET(mode_menu));
// Menu Help
GtkWidget *help_help = gtk_image_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("On _Trace"));
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(activate_help), this);
gtk_widget_add_accelerator( help_help, "activate", accel_g,
'h', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget *help_plcpgm = gtk_check_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("On _PlcPgm"));
g_signal_connect( help_plcpgm, "activate",
G_CALLBACK(activate_helpplc), 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_plcpgm);
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));
// Toolbar
GtkToolbar *tools = (GtkToolbar *) g_object_new(GTK_TYPE_TOOLBAR, NULL);
GtkWidget *tools_display_object = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_navigator.png");
gtk_container_add( GTK_CONTAINER(tools_display_object),
gtk_image_new_from_file( fname));
g_signal_connect(tools_display_object, "clicked", G_CALLBACK(activate_display_object), this);
gtk_toolbar_append_widget( tools, tools_display_object, "Display object in Navigator", "");
GtkWidget *tools_show_cross = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_crossref.png");
gtk_container_add( GTK_CONTAINER(tools_show_cross),
gtk_image_new_from_file( fname));
g_signal_connect(tools_show_cross, "clicked", G_CALLBACK(activate_show_cross), this);
gtk_toolbar_append_widget( tools, tools_show_cross, "Show Crossreferences", "");
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(activate_zoomin), this);
gtk_toolbar_append_widget( tools, tools_zoom_in, "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(activate_zoomout), this);
gtk_toolbar_append_widget( tools, tools_zoom_out, "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(activate_zoomreset), this);
gtk_toolbar_append_widget( tools, tools_zoom_reset, "Zoom reset", "");
// Flow widget
GtkWidget *flow_scrolled = scrolledflowwidgetgtk_new( init_flow,
this, &flow_widget);
gtk_widget_show_all(flow_widget);
nav_widget = flownavwidgetgtk_new( flow_widget);
GtkWidget *paned = gtk_hpaned_new();
gtk_paned_pack1( GTK_PANED(paned), flow_scrolled, TRUE, TRUE);
gtk_paned_pack2( GTK_PANED(paned), nav_widget, FALSE, TRUE);
GtkWidget *vbox = gtk_vbox_new( FALSE, 0);
gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(menu_bar), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(tools), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(paned), TRUE, TRUE, 0);
gtk_container_add( GTK_CONTAINER(toplevel), vbox);
gtk_widget_show_all( toplevel);
gtk_paned_set_position( GTK_PANED(paned), window_width - nav_width);
#if 0
// Navigator window
nav_shell = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW,
"default-height", 200,
"default-width", 200,
"title", "Navigator",
NULL);
g_signal_connect( nav_shell, "delete_event", G_CALLBACK(nav_delete_event), this);
nav_widget = flownavwidgetgtk_new( flow_widget);
gtk_container_add( GTK_CONTAINER(nav_shell), nav_widget);
gtk_widget_show_all( nav_shell);
#endif
wow = new CoWowGtk( toplevel);
trace_timerid = wow->timer_new();
viewsetup();
flow_Open( flow_ctx, filename);
gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( mode_trace), TRUE);
gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( view_scantime1), TRUE);
//trasetup();
//trace_start();
#if defined OS_LINUX
{
struct stat info;
if ( stat( filename, &info) != -1)
version = info.st_ctime;
}
#endif
// Check version
unsigned int flow_version;
pwr_tUInt32 window_version;
pwr_tAName aname;
flow_GetCtxUserVersion( flow_ctx, &flow_version);
strcpy( aname, name);
strcat( aname, ".Version");
sts = gdh_GetObjectInfo( aname, &window_version, sizeof(window_version));
if ( EVEN(sts)) return;
if ( flow_version > window_version)
wow->DisplayError( "Version mismatch", "Trace file is newer than database version");
else if ( flow_version < window_version)
wow->DisplayError( "Version mismatch", "Trace file is older than database version");
}
int XNav::GetObjectMenu( xmenu_sMenuCall *ip,
pwr_tCid classid,
xmenu_sMenuItem **Item,
pwr_tUInt32 Level,
int *nItems,
int AddSeparator,
pwr_sAttrRef *CurrentObject)
{
int sts;
pwr_tObjid child;
pwr_tObjid menu_objid;
char menu[80];
pwr_tOName classname;
pwr_sAttrRef currentar = pwr_cNAttrRef;
pwr_tCid supercid;
if ( cdh_ObjidIsNotNull( CurrentObject->Objid))
currentar = *CurrentObject;
if ( ip->ItemType == xmenu_eItemType_Object) {
// Popup-menu for an object
if ( !cdh_tidIsCid( classid))
return XNAV__SUCCESS;
// Get the RtXtt common menu-objects
strcpy( menu, "pwrs:Class-$Object-RtXtt");
sts = gdh_NameToObjid( menu, &menu_objid);
if ( ODD(sts)) {
sts = gdh_GetChild( menu_objid, &child);
while( ODD(sts)) {
sts = getAllMenuItems( ip, Item, child, Level, nItems, 0, ¤tar);
if ( EVEN(sts)) return sts;
sts = gdh_GetNextSibling( child, &child);
}
}
// Get the RtXtt menu-objects for superclasses
// TODO shadow overlayed methods...
sts = gdh_GetSuperClass( classid, &supercid, CurrentObject->Objid);
while ( ODD(sts)) {
sts = gdh_ObjidToName( cdh_ClassIdToObjid( supercid), classname,
sizeof(classname), cdh_mName_volumeStrict);
if ( EVEN(sts)) return sts;
sprintf( menu, "%s-RtXtt", classname);
sts = gdh_NameToObjid( menu, &menu_objid);
if ( ODD(sts)) {
sts = gdh_GetChild( menu_objid, &child);
while( ODD(sts)) {
sts = getAllMenuItems( ip, Item, child, 0, nItems, 0, ¤tar);
if ( EVEN(sts)) return sts;
sts = gdh_GetNextSibling( child, &child);
}
}
sts = gdh_GetSuperClass( supercid, &supercid, CurrentObject->Objid);
}
// Get the RtXtt menu-objects for this class, or for superclasses
sts = gdh_ObjidToName( cdh_ClassIdToObjid( classid), classname,
sizeof(classname), cdh_mName_volumeStrict);
if ( EVEN(sts)) return sts;
sprintf( menu, "%s-RtXtt", classname);
sts = gdh_NameToObjid( menu, &menu_objid);
if ( ODD(sts)) {
sts = gdh_GetChild( menu_objid, &child);
while( ODD(sts)) {
sts = getAllMenuItems( ip, Item, child, 0, nItems, 0, ¤tar);
if ( EVEN(sts)) return sts;
sts = gdh_GetNextSibling( child, &child);
}
}
}
else if ( ip->ItemType == xmenu_eItemType_AttrObject) {
// Find attribute object methods...
if ( !cdh_tidIsCid( classid))
return XNAV__SUCCESS;
// Get the RtXtt common menu-objects
strcpy( menu, "pwrs:Class-$Object-RtXttAttrObject");
sts = gdh_NameToObjid( menu, &menu_objid);
if ( ODD(sts)) {
sts = gdh_GetChild( menu_objid, &child);
while( ODD(sts)) {
sts = getAllMenuItems( ip, Item, child, 0, nItems, 0, ¤tar);
if ( EVEN(sts)) return sts;
sts = gdh_GetNextSibling( child, &child);
}
}
// Get the RtXtt menu-objects for this class
sts = gdh_ObjidToName( cdh_ClassIdToObjid( classid), classname,
sizeof(classname), cdh_mName_volumeStrict);
if ( EVEN(sts)) return sts;
sprintf( menu, "%s-RtXtt", classname);
sts = gdh_NameToObjid( menu, &menu_objid);
if ( ODD(sts)) {
sts = gdh_GetChild( menu_objid, &child);
while( ODD(sts)) {
sts = getAllMenuItems( ip, Item, child, 0, nItems, 0, ¤tar);
if ( EVEN(sts)) return sts;
sts = gdh_GetNextSibling( child, &child);
}
}
}
else if ( ip->ItemType == xmenu_eItemType_Attribute) {
// Find attribute methods...
// Get the RtXttAttribute common menu-objects
strcpy( menu, "pwrs:Class-$Object-RtXttAttribute");
sts = gdh_NameToObjid( menu, &menu_objid);
if ( ODD(sts)) {
sts = gdh_GetChild( menu_objid, &child);
while( ODD(sts)) {
sts = getAllMenuItems( ip, Item, child, 0, nItems, 0, ¤tar);
if ( EVEN(sts)) return sts;
sts = gdh_GetNextSibling( child, &child);
}
}
}
else if ( ip->ItemType == xmenu_eItemType_Crossref) {
// Find attribute methods...
// Get the RtXttCrossref common menu-objects
strcpy( menu, "pwrs:Class-$Object-RtXttCrossref");
sts = gdh_NameToObjid( menu, &menu_objid);
if ( ODD(sts)) {
sts = gdh_GetChild( menu_objid, &child);
while( ODD(sts)) {
sts = getAllMenuItems( ip, Item, child, 0, nItems, 0, ¤tar);
if ( EVEN(sts)) return sts;
sts = gdh_GetNextSibling( child, &child);
}
}
}
return XNAV__SUCCESS;
}
static pwr_tStatus xtt_pb_dp_slave_load_modules( xtt_slave_sCtx *ctx)
{
pwr_tOid oid;
pwr_tCid cid;
int found;
pwr_tObjName name;
pwr_tString40 module_name;
int sts;
pwr_tAttrRef maref, aaref;
for ( sts = gdh_GetChild( ctx->aref.Objid, &oid);
ODD(sts);
sts = gdh_GetNextSibling( oid, &oid)) {
// Check that this is a module
sts = gdh_GetObjectClass( oid, &cid);
if ( EVEN(sts)) return sts;
found = 0;
for ( int i = 0; ; i++) {
if ( ctx->gsd->module_classlist[i].cid == 0)
break;
if ( ctx->gsd->module_classlist[i].cid == cid) {
found = 1;
break;
}
}
if ( !found)
// This is not a known module object
continue;
// Get name
sts = gdh_ObjidToName( oid, name, sizeof(name), cdh_mName_object);
if ( EVEN(sts)) return sts;
maref = cdh_ObjidToAref( oid);
// Get ModuleName attribute
sts = gdh_ArefANameToAref( &maref, "ModuleName", &aaref);
if ( EVEN(sts)) return sts;
sts = gdh_GetObjectInfoAttrref( &aaref, module_name, sizeof(module_name));
if ( EVEN(sts)) return sts;
ctx->gsd->add_module_conf( cid, oid, name, module_name);
}
// Set address
pwr_tUInt16 address;
sts = gdh_ArefANameToAref( &ctx->aref, "SlaveAddress", &aaref);
if ( EVEN(sts)) return sts;
sts = gdh_GetObjectInfoAttrref( &aaref, &address, sizeof(address));
if ( EVEN(sts)) return sts;
ctx->gsd->address = address;
// Set byte order
pwr_tByteOrderingEnum byte_order;
sts = gdh_ArefANameToAref( &ctx->aref, "ByteOrdering", &aaref);
if ( EVEN(sts)) return sts;
sts = gdh_GetObjectInfoAttrref( &aaref, &byte_order, sizeof(byte_order));
if ( EVEN(sts)) return sts;
ctx->gsd->byte_order = byte_order;
// Set Ext_User_Prm_Data
pwr_tUInt8 prm_user_data[256];
pwr_tUInt16 prm_user_data_len;
int len;
sts = gdh_ArefANameToAref( &ctx->aref, "PrmUserData", &aaref);
if ( EVEN(sts)) return sts;
sts = gdh_GetObjectInfoAttrref( &aaref, prm_user_data, sizeof(prm_user_data));
if ( EVEN(sts)) return sts;
sts = gdh_ArefANameToAref( &ctx->aref, "PrmUserDataLen", &aaref);
if ( EVEN(sts)) return sts;
sts = gdh_GetObjectInfoAttrref( &aaref, &prm_user_data_len, sizeof(prm_user_data_len));
if ( EVEN(sts)) return sts;
len = prm_user_data_len;
if ( len != 0) {
sts = ctx->gsd->unpack_ext_user_prm_data( (char *)prm_user_data, len);
if ( EVEN(sts)) return sts;
}
return 1;
}
static pwr_tStatus IoRackInit (
io_tCtx ctx,
io_sAgent *ap,
io_sRack *rp
)
{
io_sServerLocal *local;
pthread_t thread;
pwr_tOName name;
pwr_tStatus sts;
pwr_sClass_Modbus_TCP_Server *op;
int i;
unsigned short port;
op = (pwr_sClass_Modbus_TCP_Server *) rp->op;
op->Connections = 0;
port = op->Port == 0 ? 502 : op->Port;
sts = gdh_ObjidToName(rp->Objid, (char *) &name, sizeof(name), cdh_mNName);
errh_Info( "Init of Modbus TCP Server %s", name);
rp->Local = calloc(1, sizeof(io_sServerLocal));
local = rp->Local;
if ( op->DisableServer)
return IO__SUCCESS;
/* Create socket, store in local struct */
uid_t ruid;
ruid = getuid();
printf( "ruid: %d\n", ruid);
local->s = socket(AF_INET, SOCK_STREAM, 0);
if (local->s < 0) {
errh_Error( "Error creating socket for IO modbus tcp server %s, %d", rp->Name, local->s);
return 0;
}
local->loc_addr.sin_family = AF_INET;
local->loc_addr.sin_port = htons(port);
for ( i = 0; i < 10; i++) {
sts = bind( local->s, (struct sockaddr *) &local->loc_addr, sizeof(local->loc_addr));
if ( sts == 0)
break;
perror( "Modbus TCP Bind socket failure, retrying... ");
sleep( 10);
}
if ( sts != 0) {
printf( "Modbus TCP Bind socket failure, exiting");
errh_Error( "Error bind socket to port for IO modbus tcp server %s, %d", rp->Name, local->s);
return 0;
}
errh_Info( "Modbus TCP Sever bind to port %d, %s", port, name);
sts = listen( local->s, 16);
sts = thread_MutexInit( &local->mutex);
if ( EVEN(sts)) return sts;
/* Create a thread that listens for connections */
sts = pthread_create( &thread, NULL, mb_connect, (void *)rp);
if ( sts != 0) return sts;
sts = mb_init_channels( ctx, ap, rp);
if ( EVEN(sts)) return sts;
op->Status = MB__NORMAL;
return IO__SUCCESS;
}
static pwr_tStatus IoRackInit (
io_tCtx ctx,
io_sAgent *ap,
io_sRack *rp
)
{
io_sCardLocal *local_card;
io_sCard *cardp;
short input_counter;
short output_counter;
pwr_sClass_Pb_DP_Slave *op;
pwr_sClass_Pb_Di *dip;
pwr_sClass_Pb_Do *dop;
pwr_sClass_Pb_Ai *aip;
pwr_sClass_Pb_Ao *aop;
pwr_sClass_Pb_Ii *iip;
pwr_sClass_Pb_Io *iop;
pwr_sClass_Pb_Module *mp;
char name[196];
pwr_tStatus sts;
pwr_tCid cid;
io_sChannel *chanp;
int i, latent_input_count, latent_output_count;
pwr_tInt32 chan_size;
pwr_sClass_ChanDi *chan_di;
pwr_sClass_ChanDo *chan_do;
pwr_sClass_ChanAi *chan_ai;
pwr_sClass_ChanAit *chan_ait;
pwr_sClass_ChanIi *chan_ii;
pwr_sClass_ChanAo *chan_ao;
pwr_sClass_ChanIo *chan_io;
sts = gdh_ObjidToName(rp->Objid, (char *) &name, sizeof(name), cdh_mNName);
errh_Info( "Init of Profibus DP Slave and Modules %s", name);
op = (pwr_sClass_Pb_DP_Slave *) rp->op;
// Do configuration check and initialize modules.
cardp = rp->cardlist;
input_counter = 0;
output_counter = 0;
op->NumberModules = 0;
latent_input_count = 0;
latent_output_count = 0;
while(cardp) {
local_card = calloc(1, sizeof(*local_card));
cardp->Local = local_card;
local_card->input_area = (void *) &(op->Inputs);
local_card->output_area = (void *) &(op->Outputs);
/* From v4.1.3 we can have subclasses, find the super class */
cid = cardp->Class;
while ( ODD( gdh_GetSuperClass( cid, &cid, cardp->Objid))) ;
switch (cid) {
/* Old style configuring with Pb_xx objects. Still here for combatibility reasons.
New systems (from v4.1.3) should be build with Pb_Module objects or subclasses */
case pwr_cClass_Pb_Di:
dip = (pwr_sClass_Pb_Di *) cardp->op;
dip->OffsetInputs = input_counter;
dip->BytesOfInput = dip->NumberOfChannels / 8;
input_counter += dip->BytesOfInput;
dip->Status = PB_MODULE_STATE_OPERATE;
break;
case pwr_cClass_Pb_Do:
dop = (pwr_sClass_Pb_Do *) cardp->op;
dop->OffsetOutputs = output_counter;
dop->BytesOfOutput = dop->NumberOfChannels / 8;
output_counter += dop->BytesOfOutput;
dop->Status = PB_MODULE_STATE_OPERATE;
break;
case pwr_cClass_Pb_Ai:
aip = (pwr_sClass_Pb_Ai *) cardp->op;
aip->OffsetInputs = input_counter;
aip->BytesOfInput = aip->NumberOfChannels * aip->BytesPerChannel;
input_counter += aip->BytesOfInput;
aip->Status = PB_MODULE_STATE_OPERATE;
break;
case pwr_cClass_Pb_Ao:
aop = (pwr_sClass_Pb_Ao *) cardp->op;
aop->OffsetOutputs = output_counter;
aop->BytesOfOutput = aop->NumberOfChannels * aop->BytesPerChannel;
output_counter += aop->BytesOfOutput;
aop->Status = PB_MODULE_STATE_OPERATE;
break;
case pwr_cClass_Pb_Ii:
iip = (pwr_sClass_Pb_Ii *) cardp->op;
iip->OffsetInputs = input_counter;
iip->BytesOfInput = iip->NumberOfChannels * iip->BytesPerChannel;
input_counter += iip->BytesOfInput;
iip->Status = PB_MODULE_STATE_OPERATE;
break;
case pwr_cClass_Pb_Io:
iop = (pwr_sClass_Pb_Io *) cardp->op;
iop->OffsetOutputs = output_counter;
iop->BytesOfOutput = iop->NumberOfChannels * iop->BytesPerChannel;
output_counter += iop->BytesOfOutput;
iop->Status = PB_MODULE_STATE_OPERATE;
break;
/* New style configuring (from v4.1.3) with Pb_Module objects or subclass. Loop all channels
in the module and set channel size and offset. */
case pwr_cClass_Pb_Module:
mp = (pwr_sClass_Pb_Module *) cardp->op;
mp->Status = PB__INITFAIL;
cardp->offset = 0;
for (i=0; i<cardp->ChanListSize; i++) {
chanp = &cardp->chanlist[i];
if ( is_diag( &chanp->ChanAref)) {
chanp->udata |= PB_UDATA_DIAG;
switch (chanp->ChanClass) {
case pwr_cClass_ChanIi:
chanp->offset = ((pwr_sClass_ChanIi *)chanp->cop)->Number;
chanp->size = GetChanSize( ((pwr_sClass_ChanIi *)chanp->cop)->Representation);
break;
default:
errh_Error( "Diagnostic channel class, card %s", cardp->Name);
}
continue;
}
if (chanp->ChanClass != pwr_cClass_ChanDi) {
input_counter += latent_input_count;
latent_input_count = 0;
}
if (chanp->ChanClass != pwr_cClass_ChanDo) {
output_counter += latent_output_count;
latent_output_count = 0;
}
switch (chanp->ChanClass) {
case pwr_cClass_ChanDi:
chan_di = (pwr_sClass_ChanDi *) chanp->cop;
if (chan_di->Number == 0) {
input_counter += latent_input_count;
latent_input_count = 0;
}
chanp->offset = input_counter;
chanp->mask = 1<<chan_di->Number;
if (chan_di->Representation == pwr_eDataRepEnum_Bit16 && op->ByteOrdering == pwr_eByteOrderingEnum_BigEndian)
chanp->mask = swap16(chanp->mask);
if (chan_di->Representation == pwr_eDataRepEnum_Bit32 && op->ByteOrdering == pwr_eByteOrderingEnum_BigEndian)
chanp->mask = swap32((unsigned short) chanp->mask);
if (chan_di->Number == 0) latent_input_count = GetChanSize(chan_di->Representation);
// printf("Di channel found in %s, Number %d, Offset %d\n", cardp->Name, chan_di->Number, chanp->offset);
break;
case pwr_cClass_ChanAi:
chan_ai = (pwr_sClass_ChanAi *) chanp->cop;
chanp->offset = input_counter;
chan_size = GetChanSize(chan_ai->Representation);
chanp->size = chan_size;
chanp->mask = 0;
input_counter += chan_size;
io_AiRangeToCoef(chanp);
// printf("Ai channel found in %s, Number %d, Offset %d\n", cardp->Name, chan_ai->Number, chanp->offset);
break;
case pwr_cClass_ChanAit:
chan_ait = (pwr_sClass_ChanAit *) chanp->cop;
chanp->offset = input_counter;
chan_size = GetChanSize(chan_ait->Representation);
chanp->size = chan_size;
chanp->mask = 0;
input_counter += chan_size;
io_AiRangeToCoef(chanp);
break;
case pwr_cClass_ChanIi:
chan_ii = (pwr_sClass_ChanIi *) chanp->cop;
chanp->offset = input_counter;
chan_size = GetChanSize(chan_ii->Representation);
chanp->size = chan_size;
chanp->mask = 0;
input_counter += chan_size;
// printf("Ii channel found in %s, Number %d, Offset %d\n", cardp->Name, chan_ii->Number, chanp->offset);
break;
case pwr_cClass_ChanDo:
chan_do = (pwr_sClass_ChanDo *) chanp->cop;
if (chan_do->Number == 0) {
output_counter += latent_output_count;
latent_output_count = 0;
}
chanp->offset = output_counter;
chan_size = GetChanSize(chan_do->Representation);
chanp->mask = 1<<chan_do->Number;
if (chan_do->Representation == pwr_eDataRepEnum_Bit16 && op->ByteOrdering == pwr_eByteOrderingEnum_BigEndian)
chanp->mask = swap16(chanp->mask);
if (chan_do->Representation == pwr_eDataRepEnum_Bit32 && op->ByteOrdering == pwr_eByteOrderingEnum_BigEndian)
chanp->mask = swap32((unsigned short) chanp->mask);
if (chan_do->Number == 0) latent_output_count = GetChanSize(chan_do->Representation);
// printf("Do channel found in %s, Number %d, Offset %d\n", cardp->Name, chan_do->Number, chanp->offset);
break;
case pwr_cClass_ChanAo:
chan_ao = (pwr_sClass_ChanAo *) chanp->cop;
chanp->offset = output_counter;
chan_size = GetChanSize(chan_ao->Representation);
chanp->size = chan_size;
chanp->mask = 0;
output_counter += chan_size;
io_AoRangeToCoef(chanp);
// printf("Ao channel found in %s, Number %d, Offset %d\n", cardp->Name, chan_ao->Number, chanp->offset);
break;
case pwr_cClass_ChanIo:
chan_io = (pwr_sClass_ChanIo *) chanp->cop;
chanp->offset = output_counter;
chan_size = GetChanSize(chan_io->Representation);
chanp->size = chan_size;
chanp->mask = 0;
output_counter += chan_size;
// printf("Io channel found in %s, Number %d, Offset %d\n", cardp->Name, chan_io->Number, chanp->offset);
break;
}
}
mp->Status = PB__NOCONN;
break;
}
op->NumberModules++;
cardp = cardp->next;
}
return IO__SUCCESS;
}
int rtt_show_signals(
menu_ctx parent_ctx, char* filename, char* windowname, int debug)
{
pwr_tFileName default_filename;
FILE* file;
char line[500];
int window_spaces;
pwr_tOName window;
pwr_tOName object;
pwr_tOName objname;
int spaces = 30;
int sts;
char* s;
int wildcard;
char title[250];
char classname[32];
int j;
int index = 0;
pwr_tObjid objid;
pwr_tObjid childobjid;
rtt_t_menu* menulist = 0;
char filestr[80];
int lines;
int window_found;
pwr_tVolumeId volid;
window_found = 0;
rtt_toupper(windowname, windowname);
/* Check if wildcard */
s = strchr(windowname, '*');
if (s == 0)
wildcard = 0;
else
wildcard = 1;
/* Open file */
if (filename == NULL) {
/* Open file, first get the volume id */
if (!wildcard) {
sts = gdh_NameToObjid(windowname, &objid);
if (EVEN(sts)) {
rtt_message('E', "Window not found");
return RTT__NOPICTURE;
}
volid = objid.vid;
} else {
sts = gdh_GetNodeObject(0, &objid);
if (EVEN(sts))
return sts;
volid = objid.vid;
}
sprintf(default_filename, "%srtt_plc_%s.dat", rtt_pwr_dir("pwrp_load"),
rtt_VolumeIdToStr(volid));
rtt_get_defaultfilename(default_filename, filestr, NULL);
file = fopen(filestr, "r");
} else {
rtt_get_defaultfilename(filename, filestr, ".lis");
file = fopen(filestr, "r");
}
if (file == 0) {
rtt_message('E', "Unable to open file");
return RTT__NOPICTURE;
}
/* First line is a header, skip it */
sts = rtt_get_signal_line(
file, line, sizeof(line), &window_spaces, object, &lines);
if (EVEN(sts))
return RTT__NOFILE;
/* Get the hierarchy */
while (spaces >= 30) {
/* This is still the header */
sts = rtt_get_signal_line(
file, line, sizeof(line), &spaces, object, &lines);
if (EVEN(sts))
return RTT__NOFILE;
}
window_spaces = spaces;
while (1) {
while (spaces != window_spaces) {
sts = rtt_get_signal_line(
file, line, sizeof(line), &spaces, object, &lines);
if (EVEN(sts))
goto finish;
}
strcpy(window, object);
rtt_toupper(window, window);
sts = rtt_wildcard(windowname, window);
if (!sts) {
window_found = 1;
/* Hit, print the window */
/* Get objid for the object */
sts = gdh_NameToObjid(window, &objid);
if (EVEN(sts)) {
sts = rtt_get_signal_line(
file, line, sizeof(line), &spaces, object, &lines);
if (EVEN(sts))
goto finish;
continue;
}
/* Get the object name */
sts = gdh_ObjidToName(objid, objname, sizeof(objname), cdh_mNName);
if (EVEN(sts))
return sts;
/* Get class name */
sts = rtt_objidtoclassname(objid, classname);
if (EVEN(sts))
return sts;
/* Add class name to objname in title */
strcpy(title, objname);
for (j = strlen(title); j < 45; j++)
strcat(title, " ");
strcat(title, " ");
strcat(title, classname);
/* Mark if the object has children */
sts = gdh_GetChild(objid, &childobjid);
if (ODD(sts))
strcat(title, " *");
if (!debug) {
sts = rtt_menu_list_add(&menulist, index, 0, title,
&rtt_hierarchy_child, &rtt_object_parameters, &rtt_crossref_signal,
objid, 0, 0, 0, 0);
if (EVEN(sts))
return sts;
index++;
}
/* Find the signal list */
sts = rtt_get_signal_line(
file, line, sizeof(line), &spaces, object, &lines);
if (EVEN(sts))
goto finish;
while (spaces > window_spaces) {
if (streq(object, "Signals")) {
/* This is the signals */
sts = rtt_get_signal_line(
file, line, sizeof(line), &spaces, object, &lines);
if (EVEN(sts))
goto finish;
lines = 1;
while ((spaces > window_spaces) && (lines == 1)) {
/* Insert the object in menulist */
/* Get objid for the object */
sts = gdh_NameToObjid(object, &objid);
if (EVEN(sts)) {
/* End of this list, read next line and continue */
sts = rtt_get_signal_line(
file, line, sizeof(line), &spaces, object, &lines);
if (EVEN(sts))
goto finish;
continue;
}
/* Get the object name */
sts = gdh_ObjidToName(objid, objname, sizeof(objname), cdh_mNName);
if (EVEN(sts))
return sts;
/* Get class name */
sts = rtt_objidtoclassname(objid, classname);
if (EVEN(sts))
return sts;
/* Add class name to objname in title */
strcpy(title, " ");
strcat(title, objname);
for (j = strlen(title); j < 45; j++)
strcat(title, " ");
strcat(title, " ");
strcat(title, classname);
if (!debug) {
sts = rtt_menu_list_add(&menulist, index, 0, title,
&rtt_hierarchy_child, &rtt_object_parameters,
&rtt_crossref_signal, objid, 0, 0, 0, 0);
if (EVEN(sts))
return sts;
index++;
} else {
sts = rtt_debug_object_add(
objid, (rtt_t_menu_upd**)&menulist, &index, &one, 0, 0);
if (EVEN(sts))
return sts;
}
sts = rtt_get_signal_line(
file, line, sizeof(line), &spaces, object, &lines);
if (EVEN(sts))
goto finish;
/* Check if end of signals !! */
}
} else {
sts = rtt_get_signal_line(
file, line, sizeof(line), &spaces, object, &lines);
if (EVEN(sts))
goto finish;
}
}
if (!wildcard)
goto finish;
} else {
if (window_found)
goto finish;
sts = rtt_get_signal_line(
file, line, sizeof(line), &spaces, object, &lines);
if (EVEN(sts))
goto finish;
}
}
finish:
fclose(file);
if (menulist != 0) {
strcpy(title, "LIST OF SIGNALS");
/* sts = rtt_menu_bubblesort( menulist);*/
if (!debug)
sts = rtt_menu_new(
parent_ctx, pwr_cNObjid, &menulist, title, 0, RTT_MENUTYPE_DYN);
else
sts = rtt_menu_upd_new(parent_ctx, pwr_cNObjid,
(rtt_t_menu_upd**)&menulist, title, 0, RTT_MENUTYPE_DYN);
if (sts == RTT__FASTBACK)
return sts;
else if (sts == RTT__BACKTOCOLLECT)
return sts;
else if (EVEN(sts))
return sts;
} else {
rtt_message('E', "No windows found");
return RTT__NOPICTURE;
}
return RTT__SUCCESS;
}
static void pwrsrv_SubAdd( rpvd_sMsgSubAdd *msg)
{
rpvd_sMsgAny rmsg;
pwr_tAName name;
pwr_tUInt32 asize, aoffs, aelem;
pwr_tTypeId atid;
pwr_tStatus sts;
pwrsrv_sSubItem *si;
void *p;
pwr_tRefId dlid;
rmsg.Type = rpvd_eMsg_Status;
rmsg.Id = msg->Id;
/* Check that this rix doesn't exist */
for ( si = pwrsrv_sublist; si; si = si->next) {
if ( si->rix == msg->Rix) {
return;
}
}
sts = gdh_ObjidToName( msg->Oid, name, sizeof(name), cdh_mName_volumeStrict);
if ( EVEN(sts)) {
rmsg.Status = sts;
udp_Send( (char *)&rmsg, sizeof(rmsg));
return;
}
if ( strcmp( msg->Attribute, "") != 0) {
strcat( name, ".");
strcat( name, msg->Attribute);
sts = gdh_GetAttributeCharacteristics( name, &atid, &asize, &aoffs, &aelem);
if ( EVEN(sts)) {
rmsg.Status = sts;
udp_Send( (char *)&rmsg, sizeof(rmsg));
return;
}
}
else {
sts = gdh_GetObjectSize( msg->Oid, &asize);
if ( EVEN(sts)) {
rmsg.Status = sts;
udp_Send( (char *)&rmsg, sizeof(rmsg));
return;
}
}
/* Direct link to atttribute */
sts = gdh_RefObjectInfo( name, &p, &dlid, asize);
if ( EVEN(sts)) {
rmsg.Status = sts;
udp_Send( (char *)&rmsg, sizeof(rmsg));
return;
}
/* Insert first in sublist */
si = (pwrsrv_sSubItem *) calloc( 1, sizeof(pwrsrv_sSubItem));
si->oid = msg->Oid;
strcpy( si->attribute, msg->Attribute);
si->size = asize;
si->rix = msg->Rix;
si->p = p;
si->dlid = dlid;
si->next = pwrsrv_sublist;
if ( si->next)
si->next->prev = si;
pwrsrv_sublist = si;
printf( "SubAdd: %d %s\n", msg->Rix, name);
rmsg.Status = GDH__SUCCESS;
udp_Send( (char *)&rmsg, sizeof(rmsg));
}
static void attrvalue_to_string( int type_id, void *value_ptr,
char *str, int size, int *len, char *format)
{
pwr_tObjid objid;
pwr_sAttrRef *attrref;
int sts;
char timstr[64];
if ( value_ptr == 0)
{
strcpy( str, "UNDEFINED");
return;
}
switch ( type_id )
{
case pwr_eType_Boolean:
{
if ( !format)
*len = sprintf( str, "%d", *(pwr_tBoolean *)value_ptr);
else
*len = sprintf( str, format, *(pwr_tBoolean *)value_ptr);
break;
}
case pwr_eType_Float32:
{
if ( !format)
*len = sprintf( str, "%f", *(float *)value_ptr);
else
*len = sprintf( str, format, *(float *)value_ptr);
break;
}
case pwr_eType_Float64:
{
if ( !format)
*len = sprintf( str, "%f", *(double *)value_ptr);
else
*len = sprintf( str, format, *(double *)value_ptr);
break;
}
case pwr_eType_Char:
{
if ( !format)
*len = sprintf( str, "%c", *(char *)value_ptr);
else
*len = sprintf( str, format, *(char *)value_ptr);
break;
}
case pwr_eType_Int8:
{
if ( !format)
*len = sprintf( str, "%d", *(char *)value_ptr);
else
*len = sprintf( str, format, *(char *)value_ptr);
break;
}
case pwr_eType_Int16:
{
if ( !format)
*len = sprintf( str, "%hd", *(short *)value_ptr);
else
*len = sprintf( str, format, *(short *)value_ptr);
break;
}
case pwr_eType_Int32:
{
if ( !format)
*len = sprintf( str, "%d", *(int *)value_ptr);
else
*len = sprintf( str, format, *(int *)value_ptr);
break;
}
case pwr_eType_Int64:
{
if ( !format)
*len = sprintf( str, pwr_dFormatInt64, *(pwr_tInt64 *)value_ptr);
else
*len = sprintf( str, format, *(pwr_tInt64 *)value_ptr);
break;
}
case pwr_eType_UInt8:
{
if ( !format)
*len = sprintf( str, "%d", *(unsigned char *)value_ptr);
else
*len = sprintf( str, format, *(unsigned char *)value_ptr);
break;
}
case pwr_eType_UInt16:
{
if ( !format)
*len = sprintf( str, "%hd", *(unsigned short *)value_ptr);
else
*len = sprintf( str, format, *(unsigned short *)value_ptr);
break;
}
case pwr_eType_UInt32:
case pwr_eType_Mask:
case pwr_eType_Enum:
{
if ( !format)
*len = sprintf( str, "%d", *(unsigned int *)value_ptr);
else
*len = sprintf( str, format, *(unsigned int *)value_ptr);
break;
}
case pwr_eType_UInt64:
{
if ( !format)
*len = sprintf( str, pwr_dFormatUInt64, *(pwr_tUInt64 *)value_ptr);
else
*len = sprintf( str, format, *(pwr_tUInt64 *)value_ptr);
break;
}
case pwr_eType_String:
{
strncpy( str, (char *)value_ptr, size);
str[size-1] = 0;
*len = strlen(str);
break;
}
case pwr_eType_Objid:
{
pwr_tOName hiername;
objid = *(pwr_tObjid *)value_ptr;
if ( !objid.oix)
sts = gdh_ObjidToName ( objid, hiername, sizeof(hiername),
cdh_mName_volumeStrict);
else
sts = gdh_ObjidToName ( objid, hiername, sizeof(hiername),
cdh_mNName);
if (EVEN(sts))
{
strcpy( str, "");
*len = 0;
break;
}
*len = sprintf( str, "%s", hiername);
break;
}
case pwr_eType_AttrRef:
{
pwr_tAName hiername;
attrref = (pwr_sAttrRef *) value_ptr;
sts = gdh_AttrrefToName ( attrref, hiername, sizeof(hiername), cdh_mNName);
if (EVEN(sts))
{
strcpy( str, "");
*len = 0;
break;
}
*len = sprintf( str, "%s", hiername);
break;
}
case pwr_eType_Time:
{
sts = time_AtoAscii( (pwr_tTime *) value_ptr, time_eFormat_DateAndTime,
timstr, sizeof(timstr));
if ( EVEN(sts))
strcpy( timstr, "-");
*len = sprintf( str, "%s", timstr);
break;
}
case pwr_eType_DeltaTime:
{
sts = time_DtoAscii( (pwr_tDeltaTime *) value_ptr, 1,
timstr, sizeof(timstr));
if ( EVEN(sts))
strcpy( timstr, "Undefined time");
*len = sprintf( str, "%s", timstr);
break;
}
case pwr_eType_ObjectIx:
{
*len = sprintf( str, "%s", cdh_ObjectIxToString( NULL,
*(pwr_tObjectIx *) value_ptr, 1));
break;
}
case pwr_eType_ClassId:
{
pwr_tOName hiername;
objid = cdh_ClassIdToObjid( *(pwr_tClassId *) value_ptr);
sts = gdh_ObjidToName ( objid, hiername, sizeof(hiername), cdh_mNName);
if (EVEN(sts))
{
strcpy( str, "");
*len = 0;
break;
}
*len = sprintf( str, "%s", hiername);
break;
}
case pwr_eType_TypeId:
{
pwr_tOName hiername;
objid = cdh_TypeIdToObjid( *(pwr_tTypeId *) value_ptr);
sts = gdh_ObjidToName ( objid, hiername, sizeof(hiername), cdh_mNName);
if (EVEN(sts))
{
strcpy( str, "");
*len = 0;
break;
}
*len = sprintf( str, "%s", hiername);
break;
}
case pwr_eType_VolumeId:
{
*len = sprintf( str, "%s", cdh_VolumeIdToString( NULL,
*(pwr_tVolumeId *) value_ptr, 1, 0));
break;
}
case pwr_eType_RefId:
{
*len = sprintf( str, "%s", cdh_SubidToString( NULL,
*(pwr_tSubid *) value_ptr, 1));
break;
}
}
}
pwr_tStatus xtt_pb_dp_slave_create_ctx( pwr_tAttrRef aref, void *editor_ctx,
xtt_slave_sCtx **ctxp)
{
pwr_tAName name;
pwr_tString80 gsdfile;
int sts;
pwr_tFileName fname;
pwr_tCid cid;
pwr_tOid oid;
int found;
int mc_cnt;
int module_cnt;
pwr_tAttrRef aaref;
sts = gdh_ObjidToName( aref.Objid,
name, sizeof(name), cdh_mName_volumeStrict);
if ( EVEN(sts)) return sts;
sts = gdh_ArefANameToAref( &aref, "GSDFile", &aaref);
if ( EVEN(sts)) return sts;
sts = gdh_GetObjectInfoAttrref( &aaref, gsdfile, sizeof(gsdfile));
if ( EVEN(sts)) return sts;
if ( strcmp( gsdfile, "") == 0) {
return PB__GSDATTR;
}
xtt_slave_sCtx *ctx = (xtt_slave_sCtx *) calloc( 1, sizeof(xtt_slave_sCtx));
ctx->aref = aref;
// Count modules
module_cnt = 0;
for ( sts = gdh_GetChild( aref.Objid, &oid);
ODD(sts);
sts = gdh_GetNextSibling( oid, &oid)) {
module_cnt++;
}
ctx->mc = (gsd_sModuleClass *) calloc( module_cnt + 2, sizeof(gsd_sModuleClass));
mc_cnt = 0;
ctx->editor_ctx = editor_ctx;
ctx->mc[0].cid = pwr_cClass_Pb_Module;
sts = gdh_ObjidToName( cdh_ClassIdToObjid(ctx->mc[0].cid),
ctx->mc[0].name, sizeof(ctx->mc[0].name), cdh_mName_object);
if ( EVEN(sts)) return sts;
mc_cnt++;
for ( sts = gdh_GetChild( aref.Objid, &oid);
ODD(sts);
sts = gdh_GetNextSibling( oid, &oid)) {
sts = gdh_GetObjectClass( oid, &cid);
if ( EVEN(sts)) return sts;
found = 0;
for ( int i = 0; i < mc_cnt; i++) {
if ( ctx->mc[i].cid == cid) {
found = 1;
break;
}
}
if ( found)
continue;
ctx->mc[mc_cnt].cid = cid;
sts = gdh_ObjidToName( cdh_ClassIdToObjid(cid),
ctx->mc[mc_cnt].name, sizeof(ctx->mc[0].name), cdh_mName_object);
if ( EVEN(sts)) return sts;
mc_cnt++;
}
if ( strchr( gsdfile, '/') == 0) {
strcpy( fname, "$pwrp_exe/");
strcat( fname, gsdfile);
}
else
strcpy( fname, gsdfile);
ctx->gsd = new pb_gsd();
sts = ctx->gsd->read( fname);
if ( EVEN(sts))
return sts;
ctx->gsd->set_classes( ctx->mc);
sts = xtt_pb_dp_slave_load_modules( ctx);
if ( EVEN(sts)) return sts;
*ctxp = ctx;
return 1;
}
static int graph_object_dx( Graph *graph, pwr_sAttrRef *arp)
{
int sts;
graph_sObjectDx *od;
pwr_tAttrRef aref, chanaref;
pwr_tAName aname;
pwr_tCid card_cid;
od = (graph_sObjectDx *) calloc( 1, sizeof(graph_sObjectDx));
graph->graph_object_data = (void *) od;
graph->graph_object_close = graph_object_dx_close;
sts = gdh_GetAttrRefTid( arp, &od->cid);
if ( EVEN(sts)) return sts;
// Get channel object
sts = gdh_ArefANameToAref( arp, "SigChanCon", &aref);
if ( EVEN(sts)) {
// Dv object, register scan function and return with success
graph->graph_object_scan = graph_object_dx_scan;
return 1;
}
sts = gdh_GetObjectInfoAttrref( &aref, &chanaref, sizeof(chanaref));
if ( EVEN(sts)) return sts;
od->local_conv_p = (pwr_tBoolean *) graph->localdb_ref_or_create( "ConversionOn",
pwr_eType_Boolean);
od->local_inv_p = (pwr_tBoolean *) graph->localdb_ref_or_create( "InvertOn",
pwr_eType_Boolean);
od->local_test_p = (pwr_tBoolean *) graph->localdb_ref_or_create( "TestOn",
pwr_eType_Boolean);
// Get card object
if ( chanaref.Flags.b.ObjectAttr) {
sts = gdh_GetObjectClass( chanaref.Objid, &card_cid);
if ( EVEN(sts)) return sts;
}
else
card_cid = 0;
switch ( card_cid) {
case pwr_cClass_Ssab_DI32D: {
pwr_tAName card_name;
unsigned int chan_idx = (chanaref.Offset - pwr_AlignLW(sizeof(pwr_sClass_Ssab_BaseDiCard))) / pwr_AlignLW(sizeof(pwr_sClass_ChanDi));
sts = gdh_ObjidToName( chanaref.Objid, card_name, sizeof(card_name), cdh_mNName);
if ( EVEN(sts)) return sts;
if ( chan_idx < 16) {
strcpy( aname, card_name);
strcat( aname, ".ConvMask1");
graph->ref_object_info( glow_eCycle_Slow, aname, (void **)&od->conv_p, &od->conv_subid,
sizeof(pwr_tBoolean), 0, true);
strcpy( aname, card_name);
strcat( aname, ".InvMask1");
graph->ref_object_info( glow_eCycle_Slow, aname, (void **)&od->inv_p, &od->inv_subid,
sizeof(pwr_tBoolean), 0, true);
od->mask = 1 << chan_idx;
}
else if ( chan_idx < 32) {
strcpy( aname, card_name);
strcat( aname, ".ConvMask2");
graph->ref_object_info( glow_eCycle_Slow, aname, (void **)&od->conv_p, &od->conv_subid,
sizeof(pwr_tBoolean), 0, true);
strcpy( aname, card_name);
strcat( aname, ".InvMask2");
graph->ref_object_info( glow_eCycle_Slow, aname, (void **)&od->inv_p, &od->inv_subid,
sizeof(pwr_tBoolean), 0, true);
od->mask = 1 << (chan_idx - 16);
}
else
return 0;
break;
}
case pwr_cClass_Ssab_DO32DKS:
case pwr_cClass_Ssab_DO32DKS_Stall: {
pwr_tAName card_name;
unsigned int chan_idx = (chanaref.Offset - pwr_AlignLW(sizeof(pwr_sClass_Ssab_BaseDoCard))) / pwr_AlignLW(sizeof(pwr_sClass_ChanDo));
sts = gdh_ObjidToName( chanaref.Objid, card_name, sizeof(card_name), cdh_mNName);
if ( EVEN(sts)) return sts;
if ( chan_idx < 16) {
strcpy( aname, card_name);
strcat( aname, ".TestMask1");
graph->ref_object_info( glow_eCycle_Slow, aname, (void **)&od->test_p, &od->test_subid,
sizeof(pwr_tBoolean), 0, true);
strcpy( aname, card_name);
strcat( aname, ".InvMask1");
graph->ref_object_info( glow_eCycle_Slow, aname, (void **)&od->inv_p, &od->inv_subid,
sizeof(pwr_tBoolean), 0, true);
od->mask = 1 << chan_idx;
}
else if ( chan_idx < 32) {
strcpy( aname, card_name);
strcat( aname, ".TestMask2");
graph->ref_object_info( glow_eCycle_Slow, aname, (void **)&od->test_p, &od->test_subid,
sizeof(pwr_tBoolean), 0, true);
strcpy( aname, card_name);
strcat( aname, ".InvMask2");
graph->ref_object_info( glow_eCycle_Slow, aname, (void **)&od->inv_p, &od->inv_subid,
sizeof(pwr_tBoolean), 0, true);
od->mask = 1 << (chan_idx - 16);
}
else
return 0;
if ( od->local_conv_p)
*od->local_conv_p = 1;
break;
}
default: {
pwr_tAName chan_name;
sts = gdh_AttrrefToName( &chanaref, chan_name, sizeof(chan_name),
cdh_mNName);
if ( ODD(sts)) {
if ( od->cid == pwr_cClass_Di) {
strcpy( aname, chan_name);
strcat( aname, ".ConversionOn");
graph->ref_object_info( glow_eCycle_Slow, aname, (void **)&od->conv_p, &od->conv_subid,
sizeof(pwr_tBoolean), 0, true);
}
strcpy( aname, chan_name);
strcat( aname, ".InvertOn");
graph->ref_object_info( glow_eCycle_Slow, aname, (void **)&od->inv_p, &od->inv_subid,
sizeof(pwr_tBoolean), 0, true);
if ( od->cid == pwr_cClass_Do) {
strcpy( aname, chan_name);
strcat( aname, ".TestOn");
graph->ref_object_info( glow_eCycle_Slow, aname, (void **)&od->test_p, &od->test_subid,
sizeof(pwr_tBoolean), 0, true);
if ( od->local_conv_p)
*od->local_conv_p = 1;
}
}
}
}
// Register scan function
graph->graph_object_scan = graph_object_dx_scan;
return 1;
}
RtTraceMotif::RtTraceMotif( void *tr_parent_ctx, Widget tr_parent_wid, pwr_tObjid tr_objid,
pwr_tStatus *status) :
RtTrace( tr_parent_ctx, tr_objid, status), parent_wid(tr_parent_wid)
{
// FlowWidget fwidget;
char uid_filename[120] = {"xtt_trace.uid"};
char *uid_filename_p = uid_filename;
Arg args[20];
unsigned long sts;
pwr_tOName name;
int i;
pwr_tObjid window_objid;
pwr_tClassId cid;
char title[220];
pwr_tOName hostname;
pwr_tOName plcconnect;
MrmHierarchy s_DRMh;
MrmType dclass;
Widget trace_widget;
static MrmRegisterArg reglist[] = {
{(char*) "tra_ctx", 0 },
{(char*) "tra_activate_close",(caddr_t)activate_close },
{(char*) "tra_activate_print",(caddr_t)activate_print },
{(char*) "tra_activate_printselect",(caddr_t)activate_printselect },
{(char*) "tra_activate_savetrace",(caddr_t)activate_savetrace },
{(char*) "tra_activate_restoretrace",(caddr_t)activate_restoretrace },
{(char*) "tra_activate_cleartrace",(caddr_t)activate_cleartrace },
{(char*) "tra_activate_trace",(caddr_t)activate_trace },
{(char*) "tra_activate_display_object",(caddr_t)activate_display_object },
{(char*) "tra_activate_open_object",(caddr_t)activate_open_object },
{(char*) "tra_activate_show_cross",(caddr_t)activate_show_cross },
{(char*) "tra_activate_open_classgraph",(caddr_t)activate_open_classgraph },
{(char*) "tra_activate_collect_insert",(caddr_t)activate_collect_insert },
{(char*) "tra_activate_view",(caddr_t)activate_view },
{(char*) "tra_activate_simulate",(caddr_t)activate_simulate },
{(char*) "tra_activate_zoomin",(caddr_t)activate_zoomin },
{(char*) "tra_activate_zoomout",(caddr_t)activate_zoomout },
{(char*) "tra_activate_zoomreset",(caddr_t)activate_zoomreset },
{(char*) "tra_activate_scantime1",(caddr_t)activate_scantime1 },
{(char*) "tra_activate_scantime2",(caddr_t)activate_scantime2 },
{(char*) "tra_activate_scantime3",(caddr_t)activate_scantime3 },
{(char*) "tra_activate_scantime4",(caddr_t)activate_scantime4 },
{(char*) "tra_activate_scantime5",(caddr_t)activate_scantime5 },
{(char*) "tra_activate_help",(caddr_t)activate_help },
{(char*) "tra_activate_helpplc",(caddr_t)activate_helpplc },
{(char*) "tra_create_form",(caddr_t)create_form },
{(char*) "tra_create_menu",(caddr_t)create_menu }
};
static int reglist_num = (sizeof reglist / sizeof reglist[0]);
lng_get_uid( uid_filename, uid_filename);
sts = gdh_ObjidToName( tr_objid, name, sizeof(name), cdh_mNName);
if (EVEN(sts)) {
*status = sts;
return;
}
strcpy( title, "Trace ");
strcat( title, name);
/* Find plcwindow */
sts = gdh_GetObjectClass( tr_objid, &cid);
if ( EVEN(sts)) {
*status = sts;
return;
}
if ( !(cid == pwr_cClass_windowplc ||
cid == pwr_cClass_windowcond ||
cid == pwr_cClass_windoworderact ||
cid == pwr_cClass_windowsubstep ))
{
sts = gdh_GetChild( tr_objid, &window_objid);
if ( EVEN(sts)) {
*status = sts;
return;
}
}
else
window_objid = tr_objid;
sts = gdh_GetObjectClass( window_objid, &cid);
if ( EVEN(sts)) {
*status = sts;
return;
}
if ( !(cid == pwr_cClass_windowplc ||
cid == pwr_cClass_windowcond ||
cid == pwr_cClass_windoworderact ||
cid == pwr_cClass_windowsubstep )) {
*status = 0;
return;
}
sts = get_filename( window_objid, filename, &m_has_host, hostname,
plcconnect);
if ( EVEN(sts)) {
*status = sts;
return;
}
/* Create object context */
objid = window_objid;
if ( m_has_host) {
strcpy( m_hostname, hostname);
strcpy( m_plcconnect, plcconnect);
}
reglist[0].value = (caddr_t) this;
toplevel = XtCreatePopupShell( name,
topLevelShellWidgetClass, parent_wid, args, 0);
/* Save the context structure in the widget */
XtSetArg (args[0], XmNuserData, (XtPointer) this);
sts = MrmOpenHierarchy( 1, &uid_filename_p, NULL, &s_DRMh);
if (sts != MrmSUCCESS) printf("can't open %s\n", uid_filename);
MrmRegisterNames(reglist, reglist_num);
sts = MrmFetchWidgetOverride( s_DRMh, (char*) "trace_window", toplevel,
title, args, 1, &trace_widget, &dclass);
if (sts != MrmSUCCESS) printf("can't fetch %s\n", name);
MrmCloseHierarchy(s_DRMh);
i = 0;
XtSetArg(args[i],XmNwidth,800);i++;
XtSetArg(args[i],XmNheight,600);i++;
XtSetValues( toplevel ,args,i);
XtManageChild( trace_widget);
i = 0;
/*
XtSetArg(args[i],XmNwidth,790);i++;
XtSetArg(args[i],XmNheight,560);i++;
*/
XtSetArg( args[i], XmNtopAttachment, XmATTACH_WIDGET);i++;
XtSetArg( args[i], XmNtopWidget, menu);i++;
XtSetArg( args[i], XmNrightAttachment, XmATTACH_FORM);i++;
XtSetArg( args[i], XmNleftAttachment, XmATTACH_FORM);i++;
XtSetArg( args[i], XmNbottomAttachment, XmATTACH_FORM);i++;
flow_widget = FlowCreate( form, (char*) "Flow window", args, i,
init_flow, (void *)this);
XtManageChild( (Widget) flow_widget);
/*
XtRealizeWidget(toplevel);
*/
XtPopup( toplevel, XtGrabNone);
// fwidget = (FlowWidget) flow_widget;
// flow_ctx = (flow_tCtx)fwidget->flow.flow_ctx;
// flow_SetCtxUserData( flow_ctx, this);
/* Create navigator popup */
i = 0;
XtSetArg(args[i],XmNallowShellResize, TRUE); i++;
XtSetArg(args[i],XmNallowResize, TRUE); i++;
XtSetArg(args[i],XmNwidth,200);i++;
XtSetArg(args[i],XmNheight,200);i++;
XtSetArg(args[i],XmNx,500);i++;
XtSetArg(args[i],XmNy,500);i++;
nav_shell = XmCreateDialogShell( flow_widget, (char*) "Navigator",
args, i);
XtManageChild( nav_shell);
i = 0;
XtSetArg(args[i],XmNwidth,200);i++;
XtSetArg(args[i],XmNheight,200);i++;
nav_widget = FlowCreateNav( nav_shell, (char*) "navigator",
args, i, flow_widget);
XtManageChild( nav_widget);
XtRealizeWidget( nav_shell);
// Connect the window manager close-button to exit
flow_AddCloseVMProtocolCb( toplevel,
(XtCallbackProc)activate_close, this);
wow = new CoWowMotif( toplevel);
trace_timerid = wow->timer_new();
viewsetup();
flow_Open( flow_ctx, filename);
trasetup();
trace_start();
#if defined OS_LINUX
{
struct stat info;
if ( stat( filename, &info) != -1)
version = info.st_ctime;
}
#endif
}
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
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;
}
static void pwrsrv_Oid( rpvd_sMsgOid *msg)
{
rpvd_sMsgObject rmsg;
pwr_tOid fth;
pwr_tOid fch;
pwr_tOid lch;
pwr_tOid bws;
pwr_tOid fws;
pwr_tCid cid;
pwr_tObjName name;
pwr_tOid o;
pwr_tStatus sts;
pwr_tOid plist[200];
int psize = 0;
int i, j;
char *s;
rmsg.Type = rpvd_eMsg_Object;
rmsg.Id = msg->Id;
rmsg.Status = 1;
rmsg.Oid = msg->Oid;
sts = gdh_GetObjectClass( msg->Oid, &cid);
if ( EVEN(sts)) {
rmsg.Status = sts;
udp_Send( (char *)&rmsg, sizeof(rmsg));
return;
}
plist[psize++] = msg->Oid;
for ( sts = gdh_GetParent( plist[psize-1], &o);
ODD(sts);
sts = gdh_GetParent( plist[psize-1], &o)) {
plist[psize++] = o;
}
/* Add volume object */
plist[psize].oix = 0;
plist[psize++].vid = msg->Oid.vid;
for ( j = 0; j < psize; j++) {
i = psize - j - 1;
sts = gdh_GetObjectClass( plist[i], &cid);
if ( i == psize - 1) {
/* Volume object */
fth.oix = 0;
sts = gdh_GetRootList( &fch);
if ( EVEN(sts)) {
fch.oix = 0;
lch.oix = 0;
}
else {
sts = 1;
for ( lch = fch; ODD(sts); sts = gdh_GetNextSibling( lch, &o)) {
lch = o;
}
}
fws.oix = 0;
bws.oix = 0;
sts = gdh_ObjidToName( plist[i], name, sizeof(name), cdh_mName_volume);
if ( (s = strrchr( name, ':')))
*s = 0;
}
else {
sts = gdh_GetParent( plist[i], &fth);
if ( EVEN(sts))
fth.oix = 0;
sts = gdh_GetChild( plist[i], &fch);
if ( EVEN(sts)) {
fch.oix = 0;
lch.oix = 0;
}
else {
lch = fch;
for ( sts = gdh_GetNextSibling( lch, &o);
ODD(sts);
sts = gdh_GetNextSibling( lch, &o)) {
lch = o;
}
}
sts = gdh_GetNextSibling( plist[i], &fws);
if ( EVEN(sts))
fws.oix = rmsg.o[j-1].fchoix;
sts = gdh_GetPreviousSibling( plist[i], &bws);
if ( EVEN(sts))
bws.oix = rmsg.o[j-1].lchoix;
sts = gdh_ObjidToName( plist[i], name, sizeof(name), cdh_mName_object);
}
rmsg.o[j].oix = plist[i].oix;
rmsg.o[j].fthoix = fth.oix;
rmsg.o[j].fchoix = fch.oix;
rmsg.o[j].lchoix = lch.oix;
rmsg.o[j].fwsoix = fws.oix;
rmsg.o[j].bwsoix = bws.oix;
rmsg.o[j].cid = cid;
strcpy( rmsg.o[j].name, name);
}
rmsg.OSize = psize;
udp_Send( (char *)&rmsg, sizeof(rmsg));
}
static pwr_tStatus mb_init_channels( io_tCtx ctx, io_sAgent *ap, io_sRack *rp)
{
io_sServerModuleLocal *local_card;
io_sCard *cardp;
io_sServerLocal *local;
pwr_sClass_Modbus_TCP_Server *op;
char name[196];
pwr_tStatus sts;
io_sChannel *chanp;
int i;
sts = gdh_ObjidToName(rp->Objid, (char *) &name, sizeof(name), cdh_mNName);
op = (pwr_sClass_Modbus_TCP_Server *) rp->op;
local = rp->Local;
/* Create socket, store in local struct */
/* Do configuration check and initialize modules. */
cardp = rp->cardlist;
unsigned int prev_input_area_offset = 0;
unsigned int prev_output_area_offset = 0;
unsigned int input_area_offset = 0;
unsigned int output_area_offset = 0;
unsigned int input_area_chansize = 0;
unsigned int output_area_chansize = 0;
while(cardp) {
local_card = calloc(1, sizeof(*local_card));
cardp->Local = local_card;
local_card->input_area = (void *) &(op->Inputs) + input_area_offset +
input_area_chansize;
local_card->output_area = (void *) &(op->Outputs) + output_area_offset +
output_area_chansize;
io_bus_card_init( ctx, cardp, &input_area_offset, &input_area_chansize,
&output_area_offset, &output_area_chansize,
pwr_eByteOrderingEnum_BigEndian);
for (i = 0; i < cardp->ChanListSize; i++) {
chanp = &cardp->chanlist[i];
switch (chanp->ChanClass) {
case pwr_cClass_ChanDi: {
pwr_sClass_ChanDi *chan_di = (pwr_sClass_ChanDi *) chanp->cop;
if (local_card->di_size == 0)
local_card->di_offset = chanp->offset;
if (chan_di->Number == 0 || local_card->di_size == 0)
local_card->di_size += GetChanSize(chan_di->Representation);
break;
}
case pwr_cClass_ChanDo: {
pwr_sClass_ChanDo *chan_do = (pwr_sClass_ChanDo *) chanp->cop;
if (local_card->do_size == 0)
local_card->do_offset = chanp->offset;
if (chan_do->Number == 0 || local_card->do_size == 0)
local_card->do_size += GetChanSize(chan_do->Representation);
break;
}
case pwr_cClass_ChanD: {
pwr_sClass_ChanD *chan_d = (pwr_sClass_ChanD *) chanp->cop;
if ( chan_d->Type == pwr_eDChanTypeEnum_Di) {
if (local_card->di_size == 0)
local_card->di_offset = chanp->offset;
if (chan_d->Number == 0 || local_card->di_size == 0)
local_card->di_size += GetChanSize(chan_d->Representation);
}
else {
if (local_card->do_size == 0)
local_card->do_offset = chanp->offset;
if (chan_d->Number == 0 || local_card->do_size == 0)
local_card->do_size += GetChanSize(chan_d->Representation);
}
break;
}
}
}
local_card->input_size = input_area_offset + input_area_chansize -
prev_input_area_offset;
local_card->output_size = output_area_offset + output_area_chansize -
prev_output_area_offset;
prev_input_area_offset = input_area_offset + input_area_chansize;
prev_output_area_offset = output_area_offset + output_area_chansize;
cardp = cardp->next;
}
local->input_size = input_area_offset + input_area_chansize;
local->output_size = output_area_offset + output_area_chansize;
return IO__SUCCESS;
}
//
// Callbacks from brow
//
int XAttNav::brow_cb( FlowCtx *ctx, flow_tEvent event)
{
XAttNav *xattnav;
Item *item;
if ( event->event == flow_eEvent_ObjectDeleted) {
brow_GetUserData( event->object.object, (void **)&item);
delete item;
return 1;
}
brow_GetCtxUserData( (BrowCtx *)ctx, (void **) &xattnav);
xattnav->message( ' ', "");
switch ( event->event) {
case flow_eEvent_Key_Up: {
brow_tNode *node_list;
int node_count;
brow_tObject object;
int sts;
brow_GetSelectedNodes( xattnav->brow->ctx, &node_list, &node_count);
if ( !node_count) {
sts = brow_GetLastVisible( xattnav->brow->ctx, &object);
if ( EVEN(sts)) return 1;
}
else {
if ( !brow_IsVisible( xattnav->brow->ctx, node_list[0], flow_eVisible_Partial)) {
sts = brow_GetLastVisible( xattnav->brow->ctx, &object);
if ( EVEN(sts)) return 1;
}
else {
sts = brow_GetPrevious( xattnav->brow->ctx, node_list[0], &object);
if ( EVEN(sts)) {
if ( node_count)
free( node_list);
return 1;
}
}
}
brow_SelectClear( xattnav->brow->ctx);
brow_SetInverse( object, 1);
brow_SelectInsert( xattnav->brow->ctx, object);
if ( !brow_IsVisible( xattnav->brow->ctx, object, flow_eVisible_Full))
brow_CenterObject( xattnav->brow->ctx, object, 0.25);
if ( node_count)
free( node_list);
break;
}
case flow_eEvent_Key_Down: {
brow_tNode *node_list;
int node_count;
brow_tObject object;
int sts;
brow_GetSelectedNodes( xattnav->brow->ctx, &node_list, &node_count);
if ( !node_count) {
sts = brow_GetFirstVisible( xattnav->brow->ctx, &object);
if ( EVEN(sts)) return 1;
}
else {
if ( !brow_IsVisible( xattnav->brow->ctx, node_list[0], flow_eVisible_Partial)) {
sts = brow_GetFirstVisible( xattnav->brow->ctx, &object);
if ( EVEN(sts)) return 1;
}
else {
sts = brow_GetNext( xattnav->brow->ctx, node_list[0], &object);
if ( EVEN(sts)) {
if ( node_count)
free( node_list);
return 1;
}
}
}
brow_SelectClear( xattnav->brow->ctx);
brow_SetInverse( object, 1);
brow_SelectInsert( xattnav->brow->ctx, object);
if ( !brow_IsVisible( xattnav->brow->ctx, object, flow_eVisible_Full))
brow_CenterObject( xattnav->brow->ctx, object, 0.75);
if ( node_count)
free( node_list);
break;
}
case flow_eEvent_SelectClear:
brow_ResetSelectInverse( xattnav->brow->ctx);
break;
case flow_eEvent_MB1Click: {
// Select
double ll_x, ll_y, ur_x, ur_y;
int sts;
switch ( event->object.object_type) {
case flow_eObjectType_Node:
brow_MeasureNode( event->object.object, &ll_x, &ll_y,
&ur_x, &ur_y);
if ( event->object.x < ll_x + 1.0) {
// Simulate doubleclick
flow_tEvent doubleclick_event;
doubleclick_event = (flow_tEvent) calloc( 1, sizeof(*doubleclick_event));
memcpy( doubleclick_event, event, sizeof(*doubleclick_event));
doubleclick_event->event = flow_eEvent_MB1DoubleClick;
sts = brow_cb( ctx, doubleclick_event);
free( (char *) doubleclick_event);
return sts;
}
if ( brow_FindSelectedObject( xattnav->brow->ctx, event->object.object)) {
brow_SelectClear( xattnav->brow->ctx);
}
else {
brow_SelectClear( xattnav->brow->ctx);
brow_SetInverse( event->object.object, 1);
brow_SelectInsert( xattnav->brow->ctx, event->object.object);
}
break;
default:
brow_SelectClear( xattnav->brow->ctx);
}
break;
}
case flow_eEvent_Key_PageDown: {
brow_Page( xattnav->brow->ctx, 0.8);
break;
}
case flow_eEvent_Key_PageUp: {
brow_Page( xattnav->brow->ctx, -0.8);
break;
}
case flow_eEvent_ScrollDown: {
brow_Page( xattnav->brow->ctx, 0.1);
break;
}
case flow_eEvent_ScrollUp: {
brow_Page( xattnav->brow->ctx, -0.1);
break;
}
case flow_eEvent_Key_Left: {
brow_tNode *node_list;
int node_count;
brow_tObject object;
int sts;
brow_GetSelectedNodes( xattnav->brow->ctx, &node_list, &node_count);
if ( !node_count)
return 1;
if ( brow_IsOpen( node_list[0]))
// Close this node
object = node_list[0];
else {
// Close parent
sts = brow_GetParent( xattnav->brow->ctx, node_list[0], &object);
if ( EVEN(sts)) {
free( node_list);
return 1;
}
}
brow_GetUserData( object, (void **)&item);
switch( item->type) {
case xnav_eItemType_Attr:
((ItemAttr *)item)->close( xattnav->brow, 0, 0);
break;
case xnav_eItemType_AttrArrayElem:
((ItemAttrArrayElem *)item)->close( xattnav->brow, 0, 0);
break;
case xnav_eItemType_AttrArray:
((ItemAttrArray *)item)->close( xattnav->brow, 0, 0);
break;
case xnav_eItemType_AttrObject:
((ItemAttrObject *)item)->close( xattnav->brow, 0, 0);
break;
default:
;
}
brow_SelectClear( xattnav->brow->ctx);
brow_SetInverse( object, 1);
brow_SelectInsert( xattnav->brow->ctx, object);
if ( !brow_IsVisible( xattnav->brow->ctx, object, flow_eVisible_Full))
brow_CenterObject( xattnav->brow->ctx, object, 0.25);
free( node_list);
break;
}
case flow_eEvent_MB3Down: {
brow_SetClickSensitivity( xattnav->brow->ctx,
flow_mSensitivity_MB3Press);
break;
}
case flow_eEvent_MB3Press: {
// Popup menu
int x, y;
pwr_sAttrRef attrref;
int sts;
switch ( event->object.object_type) {
case flow_eObjectType_Node:
brow_GetUserData( event->object.object, (void **)&item);
if ( cdh_ObjidIsNull( item->objid))
break;
xattnav->popup_position( event->any.x_pixel + 8, event->any.y_pixel, &x, &y);
memset( &attrref, 0, sizeof(attrref));
switch ( item->type) {
case xnav_eItemType_Attr:
case xnav_eItemType_AttrArrayElem:
case xnav_eItemType_AttrObject: {
pwr_tAName attr_str;
sts = gdh_ObjidToName( item->objid,
attr_str, sizeof(attr_str), cdh_mName_volumeStrict);
if ( EVEN(sts)) return sts;
strcat( attr_str, ".");
strcat( attr_str, item->name);
sts = gdh_NameToAttrref( pwr_cNObjid, attr_str, &attrref);
if ( EVEN(sts)) return sts;
(xattnav->popup_menu_cb)( xattnav->parent_ctx, attrref,
(unsigned long)xmenu_eItemType_Attribute,
(unsigned long)xmenu_mUtility_AttrEditor, NULL, x, y);
break;
}
case xnav_eItemType_Collect: {
sts = gdh_NameToAttrref( pwr_cNObjid, item->name, &attrref);
if ( EVEN(sts)) return sts;
(xattnav->popup_menu_cb)( xattnav->parent_ctx, attrref,
(unsigned long)xmenu_eItemType_Attribute,
(unsigned long)xmenu_mUtility_AttrEditor, NULL, x, y);
break;
}
case xnav_eItemType_Crossref: {
ItemCrossref *itemc = (ItemCrossref *)item;
memset( &attrref, 0, sizeof(attrref));
attrref.Objid = itemc->objid;
(xattnav->popup_menu_cb)( xattnav->parent_ctx, attrref,
(unsigned long)xmenu_eItemType_Crossref,
(unsigned long)xmenu_mUtility_AttrEditor,
itemc->ref_name, x, y);
break;
}
default:
;
}
break;
default:
;
}
break;
}
case flow_eEvent_Key_Right: {
brow_tNode *node_list;
int node_count;
pwr_tStatus sts;
brow_GetSelectedNodes( xattnav->brow->ctx, &node_list, &node_count);
if ( !node_count)
return 1;
brow_GetUserData( node_list[0], (void **)&item);
switch( item->type) {
case xnav_eItemType_Attr:
case xnav_eItemType_AttrArrayElem:
case xnav_eItemType_Collect:
sts = item->open_children( xattnav->brow, 0, 0);
if (ODD(sts)) break;
if ( xattnav->advanced_user && xattnav->change_value_cb)
(xattnav->change_value_cb)( xattnav->parent_ctx);
break;
case xnav_eItemType_AttrArray:
((ItemAttrArray *)item)->open_attributes( xattnav->brow, 0, 0);
break;
case xnav_eItemType_AttrObject:
((ItemAttrObject *)item)->open_attributes( xattnav->brow, 0, 0);
break;
case xnav_eItemType_Enum:
if ( xattnav->advanced_user)
((ItemEnum *)item)->set_value();
break;
case xnav_eItemType_Mask:
if ( xattnav->advanced_user)
((ItemMask *)item)->toggle_value();
break;
default:
;
}
free( node_list);
break;
}
case flow_eEvent_MB1DoubleClick:
switch ( event->object.object_type) {
case flow_eObjectType_Node:
brow_GetUserData( event->object.object, (void **)&item);
switch( item->type) {
case xnav_eItemType_Attr:
((ItemAttr *)item)->open_children( xattnav->brow,
event->object.x, event->object.y);
break;
case xnav_eItemType_AttrArray:
((ItemAttrArray *)item)->open_attributes( xattnav->brow,
event->object.x, event->object.y);
break;
case xnav_eItemType_AttrObject:
((ItemAttrObject *)item)->open_attributes( xattnav->brow,
event->object.x, event->object.y);
break;
case xnav_eItemType_AttrArrayElem:
((ItemAttrArrayElem *)item)->open_children( xattnav->brow,
event->object.x, event->object.y);
break;
case xnav_eItemType_Crossref:
if ( xattnav->start_trace_cb) {
(xattnav->start_trace_cb)( xattnav->parent_ctx, item->objid,
((ItemCrossref *)item)->ref_name);
if ( xattnav->close_cb) {
(xattnav->close_cb)( xattnav->parent_ctx);
return 1;
}
}
break;
default:
;
}
break;
default:
;
}
break;
case flow_eEvent_Radiobutton: {
switch ( event->object.object_type) {
case flow_eObjectType_Node:
brow_GetUserData( event->object.object, (void **)&item);
switch( item->type) {
case xnav_eItemType_Enum:
if ( !event->radiobutton.value)
((ItemEnum *)item)->set_value();
break;
case xnav_eItemType_Mask:
((ItemMask *)item)->set_value( !event->radiobutton.value);
break;
default:
;
}
break;
default:
;
}
break;
}
case flow_eEvent_Map: {
xattnav->displayed = 1;
break;
}
default:
;
}
return 1;
}