Python Smart Terminal Technical - Revision history

Russ hensel: /* Files and Directories */

2020-02-18T22:50:27Z

Files and Directories

Russ hensel: /* Components and Functions */

2020-02-18T22:45:47Z

Components and Functions

Russ hensel: /* Names */

2018-09-24T15:52:58Z

Names

Russ hensel: /* Documentation for Class Instance Methods */

2018-09-24T01:17:58Z

Documentation for Class Instance Methods

Russ hensel: /* The Controller: SmartTerminal */

2018-09-24T01:16:43Z

The Controller: SmartTerminal

Russ hensel at 01:13, 24 September 2018

2018-09-24T01:13:13Z

Russ hensel: /* Logging */

2018-09-24T01:09:52Z

Logging

Russ hensel: /* Logging */

2018-09-24T01:09:07Z

Logging

Russ hensel: /* Class Methods */

2018-09-23T18:59:39Z

Class Methods

Russ hensel: /* Names */

2018-09-23T18:57:38Z

Names

@@ Line 35: / Line 35: @@
 * readme_xxx.txt ------------- various readmes mostly with scratch info, and ideas I may be thinking about.
 * smart_terminal_helper.py --- code to support a second thread and the basis for the extensions.
+* various *.py files for misc testing or data generation, treat as junk, if not linked to smart_terminal.py they are probably not maintained.
 = Components and Functions =

← Older revision		Revision as of 22:45, 18 February 2020
Line 18:		Line 18:

	The application has a main thread running in a Tkinter mainloop. There is also a second thread called a "helper" running which makes some processing much easier. To make gui mainloop responsive to both the GUI and its own processing it uses a pseudo event loop or a polling subroutine that is implemented in SmartTerminal.polling(). This is where data is received from there comm port ( or sometimes the responsibility is passed to the helper thread). The frequency which it is called is set in parameters, the relatively low rate of 100 ms between calls ( .1 sec ) seems to give a perfectly responsive application in most cases. I have run it as fast as once every 10 ms. Have not tried to find a limit. The second thread is mostly intended for your custom processing, see the section Processing below.		The application has a main thread running in a Tkinter mainloop. There is also a second thread called a "helper" running which makes some processing much easier. To make gui mainloop responsive to both the GUI and its own processing it uses a pseudo event loop or a polling subroutine that is implemented in SmartTerminal.polling(). This is where data is received from there comm port ( or sometimes the responsibility is passed to the helper thread). The frequency which it is called is set in parameters, the relatively low rate of 100 ms between calls ( .1 sec ) seems to give a perfectly responsive application in most cases. I have run it as fast as once every 10 ms. Have not tried to find a limit. The second thread is mostly intended for your custom processing, see the section Processing below.
		+
		+	= Files and Directories =
		+	* .../smart_terminal --------------- All the code to run the terminal
		+	* .../smart_terminal/images -------- Various image files, mostly junk may be some screen shots, png versions of some icons.....
		+	* .../smart_terminal/sounds -------- wave files for the ext_process_dm.py
		+	* .../smart_terminal/wiki_etc - ---- various documentation including some of this wiki in pdf format.
		+
		+	Particular Files:
		+
		+	* smart_terminal.py ---------- the main program
		+	* parameters.py -------------- the configuration file
		+	* gui.py --------------------- the GUI of the program ( less what extensions may build )
		+	* running_on.py -------------- a module to discover the environment the program is running on, helps adapt program to different machines and operating systems
		+	* *.ico ---------------------- various icons that may be used with the program
		+	* ext_process_xxxxx.py ------- extension modules ... I should make a page or more to document each, coming...
		+	* readme_xxx.txt ------------- various readmes mostly with scratch info, and ideas I may be thinking about.
		+	* smart_terminal_helper.py --- code to support a second thread and the basis for the extensions.
		+

	= Components and Functions =		= Components and Functions =

@@ Line 100: / Line 100: @@
 == Names ==
-Be consistent: this is good but have not been very successful in standards: I keep changing my mind.  Names across classes are pretty consistent.  I am avoiding short names and try to make them descriptive enough that they are somewhat self documenting.
+Be consistent: this is good but have not been very successful in standards: I keep changing my mind.  Names across classes are pretty consistent.  I am avoiding short names and try to make them descriptive enough that they are somewhat self documenting.  References are often copied across objects for easy access ( lots of parameters for example ); when this happens the name of the object is generally ( should be always ) the same in both objects.
 == Formatting ==

@@ Line 130: / Line 130: @@
          args:  strings
          ret:   instance of the class
          """

← Older revision		Revision as of 01:16, 24 September 2018
Line 35:		Line 35:

	The SmartTerminal.__init__ method is the initialization and "run" method for the application. Much of the code that would normally be in it has been moved to SmartTerminal.restart which is used to restart the application when just the parameters have been changed. See the docstring there.		The SmartTerminal.__init__ method is the initialization and "run" method for the application. Much of the code that would normally be in it has been moved to SmartTerminal.restart which is used to restart the application when just the parameters have been changed. See the docstring there.
		+
		+	== Global Values ==
		+
		+	Yes I know that globals are bad, but they can be useful. For example many class instances need to access the parameter file. This can be done using the singleton class AppGlobal.
		+	It has values at the class level ( not instance ) that are available simply by importing the class. Most values are defaulted to None, and are set to valid values as the application initializes.

	== Threads ==		== Threads ==

@@ Line 36: / Line 36: @@
 The SmartTerminal.__init__ method is the initialization and "run" method for the application.  Much of the code that would normally be in it has been moved to SmartTerminal.restart which is used to restart the application when just the parameters have been changed.  See the docstring there.
-== The Tkinker Thread ==
+== Threads ==
-Once Tkinker is started it runs its own mainloop.  In order to receive however we need to check the rs232 port from time to time.  This is done in SmartTerminal.polling()  I call this thread the GUI thread or gt.  The terminal is configured to have a second thread called the Helper Thread or ht.  In some cases the recieving of data is passed to the Helper Thread so where data is processed in addition to being posted to the GUI. See the section HelperThread for more info.
+The application runs two threads, one for the GUI and one where processing can occur ( HelperThread ) with out locking up the GUI.  There are 2 queues that allow the threads to communicate.
-== HelperThread ==
+=== The Tkinker Thread ===
 HelperThread in smart_terminal_helper.py  This class provides the support for a second thread of execution that does not block the main thread being run by Tinker.  I call the two threads the GUI Thread (gt) and the Helper Thread ( ht ).  It can get confusing keeping track of which method is running in which thread, I sometimes annotate them with gt and ht.  The helper thread is started by running HelperThread.run() which pretty much just runs a polling task in HelperThread.polling().  HelperThread.polling() is an infinite loop, it uses sleep to set the polling rate.  When used with the green house processing module, it may call a function there that is its own infinite loop.  There are a lot of details here, I should write some more about it.

@@ Line 81: / Line 81: @@
 == Logging ==
-This uses the standard Python logging class.  Logging level is set up using the parameter file.
+This uses the standard Python logging class.  Logging level and other logging details are set up using the parameter file.
 == Other Classes ==

← Older revision		Revision as of 01:09, 24 September 2018
Line 76:		Line 76:

	GHProcessing( in gh_processing.py )		GHProcessing( in gh_processing.py )
		+
		+	== Polling ==
		+	Both threads have method that perform polling for events, events like received text, or items in their queue that may have been sent from the other thread. More info in [[Python Smart Terminal Technical Details]]

	== Logging ==		== Logging ==

@@ Line 107: / Line 107: @@
 Almost everything is a class.  Not much in the way of module functions, not many classes in a module.  I am trying to have all my classes descend from something be it only Object.  And now that I am in Python 3.6 this is how it always works.
-== Class Methods ==
+== Documentation for Class Instance Methods ==
 Look something like this: