Python Smart Terminal Technical

Python Smart Terminal Technical

Overview

These notes are here so you can more easily modify the code. Contact me Russ Hensel if you need additional help.

Before modifying the code it is best to understand how it works. Here is an overview of the general plan, details can be filled out by reading the code.

The architecture is called the model view controller or MVC. The class SmartTerminal ( in smart_terminal.py ) could be viewed as the main class. To run the program run its file ( see code at end of file) SmartTerminal is the controller in MVC it is responsible for all overall control, it directly or indirectly creates all other program objects.

The view component is called GUI ( in gui.py ). It creates all the visible components, and relays user input to the controller.

The model component is the component that actually does the communication it is called RS232Driver ( in rs232driver.py ) and like the GUI is controlled by the controller.

The GUI is not allowed to directly communicate with the model and vise versa. Thus you can unplug them from the application and plug in new components. Don't like the GUI? You could modify mine, or you could make a modification and choose which one to use. This is sort of like a skin for an application. You can even set up to run with no GUI at all. The RS232Driver like the GUI easy to remove and replace in the program, its use has been parameterized in to the Parameter object, so to use SPI instead of RS232 all we have to do is write an SPI object and change the values in Parameter.

Two other important components are called Logger ( in logger.py ) and Parameters ( in parameters.py ). The controller creates one of each, and make them available to the other components. The other components can interact with them, and uses them respectively for logging events, and getting access to parameters ( those aspects of the application that are particularly easy to change ).

The application is pretty much single threaded running in a Tkinter mainloop. There is also a second thread called a helper running which makes some processing much easier. To make it responsive to both the GUI and its processing it uses a psedo event loop or a polling subroutine that is implemented in SmartTerminal.polling(). This is where data is received from there comm port. 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.

Coding Conventions Etc.

In reading the code it may be of some use to know what conventions I have ( tried ) to follow. The code has been developed over quite a period of time so the standards are not uniform. What I write here are the standards that are in quite a bit of the code and the directions that I am trying to move.

Object Orientation

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.

Class Methods

Look something like this:

   def create_class_from_strings( self, module_name, class_name):
       """
       This will load a class from string names
       It makes it easier to specify classes in the parameter file.
       I believe it is used for both the comm drive and the "processor"
       args:  strings
       ret:   instance of the class
       """

The comment should give the intent of the method, some hint as to the args ( which hopefully have good names ), and some info. on the return value. zip means nothing, void....

I am moving toward using __ and _ as prefixes for more private methods, but have not gone too far in this direction.

The Controller: SmartTerminal

SmartTerminal ( in smart_terminal .py )

This is the class you create to run the application see the code at the bottom of the file, just run the file. Similar code is at the bottom of some of the other source files to make it convenient to run from those files, this is just to make it easier in development, the code in smart_terminal is the model for what should be used. Sometimes the code at the bottom of the file may have code for testing objects in the file, it may not be maintained, may not work as intended.

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.

Parameters

Parameters ( in parameters.py )

Processing

So called processing modules offer you the opportunity to put some custom automatic processing in your terminal. Typically this is matched up with a custom microcontroller application on the other end of the com port. These are all implemented as descandants of the class . A couple of examples of processing modules and the arduino code are included in the download package.

Microcontroller and Its Protocol

All my microcontroller projects use a simple protocol where commands are sent from the terminal and microcontroller responds, all commands and responses are in human readable encoded strings. If we take the greeenhouse monitor code here are some of the most important commands:

v<cr> microcontroller responds with the name and version of its software a<cr> microcontroller aquires data and responds "ok" t<cr> microcontroller responds with the aquired temperatures ex:

MotorProcessing( in xx_processing.py )

HelperThread

HelperThread in smart_terminal_helper.py

Other Classes

• RS232Driver