int print_attribute( pwr_tObjid objid, pwr_tClassId classid, char *object_p, char *attributename, int array_element, int index, FILE *fp) { pwr_tTypeId tid; pwr_tUInt32 size, offs, elem; char objectname[120]; char parname[120]; char *s; int sts; char buf[1024]; strcpy( objectname, attributename); s = strchr( objectname, '.'); strcpy( parname, s+1); *s = 0; sts = gdh_GetAttributeCharacteristics( attributename, &tid, &size, &offs, &elem); if ( EVEN(sts)) return sts; if ( !array_element) { sts = gdh_GetObjectInfo( attributename, buf, sizeof(buf)); if ( EVEN(sts)) return sts; print_attr( buf, objid, objectname, parname, tid, size, 0, elem, fp); } else { print_attr( object_p, objid, objectname, parname, tid, size, offs, elem, fp); } return 1; }
/*------------------------------------------------------------------------------ */ 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; }
pwr_tStatus bck_print( char *filename) { char fname[256]; pwr_sAttrRef aref; pwr_tAName objname; FILE *fp = 0; pwr_sAttrRef dataname; int sts; if ( filename) { dcli_translate_filename( fname, filename); fp = fopen( fname, "w"); if ( !fp) return 0; } sts = gdh_Init("pwr_bck_print"); if (EVEN(sts)) return sts; sts = gdh_GetClassListAttrRef( pwr_cClass_Backup, &aref); while ( ODD(sts)) { if ( aref.Objid.vid < cdh_cUserVolMin) { // In template plc, continue sts = gdh_GetNextAttrRef( pwr_cClass_Backup, &aref, &aref); continue; } sts = gdh_AttrrefToName( &aref, objname, sizeof(objname), cdh_mName_volumeStrict); if ( EVEN(sts)) return sts; if ( fp) fprintf( fp, "// %s\n", objname); else printf( "// %s\n", objname); strcat( objname, ".DataName"); sts = gdh_GetObjectInfo( objname, &dataname, sizeof(dataname)); sts = print_data( &dataname, fp); if ( EVEN(sts)) error_msg( sts, fp); sts = gdh_GetNextAttrRef( pwr_cClass_Backup, &aref, &aref); } if ( fp) fclose(fp); return 1; }
static void pwrsrv_ReadAttribute( rpvd_sMsgReadAttribute *msg) { rpvd_sMsgAttribute rmsg; pwr_tAName name; pwr_tUInt32 asize, aoffs, aelem; pwr_tTypeId atid; pwr_tStatus sts; rmsg.Type = rpvd_eMsg_Attribute; rmsg.Id = msg->Id; rmsg.Status = 1; rmsg.Oid = msg->Oid; strcpy( rmsg.Attribute, msg->Attribute); 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_GetObjectInfo( name, &rmsg.Value, asize); rmsg.Status = sts; rmsg.Size = asize; rmsg.Tid = atid; udp_Send( (char *)&rmsg, sizeof(rmsg)); }
int main (int argc, char **argv) { pwr_tStatus sts; char *c; int cidopt = 0; pwr_tObjName cidstr; pwr_tAName astr; int i; if ( argc <= 1) { usage(); exit(1); } sts = gdh_Init("rt_gdhget"); if ( EVEN(sts)) { exit(sts); } for ( i = 1; i < argc; i++) { c = argv[i]; if ( *c == '-') { c++; switch ( *c) { case 'h': usage(); exit(0); case 'c': if ( argc <= i+1) { usage(); exit(1); } strncpy( cidstr, argv[i+1], sizeof(cidstr)); cidopt = 1; i++; break; } } else strcpy( astr, argv[i]); } if ( cidopt) { // Get the first object of class cidstr, and print the value of attribute // astr in this object pwr_tCid cid; pwr_tOid oid; pwr_tAttrRef aref, aaref; pwr_tTid a_tid; unsigned int a_size, a_offs, a_dim; void *a_valp; char str[256]; sts = gdh_ClassNameToId( cidstr, &cid); if ( EVEN(sts)) { exit(sts); } sts = gdh_GetClassList( cid, &oid); if ( EVEN(sts)) { exit(sts); } aref = cdh_ObjidToAref( oid); sts = gdh_ArefANameToAref( &aref, astr, &aaref); if ( EVEN(sts)) { exit(sts); } sts = gdh_GetAttributeCharAttrref( &aaref, &a_tid, &a_size, &a_offs, &a_dim); if ( EVEN(sts)) { exit(sts); } a_valp = calloc( 1, a_size); sts = gdh_GetObjectInfoAttrref( &aaref, a_valp, a_size); if ( EVEN(sts)) { free( a_valp); exit(sts); } sts = cdh_AttrValueToString( a_tid, a_valp, str, sizeof(str)); if ( EVEN(sts)) { free( a_valp); exit(sts); } printf( "%s\n", str); free( a_valp); exit(0); } else { // Print the value of the attriute in astr pwr_tTypeId a_tid; pwr_tUInt32 a_size, a_offs, a_elem; void *a_valp; char str[256]; sts = gdh_GetAttributeCharacteristics( astr, &a_tid, &a_size, &a_offs, &a_elem); if ( EVEN(sts)) { exit(sts); } a_valp = calloc( 1, a_size); sts = gdh_GetObjectInfo( astr, a_valp, a_size); if ( EVEN(sts)) { free( a_valp); exit(sts); } sts = cdh_AttrValueToString( a_tid, a_valp, str, sizeof(str)); if ( EVEN(sts)) { free( a_valp); exit(sts); } printf( "%s\n", str); free( a_valp); exit(0); } exit(1); }
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"); }
XttFast::XttFast( void *parent_ctx, char *name, pwr_sAttrRef *fast_arp, int *sts) : xnav(parent_ctx), fast_cnt(0), timerid(0), close_cb(0), help_cb(0), first_scan(1), axis_configured(false) { pwr_sAttrRef aref = pwr_cNAttrRef; pwr_tAName fast_name; pwr_tAName attr_name; pwr_sClass_DsFastCurve fp; int i, j; *sts = XNAV__SUCCESS; // Get current status of the fast objects i = 0; aref = *fast_arp; if ( cdh_ObjidIsNull( aref.Objid)) { *sts = XNAV__FASTCONFIG; return; } *sts = gdh_AttrrefToName( &aref, fast_name, sizeof(fast_name), cdh_mNName); if (EVEN(*sts)) return; *sts = gdh_GetObjectInfo( fast_name, &fp, sizeof(fp)); if ( EVEN(*sts)) return; max_points = fp.NoOfPoints; fast_function = fp.Function; strcpy( attr_name, fast_name); strcat( attr_name, ".TriggTime"); gdh_NameToAttrref( pwr_cNObjid, attr_name, &trigg_time_attr); if ( fast_function & fast_mFunction_BeforeTrigg) { strcpy( attr_name, fast_name); strcat( attr_name, ".TriggIndex"); gdh_NameToAttrref( pwr_cNObjid, attr_name, &trigg_index_attr); strcpy( attr_name, fast_name); strcat( attr_name, ".FirstIndex"); gdh_NameToAttrref( pwr_cNObjid, attr_name, &first_index_attr); strcpy( attr_name, fast_name); strcat( attr_name, ".LastIndex"); gdh_NameToAttrref( pwr_cNObjid, attr_name, &last_index_attr); } // Create data for time axis gcd = new GeCurveData( curve_eDataType_DsTrend); gcd->x_data[0] = (double *) malloc( 8 * max_points); strcpy( gcd->x_name, "Time"); gcd->x_axis_type[0] = curve_eAxis_x; memcpy( &time_buff, &fp.TimeBuffer, sizeof(time_buff)); fast_cnt = 0; for ( i = 0; i < FAST_CURVES; i++) { if ( fp.CurveValid[i]) { gcd->y_data[fast_cnt] = (double *) calloc( 1, 8 * max_points); gcd->y_axis_type[fast_cnt] = curve_eAxis_y; memcpy( &buff[fast_cnt], &fp.Buffers[i], sizeof(buff[0])); type[fast_cnt] = (pwr_eType) fp.AttributeType[i]; fast_idx[i] = fast_cnt; curve_idx[fast_cnt] = i; *sts = gdh_AttrrefToName( &fp.Attribute[i], attr_name, sizeof(attr_name), cdh_mNName); if (EVEN(*sts)) continue; strcpy( gcd->y_name[fast_cnt], attr_name); fast_cnt++; } } if ( !fast_cnt) { *sts = XNAV__NOVALIDCURVE; free(gcd); gcd = 0; return; } // Subscribe to object strcpy( attr_name, fast_name); strcat( attr_name, ".New"); *sts = gdh_RefObjectInfo( attr_name, (pwr_tAddress *)&new_p, &new_subid, sizeof(pwr_tBoolean)); if ( EVEN(*sts)) return; for ( i = 0; i < fast_cnt; i++) { switch( type[i]) { case pwr_eType_Float32: case pwr_eType_Int32: case pwr_eType_UInt32: element_size[i] = 4; break; case pwr_eType_Float64: case pwr_eType_Int64: case pwr_eType_UInt64: element_size[i] = 8; break; case pwr_eType_Int16: case pwr_eType_UInt16: element_size[i] = 2; break; case pwr_eType_Int8: case pwr_eType_UInt8: element_size[i] = 1; break; default: element_size[i] = 4; } gcd->rows[i] = max_points; } gcd->cols = fast_cnt; axis_configured = true; for ( i = 0; i < FAST_CURVES; i++) { if ( fp.CurveValid[i]) { j = fast_idx[i]; if ( fp.YMinValue[i] != fp.YMaxValue[i]) gcd->scale( gcd->y_axis_type[j], gcd->y_value_type[j], fp.YMinValue[i], fp.YMaxValue[i], &gcd->y_min_value_axis[j], &gcd->y_max_value_axis[j], &gcd->y_trend_lines[j], &gcd->y_axis_lines[j], &gcd->y_axis_linelongq[j], &gcd->y_axis_valueq[j], gcd->y_format[j], &gcd->y_axis_width[j], 1, 1); else axis_configured = false; } } if ( fp.Active) first_scan = 0; fast_scan( this); gcd->select_color( 0); if ( strcmp( fp.Title, "") != 0) strcpy( title, fp.Title); else cdh_StrncpyCutOff( title, name, sizeof(title), 1); // timerid = XtAppAddTimeOut( // XtWidgetToApplicationContext(parent_widget), 1000, // (XtTimerCallbackProc)fast_scan, this); }
int main(int argc, char *argv[]) { pwr_tStatus sts; pwr_tObjid Object; pwr_tClassId Class; mh_eOutunitType Type; mh_mOutunitFlags Flags; pwr_tInt32 TenthsOfSeconds = 10; pwr_tInt32 TimerId = 10; sts = gdh_Init("pwr_epri"); if (EVEN(sts)) { exit (sts); } if (argc > 1) { if (strcmp(argv[1], "-t") == 0) { /* test mode */ Object = pwr_cNObjid; Type = mh_eOutunitType_Logger; Flags = mh_mOutunitFlags_ReadWait; } else { Type = mh_eOutunitType_Printer; Flags = mh_mOutunitFlags_ReadWait; strcpy(EventPrinter ,argv[1]); sts = gdh_NameToObjid(argv[1], &Object); if (EVEN(sts)) { printf("%%PRI-E-NOVALID_EVENTPRINT. No valid EventPrinter object\n"); exit(sts); } sts = gdh_GetObjectClass(Object , &Class); if (Class != pwr_cClass_EventPrinter) { printf("%%PRI-E-NOVALID_EVENTPRINT. EventPrinter object, wrong class\n"); exit(sts); } } } else { printf("%%PRI-E-NO_EVENT_PRINTER. No EventPrinter object\n"); exit(2); } sts = mh_OutunitConnect( Object, Type, Flags, (mh_cbOutunitAck)PrintEvent, (mh_cbOutunitAlarm)PrintEvent, (mh_cbOutunitBlock)PrintEvent, (mh_cbOutunitCancel)PrintEvent, NULL, NULL, (mh_cbOutunitInfo)PrintEvent, (mh_cbOutunitReturn)PrintEvent, NULL ); if (EVEN(sts)) { printf("%%PRI-E-CONNECT. Could not connect Outunit to message handler.\n"); exit(sts); } if (Type == mh_eOutunitType_Printer) { sts = gdh_GetObjectInfo(EventPrinter, &EventPrinterObj, sizeof(EventPrinterObj) ); if (EVEN(sts)) { printf("%%PRI-E-EVENTPRINT Cannot get EventPrinter object\n"); exit(sts); } if ((Printer = fopen(EventPrinterObj.DeviceName, "w")) == NULL) { printf("%%PRI-E-NOPRINT Cannot open printer: %s\n", Printer); exit(1); } if (EventPrinterObj.RowSize == 0) EventPrinterObj.RowSize = 80; } else { #if 0 sts = mh_OutunitSetTimer(&TenthsOfSeconds, &TimerId); #endif Printer = stdout; EventPrinterObj.RowSize = 80; } for(;;) { sts = mh_OutunitReceive(); } }
int GeMethods::get_xm_mask(pwr_tAttrRef* arp, char* name, pwr_sClass_XttMethodsMask* xm_mask, int* configured, int(command_cb)(char* cmd, void* udata), void* udata) { pwr_tAName aname, xm_name; pwr_tStatus sts; pwr_tCmd command; int mask_configure = 0; *configured = 0; if (name) { strncpy(aname, name, sizeof(aname)); } else { sts = gdh_AttrrefToName(arp, aname, sizeof(aname), cdh_mName_pathStrict); if (EVEN(sts)) return sts; } strcpy(xm_name, aname); strcat(xm_name, ".XttMethodsMask"); sts = gdh_GetObjectInfo(xm_name, xm_mask, sizeof(*xm_mask)); if (ODD(sts)) { if (!(xm_mask->Flags & pwr_mXttMethodsFlagsMask_IsConfigured)) { mask_configure = 1; *configured = 1; } } else { mask_configure = 1; xm_mask->Flags = 0; } if (mask_configure) { xm_mask->OpMethods = 0; for (int i = 0; i < opmeth_size; i++) { if (streq(op_name[i], "")) continue; sprintf( command, "check method/filter=\"%s\"/object=%s", op_filter[i], aname); sts = (command_cb)(command, udata); if (ODD(sts)) xm_mask->OpMethods |= 1 << i; } xm_mask->MntMethods = 0; for (int i = 0; i < mntmeth_size; i++) { if (streq(mnt_name[i], "")) continue; sprintf(command, "check method/filter=\"%s\"/object=%s", mnt_filter[i], aname); sts = (command_cb)(command, udata); if (ODD(sts)) xm_mask->MntMethods |= 1 << i; } xm_mask->Flags |= pwr_mXttMethodsFlagsMask_IsConfigured; } return 1; }
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 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; }
/*----------------------------------------------------------------------------*\ Init method for the Powerlink module \*----------------------------------------------------------------------------*/ static pwr_tStatus IoAgentInit (io_tCtx ctx, io_sAgent *ap) { io_sLocalEpl_MN *local; int sts; pwr_sClass_Epl_MN *op = (pwr_sClass_Epl_MN *)ap->op; local = (io_sLocalEpl_MN *) calloc( 1, sizeof(io_sLocalEpl_MN)); ap->Local = local; local->inputResetEnabled = 0; op->NumberOfSlaves = 0; static tEplApiInitParam EplApiInitParam; tEplKernel EplRet = kEplSuccessful; pwr_tFileName cdc_file; char* sHostname = malloc(1023); if ( strchr(op->CDCfile, '/') != 0) strcpy( cdc_file, op->CDCfile); else { strcpy( cdc_file, "$pwrp_load/"); strcat( cdc_file, op->CDCfile); } dcli_translate_filename( cdc_file, cdc_file); gethostname(sHostname, 1023); if( op->StallAction == pwr_eStallActionEnum_ResetInputs) local->inputResetEnabled = 1; // Init the I/O area unsigned int input_area_offset = 0; unsigned int input_area_chansize = 0; unsigned int output_area_offset = 0; unsigned int output_area_chansize = 0; io_sRack *rp; io_sCard *cp; pwr_tCid cid; for ( rp = ap->racklist; rp; rp = rp->next) { rp->Local = calloc( 1, sizeof(io_sLocalEpl_CN)); rp->MethodDisabled = 1; op->NumberOfSlaves++; if( ((pwr_sClass_Epl_CN *)rp->op)->StallAction == pwr_eStallActionEnum_ResetInputs) local->inputResetEnabled = 1; // Show device offset and size if ( rp->Class == pwr_cClass_Epl_CN && rp->op) { ((pwr_sClass_Epl_CN *)rp->op)->InputAreaOffset = input_area_offset + input_area_chansize; ((pwr_sClass_Epl_CN *)rp->op)->OutputAreaOffset = output_area_offset + output_area_chansize; } // Get byte ordering pwr_tAName name; pwr_tEnum byte_ordering; strcpy( name, rp->Name); strcat( name, ".ByteOrdering"); sts = gdh_GetObjectInfo( name, &byte_ordering, sizeof(byte_ordering)); if ( ODD(sts)) ((io_sLocalEpl_CN *)rp->Local)->byte_ordering = byte_ordering; else ((io_sLocalEpl_CN *)rp->Local)->byte_ordering = pwr_eByteOrderingEnum_LittleEndian; for ( cp = rp->cardlist; cp; cp = cp->next) { cid = cp->Class; while ( ODD( gdh_GetSuperClass( cid, &cid, cp->Objid))) ; cp->MethodDisabled = 1; // Show module offset and size if ( cid == pwr_cClass_Epl_Module && cp->op) { ((pwr_sClass_Epl_Module *)cp->op)->InputAreaOffset = input_area_offset + input_area_chansize; ((pwr_sClass_Epl_Module *)cp->op)->OutputAreaOffset = output_area_offset + output_area_chansize; } io_bus_card_init( ctx, cp, &input_area_offset, &input_area_chansize, &output_area_offset, &output_area_chansize, byte_ordering, io_eAlignment_Powerlink); // Show module offset and size if ( cid == pwr_cClass_Epl_Module && cp->op) { ((pwr_sClass_Epl_Module *)cp->op)->InputAreaSize = input_area_offset + input_area_chansize - ((pwr_sClass_Epl_Module *)cp->op)->InputAreaOffset; ((pwr_sClass_Epl_Module *)cp->op)->OutputAreaSize = output_area_offset + output_area_chansize - ((pwr_sClass_Epl_Module *)cp->op)->OutputAreaOffset; } if(rp->next == NULL) { if(cp->next == NULL) { ((pwr_sClass_Epl_Module *)cp->op)->InputAreaSize += pwr_Align(input_area_offset + input_area_chansize, 4) - (input_area_offset + input_area_chansize); ((pwr_sClass_Epl_Module *)cp->op)->OutputAreaSize += pwr_Align(output_area_offset + output_area_chansize, 4) - (output_area_offset + output_area_chansize); } } } // Show slave offset and size if ( rp->Class == pwr_cClass_Epl_CN && rp->op) { ((pwr_sClass_Epl_CN *)rp->op)->InputAreaSize = input_area_offset + input_area_chansize - ((pwr_sClass_Epl_CN *)rp->op)->InputAreaOffset; ((pwr_sClass_Epl_CN *)rp->op)->OutputAreaSize = output_area_offset + output_area_chansize - ((pwr_sClass_Epl_CN *)rp->op)->OutputAreaOffset; if(rp->next == NULL) { ((pwr_sClass_Epl_CN *)rp->op)->InputAreaSize += pwr_Align(input_area_offset + input_area_chansize, 4) - (input_area_offset + input_area_chansize); ((pwr_sClass_Epl_CN *)rp->op)->OutputAreaSize += pwr_Align(output_area_offset + output_area_chansize, 4) - (output_area_offset + output_area_chansize); } } } // This is the calculated in- and outputarea size local->input_area_size = pwr_Align(input_area_offset + input_area_chansize, 4); local->output_area_size = pwr_Align(output_area_offset + output_area_chansize, 4); // Show agent in- and output area size op->InputAreaSize = local->input_area_size; op->OutputAreaSize = local->output_area_size; struct sched_param schedParam; // adjust process priority // push nice level in case we have no RTPreempt if (nice (-20) == -1) { errh_Error("%s() couldn't set nice value! (%s)", __func__, strerror(errno)); } //schedParam.sched_priority = MIN(sched_get_priority_max(SCHED_FIFO), // sched_get_priority_min(SCHED_FIFO) + op->Priority); schedParam.__sched_priority = op->Priority; if (pthread_setschedparam(pthread_self(), SCHED_RR, &schedParam) != 0) { errh_Error("%s() couldn't set thread scheduling parameters! %d", __func__, schedParam.__sched_priority); } // binds all openPOWERLINK threads to the second CPU core cpu_set_t affinity; CPU_ZERO(&affinity); CPU_SET(1, &affinity); sched_setaffinity(0, sizeof(cpu_set_t), &affinity); // Initialize target specific stuff EplTgtInit(); EPL_MEMSET(&EplApiInitParam, 0, sizeof (EplApiInitParam)); EplApiInitParam.m_uiSizeOfStruct = sizeof (EplApiInitParam); EplApiInitParam.m_pEventUserArg = ap; // Get devicename from attribute in agent EplApiInitParam.m_HwParam.m_pszDevName = op->Device; // Get nodeid from attribute in agent EplApiInitParam.m_uiNodeId = op->NodeId; EplApiInitParam.m_dwIpAddress = ntohl( inet_addr( op->IpAddress)); // write 00:00:00:00:00:00 to MAC address, so that the driver uses the real hardware address EPL_MEMCPY(EplApiInitParam.m_abMacAddress, abMacAddr, sizeof (EplApiInitParam.m_abMacAddress)); EplApiInitParam.m_fAsyncOnly = FALSE; EplApiInitParam.m_dwFeatureFlags = -1; // required for error detection EplApiInitParam.m_dwCycleLen = uiCycleLen_g; // const EplApiInitParam.m_uiIsochrTxMaxPayload = 256; // const EplApiInitParam.m_uiIsochrRxMaxPayload = 256; // const; only required for IdentRes EplApiInitParam.m_dwPresMaxLatency = 50000; // required for initialisation (+28 bytes) EplApiInitParam.m_uiPreqActPayloadLimit = 36; // required for initialisation of Pres frame (+28 bytes) EplApiInitParam.m_uiPresActPayloadLimit = 36; // const; only required for IdentRes EplApiInitParam.m_dwAsndMaxLatency = 150000; // required for error detection EplApiInitParam.m_uiMultiplCycleCnt = 0; // required to set up max frame size EplApiInitParam.m_uiAsyncMtu = 1500; // required for sync EplApiInitParam.m_uiPrescaler = 2; EplApiInitParam.m_dwLossOfFrameTolerance = 500000; EplApiInitParam.m_dwAsyncSlotTimeout = 3000000; EplApiInitParam.m_dwWaitSocPreq = 150000; // NMT_DeviceType_U32 EplApiInitParam.m_dwDeviceType = -1; // NMT_IdentityObject_REC.VendorId_U32 EplApiInitParam.m_dwVendorId = -1; // NMT_IdentityObject_REC.ProductCode_U32 EplApiInitParam.m_dwProductCode = -1; // NMT_IdentityObject_REC.RevisionNo_U32 EplApiInitParam.m_dwRevisionNumber = -1; // NMT_IdentityObject_REC.SerialNo_U32 EplApiInitParam.m_dwSerialNumber = -1; EplApiInitParam.m_dwSubnetMask = ntohl( inet_addr( op->IpNetmask)); EplApiInitParam.m_dwDefaultGateway = 0; EPL_MEMCPY(EplApiInitParam.m_sHostname, sHostname, sizeof(EplApiInitParam.m_sHostname)); EplApiInitParam.m_uiSyncNodeId = EPL_C_ADR_SYNC_ON_SOA; EplApiInitParam.m_fSyncOnPrcNode = FALSE; // set callback functions EplApiInitParam.m_pfnCbEvent = (tEplApiCbEvent)AppCbEvent; EplApiInitParam.m_pfnObdInitRam = EplObdInitRam; EplApiInitParam.m_pfnCbSync = AppCbSync; // initialize POWERLINK stack EplRet = EplApiInitialize(&EplApiInitParam); if(EplRet != kEplSuccessful) { errh_Error("EplApiInitialize() failed (Error:0x%x!", EplRet); goto Exit; } EplRet = EplApiSetCdcFilename(cdc_file); if(EplRet != kEplSuccessful) { goto Exit; } // Allocate memory for the in- and outputareas if( local->output_area_size > 0) AppProcessImageIn_g = malloc(local->output_area_size); if( local->input_area_size > 0) { AppProcessImageOut_g = malloc(local->input_area_size); } // Save pointer to in- and outputareas in THIS agent object local->input_area = AppProcessImageOut_g; local->output_area = AppProcessImageIn_g; if( local->inputResetEnabled && local->input_area_size > 0) local->tmp_area = malloc(local->input_area_size); else local->tmp_area = local->input_area; AppProcessImageCopyJob_g.m_fNonBlocking = FALSE; AppProcessImageCopyJob_g.m_uiPriority = 0; AppProcessImageCopyJob_g.m_In.m_pPart = AppProcessImageIn_g; AppProcessImageCopyJob_g.m_In.m_uiOffset = 0; AppProcessImageCopyJob_g.m_In.m_uiSize = local->output_area_size; AppProcessImageCopyJob_g.m_Out.m_pPart = AppProcessImageOut_g; AppProcessImageCopyJob_g.m_Out.m_uiOffset = 0; AppProcessImageCopyJob_g.m_Out.m_uiSize = local->input_area_size; EplRet = EplApiProcessImageAlloc(local->output_area_size, local->input_area_size, 2, 2); if (EplRet != kEplSuccessful) { goto Exit; } EplRet = EplApiProcessImageSetup(); if (EplRet != kEplSuccessful) { goto Exit; } // start processing EplRet = EplApiExecNmtCommand(kEplNmtEventSwReset); if (EplRet != kEplSuccessful) { IoAgentClose(NULL, NULL); goto Exit; } errh_Success ("Powerlink init successfull"); return IO__SUCCESS; Exit: errh_Error("IoCardInit: returns 0x%X", EplRet); return IO__SUCCESS; }
static void trace_changevalue ( WGre *gre, flow_tNode fnode ) { WFoe *foe; ldh_tSesContext ldhses; pwr_tStatus sts; char name[200]; pwr_tBoolean value; flow_tTraceObj object_str; flow_tTraceAttr attr_str; flow_eTraceType trace_type; int inverted; foe = (WFoe *)gre->parent_ctx; ldhses = (gre->wind)->hw.ldhses ; /* take away the old messages */ if ( foe->msg_label_id != 0 ) foe->message( ""); if ( flow_GetNodeGroup( fnode) == flow_eNodeGroup_Trace) { gre->trace_changenode = fnode; /* Get a value */ foe->get_textinput( "Enter value : ", &trace_aanalyse_set_value); return; } else { /* Toggle the value, start to get the current value */ flow_GetTraceAttr( fnode, object_str, attr_str, &trace_type, &inverted); strcpy( name, object_str); strcat( name, "."); strcat( name, attr_str); switch ( trace_type) { case flow_eTraceType_Boolean: sts = gdh_GetObjectInfo( name, &value, sizeof(value)); if (EVEN(sts)) { foe->message( "Unable to set value"); WFoe::error_msg( sts); return; } /* Toggle the value */ if ( value == 0) value = 1; else value = 0; sts = gdh_SetObjectInfo( name, &value, sizeof(value)); if (EVEN(sts)) { foe->message( "Unable to set value"); WFoe::error_msg( sts); return; } break; default: foe->message( "Unable to toggle value"); } } }