config_gtk.c

来自「CNC 的开放码,EMC2 V2.2.8版」· C语言 代码 · 共 643 行 · 第 1/2 页

		pConf->FlagInverted = 0;

		IOParamDevice = ForInputs?&InputDeviceParam[ NumLine ]:&OutputDeviceParam[ NumLine ];
		ComboVal = ConvComboToNum( (char *)gtk_entry_get_text((GtkEntry *)((GtkCombo *)*IOParamDevice)->entry), Devices );
		if ( ComboVal>0 )
		{
			int FirstIO = -1;
			if ( ComboVal==1 )
				pConf->DeviceType = DEVICE_TYPE_DIRECT_ACCESS;
			else
				pConf->DeviceType = DEVICE_TYPE_COMEDI+ComboVal-2;
			IOParamFlag = ForInputs?&InputFlagParam[ NumLine ]:&OutputFlagParam[ NumLine ];
			if ( gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON( *IOParamFlag ) ) )
				pConf->FlagInverted = 1;
			for (NumObj=0; NumObj<NBR_IO_PARAMS; NumObj++)
			{
				IOParamEntry = ForInputs?&InputParamEntry[ NumLine ][ NumObj ]:&OutputParamEntry[ NumLine ][ NumObj ];
				switch( NumObj )
				{
					case 0:
						text = (char *)gtk_entry_get_text((GtkEntry *)*IOParamEntry);
						FirstIO = atoi( text );
						break;
					case 2:
						text = (char *)gtk_entry_get_text((GtkEntry *)*IOParamEntry);
						if ( pConf->DeviceType==DEVICE_TYPE_DIRECT_ACCESS )
							sscanf( text, "%X", &pConf->SubDevOrAdr );
						else
							pConf->SubDevOrAdr = atoi( text );
						break;
					case 3:
						text = (char *)gtk_entry_get_text((GtkEntry *)*IOParamEntry);
						pConf->FirstChannel = atoi( text );
						break;
					case 4:
						text = (char *)gtk_entry_get_text((GtkEntry *)*IOParamEntry);
						pConf->NbrConsecutivesChannels = atoi( text );
						break;
				}
			}
			/* verify if not overflowing */
			if ( FirstIO+pConf->NbrConsecutivesChannels>( ForInputs?NBR_PHYS_INPUTS:NBR_PHYS_OUTPUTS ) )
			{
				printf("Error in I/O conf: overflow for Ixx or Qxx mapping detected...\n" );
				FirstIO = -1;
			}
			/* done at the end, do not forget multi-task ! */
			pConf->FirstClassicLadderIO = FirstIO;
		}//if ( ComboVal>0 )
	}
}

#ifdef USE_MODBUS
GtkWidget * CreateModbusModulesIO( void )
{
	static char * Labels[] = { "Slave Address", "TypeAccess", "1st Modbus Ele.", "Nbr Modbus Ele.", "Logic", "1st %I/%Q Mapped" };
	GtkWidget *vbox;
	GtkWidget *hbox[ NBR_MODBUS_MASTER_REQ+2 ];
	int NumObj;
	int NumLine;
	GList * ItemsDevices = NULL;
	int ScanDev = 0;
	StrModbusMasterReq * pConf;
	char BuffValue[ 40 ];
	GtkWidget *ModbusParamLabel[ NBR_MODBUS_PARAMS];	
	GtkWidget *SerialPortLabel;
	GtkWidget *SerialSpeedLabel;
	GtkWidget *PauseInterFrameLabel;
	GtkWidget *DebugLevelLabel;

	do
	{
		ItemsDevices = g_list_append( ItemsDevices, ModbusReqType[ ScanDev++ ] );
	}
	while( ModbusReqType[ ScanDev ] );

	vbox = gtk_vbox_new (FALSE, 0);
	gtk_widget_show (vbox);

	for (NumLine=-2; NumLine<NBR_MODBUS_MASTER_REQ; NumLine++ )
	{
		hbox[NumLine+2] = gtk_hbox_new (FALSE, 0);
		gtk_container_add (GTK_CONTAINER (vbox), hbox[NumLine+2]);
		gtk_widget_show (hbox[NumLine+2]);

		for (NumObj=0; NumObj<NBR_MODBUS_PARAMS; NumObj++)
		{
			switch( NumLine )
			{
				case -2:
				{
					if ( NumObj==0 )
					{
						SerialPortLabel = gtk_label_new( "Serial port (blank = IP mode)" );
						gtk_box_pack_start(GTK_BOX (hbox[ NumLine+2 ]), SerialPortLabel, FALSE, FALSE, 0);
						gtk_widget_show( SerialPortLabel );
						SerialPortEntry = gtk_entry_new( );
						gtk_box_pack_start( GTK_BOX (hbox[NumLine+2]), SerialPortEntry, FALSE, FALSE, 0 );
						gtk_widget_show ( SerialPortEntry );
						gtk_entry_set_text( GTK_ENTRY(SerialPortEntry), ModbusSerialPortNameUsed );
//TODO: configplc file written by hand for now...
gtk_editable_set_editable( GTK_EDITABLE(SerialPortEntry), FALSE);
						
						SerialSpeedLabel = gtk_label_new( "Serial speed" );
						gtk_box_pack_start(GTK_BOX (hbox[ NumLine+2 ]), SerialSpeedLabel, FALSE, FALSE, 0);
						gtk_widget_show( SerialSpeedLabel );
						SerialSpeedEntry = gtk_entry_new( );
						gtk_widget_set_usize( SerialSpeedEntry,90,0 );
						gtk_box_pack_start( GTK_BOX (hbox[NumLine+2]), SerialSpeedEntry, FALSE, FALSE, 0 );
						gtk_widget_show ( SerialSpeedEntry );
						sprintf( BuffValue, "%d", ModbusSerialSpeed );
						gtk_entry_set_text( GTK_ENTRY(SerialSpeedEntry), BuffValue );
//TODO: configplc file written by hand for now...
gtk_editable_set_editable( GTK_EDITABLE(SerialSpeedEntry), FALSE);
						
						PauseInterFrameLabel = gtk_label_new( "Pause Inter-Frame" );
						gtk_box_pack_start(GTK_BOX (hbox[ NumLine+2 ]), PauseInterFrameLabel, FALSE, FALSE, 0);
						gtk_widget_show( PauseInterFrameLabel );
						PauseInterFrameEntry = gtk_entry_new( );
						gtk_widget_set_usize( PauseInterFrameEntry,90,0 );
						gtk_box_pack_start( GTK_BOX (hbox[NumLine+2]), PauseInterFrameEntry, FALSE, FALSE, 0 );
						gtk_widget_show ( PauseInterFrameEntry );
						sprintf( BuffValue, "%d", ModbusTimeInterFrame );
						gtk_entry_set_text( GTK_ENTRY(PauseInterFrameEntry), BuffValue );
//TODO: configplc file written by hand for now...
gtk_editable_set_editable( GTK_EDITABLE(PauseInterFrameEntry), FALSE);
						
						DebugLevelLabel = gtk_label_new( "Debug level" );
						gtk_box_pack_start(GTK_BOX (hbox[ NumLine+2 ]), DebugLevelLabel, FALSE, FALSE, 0);
						gtk_widget_show( DebugLevelLabel );
						DebugLevelEntry = gtk_entry_new( );
						gtk_widget_set_usize( DebugLevelEntry,70,0 );
						gtk_box_pack_start( GTK_BOX (hbox[NumLine+2]), DebugLevelEntry, FALSE, FALSE, 0 );
						gtk_widget_show ( DebugLevelEntry );
						sprintf( BuffValue, "%d", ModbusDebugLevel );
						gtk_entry_set_text( GTK_ENTRY(DebugLevelEntry), BuffValue );
					}
					break;
				}
				case -1:
				{
					GtkWidget **IOParamLabel = &ModbusParamLabel[ NumObj ];
					*IOParamLabel = gtk_label_new( Labels[ NumObj ] );
					gtk_widget_set_usize(*IOParamLabel,(NumObj<=1 || NumObj==5)?120:100,0);
					gtk_box_pack_start(GTK_BOX (hbox[ NumLine+2 ]), *IOParamLabel, FALSE, FALSE, 0);
					gtk_widget_show( *IOParamLabel );
					break;
				}
				default:
				{
					pConf = &ModbusMasterReq[ NumLine ];
					switch( NumObj )
					{
						/* For req type (combo-list) */
						case 1:
						{
							int ValueToDisplay = pConf->TypeReq;
							GtkWidget **IOParamDevice = &ModbusParamEntry[ NumLine ][ NumObj ];
							*IOParamDevice = gtk_combo_new( );
							gtk_combo_set_value_in_list( GTK_COMBO(*IOParamDevice), TRUE /*val*/, FALSE /*ok_if_empty*/ );
							gtk_combo_set_popdown_strings( GTK_COMBO(*IOParamDevice), ItemsDevices );
							gtk_widget_set_usize( *IOParamDevice,120,0 );
							gtk_box_pack_start ( GTK_BOX (hbox[NumLine+2]), *IOParamDevice, FALSE, FALSE, 0 );
							gtk_widget_show ( *IOParamDevice );
					        	gtk_entry_set_text((GtkEntry*)((GtkCombo *)*IOParamDevice)->entry, ModbusReqType[ ValueToDisplay ]);
							break;
						}
						/* For flags */
						case 4:
						{
							GtkWidget **IOParamFlag = &ModbusParamEntry[ NumLine ][ NumObj ];
							*IOParamFlag = gtk_check_button_new_with_label( "Inverted" );
							gtk_widget_set_usize( *IOParamFlag,100,0 );
							gtk_box_pack_start( GTK_BOX (hbox[NumLine+2]), *IOParamFlag, FALSE, FALSE, 0 );
							gtk_widget_show ( *IOParamFlag );
							if ( pConf->LogicInverted )
								gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( *IOParamFlag ), TRUE );
							break;
						}
						/* For numbers/strings */
						default:
						{
							switch( NumObj )
							{
								case 0:
									strcpy( BuffValue, pConf->SlaveAdr );
									break;
								case 2:
									sprintf( BuffValue, "%d", pConf->FirstModbusElement );
									break;
								case 3:
									sprintf( BuffValue, "%d", pConf->NbrModbusElements );
									break;
								case 5:
									sprintf( BuffValue, "%d", pConf->OffsetVarMapped );
									break;
							}
							{
								GtkWidget **IOParamEntry = &ModbusParamEntry[ NumLine ][ NumObj ];
								*IOParamEntry = gtk_entry_new( );
								gtk_widget_set_usize( *IOParamEntry,(NumObj<=1 || NumObj==5)?120:100,0 );
								gtk_box_pack_start( GTK_BOX (hbox[NumLine+2]), *IOParamEntry, FALSE, FALSE, 0 );
								gtk_widget_show ( *IOParamEntry );
								gtk_entry_set_text( GTK_ENTRY(*IOParamEntry), BuffValue );
							}
							break;
						}
					}
				}//default:
			}
		}
	}
	return vbox;
}
void GetModbusModulesIOSettings( void )
{
	int NumObj;
	int NumLine;
	StrModbusMasterReq * pConf;
	GtkWidget **IOParamEntry;
	char * text;
	char BuffValue[ 40 ];
	for (NumLine=0; NumLine<NBR_MODBUS_MASTER_REQ; NumLine++ )
	{
		pConf = &ModbusMasterReq[ NumLine ];
		strcpy( pConf->SlaveAdr, "" );
		pConf->LogicInverted = 0;

		for (NumObj=0; NumObj<NBR_IO_PARAMS; NumObj++)
		{
			IOParamEntry = &ModbusParamEntry[ NumLine ][ NumObj ];
			switch( NumObj )
			{
				case 0:
					text = (char *)gtk_entry_get_text((GtkEntry *)*IOParamEntry);
					strcpy( BuffValue, text );
					break;
				case 1:
					pConf->TypeReq = ConvComboToNum( (char *)gtk_entry_get_text((GtkEntry *)((GtkCombo *)*IOParamEntry)->entry), ModbusReqType );
					break;
				case 2:
					text = (char *)gtk_entry_get_text((GtkEntry *)*IOParamEntry);
					pConf->FirstModbusElement = atoi( text );
					break;
				case 3:
					text = (char *)gtk_entry_get_text((GtkEntry *)*IOParamEntry);
					pConf->NbrModbusElements = atoi( text );
					break;
				case 4:
					if ( gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON( *IOParamEntry ) ) )
						pConf->LogicInverted = 1;
					break;
				case 5:
					text = (char *)gtk_entry_get_text((GtkEntry *)*IOParamEntry);
					pConf->OffsetVarMapped = atoi( text );
					break;
			}
		}//for (NumObj=0; 
		/* verify if not overflowing */
		if ( pConf->OffsetVarMapped+pConf->NbrModbusElements>( (pConf->TypeReq==MODBUS_REQ_INPUTS_READ)?NBR_PHYS_INPUTS:NBR_PHYS_OUTPUTS ) )
		{
			printf("Error in I/O modbus conf: overflow for Ixx or Qxx mapping detected...\n" );
			strcpy( BuffValue, "" );
		}
		/* done at the end, do not forget multi-task ! */
		/* the first char is tested to determine a valid request => paranoia mode ;-) */
		strcpy( &pConf->SlaveAdr[ 1 ], &BuffValue[ 1 ] );
		pConf->SlaveAdr[ 0 ] = BuffValue[ 0 ];
	}//for (NumLine=0; 

	text = (char *)gtk_entry_get_text(GTK_ENTRY(SerialPortEntry));
	strcpy( ModbusSerialPortNameUsed ,text );
	text = (char *)gtk_entry_get_text(GTK_ENTRY(SerialSpeedEntry));
	ModbusSerialSpeed = atoi( text );
	text = (char *)gtk_entry_get_text(GTK_ENTRY(PauseInterFrameEntry));
	ModbusTimeInterFrame = atoi( text );
	text = (char *)gtk_entry_get_text(GTK_ENTRY(DebugLevelEntry));
	ModbusDebugLevel = atoi( text );
}
#endif

void GetSettings( void )
{
#ifndef HAL_SUPPORT
	GetIOSettings( 1/*ForInputs*/ );
	GetIOSettings( 0/*ForInputs*/ );
#ifdef USE_MODBUS
	GetModbusModulesIOSettings( );
#endif
#ifndef RT_SUPPORT
	ConfigHardware( );
#endif
#endif
}

void OpenConfigWindowGtk()
{
	GtkWidget *nbook;

	ConfigWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title( GTK_WINDOW(ConfigWindow), "Config" );
	gtk_window_set_modal( GTK_WINDOW(ConfigWindow), TRUE );

	nbook = gtk_notebook_new( );
	gtk_notebook_append_page( GTK_NOTEBOOK(nbook), CreateSizesPage(),
				 gtk_label_new ("Sizes") );
#ifdef USE_MODBUS
	gtk_notebook_append_page( GTK_NOTEBOOK(nbook), CreateModbusModulesIO( ),
				 gtk_label_new ("Modbus distributed I/O") );
#endif
	gtk_container_add( GTK_CONTAINER (ConfigWindow), nbook );
	gtk_widget_show( nbook );

	gtk_window_set_position( GTK_WINDOW(ConfigWindow), GTK_WIN_POS_CENTER );
	gtk_window_set_policy( GTK_WINDOW(ConfigWindow), FALSE, FALSE, TRUE );
	gtk_signal_connect ( GTK_OBJECT(ConfigWindow), "destroy",
                        GTK_SIGNAL_FUNC(GetSettings), NULL );

	gtk_widget_show( ConfigWindow );
}