GSD - Ruby codes - Revision history

RayBe: Added category: GSD

2016-07-11T14:56:26Z

Added category: GSD

←Older revision		Revision as of 14:56, 11 July 2016
Line 1:		Line 1:
	[[Category: Programmer's Guide]]		[[Category: Programmer's Guide]]
			[[Category: GSD]]

	== GSD ==		== GSD ==

Ad88110: /* Command implementation in Ruby */ ops wich ->which

2008-08-21T07:43:58Z

Command implementation in Ruby: ops wich ->which

←Older revision		Revision as of 07:43, 21 August 2008
Line 5:		Line 5:

	== Command implementation in Ruby ==		== Command implementation in Ruby ==
	For Generic Serial Devices the architecture allows implementing the commands directly from the LinuxMCE Admin Web Page, using Advanced/Device Templates. After picking the device template, select ruby codes and add the command groups that you want to implement (should be supported by the devices for ~~wich~~ you want to create the template)		For Generic Serial Devices the architecture allows implementing the commands directly from the LinuxMCE Admin Web Page, using Advanced/Device Templates. After picking the device template, select ruby codes and add the command groups that you want to implement (should be supported by the devices for which you want to create the template)

	The framework offers an Ruby ''Command'' object that actually behaves as a container for data also found in the C++ class Command from DCE. In order to create an instance of the ruby command use:		The framework offers an Ruby ''Command'' object that actually behaves as a container for data also found in the C++ class Command from DCE. In order to create an instance of the ruby command use:

Ad88110: /* Command implementation in Ruby */ witch->wich

2008-08-21T07:42:11Z

Command implementation in Ruby: witch->wich

←Older revision		Revision as of 07:42, 21 August 2008
Line 5:		Line 5:

	== Command implementation in Ruby ==		== Command implementation in Ruby ==
	For Generic Serial Devices the architecture allows implementing the commands directly from the LinuxMCE Admin Web Page, using Advanced/Device Templates. After picking the device template, select ruby codes and add the command groups that you want to implement (should be supported by the devices for ~~witch~~ you want to create the template)		For Generic Serial Devices the architecture allows implementing the commands directly from the LinuxMCE Admin Web Page, using Advanced/Device Templates. After picking the device template, select ruby codes and add the command groups that you want to implement (should be supported by the devices for wich you want to create the template)

	The framework offers an Ruby ''Command'' object that actually behaves as a container for data also found in the C++ class Command from DCE. In order to create an instance of the ruby command use:		The framework offers an Ruby ''Command'' object that actually behaves as a container for data also found in the C++ class Command from DCE. In order to create an instance of the ruby command use:

Ad88110: /* GSD */ mostlly->mostly

2008-08-21T07:40:39Z

GSD: mostlly->mostly

←Older revision		Revision as of 07:40, 21 August 2008
Line 2:		Line 2:

	== GSD ==		== GSD ==
	Generic Serial Device is a module that offers basic functionality for accessing devices via the serial port (~~mostlly~~ through the RS232 interface). The project sources are located in pluto/src/Generic_Serial_Devices.		Generic Serial Device is a module that offers basic functionality for accessing devices via the serial port (mostly through the RS232 interface). The project sources are located in pluto/src/Generic_Serial_Devices.

	== Command implementation in Ruby ==		== Command implementation in Ruby ==

Mstovenour: Added to Category: Programmer's Guide

2007-08-11T15:16:57Z

Added to Category: Programmer's Guide

←Older revision		Revision as of 15:16, 11 August 2007
Line 1:		Line 1:
			[[Category: Programmer's Guide]]

	== GSD ==		== GSD ==
	Generic Serial Device is a module that offers basic functionality for accessing devices via the serial port (mostlly through the RS232 interface). The project sources are located in pluto/src/Generic_Serial_Devices.		Generic Serial Device is a module that offers basic functionality for accessing devices via the serial port (mostlly through the RS232 interface). The project sources are located in pluto/src/Generic_Serial_Devices.

Juliet at 13:24, 16 March 2007

2007-03-16T13:24:31Z

←Older revision		Revision as of 13:24, 16 March 2007
Line 1:		Line 1:
	<table width="100%"> <tr><td bgcolor="#FFCFCF">This page was written by Pluto and imported with their permission when LinuxMCE branched off in February, 2007. In general any information should apply to LinuxMCE. However, this page should be edited to reflect changes to LinuxMCE and remove old references to Pluto.</td></tr> </table>== GSD ==		== GSD ==
	Generic Serial Device is a module that offers basic functionality for accessing devices via the serial port (mostlly through the RS232 interface). The project sources are located in pluto/src/Generic_Serial_Devices.		Generic Serial Device is a module that offers basic functionality for accessing devices via the serial port (mostlly through the RS232 interface). The project sources are located in pluto/src/Generic_Serial_Devices.

	== Command implementation in Ruby ==		== Command implementation in Ruby ==
	For Generic Serial Devices the architecture allows implementing the commands directly from the ~~Pluto~~ Admin Web Page, using Advanced/Device Templates. After picking the device template, select ruby codes and add the command groups that you want to implement (should be supported by the devices for witch you want to create the template)		For Generic Serial Devices the architecture allows implementing the commands directly from the LinuxMCE Admin Web Page, using Advanced/Device Templates. After picking the device template, select ruby codes and add the command groups that you want to implement (should be supported by the devices for witch you want to create the template)

	The framework offers an Ruby ''Command'' object that actually behaves as a container for data also found in the C++ class Command from DCE. In order to create an instance of the ruby command use:		The framework offers an Ruby ''Command'' object that actually behaves as a container for data also found in the C++ class Command from DCE. In order to create an instance of the ruby command use:
Line 11:		Line 11:


	There is a ~~hashmap~~ associated with the ~~comand~~ object that allows setting values for the command parameters:		There is a hash map associated with the command object that allows setting values for the command parameters:


Line 23:		Line 23:


	Directly implementing each command this way may prove ~~unconveninet~~. You can use the Private Method dummy command for writing helper functions. Besides from the params_ member, the ruby Command object has members for all the parameters from the constructor. Still, the wrapper offers only simple ~~acces~~ to what a ~~commad~~ really is in the DCE Framework, but, ~~ofcourse~~, it can be extended to allow more by adding members to the RubyCommandWrapper C++ class. All that's implemented here gets translated to Ruby.		Directly implementing each command this way may prove inconvenient. You can use the Private Method dummy command for writing helper functions. Besides from the params_ member, the ruby Command object has members for all the parameters from the constructor. Still, the wrapper offers only simple access to what a command really is in the DCE Framework, but, of course, it can be extended to allow more by adding members to the RubyCommandWrapper C++ class. All that's implemented here gets translated to Ruby.

	The actual forwarding to the DCE framework is done in the Generic_Serial_Device project, in classes implementing RubyDCEConnector (ex: RubyIOManager). These are used at their turn from the RubySerialWrapper, witch offers the actual context where the Ruby code runs (Ruby twin classes are generated for each device at runtime). The SendCommand used above is a method of the RubySerialWrapper class.		The actual forwarding to the DCE framework is done in the Generic_Serial_Device project, in classes implementing RubyDCEConnector (ex: RubyIOManager). These are used at their turn from the RubySerialWrapper, witch offers the actual context where the Ruby code runs (Ruby twin classes are generated for each device at runtime). The SendCommand used above is a method of the RubySerialWrapper class.

Wikiadmin: /* Command implementation in Ruby */

2006-09-29T07:15:20Z

Command implementation in Ruby

←Older revision		Revision as of 07:15, 29 September 2006
Line 8:		Line 8:


	cmd = Command.new( <device from>, <device to>, <~~???~~>, <~~command~~ type>, <~~command~~ id>)		cmd = Command.new( <device from>, <device to>, <priority>, <type>, <id>)

Wikiadmin at 07:14, 29 September 2006

2006-09-29T07:14:30Z

←Older revision		Revision as of 07:14, 29 September 2006
Line 1:		Line 1:
	<table width="100%"> <tr><td bgcolor="#FFCFCF">This page was written by Pluto and imported with their permission when LinuxMCE branched off in February, 2007. In general any information should apply to LinuxMCE. However, this page should be edited to reflect changes to LinuxMCE and remove old references to Pluto.</td></tr> </table>~~For~~ Generic Serial ~~Devices~~ the ~~architecture allows implementing~~ the ~~commands directly from the Pluto Admin Web Page, using Advanced~~/~~Device Templates. After picking the device template, select ruby codes and add the command groups that you want to implement~~.		<table width="100%"> <tr><td bgcolor="#FFCFCF">This page was written by Pluto and imported with their permission when LinuxMCE branched off in February, 2007. In general any information should apply to LinuxMCE. However, this page should be edited to reflect changes to LinuxMCE and remove old references to Pluto.</td></tr> </table>== GSD ==
			Generic Serial Device is a module that offers basic functionality for accessing devices via the serial port (mostlly through the RS232 interface). The project sources are located in pluto/src/Generic_Serial_Devices.

	The framework offers an Ruby ''Command'' object that is actually a ~~wrapper around~~ the C++ class Command. In order to create an instance of the ruby ~~ocommand~~ use:		== Command implementation in Ruby ==
			For Generic Serial Devices the architecture allows implementing the commands directly from the Pluto Admin Web Page, using Advanced/Device Templates. After picking the device template, select ruby codes and add the command groups that you want to implement (should be supported by the devices for witch you want to create the template)

			The framework offers an Ruby ''Command'' object that actually behaves as a container for data also found in the C++ class Command from DCE. In order to create an instance of the ruby command use:


Line 19:		Line 23:


	Directly implementing ~~commands~~ this way may prove ~~un-conveninet~~. You can use the Private Method dummy ~~commadn~~ for writing helper functions.		Directly implementing each command this way may prove unconveninet. You can use the Private Method dummy command for writing helper functions. Besides from the params_ member, the ruby Command object has members for all the parameters from the constructor. Still, the wrapper offers only simple acces to what a commad really is in the DCE Framework, but, ofcourse, it can be extended to allow more by adding members to the RubyCommandWrapper C++ class. All that's implemented here gets translated to Ruby.

	Besides from the params_ member, the ruby Command object has members for all the parameters from the constructor. Still, the wrapper offers only simple acces to what a commad really is in the DCE Framework.

	The actual ~~translation level~~ is done in the Generic_Serial_Device project, in the ~~RubyCommandWrapper class. Whatever methods~~, ~~parameters etc this class~~ offers ~~will be found in~~ the Ruby ~~Command class after compilation~~. ~~This allows easily extending~~ the ~~acces the ruby code has to the framework~~.		The actual forwarding to the DCE framework is done in the Generic_Serial_Device project, in classes implementing RubyDCEConnector (ex: RubyIOManager). These are used at their turn from the RubySerialWrapper, witch offers the actual context where the Ruby code runs (Ruby twin classes are generated for each device at runtime). The SendCommand used above is a method of the RubySerialWrapper class.

Wikiadmin at 06:18, 29 September 2006

2006-09-29T06:18:24Z

←Older revision		Revision as of 06:18, 29 September 2006
Line 4:		Line 4:


	cmd = Command.new( <device from>, <device to>, <???>, <command type>, <command id>)		cmd = Command.new( <device from>, <device to>, <???>, <command type>, <command id>)


Line 10:		Line 10:


	cmd.params_[<parameter id>] = <string value for command parameter>		cmd.params_[<parameter id>] = <string value for command parameter>


Line 16:		Line 16:


	SendCommand(cmd)		SendCommand(cmd)

Wikiadmin at 05:26, 25 September 2006

2006-09-25T05:26:13Z

←Older revision		Revision as of 05:26, 25 September 2006
Line 2:		Line 2:

	The framework offers an Ruby ''Command'' object that is actually a wrapper around the C++ class Command. In order to create an instance of the ruby ocommand use:		The framework offers an Ruby ''Command'' object that is actually a wrapper around the C++ class Command. In order to create an instance of the ruby ocommand use:


	cmd = Command.new( <device from>, <device to>, <???>, <command type>, <command id>)		cmd = Command.new( <device from>, <device to>, <???>, <command type>, <command id>)


	There is a hashmap associated with the comand object that allows setting values for the command parameters:		There is a hashmap associated with the comand object that allows setting values for the command parameters:


	cmd.params_[<parameter id>] = <string value for command parameter>		cmd.params_[<parameter id>] = <string value for command parameter>


	And for sending the command you should use the SendCommand function:		And for sending the command you should use the SendCommand function:


	SendCommand(cmd)		SendCommand(cmd)