OpenCircuits - User contributions [en]

Programing Tips

2022-11-13T17:50:51Z

71.232.240.163: /* Copy Work Is Good */

These are my personal tips for programming, they work for me, not sure all programmers will endorse. Some of these tips overlap with each other, hope this is not confusing.

= Copy Work Is Good =

This is key, if you can copy code instead of writing it you can save a whole lot of work. There is nothing wrong with this given that you understand the code that you copy. I copy mostly from myself, I actually keep little pieces of code around to copy from or go into my collection of past projects. This may also give you code that works sooner. If not from yourself then use google. This is not like getting homework from another person in the class ( unless that is what you are actually doing ). The point is to get good code working and be able to do it again in the future. One note about copied code: If you copy code, you own it; that is you must take full responsibility for it. Using code you do not understand makes you a script kitty.

= Start Small and Expand =

You will typically break a complicated task down into steps. It is a good idea to program and test each individually and then put the pieces together. Each time through the code should get bigger ( functionally ) and better. Some components, like error management, I sometimes leave until the basic code is running. There is a whole philosophy of system development where successive improvement of code is a chore idea.

= Put Working Components Together =
This is part of the idea of Start Small and Expand, see above.

= Learn More Python =
From time to time make an effort to learn. Pick up a Python book, read a blog, actually read the documentation. Python is big and getting to some of the advanced topics can take a long time. Any time your coding seems tedious, stop and question your approach. Learn a bit more and the task may not be so tedious.

= Test =
Test your code. Writing special sections of code just for test is a great idea. Learn about the whole concept of unit testing. Google "Python Unit Testing"

= Keep Track Of Your Own Code =
Since you want to copy from your own code, and build on old projects, keep your code organized.

= Study from Time to Time =

There is a lot to learn, from time to time look for online resources to study. I have been doing this for years, still have a lot to learn. Many habits from other languages are not so good in Python which has its own way, some very nice, of doing things.

= Google Is Your Friend =
Got a Python problem. I can almost always find an answer on Google ( or Bing..... ). Usually the process it quick. Use It.

= Get Used to Writing Good Comments =
There is a lot to say about good comments. I will only say a small amount here.

*Comments should tell the intent or purpose of the code. Do not tell what the code does, your reader ( usually you ) can read the code.
*Comments form the internal documentation of the code. There are some Python standards. I should put a link here......
*Comments sometimes warn about something unusual in the code.
*Comments are a good place to keep track of enhancements that might be made in the code.

= Use Libraries =
If you are trying to do something big and complicated, something that is not too far off the beaten track, someone may have written a library for it. Want a web server, there are a bunch of libraries for it. Images, yep there is stuff out there. Look before you code up a storm.

= Good Coding is Good =

Writing bad code in a hurry will often bite you. Write good code as much of the time as you can. May well be faster in the long run. Please use good names, make it a habit.

Lots of people use 2.7, this includes me although I have recently added 3.6 to my environment ( you can have multiple environments on one computer ). But when you program try to be as 3.6 compliant as possible. Some of this includes:
* Always inherit classes from object.
* Use the new style print as function. Use from __future__ import print_function if < 3 to enable this.

= Do Not Invent Stuff Unless Necessary =

I developed a nice little logging system. But Python has one ( several ). Try to use the standards that are already out there.

= More =

We have more in the area of tips, look at the following:

* [[Tips and Tricks for Working with Spyder]]
* [[Intermediate Programing Tips]]
* [[Russ Python Tips and Techniques]]
* [[Debugging the Smart Terminal]]
* Use Google for Python Tips and Techniques there is quiet a bit out there.

[[Category:Python]]

Mushroom Resources

2022-10-12T16:58:11Z

71.232.240.163:

== BoostC Wiki ==

{| class="wikitable"
|-valign="top"
|What
|Where
|Comment

|-valign="top"
|Champignouf: An Identification Web Sete
|[[https://champignouf.com/]]
|Picture or pictures followed by a few questions -- then gives multiple suggestions as to what the mushroom is. So far I like this.

|-valign="top"
|Mushroom Identificator: Phone App
|Android Phone and ?other phones
|This is the Champignouf web site as an app.

|-valign="top"
|Google Lens: Web Site and Phone App
|-
|Does not seem to do useful id's for mushrooms.

|-valign="top"
|Plant dot Net: Phone App
|Android Phone and ?other phones
|Some mushroom id's but not very useful imho.

|-valign="top"
|111
|222
|3333

|-valign="top"
|111
|222
|3333

|-valign="top"
|111
|222
|3333




|}

[[Category:Mushroom]]

Category:Mushroom

2022-10-12T16:47:53Z

71.232.240.163: Created page with "Stuff about Mushrooms, should not be on this site, but I am paying for it so....."

Stuff about Mushrooms, should not be on this site, but I am paying for it so.....

Mushrrom Documentation

2022-09-16T14:26:06Z

71.232.240.163: Created page with "Some ideas for mushroom sample documentation, mostly photos. *Use numbers to distinguish photos taken closely together in time. *Photo from above *Photo from below *Photo of..."

Some ideas for mushroom sample documentation, mostly photos.

*Use numbers to distinguish photos taken closely together in time.
*Photo from above
*Photo from below
*Photo of cap underside
*Photo of scratch and dent
*Photo of cap cross section
*Photo of stem cross section
*Photo of spore print
*Microphoto of spores

*Narrative

*Cap
*Cap below
*Stem (Style)
*

Python Smart Terminal

2022-08-28T20:01:46Z

71.232.240.163: /* Why this Terminal */

= Why this Terminal =

This terminal has a variety of uses, most are focused on interaction with
micro controller projects where ASCII data is exchanged, typically with messages
terminated with a newline or carriage return ( typical for most Arduino projects).

It is also intended for those with a minimal understanding of Python ( required skill
ranges from the vary basic to familiarity with multi-threaded applications ).

Its repository includes several examples of projects where the interaction is
either with a PC ( windows, mac, or Linux ) or a raspberry pi ( Linux ).

Applications may be set up so control of the Arduino is manual, or entirely
automated.

If this is the case there are many ways to use it:

* Base Case
** Use as a replacement for an Arduino serial monitor.
** For this case there is not much point unless you use it as a stepping stone to more advanced use.
** One nice feature is multiple places for user input, each of which is rem embed until changed.
** ( note: I do not have a graphing module for this case though
one could be added. )

* Base Case Plus
** Typically the micro controller is used with a small number of command strings, typically just a few letters, and in complicated cases more complicated strings. The terminal can be set up with these preloaded and with a button that "documents" their use. This can be very nice for
debugging or manually controlled projects.

* Automatic modes
The automatic mode implements the "Base Case Plus" but there is additional code running in another thread that makes the entire operation automatic and is intended for projects that just "run". In my case all these projects
are used with a raspberry pi plus Arduino. This typically gives the
project
** high speed response in the Arduino code ( micro second )
** internet access wifi and cat5
** bluetooth support
** Python and other high level program support
** Graphical interface support
** HTTP server support
** Email access
** Remote terminal support -- either Desktop GUI or ssh terminal

I have example code for these applications included in the repository
that I have completed.

= Goal =
This program is up and running. Making improvements from time to time for my projects. Code at GitHub, see [[https://github.com/russ-hensel/python_smart_terminal Code at GitHub]] See the GUI here at [[Smart Terminal GUI]]

SmartTerminal an open source, programmable rs232 smart terminal in particular for use with micro controllers like the arduino. My motivation for writing it was first to aid in managing and debugging micro controller projects, and then actually becoming part of hybrid raspberry pi / arduino projects. The program can run in many modes ( which you can create if you wish ). Included in the repository is the code for many modes that I have created, each normally paired with an arduino application ( code may be posted, contact me if interested ) to produce a final application. For more information on these projects see the category Arduino/RaspberryPi.

This program is designed to be:
*Easily configurable through a configuration file parameters.py
*Easily extended with additional modules, several of which are in the code at GitHub and can be activated with a simple change to the parameter file.

I think it is documented well enough so people can relatively easily extend and adapt the program. It easy to download and use even for those without a desire to dive into the code. I assume some knowledge of Python, and a Python Environment to run it in. Was Python 2.7 now upgraded to Python 3.6 and a bunch of other enhancements. See features below.

See the graphical user interface here ( with screen shot ): [[Smart Terminal GUI]]

This application is also part of a family of applications see the category below: Python Projects.

This is an article started by Russ Hensel, see "http://www.opencircuits.com/index.php?title=Russ_hensel#About My Articles" About My Articles for a bit of info.

'''Who should use this program and How:'''

{| class="wikitable"
|-valign="top"
|Who
|What
|How

|-valign="top"
|Person with little programming experience, no interest in Python. Looking for download and install.
|Probably should use another program.
|Not well suited to use this, I do not plan to fix this.


|-valign="top"
|Programming microcontrollers in text based language, willing to install or has Python installed.
|Run the basic program. Customize in fairly minor ways.
|Edit the parameter file to configure the terminal. Could use processing extensions written by others.

|-valign="top"
|Modest Python experience
|Modify all over the place, monitor equipment, save data to database ......
|Program should be well documented with an API, sample extensions. Code changes localized ( now ) to one class plus the parameter file.

|}

= What/Why =

Almost all my Arduino and other microcontroller projects use serial communications for a least debugging. And in many cases I pair the Arduino with a Raspberry Pi for a very flexible system. A good serial monitor, or terminal program is useful in this sort of project. Because I wanted features not in most terminals and the ability to program it myself, I started one from scratch using Python.

The program is also designed to be a stand alone data logging, environmental monitoring program. In this case it will kick off and run without an operator. Data can be access over the web. I will largely leave a discussion of these features to another page, but probably about half the code is devoted to these features.

Currently the terminal waits for a carriage return ( or line fead ) until it displays ( or make available for processing ) the received string. This make sense for my application, it help the processing. This may not work best for you, let me know.

So what are the features?

* Free open source
* Runs across OSs Linux ( inc '''Raspberry Pi''' ), Mac or Windows
* Python
* "RS232" all standard baud rates etc.
* Easily adjusted serial communications parameters
* Multiple, preloaded with data entry fields.
* Clear ( erase ) receive area for removal of clutter.
* Copy all or part of receive area.
* Programmable
* I have extensions to work with specific arduino programs. These: Run a clock, Monitor a Green House, Monitor a root cellar, Monitor a Well.
* Database Interface ( now MYSQL can connect across the network )
* Email interface.
* Easily Modified or Replaceable GUI
* Parameter file for wide range of modifications of program behavior.
* Easy to run multiple instances with different parameters.
* Uses standard Python logging class.
* Includes some advanced data logging features in addition to database data logging.
* For more on the features see [[SmartTerminal Features]]

Limits:

* Polls the comm port at 10 to 100 hz. So full lines ( ending with carriage return <cr> ) cannot come in too fast. This is theory I have not pushed the terminal.
* One instance of the program per com port at a time, but easy to run multiple instances.

What would you like to see in the program or documentation? Email me.

A much earlier version of this terminal was described in my instructable [[http://www.instructables.com/id/Python-Terminal-for-Cheap-Pi-Arduino-Connection/ Python Terminal for Cheap Pi Arduino Connection]] It may have some information that is useful, but the program has grown a lot since then.

= Installation =
This program is intended for those who at least occasionally develop in Python. I expect that they already run some things in Python and will just add this as an additional project. There is no install program you just download the files, place where you keep your projects and run. A bit more later in this section.

== My Environment/Your Environment ==

The program has a better chance of running if your environment is not too much different from mine. The most important is that it is Python 2.7 or compatible. '''No now Pyton 3.6'''

Before you begin to install you should know a bit about the environment that I have used to build, test and run the terminal. If your environment differs too much you may have trouble getting it to run.

I run Python mostly using the install that comes with Anaconda Spyder and often use the IDE it installs. This is not necessary, it is just an nice install that downloads a lot of stuff that technical folks find useful. I have use conda and pip to add to this install and do not know offhand all that is in it. You can look at the include statements to get some idea of what you might need to add. Or you can just keep running it and add the packages it complains about.

== Download ==

Code at GitHub, see [[https://github.com/russ-hensel/python_smart_terminal Code at GitHub]] ( it is Python and you can run directly from the source ) Email me if you have issues ( use this link [[User:Russ_hensel]] ).
You will get a zip file, unzip it and you should get:

.... whatever --|
|
|-- smart_terminal --| -> all code required to run the application ( not sure if smart_terminal or python_smart_terminal or nothing is top level name, just put it in some well named place )
| some logs from my running of the code may or may not be present, these will be deleted as they creep in, when you run the program you will
| get your own log files ... all typically named xxx.py_log
| -- images -> image files, mostly screen shots, icons... or what ever, not important for the code.
| -- sounds -> wav files used for the deer me extension, my attempt to scare deer.
| -- wiki_etc -> various files documenting program, including at least some of the material from this wiki

Put them in your system making "....whatever" anything convenient for your Python ( that is move the files to where you keep your Python source ).

Note that there may be a certain amount of left over, dead code, in the directory I am cleaning out bit by bit, someday it may be nice and neat. For now if you want to tinker look at the design info below first.

== Run ==

Run it until it stops complaining about dependencies ( in the console ), after that ( and perhaps even before ) the GUI should come up. You are installed.

I have run the program on both Windows 10 and Rasperian on a RPi. It should work in most OS's. Let me know about issues.

Some parts of the program think that mySql is available. It should run fine without it ( there will be a message or two in the console ), untill you try to use the database then it is not so gracious. Straight ahead use as a terminal does not use the database.

= Configure to Run =

== Basic ==

Basic configuration of comm parameters like port, baud rate .... is all done in a file called parameters.py. It seemed easier to simply use a Python text file instead of some other format like an ini file. Pretty much all the file does is set instance variables in itself. It is used by the program controller ( smart_terminal.SmartTerminal ) to create an instance of Parameters and then the values can be used. Save the original ( parameters.py, maybe I will include a backup maybe not ) in case you mess it up too much.

I have made yet another pass to clean up and comment the code in parameters. Let me know if you have issues. You should understand some values are being phased out but may still have some implementation and some may be coming in and have little or no implementation. The comments should let you identify these situations.

Parameters starts out with some "meta" parameters. These are defined early in the creation of the objects and may effect other values. In any case you can always define a value twice, the last one always wins. The most important meta parameter is mode, you should not change it from self.mode = "Terminal" unless you understand the implications or do not mind going on a ride.

All the com port values are defined in pretty much one place, find it ( say search on "baud" ) an change it to what you need.

== Command Line Arguments ==

If you run with the command line parameters=paramaters_b then after the regular parameters file runs, then the system looks for parameters_b.py and uses that to override values that you might want to tweak ( or completely redo. There are two examples in the directory follow the pattern in them and you should be fine ).

This can be especially useful if you want to run two copies connected to different ports and possibly running in different modes. In this case it is also nice to change ( its in parameters ) the '''icon''' and '''color''' for each instance of the program. You can write or use the little bat file to start them ( although this leaves a dos console hanging around ) Command line arguments can also be placed in shortcuts. In either case they may take some tweaking to run in/from your file locations.

The above mostly applies to Windows, but the program run fine with Linux ( including the Raspberry Pi ) and I suppose the Mac. Of course the .bat file and shortcuts will not work, but similar facilities exist in the other OSs.

== Running It ==

When you run it it should open a windows a lot like the picture [[Smart Terminal GUI]]. Errors may show up in your Python console or the log file ( look in parameters.py for the name of the log file, typically self.pylogging_fn = "smart_terminal.py_log" ). The most likely errors will point to missing Python modules like pyserial. You should install with pip ( or conda if using Spyder ). Let me know how it goes.

Normally the terminal does not open the com port until you press the <Open> button. The parameters are displayed in the GUI if you do not like them ( for example when you press the <open> button the port open status changes to "open failed", not the desired "open" ) you can shutdown, edit parameters.py and restart. There is a simpler way.

*First configure parameters.py to know the name of a text editor on your system. For mine this is one of:
<pre>

self.ex_editor = r"leafpad" # linux and pi

self.ex_editor = r"D:\apps\Notepad++\notepad++.exe" # for windows.

</pre>

It is set up to auto switch between the two os to make copying the whole program back and forth between the windows and linux a bit easier.

*Now when you run it the button <Edit Parms> should let you edit the parameters.py file. Edit it and save.

*Hit the <Restart> button. In a flash the program should restart with the new parameters.

..... more here soon ......

= Notes on the Code =

In some ways I am proud of the code, it was sometimes a slog, and I had to learn a lot of Python to get it going. On the other hand it kind of sucks, it has lots of dead code, ass backwards was of doing things, poor naming...... There is also a good bit of code on features that I am adding, but that is unfinished. Until I loose interest in it it will probably improve. However, adding features is more part of the life of a programmer than polishing old features; making something better that seems good enough is not always the priority it should be. If you do not like it, mostly keep it to yourself unless it is accompanied by an offer to improve it. I do not need ideas, I need time. That said if you think you have a helpful comment contact me, my page will tell you how: [[User:Russ_hensel]]

= Design =

Description of the design, and a bit to help you figure out what the files do ( for .py files also see the top of file ).

see: [[Python Smart Terminal Technical]]

= Customizing/Extending =

Simple customization may be done simply by changing the parameter file, see: [[Smart Terminal Parameter Examples]] If you want to add code that can be done by messing with any of the source code ( not recommended ) or by programming an extension, see: [[Python Smart Terminal Technical]] and [[Writing You Own Extensions to SmartTerminal]]

= Additional Info =

*Click on the category smart terminal below ( and perhaps the others as well )
*For a graphing ( plotting ) application that is a companion to this see [[Python Smart Terminal Graph]]
*[[Writing You Own Extensions to SmartTerminal]]
*[[Debugging the Smart Terminal]]
*[[Smart Terminal as Smart Data Logger]] obsolete, gone, may come back.
*[[Smart Terminal GUI]]
*[[GreenHouse Monitor Program]]
*[[Smart Terminal Parameter Examples]]
*[[Python Desk Top Applications]]
*[ https://github.com/russ-hensel/python_smart_terminal python_smart_terminal at git hub]
*[http://www.instructables.com/id/Python-Terminal-for-Cheap-Pi-Arduino-Connection/ Python-Terminal-for-Cheap-Pi-Arduino-Connection/] Info on much earlier version may or may not be useful.

[[Category:Python Projects]] [[category:Python]] [[Category:Arduino/RaspberryPi]] [[Category:SmartTerminal]] [[Category:Serial Communications]]

Smart Terminal GUI

2022-08-27T14:10:13Z

71.232.240.163: /* Overview */

= Overview =
The GUI or graphical user interface is the key to using the Smart Terminal ( the main page for the application is at: '''[[Python Smart Terminal]]''' and it has a category page at '''[[https://opencircuits.com/index.php?title=Category:SmartTerminal Category:SmartTerminal]]''' ). In addition, but not discussed here, you can use the command line and the parameter file ( see:''' [[Smart Terminal Parameter Examples]]''' ). This page is the documentation for the GUI.

= Screen Shot =

This is what it looks like, details on each part below. Still working on it, mostly to clean up the details. Note that this screen shot was taken during a debugging session and has some artifacts that will soon disappear, then a new screen shot will be placed here.

[[File:ScreenShot 1.png | 1000x2500px]]



= What Does What: The Controls =

Control is mostly through buttons, sometimes supplemented by text fields. Outside of the GUI there is also a parameter file which controls start up and item like communications setting. The large rectangle at the bottom left, a text area, is where data sent, received, and some information messages are displayed. It is referred to as the receive area.

Working from top to bottom:

== At the Top ==
* <Window title> Program name and some additional info including version, mode, and the name of any "extra" parameter file ( see [[Smart Terminal Parameter Examples]] ).
* <ID Color Band >The green band under the title is an optional component, its height and color is set in the parameter file. It is normally useful only if you are running 2 instances of the terminal and want a quick way to tell them apart.

==Top Row of Labels ==

* <Double Row of Labels, Starting with the Communications>> > Managed by the parameter file ( see [[Smart Terminal Parameter Examples]] ).
**<Port:xxx> Status of comm port, open, closed or failed to open.
**<Type:xxx> Type of comm port, so far only RS232
**<PortID:xxx> Name of port used by the operating system. This may be changed if some of the "auto open" features are used.
**<Baud:xxx> Baud Rate of comm port.
**<StopBits:xxx> Number of stop bits for the comm port
**<Parity:xxx> Parity of comm port.

* <Additional Labels in First Row, Starting with the Database>> > Labels show status of the database connection ( not always used ). Managed by the parameter file.
**<Status:xxx> Open or closed connection to the database
**<ConnectName:xxx> Name given to the connection in the parameter file.
**<Host:xxx> Host name used by the database
**<DB:xxx> Database name
**<User:xxx> Database user

== Next Button Row ==

* <Open Button> Opens the communications port ( if configuration in parameter file(s) allow ) Parameters show to the right, port status to right of button.
* <Close Button> Close the communications port. No error if it is not open. Parameters show to the right, port status to right of button.
* <Parameters to right of open and close buttons> Parameters from the parameter file(s), not editable on the GUI.
* <Edit Log> opens an editor on the system ( needs to be configured in parameter file self.ex_editor = <name of executable or link> ) to view the python logging file for the app.
* <Edit Parms > opens an editor on the system to edit the parameters.py file. See <Edit Log>.
* <Edit Parms X > opens an editor on the system to edit the extended parameter file if used on the command line. Not visible if no extended parameter file used. See <Edit Log>.
* <SendParms> takes the contents of the send buttons and displays them in the receive area in the same format as required by the parameter file to reproduce the current configuration.
* <Ports> List the available ports in the receive area, working under windows until upgraded from 7 to 10, Linux ??
* <Restart> Restarts the application ( usually fast ) using new values ( if any ) in the parameter file(s).
* <Test> May not be present, for debugging, not generally useful or predictable, you would need to look through the code to see what it might be doing, press at your own risk.

== Buttons from Extensions ==
If you have extended the terminal with an xxx_processing module, its GUI will appear here. In this screen shot we see the GUI from the greenhouse extension ( note this is the mode in the window title ). The actual labels are something still in flux, the functions are more fixed.

** <Helper: Find and Monitor Arduino > starts auto run mode of terminal if so configured, this is still alpha and in any case will not have much success unless connected to a compatible serial device ( typically an Arduino ).
** <Helper: Find Arduino > T
** <Interrupt Helper> stops auto run mode of terminal. Also still alpha, but generally harmless.

== Send Area ==

*<Send Buttons> and <Text Entry> to right of each button. Each button sends the text to the right of the button, text is not erased after transmission. Lots of parameters in the parameter file determine the details:
** Number of send buttons
** Text of each button ( default Send )
** Text of the data to be send may or may not be protected based on parameter settings
The setup shown here is customized for a particular arduino program, the greenhouse monitor.

== Receive Area ==

* <Column of Buttons and Text Panel> The Panel shows terminal activity and some other info ( like Ports above ) the buttons act on this data in some way. You can type in the text panel, to no particular effect, perhaps could use this to make notes. Text is partly erased from time to time depending on settings in parameter file(s) The data in the recieve area falls into three classes, each with a unique prefix ( which is set in the parameters.py file ):
** Sent: ">>> "
** Received: "<<< "
** Information: "!!! "

* Other controls:
** <Clear> Clears text panel.
** <Copy Sel> Copies all selected text. Use the mouse to select text.
** <Copy All> Copies all text selected or not.
** <A Scroll> When checked text panel automatically scrolls to the most recent data, else not. This can help you read earlier material when still receiving new data.

[[Category:SmartTerminal]] [[Category:Arduino/RaspberryPi]][[category:Python]] [[category:Python Projects]]

SmartTerminal Features

2022-08-25T16:31:53Z

71.232.240.163: /* General */

= General =

Some [[Category:Draft]] of the features are fairly obvious from the GUI ( see [[Smart Terminal GUI]] ) some are a bit more hidden. In any case this page will document some of the features in more detail. Seems I have not gotten around to this so stay tuned or email me. As of Sept 2018 I am working on this to monitor my well. but in 2022 this is still a draft.

= Source Code =

Application is free open source. I update github from time to time, but email me to see if I have some new improved stuff, I work on it from time to time in episodes. Code is now Python 3.5, waiting for Raspberry Pi to fully go to 3.6 so I can use f strings. Compared to most github projects I have fairly large amounts of documentation ( mostly at this site ).

= Appearance =

= Modify GUI from Parameters =
see: [[Smart Terminal Parameter Examples]] and [[Writing You Own Extensions to SmartTerminal]]

= Access to Parameters and Log File =

The application must of course know what/where its parameter and log file are. So it can also help you look at and edit the files. For this to work you need an editing program installed on your computer. For my windows computer this is Notepad++ ( "D:\apps\Notepad++\notepad++.exe" ). Then in parameters you need to set the parameter something like this: '''self.ex_editor = r"D:\apps\Notepad++\notepad++.exe'''". Smart terminal will then open the appropriate files from the buttons on the GUI.

= A Second Thread =

When a GUI application does something that takes a fair amount of time ( several seconds or more ) the application can become unresponsive until that task is over. For this reason the SmartTermainl runs a second thread for long running background tasks.

= Send Suffix =

= Port Enumeration =

= Port Detection and Connection =

= GUI Extensions =

= Processing Extensions =

These are features beyond terminal features.

* Data scaling and filtering
* Database interface
* Python Logging
* Email Interface

= Application Extensions =

I have written 4 Application as extension to the SmartTerminal that are intended to run on a Raspberry Pi in conjunction with an Arduino. These are in addition to the basic, parameter driven Smart terminal.

* A servo motor based clock

* An environmental monitor for a Green House features multiple temperature sensors, and a humidity sensor. Filters data then logs to a Marina Db ( Open sourced MySql ). Has email interface for extreme values. Companion applications: arduino component, Python Graphing component, Application to check raspberry pi status remotely.

* Environmental monitor similar to the above, but for a Root Cellar.

* Environmental monitor similar to the above, but for a Well.

= draft material will be deleted =

* Free open source
* Runs across OSs Linux ( inc '''Raspberry Pi''' ), Mac or Windows
* Python
* "RS232" all standard baud rates etc.
* Easily adjusted serial communications parameters
* Multiple, preloaded with data entry fields.
* Clear ( erase ) receive area for removal of clutter.
* Copy all or part of receive area.
* Programmable
* I have extensions to work with specific arduino programs. These: Run a clock, Monitor a Green House, Monitor a root cellar, Monitor a Well.
* Database Interface ( now MYSQL can connect across the network )
* Email interface.
* Easily Modified or Replaceable GUI
* Parameter file for wide range of modifications of program behavior.
* Easy to run multiple instances with different parameters.
* Uses standard Python logging class.
* Includes some advanced data logging features in addition to database data logging.
* For more on the features see [[SmartTerminal Features]]

Limits:

* Polls the comm port at 10 to 100 hz. So full lines ( ending with carriage return <cr> ) cannot come in too fast. This is theory I have not pushed the terminal.
* One instance of the program per com port at a time, but easy to run multiple instances.

[[Category:Arduino/RaspberryPi]] [[Category:SmartTerminal]]

Chemical Etchants

2022-06-20T15:21:34Z

71.232.240.163: Replaced content with "removed spam, working to restore page"

removed spam, working to restore page

Command Assistant Help File

2022-01-31T14:59:45Z

71.232.240.163: /* Application Features */

This is the Help "file" for the Python Application whose main page is: *'''[ tbd ]'''

Help file for Command Assistant application ( Documentation for Verxxx ). You can also get a lot of information about how the program works by looking at the GUI and its explanation: '''[[Command Assistant GUI Images]]'''.

= Application Features =

*
*Highly configurable.

= Use =

info on use

= Download and Install =

There is really no install program. Currently the application is intended for those who have at least a little familiarity with Python coding and can just insert the downloaded code into their development environment and run it. Code at '''[https://github.com/russ-hensel/smart_plug/tree/master russ-hensel/Smart_plug Application ]''' For most of you it will not run due to dependency problems. You will need to add them. Pretty much read the error messages and install the missing code. I use Anaconda Spyder so my preferred tool is conda ( conda install pyHS100 ). If conda does not work or you do not use it use pip. pyHS100, a library for smart plugs is pretty likely to be missing ( pip install pyHS100) . Depending on your installation there may be more.

Much of the application is configurable through the parameter.py file, but the default should give you an application that runs, including a default database. You probably will not be able to talk to your smartplugs, because the parameters do need to be told what and where ( tcpip address ) they are.

So to tell the application about your plugs. You should know the address of each plug. If not you might want to use an application like advanced ip scanner ( google it ). The smartplug gives up very little information on my scans, but run the scan with the plug plugged in and out, and the address that appears ( or disappears ) it the address of your device.

With the edited parameter file saved, restart the application. Not working? Double check or email me.

== Application ==

Some operations work the same way in both applications
*Install: see section above.
*Debug: see section below.
*Edit the parameter file: *Change Parameters: Use the application button < Edit Parms > ( after configuring for your editor ) or any text editor suitable for Python ( no tabs ) on the file parameters.py. See also: The section below, [[Configuration Files For Python]] and [[tbd]]
*Edit the log file: This is a standard python logging file. Useful for debugging and general tracking of the application. You can set the level of the logging using the parameter file.

*Quick Restart of the application: As perhaps after a parameter change. Use the < Restart > button. See also: [[tbd]]

*Get Help: Press the <Help> button. Depending on how it is setup in parameters.py you may see this page.
*Work with text in message area: See buttons to the left of the area.

= How to Use the Parameter File =

See: [[Configuration Files For Python]]
You need a text editor suitable for .py files to manage the parameter file ( parameters.py )
This includes most text editors. I particularity like:

*notepad
*geany

You can also use the editor that comes in many python development environments, the simplest of
which may be Idle. But there are many many others. If you are reading this you probably have
some experience.

Once you configure an editor in parameters.py you can edit from the <Edit Parms> in the GUI ( see below )

When editing there are couple of gotchas to watch out for.
* Python cares about capitalization, use the capitalization indicated in the default files and the example code.
* Python also cares a lot about how lines are indented. Do not change the indentation from the sample files, and always indent using spaces ( not tabs. most text editors will use spaces automatically for .py files, even if you use the tab key )

Editing of the parameters.py file

*Edit so the program finds your devices.
**See above in Download and Install
*Enable your favorite editor to work with the application.
**self.ex_editor = r"D:\apps\Notepad++\notepad++.exe" # use r" or the backslashes will not work, or you can use forward slashes instead they may be wrong but they work.
*Lots of other settings:
**Read the comments in parameters.py and change as desired. If a setting does not work let me know.
*If you mess up.
**Re download and get back to the original file.



== The GUI ==

see: [[tbd]]

= Debugging =

There are several application outputs that may be useful for debugging.

* Watch the GUI
* Check the Python console.

<pre>
* Look at the python log file ( use the GUI button Edit Log ( specify your editor in xxxfirst )) or use your editor on the default name of the log file xxx.py_log.

Most issues will probably be missing libraries, parameters.py issues, or just bugs in my code (email me ).

</pre>

= Links =

*[[tbd]] main page for this project
* see categories below as well

[[Category:Python CommandAssist]] [[category:Python]] [[category:Python Projects]]