OpenCircuits - User contributions [en]

Resistors

2025-02-14T14:45:57Z

Russ hensel: Protected "Resistors" ([Edit=Allow only administrators] (expires 13:45, 14 March 2025 (UTC)) [Move=Allow only administrators] (expires 13:45, 14 March 2025 (UTC)))

{{stub}}

This article is being split into components check for duplication prior to updataing. You can find the components at ??

== Resistors ==
Probably the most basic component, just a hunk of wire ( low resistance ) or a long thin wire ( high resistance ).

When a voltage is applied to the two ends of an object, then a current usually flows through the object. If the object resists the voltage then the current will be small, if it does not then the current will be high. The amount of resistance is, tactfully, called the resistance. It is measured in ohms. ( Note that acting as a resistor is the simplest thing the object can do, there are more complicated behaviors, see capacitor, diodes, inductors, etc. A resistor is pretty much the simplest of electrical components.
If almost no current flows we call the object an insulator, if a large current flows we call it a conductor. We often view a wire as a resistor of 0 ohms and an insulator as a resistor of infinite ohms. The key equation for a resistor is:

R=V/I

where I = current ( unit: amperes, amps )
V = voltage ( unit: volts )
R = resistance ( unit: ohms = volts per amp )

List of standard 1% resistors. If you want 1% resistors, you must pick from this list or you will pay a fortune for the resistor, assuming you can ever get it.
Interpret these numbers as the "mantissa" of the value.
You can multiply the value by anything from 0.01 to about 100,000.

100 102 105 107 110 113 115 118 121 124 127 130 133 137 140 143 147 150 154 158 162 165 169 174 178 182 187 191 196
200 205 210 215 221 226 232 237 243 249 255 261 267 274 280 287 294
301 309 316 324 332 340 348 357 365 374 383 392
402 412 422 432 442 453 464 475 487 499
511 523 536 549 562 576 590
604 619 634 649 665 681 698
715 732 750 768 787
806 825 845 866 887
909 931 953 976

Uses
*current limiting:
Putting a resistor in a circuit, usually in series with another component it will reduce the current in the circuit, this is often useful to protect the other component. Very common to limit the current in a LED.
current sense:
When a resistor is in series with a circuit the voltage across it will vary with the current ( ohms law ) Sometimes we do this with a low value of resistance and use the voltage across the resistor to measure or control the current.
*Isolation :
A resistor between but connecting 2 components will tend to equalize their voltage, but only using small currents. It the components “want to go there own way, voltage wise” all they need do is put out a small current. For example people will sometimes ground themselves through a 10 mega ohm resistor. This tends to bring them to ground voltage, but they are protected from a deadly shock because most voltages cannot push a lethal current through 10 megs.
*pull up or pull down:
Sometimes a component will have a very high resistance to both the positive and negative side of the power supply and the voltage can easily drift around due to more or less random events. Under these conditions we will often connect a resistance ( typically around 10 K ohms ) to either the positive or negative side of the power supply. If to the positive side it is called a pull up resistor, if to the negative side a pull down resistor.
*voltage divider:
A voltage divider takes some voltage as an input and has an output that is some fraction of the input ( from 0 to 1 ) A volume control is usually some sort of voltage divider.

Links

#[http://www.resistorguide.com/what-is-a-resistor/ All about resistors]
#[http://www.piclist.com/techref/resistors.htm Components: Resistors]
#[http://en.wikipedia.org/wiki/Inductors Resistor From Wikipedia, the free encyclopedia]
#[http://en.wikipedia.org/wiki/Pull_up_resistor Pull-up resistor From Wikipedia, the free encyclopedia]
#[http://en.wikipedia.org/wiki/Voltage_divider Voltage divider rule From Wikipedia, the free encyclopedia]
#[http://www.radio-electronics.com/info/data/index.php Electronics and radio components] see section on '''Resistors'''

=== Carbon ===
The most common found resistor is the carbor film. Theses are generally the cheapest and most used in devices. The commonly are designed to withstand 1/8, 1/4, 1/2, and 1 watts of power. Much more information on [http://www.resistorguide.com/carbon-film-resistor/ carbon film resistors].

=== Metal Film ===
The resistive material is a thin metal film in which a spiral is cut to produce the desired resistance, see [http://www.resistorguide.com/metal-film-resistor/ metal film resistors]

=== Wire-Wound ===
The resistive material is wire, typically wound on a bobbin. Useful for cheap and accurate resistance, but has significant inductance compared to film resistors. Some may be wound in one direction, others half in one direction half in the other, this second method reduces but does not entirely eliminate the inductance. Very common in the range of 5 watts and up. Beware of these for use.

=== Precision ===
Accurate to 1% of marked value or better. In the old days even a 5% resistor was considered precision.

=== FET as a Variable Resistor ===

FETs can be used as a variable resitor over some of the gate voltages -- I think. This clearly needs more work.

Hello,

This is Dennis Perpetua from QGP.com,

We’re interested in advertising on your site.

Is this something you’d be willing to discuss?

Dennis Perpetua
Outreach Manager
www.qgp.com

P.S.: If you don't want me to contact you again, just let me know.

Hello,

I wonder if you received the message I sent a few days ago?

This is Dennis Perpetua from QGP.com,

We’re interested in advertising on your blog. Is this something you’d be willing to discuss?

Dennis Perpetua
Outreach Manager
www.qgp.com

P.S.: If you don't want me to contact you again, just let me know.

== Potentiometers ==

A Potentiometer is a resistor that has a third connection somewhere between the two main terminals. This connection is movable and if put at one end of the resistor will have no resistance between that end of the resistor and the full resistance to the other end. By moving the connection ( sometimes called a tap ) we can control the resistance to each end of the pot, but the sum of the two resistances always equals the total resistance of the potentiometer. A potentiometer is often used as a sort or adjustable voltage divider.
There is an electriclly adjustable version: [[Digital_Potentiometers]]

Uses
*Adjustable voltage divider.
*Volume control.
*Variable resistor ( sometimes used when the correct value of resistance is not know or available, then the pot is use: it is adjusted, perhaps just once, after the circuit is built – to “tweak” the circuit into operating correctly.
*Trim or 0 adjustment

External Links
* [http://en.wikipedia.org/wiki/Potentiometer Potentiometer From Wikipedia, the free encyclopedia( inc. Schematic and Picture )]
* [http://www.sc-fa.com/blog/2009/08/05/slide_potentiometers/ How to buy slide potentiometers]... and extensive blog post on what to watch out for when you're ready to buy sliders/faders/slide potentiometers.
* [http://www.vsensors.com/potentiometer_tutorial.htm Precision Potentiometer Tutorial]

=== Types of pots: ===

One set of classifications overlap with resistors (resistive material, precision, power dissapation ), others like number of turns and purpose differ from resistors.

=== Trimmer ===

Small pots, typically mounted on a circuit board to make fine adjustments to a circuit. Typically changed only when the device is built and then cemented in place, or adjusted when the circuit is serviced.

=== 10 Turn ===

Often precision with special dials to give a wide range of adjustability with calibrated results. Sometimes found in trim pots.

=== Digital Pots ===

Accept digital signals to control a solid state pot. [[Programmable Potentiometers]]

=== Laboratory Pots ===

These are very fancy pots, typically precision 10 turn mounted in a box with other auxiliary components. Often used with a standard cell to measure voltages precisely. I think they have be largely superceded by modern devices.

*[http://physics.kenyon.edu/EarlyApparatus/Electrical_Measurements/Potentiometer/Potentiometer.html The Potentiometer]

[[Category:Components]]

Resistors

2025-02-14T14:44:18Z

Russ hensel:

Chemical Etchants

2025-02-14T14:43:17Z

Russ hensel: Protected "Chemical Etchants" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))

{{stub}}

Chemical etching is one step of some popular [[techniques | PCB fabrication techniques]].

In this technique,
* one starts with a copper-clad board.
* one puts a mask over all the copper he want to keep. There are a variety of ways to do this -- see [[Toner Transfer]] and [[Photoetching]].
* one removes the parts he don't want to keep, by chemically etching away the copper.
* cleanup: wash off the board in the sink; carefully store or dispose of the acid.

There are a lot of different chemical techniques for doing this, each with its own advantages and drawbacks.

None of these chemicals is incredibly dangerous, but they can all be toxic or caustic, and should be treated with care. Eye protection and gloves are a very good idea. Before you start, make sure you know how dangerous each chemical is, and figure out what you will need to do if you spill it or get it on yourself. Washing with plenty of water is usually a good start. For some chemicals you may want to keep a neutralizing agent handy. An MSDS (Materials Safety Data Sheet) for the chemical will give you some basic information.

== vinegar and salt ==

* [http://www.kobakant.at/DIY/?p=2575 How to get what you want: Salt and Vinegar Etching]
* [http://www.flickr.com/photos/jeanbaptisteparis/4831465916/ smt pcb with Salt and Vinegar]
* [http://www.instructables.com/id/The-Saltwater-etch-process/ The Saltwater etch process]
* [http://www.electro-tech-online.com/general-electronics-chat/33876-electro-etching-no-acid.html electro etching a PCB with vinegar, salt, and a 12 V power supply] (the copper etched off the PCB is plated on the anode?) -- however, other people claim that "You should not be using any acids (or basic 'acids') with your [electro] etcher at all. No FeCl no vinegar, etc ".[http://www.bladeforums.com/forums/showthread.php?t=671936]

== Ferric Chloride ==
This is the most common hobbyist etchant. Ferric chloride, FeCl3, is a brownish substance. It's usually sold in a bottle (dissolved in water, perhaps with a little acid or peroxide) or as a powder (which you have to dissolve in water).

When in solution, ferric chloride is a ferric ion (Fe3+) and a chloride ion (Cl-). The ferric ion reacts with the metallic copper on the circuit board in a redox reaction, producing a ferrous ion (Fe2+) and cuprous or cupric (Cu1+ or Cu2+) copper. The chlorine is just along for the ride. The copper ion, unlike the metallic copper, is soluble, so it leaves the circuit board and goes into solution. The reaction products form a black sludge which settles to the bottom of the etching tank. After etching enough copper, all your Fe3+ is used up and your solution is full of Cu1+, and you need to get more etchant.

== Ammonium Persulfate ==
Expensive & hard to control and optimize the process parameters (such as specific gravity & pH value).

== HydroChloric Acid / Hydrogen Peroxide ==

Mixing about 1 part HCl (Which can be found at most hardware stores, also known as Muriatic Acid. Ask for concrete cleaner.) into 2 parts Hydrogen peroxide (normally used for cleaning cuts) you can make a fairly powerful etchant. Use gloves and don't breathe the fumes though. This will etch a 3"x5" board in less than 10 minutes. No need to heat it up. I usually like to drill a small hole through the board on a corner and thread a wire or nylon string through to help agitate / remove the board.

When the board is done etching, the etchant will probably look like green kool-aid, from the copper content in it. This stuff is highly corrosive and will burn skin, which is why you should wear gloves. But it is easy to handle, and fairly easy to dispose of. the etchant is easily deactivated with baking soda. Pour enough baking soda into it slowly (to keep it from boiling and overflowing... remember what happens with baking soda/vinegar? ya...) until it is a solid mass, then leave it in the sun to dry. You should contact your local authorities to find out what you should do with it next. Whatever you do, DO NOT dump the stuff down the drain, it will eat through your pipes just like any of the other etchants.

Alternatively, instead of disposing of the etchant, you can re-use it again and again. In fact, after etching a few boards with this solution, you will have successfully made [[Chemical Etchants#Acid Cupric Chloride|Acid Cupric Chloride]] (see below).
You can also find a detailed tutorial on etching at [http://robotplatform.com/howto/pcb%20etching/pcb_etching_1.html Muriatic Acid etching tutorial]

== Sodium Persulfate ==
More environmentally friendly than ferric chloride. Can monitor the etching as initially clear new etchant solution turns blue from the copper ions.

== Acid Cupric Chloride ==
Dead simple etchant made from ordinary, store-bought chemicals (hydrochloric acid and hydrogen peroxide). Has the advantage that it can be regenerated by bubbling oxygen/air through it, or by adding more H2O2. In addition, it doesn't get used up: the etchant bath simply grows with use (kind of like sourdough starter…)
The used etchant also makes a great algecide/pH reducer for your pool (and a whole lot cheaper than that stuff they sell at the pool store).

What you need:
* 38% Hydrochloric Acid, HCl (available at finer hardware stores or pool supply stores as Muriatic Acid)
* 3% Hydrogen Peroxide, H2O2 (available from any drug store)
* Plastic or Glass Pans, Jars, and tongs (no metal)
Directions:

# Mix your HCl and H2O2 1:1 in a non-metalic container, making sure to add the acid slowly to the H2O2. DO NOT ADD THE H2O2 TO THE ACID!!!
# After you've masked your board, dip it in the solution and constantly agitate. You should notice a dark green cloud start to come from the board almost immedately which quickly dissapears or turns lighter as it gets further from the surface of the board.
# Etching should take about 10min depending on the temperature and how well you agitated the etchant. When all of the copper is gone, dip in water to wash off any stray etchant and stop the reaction.
# When done etching, save used etchant in a non-metalic container and mark clearly its contents.
# If your etchant has become a dark, murky green color, add a little bit of H2O2 or bubble air/O2 through the solution to regenerate it back to a light, transparent green color.
See links at bottom for more information on the chemistry and some pictures of the process.

== Disposal procedures ==
Flushing used etchant down the drain is a bad idea (and usually illegal) because copper ion is toxic. The usual recommended way to dispose of hobbyist amounts of etchant is to convert it to a solid somehow and dispose of the solid in accordance with local laws.

== External Links ==

* [http://www.instructables.com/id/Sponge-Ferric-Chloride-Method-Etch-Circuit-Bo/ "Sponge + Ferric Chloride Method -- Etch PCBs in One Minute!"]
* [http://www.k9spud.com/wiki/PCB:Etchants Ferric Chloride vs. Ammonium Persulfate] and other etching chemicals.
* [http://members.optusnet.com.au/~eseychell/PCB/etching_CuCl/index.html Etching with Air Regenerated Acid Cupric Chloride] — an excellent in-depth page on acid cupric chloride etching by Adam Seychell.
* [http://www.esmonde-white.com/home/diversions/etching-a-copper-pcb Etching a Copper PCB with HCl and H2O2]
* [http://www.mgchemicals.com/ MG Chemicals] A possible source?
* [http://reprap.org/wiki/MakePCBInstructions RepRap wiki: Make PCB instructions]

== Internal Links ==

*[[Toner Transfer]]
*[[Techniques]]
*[[Eagle Links]]

[[Category:Techniques]]

Chemical Etchants

2025-02-14T14:42:19Z

Russ hensel:

Electronic design automation

2024-10-06T16:13:45Z

Russ hensel:

Content vandalized with a link to:

Buy now: https://thawking.shop
History damaged as well

DB9 Serial Connector

2024-10-06T16:12:50Z

Russ hensel:

Content vandalized perhaps by:
https://wa.link/uqh66k
Seems to have damaged history as well.

Connectors

2024-09-19T20:55:09Z

Russ hensel: Protected "Connectors": Excessive vandalism ([Edit=Allow only administrators] (expires 20:55, 19 September 2025 (UTC)) [Move=Allow only administrators] (expires 20:55, 19 September 2025 (UTC)))

[[Image:Main-GM862header.jpg|69px|GM862 SMD Connector]]
[[GM862 SMD Connector]]

[[Image:Main-DB9-PCB-1.jpg||69px|DB9 Connector]]
[[DB9 Serial Connector]]

[[Image:Main-Barrel-Connector.jpg|69px|Barrel Jack]]
[[Barrel Power Jack]]

[[Image:Mini-USB.jpg|69px|Mini-USB]]
[[Mini-USB SMD connector]]

[[Image:sf-microsd.jpg|69px|Mini-USB]]
[[MicroSD/Transflash Socket]]

UEXT: universal expansion connector. The standard UEXT connector consists of ten pins (two rows of five, with 0.1" spacing) and supports I2C, SPI, and RS-232 serial communication, as well as carrying +3.3V power and common ground. -- [http://en.wikipedia.org/wiki/UEXT Wikipedia: UEXT]

[[JTAG]] connectors?

[[ideas#better data cable ideas]]

Some connector companies in no particular order:
[[Samtec]], [[Molex]],

Rather than wiring a connector up directly to a CPU, one typically has some [[input protection]] between them.

The [[SFE Footprint Library]] includes a few connectors.

Mark Whitis has a list of "common pitfalls of Micro Development Boards".
He describes how the 26 pin connectors on his
[https://web.archive.org/web/20110929182706/http://www.freelabs.com/~whitis/electronics/9S12DP256/micro_board/ Mark Whitis Microcontroller Development Board]
avoid those pitfalls and
have many non-obvious features that make them superior to many other connectors.

[http://techref.massmind.org/techref/pcbixmax.htm Massmind: "Maximum interconnect options from minimum board space"]
discusses a board pattern that gives you the option of plugging in any one of a variety of different connectors.

Connectors and data cable ideas are further discussed at [[Ideas#better_data_cable_ideas]].

== Power-only USB connectors and cables ==

* Adafruit. [https://www.adafruit.com/product/4907 "USB C SMT / THM Jack Connector - Power Only"].

* Simon Lewis. [https://www.instructables.com/USB-Condom/ "Make a USB Cable 'power Only'"].
* Charlie Sorrel. [https://www.cultofmac.com/632796/how-and-why-to-make-your-own-power-only-usb-cable/ "How (and why) to make your own power-only USB cable"].
* [https://arstechnica.com/civis/viewtopic.php?f=11&t=1377799 "I want to make a USB C charge only cable"].

* Jeff Smoot. [https://www.cuidevices.com/blog/an-introduction-to-power-only-usb-type-c-connectors "An Introduction to Power-Only USB Type C Connectors"].
** Jeff Smoot. [https://www.digikey.com/en/articles/an-overview-of-usb-type-c-in-power-only-designs "An Overview of USB Type-C in Power-Only Designs"].
** [https://www.reddit.com/r/UsbCHardware/ Reddit "USB Type-C devices & hardware"] : [https://www.reddit.com/r/UsbCHardware/comments/qo24e6/an_introduction_to_poweronly_usb_type_c_connectors/ comments on "An Introduction to Power-Only USB Type C Connectors"]

* [https://electronics.stackexchange.com/questions/140225/how-can-i-tell-charge-only-usb-cables-from-usb-data-cables "How can I tell charge-only USB cables from USB data cables?"].
* [https://electronics.stackexchange.com/questions/327791/using-usb-c-as-a-power-source "Using USB-C as a power source"].
* [https://hardwarerecs.stackexchange.com/questions/16164/what-is-the-max-usb-cable-type-a-male-to-type-c-male-volt-current-wattage-possib "What is the max USB cable type-A male to type-c male Volt/current/Wattage possible?"].
* [https://superuser.com/questions/961176/usb-type-c-power-delivery-profile-max-length "USB Type C Power Delivery ... max length?"]: "Is there a maximum length for a charging only cable?"

* Matthew Lai. [https://dubiouscreations.com/2021/04/06/designing-with-usb-c-lessons-learned/ "Designing with USB-C: Lessons Learned"]: "Type-C connectors tend to be much harder to solder ... Power-Only SMT ... simpler connectors that only have power and the CC pins ... [such as] Korean Hroparts TYPE-C-31-M-17."

* [https://gct.co/news/6_pin_usb_type_c "GCT 6 Pin USB Type-C for Charging"]: [https://gct.co/usb-connector/list?style=Type%20C&version=Charging&interface=C "GCT USB Charging Connectors"]: GCT USB4125, GCT USB4135, GCT USB4515, GCT USB4715 Waterproof IP67 USB Type C Connector, GCT USB4180, GCT USB4130, GCT USB4140, GCT USB4175. All these USB C connectors have 6 contacts: the CC1 and CC2 pins used for USB PD negotiation, the 2 GND pins, and the 2 VBUS pins.

"Directive 2022/2380 will require any electronical hand held devices marketed in the EU to contain a USB-C charging port."
-- [https://gct.co/news/usb-eu-directive_2022_2380 "EU 2022/2380 directive - Are you (USB Type-C) compliant?"]

== USB-C breakout boards ==

* SparkFun. [https://www.sparkfun.com/products/15100 "USB-C Breakout"]: "breaks out the USB-C connector's VBUS, GND, CC1, CC2, D+, and D- pins intro a 0.1" pitch header"
* SparkFun. [https://www.sparkfun.com/products/15096 "SparkFun Serial Basic Breakout - CH340C and USB-C"]: "USB-to-Serial adapter ... The pinout of the Serial Basic mimics the common DTR/RXI/TXO/VCC/CTS/GND pinout ..."
* Adafruit. [https://www.adafruit.com/product/5180 "Simple USB C Socket Breakout"]: "it doesn't break out all the pads - it just gives you the classic 4 USB pins" Vbus, D-, D+, GND.
* Adafruit. [https://www.adafruit.com/product/4090 "Adafruit USB Type C Breakout Board"] and [https://www.mouser.com/new/adafruit/adafruit-4090-usb-c-breakout-board/ "USB C Breakout Board"].
* Adafruit. [https://www.adafruit.com/product/4396 "USB Type C Socket - SMT Inline Breakout Board"]. with nearly all of the 24 pins broken out.
* Pololu. [https://www.pololu.com/product/2585 "USB 2.0 Type-C Connector Breakout Board"]: "The USB-C connector’s 24 tightly-spaced pins make it difficult to use in a hobby project or prototype design. This breakout board helps by providing access to the connector’s pins for power (VBUS and GND), USB 2.0 differential data (D+ and D−), Configuration Channel (CC), and Sideband Use (SBU)."
* Pololu. [https://www.pololu.com/product/3411 "USB 2.0 Type-C Connector Breakout Board"].
* PMD Way. [https://pmdway.com/products/usb-3-1-type-c-male-to-female-breakout-test-board "USB 3.1 Type C Male to Female Breakout Test Board"].
* Tinkersphere. [https://tinkersphere.com/mini-usb/3551-usb-31-type-c-male-breakout-board.html "Male USB C Breakout Board"] and [https://tinkersphere.com/mini-usb/3549-female-usb-c-breakout-board-smt-inline-socket.html "Female USB C Breakout Board"].
* Newegg. [https://www.newegg.com/p/181-0135-00082 "USB-C Male Plug Connector [Breakout] Board"].

== Reduced pin count USB connectors and cables ==

* Tony P. [https://web.archive.org/web/20220725125722/https://idyl.io/how-to-add-usb-type-c-micro-usb-replacement/ "How to add USB Type C to your USB 2.0 projects"]: "replace the micro-USB / mini-USB ... 24 pin connectors are really unfriendly packages. They are very dense making it incredibly hard to reliably solder. The solution to this is to use a reduced pin count type C. ... "TYPE-C-31-M-12" ... by Korean Hroparts Elec [is a] 12 pin USB Type C connector"
* Sparkfun. [https://www.sparkfun.com/products/15424 "Reversible USB A to C Cable - 2m"]: "Supporting USB 2.0 speeds and charging up to 2A, ... the flexibility of a thinner cable and the wonderful feel of a '''reversible ... USB-A connection'''. ... This cable has the D+/D- wires along side large-gauge VBUS/GND wires."
* SparkFun. [https://learn.sparkfun.com/tutorials/connector-basics/usb-connectors "Connector Basics: USB Connectors"]: "USB-B Connectors ... is bulky, but robust, so in applications where size is not an issue, it's the preferred means for providing a removable connector for USB connectivity."

* Matthew Lai. [https://dubiouscreations.com/2021/04/06/designing-with-usb-c-lessons-learned/ "Designing with USB-C: Lessons Learned"]: "Type-C connectors tend to be much harder to solder ... The standard is also much more complicated, though as we will see shortly, actual implementation is VERY simple if we just want to use it to replace micro-B in USB 2.0 devices (as opposed to hosts). ... USB 2.0-Only SMT ... connectors ... omit all the pins not required for USB 2.0... [such as] the Korean Hroparts TYPE-C-31-M-12 (LCSC part number C165948)."

* Morten Christiansen, Synopsys. [https://www.synopsys.com/designware-ip/technical-bulletin/converting-existing-designs.html "Converting Existing USB Designs to Support Type-C Connections"]

* [https://electronics.stackexchange.com/questions/473773/usb-type-c-alternative-with-fewer-signal-wires "USB Type-C Alternative with fewer signal wires"].

== Magnetic connectors ==

* Adafruit. [https://www.adafruit.com/product/5524 "Magnetic USB Type-C Plug Tip"] and the matching [https://www.adafruit.com/product/5520 "USB A or Type-C to Type-C Cable with Magnetic Tip - 1 meter long"].

* [https://electronics.stackexchange.com/questions/473773/usb-type-c-alternative-with-fewer-signal-wires "USB Type-C Alternative with fewer signal wires"]: some of the answers mention magnetic connectors.

* Adafruit. [https://www.adafruit.com/product/5359 "DIY Magnetic Connector - Right Angle Five Contact Pins"]. A set of 2 halves that magnetically attract.

== Further reading ==

* SFUPTOWNMAKER, SparkFun member #23999 [https://learn.sparkfun.com/tutorials/connector-basics "Connector Basics"].

[[Category:Connectors]][[Category:Components]]

Connectors

2024-09-19T20:54:42Z

Russ hensel:

Connectors

2024-09-06T13:04:22Z

Russ hensel:

Chemical Etchants

2024-08-01T11:29:35Z

Russ hensel: Protected "Chemical Etchants": Excessive vandalism ([Edit=Allow only administrators] (expires 11:29, 1 November 2024 (UTC)) [Move=Allow only administrators] (expires 11:29, 1 November 2024 (UTC)))

Chemical Etchants

2024-08-01T11:28:58Z

Russ hensel:

Chemical Etchants

2024-07-23T15:13:08Z

Russ hensel:

Russ hensel

2024-02-17T15:17:57Z

Russ hensel: /* Related to Python */

= About Me =
I am a once upon a time high school teacher and database programmer/software engineer. My hobbies now are gardening, Python programming, microcontrollers, Physics/Math, my cats and whatnot. I have a nice wood shop, some metal working tools, and am learning to weld. I have a fairly large collection of scientific antiques, mostly microscopes, surveying instruments, and electronics test equipment. Online my name is often russ_hensel, gives me a pretty unique id on Google. I live in Dartmouth Ma.

I am now on Facebook, but do not post much.

I have posted a few Instructables, find me there at: [http://www.instructables.com/member/russ_hensel/ Instructables member: russ_hensel]

I have done a fair amount in Python. I am now keeping my files at github: https://github.com/russ-hensel For some there may be info here, other not.

You can reach me ( EMAIL ) at: no_spam_please_666 at comcast dot net (REFORMAT FOR A VALID EMAIL ADDRESS). This address is just for first contact, I will respond with a better address after first contact.

On this site I tend to write about the following topics

* Electronics in general ( still doing it at home, but not writing about it much ).
* Microcontrollers, PIC in the past now the Arduino
* Python and my Python Projects
* Raspberry Pi
* 3D Printing and FreeCad ( bought first printer in 2017, second one too )
* BoostC - now replaced by C++ in context of the Arduino
* Stepper Motors -- used in several of my projects. Usually in catagories with Arduino

= About My Articles =

I write about items as they interest me. Too often I start on something and drop either the article or the project for short or long periods befor picking it up again. Sorry. I am open to email with questions, this may make me complete or improve some article. If you are interested please let me know.

You may find that some pages say something like:

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. The page is only partly finished

== My Editing Links ==

These links are for me to navigate to pages I have done quite a bit of work on or want to look at frequently. They are not for you, but you can use them if you want.

*[[Mushroom Resources]]
*[[Vivek]]

*[[Russ Page Links]]

*[[Russ Editing Links]] probably dead

= Articles posted here on Open Circuits =

== Serial Communications and Microcontrollers ==

*[[Python Smart Terminal]] As of Sept 2016 still and active project.
*[http://www.opencircuits.com/Category:Microcontroller Category:Serial_Communications] Most of these have at least large input from me. Some are general, some for the Arduino, and some for the PIC microcontroller.
*[http://www.opencircuits.com/Category:PIC Category:PIC] I have mostly converted to the Arduino, but before that I used the PIC, still think it is a nice micro controller, but building the boards and finding a coding environment.... is more of a pain than I want.

*[http://www.opencircuits.com/Category:Arduino Category:Arduino] After my conversion from PIC.

= Articles posted on Instructables =

== Related to Python ==
[[Programing Tips]]

*[[Python White Space]]
*[[Random Python]]
*[[Russ Suggests an Arduino Setup]]

*[[Learning Python]]
*[[Other Maker Spaces South Coast]]

Workshop Template

*'''[http://www.instructables.com/id/Python-Terminal-for-Cheap-Pi-Arduino-Connection/ Python Terminal for Cheap Pi Arduino Connection - All ]'''
*'''[http://www.instructables.com/id/Experiments-in-Advanced-Data-Logging-Using-Python-/ Experiments in Advanced Data Logging ( Using Python ) - All ]'''
*'''[http://www.instructables.com/id/Incredibility-Powerful-Resistance-Calculator/ Incredibility Powerful Resistance Calculator - All ]'''
*'''[http://www.instructables.com/id/Use-Sage-and-Sell-Your-Calculator-before-it-is-Too/ Use Sage and Sell Your Calculator before it is Too Late - All ]'''
*'''[http://www.instructables.com/id/Python-Autoexec-for-Your-Raspberry-Pi/ Python Autoexec for Your Raspberry Pi - All ]'''
*'''[http://www.instructables.com/id/ClipBoard-Communication-PC-Pi-With-Python/ ClipBoard Communication PC ↔ Pi With Python - All ]'''
*'''[http://www.instructables.com/id/Graph-Your-Solar-Power/ Graph Your Solar Power - All ]'''
*'''[http://www.instructables.com/id/Graph-Instructable-Views-with-Pypthon-Screen-Scrap/ Graph Instructable Views with Python Screen Scraping - All ]'''
*'''[http://www.instructables.com/id/Digital-Picture-Management-Eliminate-Weak-Photos-w/ Digital Picture Management - Del Weak Pics with Python - All ]'''

== Related to Arduino ==

[[Pi Setup Nov 2016]]

*'''[http://www.instructables.com/id/Backup-Your-Pi/ Backup Your Pi - All ]'''
*'''[http://www.instructables.com/id/Python-Autoexec-for-Your-Raspberry-Pi/ Python Autoexec for Your Raspberry Pi - All ]'''
*'''[http://www.instructables.com/id/ClipBoard-Communication-PC-Pi-With-Python/ ClipBoard Communication PC ↔ Pi With Python - All ]'''

== Related to Electronics ==

[[PiSetup]]

*'''[http://www.instructables.com/id/Electronics-Building-Tips-in-21-Plus-Steps-/ Electronics Building Tips ( in 21 Plus Steps ) - All ]'''
*'''[http://www.instructables.com/id/More-Electronics-Building-Tips-in-21-plus-more-ste/ More Electronics Building Tips ( in 21 plus more steps ) - All ]'''
*'''[http://www.instructables.com/id/Comprehensive-Guide-to-Electronic-Breadboards-A-Me/ Comprehensive Guide to Electronic Breadboards: A Meta Instructable - All ]'''
*'''[http://www.instructables.com/id/Three-in-One-IC-Continuity-Tester-Signal-Generator/ Three in One: IC/ Continuity Tester, & Signal Generator - All ]'''

us double brackes for categories

category:Member Page
category:salvage
category:Test Instrument
category:Serial Communications
category:Microcontroller
category:PIC
category:Test Instrument
category:Test Instrument
[[category:BoostC]]

Russ hensel

2024-02-17T15:16:24Z

Russ hensel: /* Related to Python */

= About Me =
I am a once upon a time high school teacher and database programmer/software engineer. My hobbies now are gardening, Python programming, microcontrollers, Physics/Math, my cats and whatnot. I have a nice wood shop, some metal working tools, and am learning to weld. I have a fairly large collection of scientific antiques, mostly microscopes, surveying instruments, and electronics test equipment. Online my name is often russ_hensel, gives me a pretty unique id on Google. I live in Dartmouth Ma.

I am now on Facebook, but do not post much.

I have posted a few Instructables, find me there at: [http://www.instructables.com/member/russ_hensel/ Instructables member: russ_hensel]

I have done a fair amount in Python. I am now keeping my files at github: https://github.com/russ-hensel For some there may be info here, other not.

You can reach me ( EMAIL ) at: no_spam_please_666 at comcast dot net (REFORMAT FOR A VALID EMAIL ADDRESS). This address is just for first contact, I will respond with a better address after first contact.

On this site I tend to write about the following topics

* Electronics in general ( still doing it at home, but not writing about it much ).
* Microcontrollers, PIC in the past now the Arduino
* Python and my Python Projects
* Raspberry Pi
* 3D Printing and FreeCad ( bought first printer in 2017, second one too )
* BoostC - now replaced by C++ in context of the Arduino
* Stepper Motors -- used in several of my projects. Usually in catagories with Arduino

= About My Articles =

I write about items as they interest me. Too often I start on something and drop either the article or the project for short or long periods befor picking it up again. Sorry. I am open to email with questions, this may make me complete or improve some article. If you are interested please let me know.

You may find that some pages say something like:

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. The page is only partly finished

== My Editing Links ==

These links are for me to navigate to pages I have done quite a bit of work on or want to look at frequently. They are not for you, but you can use them if you want.

*[[Mushroom Resources]]
*[[Vivek]]

*[[Russ Page Links]]

*[[Russ Editing Links]] probably dead

= Articles posted here on Open Circuits =

== Serial Communications and Microcontrollers ==

*[[Python Smart Terminal]] As of Sept 2016 still and active project.
*[http://www.opencircuits.com/Category:Microcontroller Category:Serial_Communications] Most of these have at least large input from me. Some are general, some for the Arduino, and some for the PIC microcontroller.
*[http://www.opencircuits.com/Category:PIC Category:PIC] I have mostly converted to the Arduino, but before that I used the PIC, still think it is a nice micro controller, but building the boards and finding a coding environment.... is more of a pain than I want.

*[http://www.opencircuits.com/Category:Arduino Category:Arduino] After my conversion from PIC.

= Articles posted on Instructables =

== Related to Python ==
[[Programing Tips]]

*[[Python White Space]]
*[[Random Python]]
*[[Russ Suggests an Arduino Setup]]

*'''[http://www.instructables.com/id/Python-Terminal-for-Cheap-Pi-Arduino-Connection/ Python Terminal for Cheap Pi Arduino Connection - All ]'''
*'''[http://www.instructables.com/id/Experiments-in-Advanced-Data-Logging-Using-Python-/ Experiments in Advanced Data Logging ( Using Python ) - All ]'''
*'''[http://www.instructables.com/id/Incredibility-Powerful-Resistance-Calculator/ Incredibility Powerful Resistance Calculator - All ]'''
*'''[http://www.instructables.com/id/Use-Sage-and-Sell-Your-Calculator-before-it-is-Too/ Use Sage and Sell Your Calculator before it is Too Late - All ]'''
*'''[http://www.instructables.com/id/Python-Autoexec-for-Your-Raspberry-Pi/ Python Autoexec for Your Raspberry Pi - All ]'''
*'''[http://www.instructables.com/id/ClipBoard-Communication-PC-Pi-With-Python/ ClipBoard Communication PC ↔ Pi With Python - All ]'''
*'''[http://www.instructables.com/id/Graph-Your-Solar-Power/ Graph Your Solar Power - All ]'''
*'''[http://www.instructables.com/id/Graph-Instructable-Views-with-Pypthon-Screen-Scrap/ Graph Instructable Views with Python Screen Scraping - All ]'''
*'''[http://www.instructables.com/id/Digital-Picture-Management-Eliminate-Weak-Photos-w/ Digital Picture Management - Del Weak Pics with Python - All ]'''

== Related to Arduino ==

[[Pi Setup Nov 2016]]

*'''[http://www.instructables.com/id/Backup-Your-Pi/ Backup Your Pi - All ]'''
*'''[http://www.instructables.com/id/Python-Autoexec-for-Your-Raspberry-Pi/ Python Autoexec for Your Raspberry Pi - All ]'''
*'''[http://www.instructables.com/id/ClipBoard-Communication-PC-Pi-With-Python/ ClipBoard Communication PC ↔ Pi With Python - All ]'''

== Related to Electronics ==

[[PiSetup]]

*'''[http://www.instructables.com/id/Electronics-Building-Tips-in-21-Plus-Steps-/ Electronics Building Tips ( in 21 Plus Steps ) - All ]'''
*'''[http://www.instructables.com/id/More-Electronics-Building-Tips-in-21-plus-more-ste/ More Electronics Building Tips ( in 21 plus more steps ) - All ]'''
*'''[http://www.instructables.com/id/Comprehensive-Guide-to-Electronic-Breadboards-A-Me/ Comprehensive Guide to Electronic Breadboards: A Meta Instructable - All ]'''
*'''[http://www.instructables.com/id/Three-in-One-IC-Continuity-Tester-Signal-Generator/ Three in One: IC/ Continuity Tester, & Signal Generator - All ]'''

us double brackes for categories

category:Member Page
category:salvage
category:Test Instrument
category:Serial Communications
category:Microcontroller
category:PIC
category:Test Instrument
category:Test Instrument
[[category:BoostC]]

Russ hensel

2024-02-17T15:14:59Z

Russ hensel: /* Related to Python */

= About Me =
I am a once upon a time high school teacher and database programmer/software engineer. My hobbies now are gardening, Python programming, microcontrollers, Physics/Math, my cats and whatnot. I have a nice wood shop, some metal working tools, and am learning to weld. I have a fairly large collection of scientific antiques, mostly microscopes, surveying instruments, and electronics test equipment. Online my name is often russ_hensel, gives me a pretty unique id on Google. I live in Dartmouth Ma.

I am now on Facebook, but do not post much.

I have posted a few Instructables, find me there at: [http://www.instructables.com/member/russ_hensel/ Instructables member: russ_hensel]

I have done a fair amount in Python. I am now keeping my files at github: https://github.com/russ-hensel For some there may be info here, other not.

You can reach me ( EMAIL ) at: no_spam_please_666 at comcast dot net (REFORMAT FOR A VALID EMAIL ADDRESS). This address is just for first contact, I will respond with a better address after first contact.

On this site I tend to write about the following topics

* Electronics in general ( still doing it at home, but not writing about it much ).
* Microcontrollers, PIC in the past now the Arduino
* Python and my Python Projects
* Raspberry Pi
* 3D Printing and FreeCad ( bought first printer in 2017, second one too )
* BoostC - now replaced by C++ in context of the Arduino
* Stepper Motors -- used in several of my projects. Usually in catagories with Arduino

= About My Articles =

I write about items as they interest me. Too often I start on something and drop either the article or the project for short or long periods befor picking it up again. Sorry. I am open to email with questions, this may make me complete or improve some article. If you are interested please let me know.

You may find that some pages say something like:

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. The page is only partly finished

== My Editing Links ==

These links are for me to navigate to pages I have done quite a bit of work on or want to look at frequently. They are not for you, but you can use them if you want.

*[[Mushroom Resources]]
*[[Vivek]]

*[[Russ Page Links]]

*[[Russ Editing Links]] probably dead

= Articles posted here on Open Circuits =

== Serial Communications and Microcontrollers ==

*[[Python Smart Terminal]] As of Sept 2016 still and active project.
*[http://www.opencircuits.com/Category:Microcontroller Category:Serial_Communications] Most of these have at least large input from me. Some are general, some for the Arduino, and some for the PIC microcontroller.
*[http://www.opencircuits.com/Category:PIC Category:PIC] I have mostly converted to the Arduino, but before that I used the PIC, still think it is a nice micro controller, but building the boards and finding a coding environment.... is more of a pain than I want.

*[http://www.opencircuits.com/Category:Arduino Category:Arduino] After my conversion from PIC.

= Articles posted on Instructables =

== Related to Python ==
[[Programing Tips]]

*'''[http://www.instructables.com/id/Python-Terminal-for-Cheap-Pi-Arduino-Connection/ Python Terminal for Cheap Pi Arduino Connection - All ]'''
*'''[http://www.instructables.com/id/Experiments-in-Advanced-Data-Logging-Using-Python-/ Experiments in Advanced Data Logging ( Using Python ) - All ]'''
*'''[http://www.instructables.com/id/Incredibility-Powerful-Resistance-Calculator/ Incredibility Powerful Resistance Calculator - All ]'''
*'''[http://www.instructables.com/id/Use-Sage-and-Sell-Your-Calculator-before-it-is-Too/ Use Sage and Sell Your Calculator before it is Too Late - All ]'''
*'''[http://www.instructables.com/id/Python-Autoexec-for-Your-Raspberry-Pi/ Python Autoexec for Your Raspberry Pi - All ]'''
*'''[http://www.instructables.com/id/ClipBoard-Communication-PC-Pi-With-Python/ ClipBoard Communication PC ↔ Pi With Python - All ]'''
*'''[http://www.instructables.com/id/Graph-Your-Solar-Power/ Graph Your Solar Power - All ]'''
*'''[http://www.instructables.com/id/Graph-Instructable-Views-with-Pypthon-Screen-Scrap/ Graph Instructable Views with Python Screen Scraping - All ]'''
*'''[http://www.instructables.com/id/Digital-Picture-Management-Eliminate-Weak-Photos-w/ Digital Picture Management - Del Weak Pics with Python - All ]'''

== Related to Arduino ==

[[Pi Setup Nov 2016]]

*'''[http://www.instructables.com/id/Backup-Your-Pi/ Backup Your Pi - All ]'''
*'''[http://www.instructables.com/id/Python-Autoexec-for-Your-Raspberry-Pi/ Python Autoexec for Your Raspberry Pi - All ]'''
*'''[http://www.instructables.com/id/ClipBoard-Communication-PC-Pi-With-Python/ ClipBoard Communication PC ↔ Pi With Python - All ]'''

== Related to Electronics ==

[[PiSetup]]

*'''[http://www.instructables.com/id/Electronics-Building-Tips-in-21-Plus-Steps-/ Electronics Building Tips ( in 21 Plus Steps ) - All ]'''
*'''[http://www.instructables.com/id/More-Electronics-Building-Tips-in-21-plus-more-ste/ More Electronics Building Tips ( in 21 plus more steps ) - All ]'''
*'''[http://www.instructables.com/id/Comprehensive-Guide-to-Electronic-Breadboards-A-Me/ Comprehensive Guide to Electronic Breadboards: A Meta Instructable - All ]'''
*'''[http://www.instructables.com/id/Three-in-One-IC-Continuity-Tester-Signal-Generator/ Three in One: IC/ Continuity Tester, & Signal Generator - All ]'''

us double brackes for categories

category:Member Page
category:salvage
category:Test Instrument
category:Serial Communications
category:Microcontroller
category:PIC
category:Test Instrument
category:Test Instrument
[[category:BoostC]]

Python Names

2024-02-16T22:30:26Z

Russ hensel: /* Avoid Reserved Words */

In programming a constant task is to make up names for things you wish the program to work with. Numbers, names.... functions, objects... classes all need names. There are some good practices in making up name and not so good ones. Python even has an official document PEP 8, I think it is called, that discusses this. I have not found the document all that useful. I will give you my version here.

= When to use Good Names =
The right answer is all the time, but in practice people go to more effort when they expect the program to be around for a longer time. Also in practice programs tend to be around longer than you expect. Try to develop good habits, it will pay off.
= Short vs Long =
Really short names are rarely good they just have too little meaning. You should remember that a program is more often read than written ( only once not counting fix up ) so make it easy to read. That said names can get too long. Over 12 characters?: take a second look. Abbreviation are fine but should be consistent. I use hi and lo for high and low, max and min for maximum and minimum. But n for number? Too short, also may hide an important function n().

Short vs long also applies to how long the variable will exist, or be in scope. If the scope of a variable is short, it is easier to live with a short, and less clear, name. I use ix for a index with short scope, if the scope is longer then I might use ix_toy if the index is indexing into a list of toys.

= Singular vs Plural =

Often I use a plural for a list, a list of toys might be toys, an element in it a toy ( or a_toy, or if indexing through the list ix_toy for the numerical index and i_toy for toys[ix_toy].

<pre>
for ix_toy, i_toy enumerate( toys ):
i_toy.my_index = ix_toy # not necessarily a useful example of code
</pre>

= Generic Variables =

Sometimes it is useful to use generic names rather than specific ones. One use I often encounter is in constructing tkiner gui's. Say I want a button, and want to configure it in some specific way:

<pre>
a_button = Button( a_frame , width=10, height=2, text = "Edit Parms" )
a_button.config( command = self.controller.os_open_parmfile )
a_button.pack( side = LEFT )
</pre>

This is fine, but I often copy the code and use it for a different widiget ( many widgets use the same sorts of parameters and setup functions. Then I may ue a more generic name.

<pre>
# record checkbox
cb_record_var = IntVar()
a_widget = Checkbutton( a_frame, text="Record", variable=cb_record_var, width = 10, anchor="w" )
a_widget.config( command = lambda ix = ix__smartplug_adapter: self.controller.cb_device_action( ix, "record" ) )
a_widget.config( borderwidth = 5, relief = RAISED, )
a_widget.grid( row = lrow * rowspan, column = lcol, rowspan = 2, sticky=E + W + N + S )
i_smartplug_adapter.gui_tk_record_checkbox_var = cb_record_var
lcol += 1

# time combobox
times = ( "infinite", .1, .5, 1, 2, 3, 5, 10, 15, 20, 25, 30, 40, 50, 60 )
a_widget = ttk.Combobox( a_frame, values=times, state='readonly', width = 10, )
a_widget.current( 6 ) # set default value
a_widget.grid( row = lrow * rowspan, column = lcol, rowspan = rowspan, sticky=E + W + N + S )
i_smartplug_adapter.gui_tk_combo = a_widget
lcol += 1
</pre>

= Local Variables =

Local variables are fast, and may be useful as generic variables ( see above ). But some times as for the combo box ( above ) you need a reference to be used later ( i_smartplug_adapter.gui_tk_combo = a_widget ). But it is useful and ( I think faster and easier ) to use a more generic local variable for the set up and initial manipulations, and save the reference at the end ).

= Avoid Reserved Words =

Reserved words are words that are reserved for the language that you are not suppose to use, words like if, else, while, def. Python will actually throw an syntax error in most cases if you use them.

There are even more words that you should treat as reserved words, that is do not use them. These words are ones that other parts of the language may already be using. Suppose that you are doing some math. Then you might suspect that words like sin, sine, min, max, random might already be in use. Try to be a bit careful. In some contexts both n and i are already defined ( i for the imaginary unit, n for a function that forces numerical evaluation )

For words that are reserved, are already in use, or look as if they might be, I often prefix them with "a_". So if I have a reference to a thread I will call it something like "a_thread".

= Break into Words =

If you use temp for temperature ( and beware some people use it for temporary ) then the high and low temperatures would be hi_temp and low_temp. Another style is HiTemp and LoTemp. The second is called camel case.

Most Python is written using underscores for variable name and functions, camel case is used for class names. Again be consistent.

= Verbs and Nouns =

Most functions ( methods... ) do something. So make them verbs or verb like. Classes are typically more like things, so make them noun like.
<pre>
self.monitor_state = 1 # noun
plug_adapter = PlugAdapter() # noun
def display_help(): # verb like
</pre>

= Declare at top of Class =

Actually Python does not have declarations but for me this means do an assignment in __init__ or very nearby and comment the variables. Sometimes this is a natural part of the initialization, other times it is not, perhaps because the value is not know yet. In this case assign it to None.

<pre>
self.live_graph_lines = None # lines on the graph, we keep for later updating
</pre>
= Variables =

Most programming languages have variables, and Python users often refer to variables, but actually, sort of, '''Python does not have variables''' it has '''names'''. Is this a difference that makes a difference? If I say:

<pre>
self.monitor_state = 1
# then....
self.monitor_state = 2
</pre>

Then self.monitor_state has changed or varied, so it must be a variable. Yes and No. self.monitor_state is a name and at one time it "pointed to" a value of 1 and later it "pointed to" a value of 2. A mutable object is in some ways more like a variable. I will not say more here, but at some point you might want to investigate this issues because, sometimes, they make a difference.
You may find this useful: '''[https://www.youtube.com/watch?v=4MCT4WLf7Ac&__s=dibfsizig3wuxjywoekt (26) "Python Oddities Explained" - Trey Hunner (PyCon AU 2019) - YouTube ]''' and '''[https://treyhunner.com/python-oddities/#/3 Python Oddities Explained ]'''

= Class Instance Variables =

I try to name variables that refer to classes with names that reflect the class. Since the class is in camel case and the instance variable uses underscores this is often simple

<pre>
self.gui = Gui()
plug_adapter = PlugAdapter()
</pre>

= Examples =

comming.....
== Bad ==

== Good ==

== Too Good ==

[[Category:Python]] [[Category:Draft]]

Chemical Etchants

2024-02-16T13:06:53Z

Russ hensel:

Python Code Example Files

2023-02-04T14:00:20Z

Russ hensel: /* What/Why */

= What/Why =

When I learn a new thing in Python I often keep an example file. I can then use it for reference and/or copy code out of it for other uses. I have a few "tricks" that I will describe here.
I like to have many examples in one file to make them easy to review, and find the right example. Comments can be used to turn on/off some of the code. I use a technique to make it easy to control
examples by commenting a single line: put each example in a function and then comment in/out the function call.

= Moved =

I am beginning to move the actual code to:

*'''[https://github.com/russ-hensel/python_example_code russ-hensel/python_example_code: python_example_code ]'''

an there is a better wiki for this topic there.

= How =

I think this is best seen with a commented example file. The example is very simple, the central point is the technique of using subroutines. You should be able to copy the code into your IDE of choice and run it.
I am pretty far out of compliancee with PEP 8, but it is my file so I format it the way I want. Run it through Black if you want. Formatting is not the point here.
<pre>

# -*- coding: utf-8 -*-

""""
this is a template/example file for booleans
( it is commented also as a guide to the subroutine technique for example files )

In python pretty much everything has a truthiness which is "boolean like""

Try searching on:
True
truthy
....

Author: Russ Hensel You can reach me ( EMAIL ) at:
no_spam_please_666 at comcast dot net (REFORMAT FOR A VALID EMAIL ADDRESS).
This address is just for first contact, I will respond with a better
address after first contact.

"""

# a helper function is not an example but will be used by an example

# ------------ helper function ------------------
def is_truthy( a_value ):
"""
what is says: is a_value truthy or not?
"""
if a_value:
return "truthy"

else:
return "Not truthy"

# ------------ helper function ------------------
def eval_me( exp ):
"""
print and evalueate exp
"""
# print( msg )
print( f"eval of {exp} is {eval(exp)}")

# all example functions start with ex_ and right after the function definition
# is a function call.
# try to make name discriptive

# ----------------------------------------
def ex_is_truthy():

# I alsays print something so I know which example is running
print( """
================ ex_is_truthy(): ===============
test to see what simple expressions have what truthyness
""" )

exp = "is_truthy( 0 )"

test_me = [ "True", "False", "0", "1", '"TRUE"', '"FALSE"', "1 < 2" ]

for i_test in test_me:

exp = f"is_truthy( {i_test} )"
eval_me( exp)

# call to function, comment out to eliminate the entire example

ex_is_truthy()

# ----------------------------------------
def ex_case_statement_using_if():
print( """
================ ex_two(): ===============
just show another example
""" )

x = 3

if x == 1:
print( "x is one" )
elif x == 2:
print( "x is two" )
elif x == 3:
print( "x is three" )
elif x == 4:
print( "x is four" )
else:
print( "what else could x be?" )

#ex_case_statement_using_if()

"""
typically I would have many more examples in the file....
"""

</pre>

Russ Python Tips and Techniques

2023-02-04T13:57:50Z

Russ hensel: /* Polling withing Tkinker */

= What =
These are Tips and Techniques I have found useful in my Python programming [[User:Russ_hensel]]. I would be interested in your feedback. Let me know if you think the tip is useful/wrong/something everyone knows. A good set of this material relates to applications with a GUI. They are often not beginner techniques, but neither are they all advanced ones.
Just starting Feb 2017 check history tab above to see if progress is being made. If you find a tip not finished or working feel free to contact me.

== Ones Still To Be Written ==

* when division by 0 is useful
* code is multiple files - scratch file
* moving to 3.6 use fstrings
* example files with functions [[Python Example Code]]
* when you need a reference and when not
* dict based case statements
* choose names for cut and paste
* mark your code with unusual string * zzz in your code

=== Move these to a good place in the outline ===

==== Python Installation ====

I have a separate page [[Category:Python Installation]] about installation an maintenance, the first part is of general interest, the second on particular issues I have encountered. It may be useful to get some of my projects running [[Category:Python Projects]].

==== FStrings ====

FStrings are incredibly nice. New in 3.6, use it ( or 3.7.... ) They also are reputed to be really fast. Use them. At a later time I may have a bunch of examples, but for now just the basic statement:

<pre>
joe = "Joe Smith Jones Norton"
msg = f"Joe's name is actually {joe}"
print( msg 0
</pre>

==== Comments for Navigation ====

Spyder has a nice feature for code navigation: the "Outline Tab". This tab outlines the code nesting classes, methods.... and expands and contracts the tree much like the code folding show in the editor. The outline tab works both to help you navigate to a place in the code, or to show you where in the code the cursor currently lies. What is less obvious is that comments can also mark a section. I have not found documentation for this but here is what I have found. A comment like "# ------ frame building methods --" will create an outline section whose indentation in the outline depends on indentation of the comment. The space and the "-" characters are important. Start by using exactly what is shown here, and experiment to see how much you can change it before it disappears from the outline. I often use this to group a large number of similar methods that can then be folded out of view.

==== msg ====

A name I use over and over again for messages, often like:

<pre>
msg = "this is a message"
print( msg )
</pre>

Why two lines instead of one? Because I often change it to include logging or sending to the GUI. It might then become:

<pre>
msg = "this is a message"
print( msg )
AppGlobal.logger.debug( msg )
</pre>

I find this a nice way to manage code.

==== #rint ====

If you use print for debugging you may want to scan your code of "print" to remove unwanted statements. I do not delete them because sometimes I want them again for more debugging. I change "print" to "#rint"
to comment out the print but to stop it form showing up on searches.

==== Make Code Searchable ====

I like generic names to enable cut and paste but this runs against the idea of searchable code. The idea is that unusual names are easy to search for. It also helps if names are descriptive. Why searchable? So you can find the code you want to work on. One way to be both searchable and generic is to take instance references and make local ( or the reverse ) For example consider this tkinter code:

<pre>
a_list = list(self.sort_order_dict.keys())
a_widget = ttk.Combobox( a_frame, values = a_list, state='readonly')
a_widget.grid( row = lrow + 1, column = lcol, rowspan = 1, columnspan = 3, sticky = E + W + N + S )
a_widget.set( a_list[0] )
self.sort_order_widget = a_widget
lcol += 3
</pre>

The name a_widget is generic, but to see what it "really" is you have the none generic name "self.sort_order_widget"

If you do not see an easy way to do this with names use a comment. Using zzzz.... is a short term way of doing this.

==== Dict Based Case Statements ====

Python does not have a case statement, but it does have if....elif which can be used and is only a little more verbose. However if you have more than a few cases it can be cumbersome. Using a dict gives a very compact and fast case statement. Suppose you want to have a case statement based on strings:

<pre>
# set up, ideally only done onece, perhaps at module or class level
dispatch_dict = { "one": print_one,
"two": print_two,
"three": print_three,
}

# set a case for an example call:
key = "two"

# the slightly verbose case statement
function = dispatch_dict[ key ]
function()
</pre>

= Parameters for Applications =

There are various ways of storing start up parameters for applications. In the old days almost all windows programs had a "ini" file. Linux had/has "config" files. In both cases these are text files that are easily edited with a simple text editor. More recently xml files ( which i tend to hate ) have come into vogue. Finally some applications give you a gui for editing configuration values and then save them any way they want, perhaps in the "registry".

Using a gui is the easiest way for the user in particular the naive user. They are also a lot of work to implement and maintain. So I favor a flat, non-xml file. But what file? For Python my answere is a python.py file that has pretty much one class, Parameters, that is implemented as a singleton ( in what ever way you want to implement singletons ). These are easy to implement, easy to maintain, and very flexible. They can also do clever things like detecting what operating system they are running on and make automatic adjustments. There are no issues of converting type into strings for the file. Comments are easily included. Loading can print the progress of initialization.

I will put a brief sample here soon so you can see what a file looks like.

<pre>
code comming here
</pre>

= Logging =

I use the logging class that is part of standard python. I provide a button to view and edit the file. Why invent your own method. Here is some code:

<pre>
code comming
</pre>

= Restart =
When an application ( here I am thinking about GUI applications ) starts there can be a considerable delay as all the modules are imported. Typically a restart is done after an exception or when parameters are changed. So I include a restart button on the GUI to quickly restart the application. In my case applications are usually started by constructing some application class. So what I do is break up the __init__ method into 2 parts, only the second needs to be run to restart the application. Here is some sample code:

<pre>

def __init__(self ):
"""
create the application, its GUI is called self.gui which is
created in restart
"""
...... more code ......

self.restart( ) # continue in restart

# --------------------------------------------------------
def restart(self ):
"""
use to restart the app without ending it
parameters will be reloaded and the gui rebuilt
call from a button on the GUI
args: zip
ret: zip ... all sided effects
"""

self.no_restarts += 1 # if we want to keep track
if not( self.gui is None ): # determines if a restart or the start
# !! # need to shut down other thread
self.gui.root.destroy()
reload( parameters )

self.logger = None

.... and so on ......

</pre>

= Names =

I have heard it said that proper naming is the hardest problem in programming. Not sure if true, but it is not easy. So here is my take:

* Of course be consistent. It may help to make a vocabulary list of the terms you prefer. I have found that the values often come in pairs:

start_date / stop_date or low_temp / high_temp ( or hi_temp ) or start_date / end_date
then some style are:
date_start / date_stop

Note that the stop_date and end_date is an easy place for confusion. So decide on your style and stick to it.

* Do not be afraid of long names but consistent abbreviations are fine ( keep a list ).
* I generally think that methods should be named with verb like names: os_open_file.
* I find that people use the name '''file''' for both the '''file name''' ( often string like ) and for the '''file handle''' ( the thing you get when you open a file ), so my variables for file names are like:

input_file_name ( sometimes input_fn )

* Lists and other iteratables often get a name to indicate that: so a list of names might be called something like student_names

* Sometimes generic names are preferable especially if there scope is just a few lines. I am willing to iterate over a list of numbers with i, but I prefer ix and even then I fell lazy. If I have a list of names as above I might itterate with the singular, but usually i prefix it with i_ so:

for i_name in student_names
print( i_name )

= Comments =
Extreme programming trys to make the code so obvious that it is easy to tell what the code is doing without comments. If not taken too far I think this is a great idea. It requires really good names. But most of my comments do not tell what the code is doing, they tell either why the code is doing something or what the purpose is of doing what ever. But that is not all:
* Comments are left to indicate where the code might be made better:
** More careful error management.
** Where I am thinking about refactoring
** To make up for deliberately generic names -- ?? I need more explanation here
** To provide a search string so I can find a place in the code
** Where a little trap may lurk in the code:
For example most methods return at the end, but sometimes you discover in your processing that you are done
early. You could put some sort of if then structure in, but now you indent one level more making the
code somewhat more difficult. So just return. In these cases I may put a comment at the beginning of the method:

# beware of early return

I try to indicate that there may be an early return, but refactoring may remove it and leave the comment in place
** Of course no comment should be considered 100% reliable

= Copy and Paste =
some content may move to [[Copy and Paste Is Good]] or not

There are lots of arguments against copy and paste, but used carefully I think that it is extremely useful. But used carefully.

One of the biggest arguments against it is that you may be using code that you do not really understand. This can be true, but the
same is true when you use someone else's module.

So I have a procedure depending on where I copy from:

* My own code:
** I only take working code.
** I reread it and make appropriate changes.
** I own the results, if it does not work properly I am to blame
** I write code in a generic way to make it easy to copy and paste.

* Refactoring:
** Of course when I refactor I use copy and paste, because basically your are just rearranging code you already have that works.
** Many people use git to make sure they do not loose stuff in translation. I just use file copies, I have my own methods
** Sleep that is zzzzzzz: I put zzzz or similar around the place where I am making changes. It throws a quick syntax method if I foolishly try to run the code and is easy to find as zzzz is not anything I would normally use in code. Sometimes I copy a lot of junk in between a pair of zzz so I have all the names I need in easy view. Then I do the new code, remove the junk and finally the pair of zzzz'a.

* Other peoples code:
** I put there code in an example file.
** I change the code to my style and comment it, often keeping a url to the source.
** I run it to make sure it does what I want.
** I may make it generic in a way to make copying easier.
** I save the example.
**

= Python Code Example Files =
When I learn a new thing in Python I often keep an example file. I can then use it for reference and/or copy code out of it for other uses. I have a few "tricks". See: '''[[Python Code Example Files]]'''

= Tkinker =
== Complex Tkinker Windows ==
I found it really easy to get confused in coding Tkinter because it is not done in a visual interface.
One of my goal in coding is to make the code create the gui from top to bottom and from left to right. That way the layout of code and the layout of the gui are easier to match up in my mind. This has a benefit of making it relatively easy to:

* Cut and paste code to rearrange placement in the gui.
* Cut/paste/modify code to build new widgets.

So here are some tips:

* I do a sketch of what I want on paper.
* The GUI is built in a class.
* I break the sketch into Tkinter frames each of which will layout into the window in some fairly simple scheme, often the pack layout will work. When this is not enough I use grid.
* When using grids I always have variables for the row and column positions. These are typically managed with statements like lrow += 1. Coding this way make movement of the code much easier. Placement methods may also be used to manage the row and column variables.
* Each individual frame is built in its own method, it takes the parent frame as an argument and returns the frame that it builds. The returned frame is then placed in its parent.
* References to the widgets are often not needed once the GUI is built, so local variable are often used. Using a local variable makes it easier to copy/paste. I try to always use the name a_widget, thus code that places or otherwise manipulates the widget in a generic way ( like placement ) works well in a copy paste. If I need a reference, I typically will do that on the last line of the code for the widget. For widgets that need references you can use an instance variable of the class, or in some cases it it useful to store them in a dictionary.
* Building helper classes for either building the widgets, or placing them or both is often useful.
* You can see these techniques in GUI class of my various application documented on this wiki.
* See: '''[[Python Buttons Switch Case]]''' for some tricks on building Tkinter frames with lots of buttons linked to functions.

== Threading with Tkinker ==

Tkinker wants to own the processing of the application. If you make a button start a long running operation then the GUI blocks and becomes unresponsive. So you need some sort of threading. Here are some tips.

== Row and Column IX ==

I mostly use the grid layout. In this you will see "column = 3, row = 5" and the like, in the next use often one of the indices is incremented. So a way to do this with less typing ( assuming copy and paste ) is:

<pre>
ix_row = 0
ix_col = 0
rowspan = 1
widget_var = IntVar()
a_widget = Checkbutton( a_frame, text="Live Graph", variable = widget_var, width = 10, anchor="w" )
a_widget.config( command = self.controller.cb_graph_live )
a_widget.config( borderwidth = 5, relief = RAISED, )
a_widget.grid( row = ix_row, column = ix_col, rowspan = rowspan, sticky = E + W + N + S )
self.graph_live_var = widget_var

# button to save graph data to csv file
ix_col += 1
a_widget = Button( a_frame , width = 10, height = 1, text = "Save CSV" )
a_widget.config( command = self.controller.cb_csv )
a_widget.grid( row = ix_row, column = ix_col, rowspan = rowspan, sticky = E + W + N + S )

ix_col += 1
......
</pre>

=== Polling withing Tkinker ===
You can poll in the Tkinter event loop and call any function ( no arguments I think ) using a Tkinter function. Use this to run something short. You can only run it once this way.
<pre>
self.gui.root.after( self.parameters.gt_delta_t, self.polling ) # self.gui.root = Tkinter root, .1 = .1 sec, self.polling = name of the function
# ( note no () which is a function call
</pre>

To overcome the fact that it only runs once, ask for it again at the end of the function.

<pre>
def polling( self, ):
..... do something quick

self.gui.root.after( .1, self.polling )

</pre>

If you function throws an exception it will stop running. Try Except works for me:

<pre>
def polling( self, ):

try:
..... do something quick
except Exception, ex_arg:
.... I log the error
finally:
self.gui.root.after( .1, self.polling )

</pre>

=== Use Threading ===

Use real threading. I inherit from threading.Thread and implement a override of the run method. Use threading mechanisms to "message" back and fourth to the gui, Tkinter, thread.
Seems to work fine.

== Calling across Threads ==

If you have objects in 2 different threads calling across the threads can be very dangerous. I have worked out a method that I find useful/safe/easy. It does make some assumptions.

*Both objects/threads have something resembling polling where checks can be made at a convient time to see if the other thread wants attention.

=== Step 1, Set Up Queues ===

<pre>
self.queue_to_helper = Queue.Queue( 20 ) # send from tkinker mainloop to helper here
self.queue_fr_helper = Queue.Queue( 20 ) # send back from helper thread to tkinker mainloop here

</pre>

So how does this help making calls across the threads? What I am doing in SmartTerminal ( could change, see the code ) is to always pass a tuple of 3 parts:

<pre>
( a_string, a_function, another_tuple_of_arguments_to_a_function )
</pre>

if a_string is "call" then the queue item is for a function call ( other cases not discussed here ). Then the function ( remember functions are first class objects math.sin( x ) call to a function, math sin a function ) is combined with the arguments to make the call: a_function( arguments_to_a_function ). Almost, it will not work because argument_to_a_function is itself a tuple. And even if the tuple has five elements you are only passing one argument, the tuple, to the function. You need to unpack the arguments. How do you do that:

<pre>

a_function( *another_tuple_of_arguments_to_a_function )

</pre>

Here is the code with a little more context ( for more see SmartTerminal smart_terminal_helper.HelperThread.polling ) but not actual production code.

<pre>
.........
( action, function, function_args ) = self.rec_from_queue()
if action == "call":
function( *function_args )
.........
</pre>

more coming......

== Starting a Tkinter App ==
These applications start fine but often remain in the background with their window behind other windows. It would be good to bring it to the top of your windows. This code, may not be the best, seems to work at least on the Windows.

<pre>
root.attributes("-topmost", True)
root.attributes("-topmost", False) # if left to True window always on top
</pre>

You need to get this to run once after the mainloop is started. You can do this with '''root.after()''' Some details left to you.

= Simple Techniques =
These are techniques I use that I have not often seen documented.

== Create a Local Reference ==

We often use "dotted" notation to reference non-local variables. If the variable is used several times we may want to create a local reference:

<pre>
graph_live_time_zero = self.parameters.graph_live_time_zero
if graph_live_time_zero = 1:
.....
elif graph_live_time_zero = 2:
.....
else:
......
</pre>
instead of:

<pre>

if self.parameters.graph_live_time_zero = 1:
.....
elif self.parameters.graph_live_time_zero = 2:
.....
else:
......
</pre>

Why:

*Well Python searches for local references first, they are faster so your code is faster.
*If something about the non-local reference changes, then changing the code is easier/less error prone.

[[Category:Python]]

Russ Python Tips and Techniques

2023-02-04T13:47:14Z

Russ hensel: /* Starting a Tkinter App */

= What =
These are Tips and Techniques I have found useful in my Python programming [[User:Russ_hensel]]. I would be interested in your feedback. Let me know if you think the tip is useful/wrong/something everyone knows. A good set of this material relates to applications with a GUI. They are often not beginner techniques, but neither are they all advanced ones.
Just starting Feb 2017 check history tab above to see if progress is being made. If you find a tip not finished or working feel free to contact me.

== Ones Still To Be Written ==

* when division by 0 is useful
* code is multiple files - scratch file
* moving to 3.6 use fstrings
* example files with functions [[Python Example Code]]
* when you need a reference and when not
* dict based case statements
* choose names for cut and paste
* mark your code with unusual string * zzz in your code

=== Move these to a good place in the outline ===

==== Python Installation ====

I have a separate page [[Category:Python Installation]] about installation an maintenance, the first part is of general interest, the second on particular issues I have encountered. It may be useful to get some of my projects running [[Category:Python Projects]].

==== FStrings ====

FStrings are incredibly nice. New in 3.6, use it ( or 3.7.... ) They also are reputed to be really fast. Use them. At a later time I may have a bunch of examples, but for now just the basic statement:

<pre>
joe = "Joe Smith Jones Norton"
msg = f"Joe's name is actually {joe}"
print( msg 0
</pre>

==== Comments for Navigation ====

Spyder has a nice feature for code navigation: the "Outline Tab". This tab outlines the code nesting classes, methods.... and expands and contracts the tree much like the code folding show in the editor. The outline tab works both to help you navigate to a place in the code, or to show you where in the code the cursor currently lies. What is less obvious is that comments can also mark a section. I have not found documentation for this but here is what I have found. A comment like "# ------ frame building methods --" will create an outline section whose indentation in the outline depends on indentation of the comment. The space and the "-" characters are important. Start by using exactly what is shown here, and experiment to see how much you can change it before it disappears from the outline. I often use this to group a large number of similar methods that can then be folded out of view.

==== msg ====

A name I use over and over again for messages, often like:

<pre>
msg = "this is a message"
print( msg )
</pre>

Why two lines instead of one? Because I often change it to include logging or sending to the GUI. It might then become:

<pre>
msg = "this is a message"
print( msg )
AppGlobal.logger.debug( msg )
</pre>

I find this a nice way to manage code.

==== #rint ====

If you use print for debugging you may want to scan your code of "print" to remove unwanted statements. I do not delete them because sometimes I want them again for more debugging. I change "print" to "#rint"
to comment out the print but to stop it form showing up on searches.

==== Make Code Searchable ====

I like generic names to enable cut and paste but this runs against the idea of searchable code. The idea is that unusual names are easy to search for. It also helps if names are descriptive. Why searchable? So you can find the code you want to work on. One way to be both searchable and generic is to take instance references and make local ( or the reverse ) For example consider this tkinter code:

<pre>
a_list = list(self.sort_order_dict.keys())
a_widget = ttk.Combobox( a_frame, values = a_list, state='readonly')
a_widget.grid( row = lrow + 1, column = lcol, rowspan = 1, columnspan = 3, sticky = E + W + N + S )
a_widget.set( a_list[0] )
self.sort_order_widget = a_widget
lcol += 3
</pre>

The name a_widget is generic, but to see what it "really" is you have the none generic name "self.sort_order_widget"

If you do not see an easy way to do this with names use a comment. Using zzzz.... is a short term way of doing this.

==== Dict Based Case Statements ====

Python does not have a case statement, but it does have if....elif which can be used and is only a little more verbose. However if you have more than a few cases it can be cumbersome. Using a dict gives a very compact and fast case statement. Suppose you want to have a case statement based on strings:

<pre>
# set up, ideally only done onece, perhaps at module or class level
dispatch_dict = { "one": print_one,
"two": print_two,
"three": print_three,
}

# set a case for an example call:
key = "two"

# the slightly verbose case statement
function = dispatch_dict[ key ]
function()
</pre>

= Parameters for Applications =

There are various ways of storing start up parameters for applications. In the old days almost all windows programs had a "ini" file. Linux had/has "config" files. In both cases these are text files that are easily edited with a simple text editor. More recently xml files ( which i tend to hate ) have come into vogue. Finally some applications give you a gui for editing configuration values and then save them any way they want, perhaps in the "registry".

Using a gui is the easiest way for the user in particular the naive user. They are also a lot of work to implement and maintain. So I favor a flat, non-xml file. But what file? For Python my answere is a python.py file that has pretty much one class, Parameters, that is implemented as a singleton ( in what ever way you want to implement singletons ). These are easy to implement, easy to maintain, and very flexible. They can also do clever things like detecting what operating system they are running on and make automatic adjustments. There are no issues of converting type into strings for the file. Comments are easily included. Loading can print the progress of initialization.

I will put a brief sample here soon so you can see what a file looks like.

<pre>
code comming here
</pre>

= Logging =

I use the logging class that is part of standard python. I provide a button to view and edit the file. Why invent your own method. Here is some code:

<pre>
code comming
</pre>

= Restart =
When an application ( here I am thinking about GUI applications ) starts there can be a considerable delay as all the modules are imported. Typically a restart is done after an exception or when parameters are changed. So I include a restart button on the GUI to quickly restart the application. In my case applications are usually started by constructing some application class. So what I do is break up the __init__ method into 2 parts, only the second needs to be run to restart the application. Here is some sample code:

<pre>

def __init__(self ):
"""
create the application, its GUI is called self.gui which is
created in restart
"""
...... more code ......

self.restart( ) # continue in restart

# --------------------------------------------------------
def restart(self ):
"""
use to restart the app without ending it
parameters will be reloaded and the gui rebuilt
call from a button on the GUI
args: zip
ret: zip ... all sided effects
"""

self.no_restarts += 1 # if we want to keep track
if not( self.gui is None ): # determines if a restart or the start
# !! # need to shut down other thread
self.gui.root.destroy()
reload( parameters )

self.logger = None

.... and so on ......

</pre>

= Names =

I have heard it said that proper naming is the hardest problem in programming. Not sure if true, but it is not easy. So here is my take:

* Of course be consistent. It may help to make a vocabulary list of the terms you prefer. I have found that the values often come in pairs:

start_date / stop_date or low_temp / high_temp ( or hi_temp ) or start_date / end_date
then some style are:
date_start / date_stop

Note that the stop_date and end_date is an easy place for confusion. So decide on your style and stick to it.

* Do not be afraid of long names but consistent abbreviations are fine ( keep a list ).
* I generally think that methods should be named with verb like names: os_open_file.
* I find that people use the name '''file''' for both the '''file name''' ( often string like ) and for the '''file handle''' ( the thing you get when you open a file ), so my variables for file names are like:

input_file_name ( sometimes input_fn )

* Lists and other iteratables often get a name to indicate that: so a list of names might be called something like student_names

* Sometimes generic names are preferable especially if there scope is just a few lines. I am willing to iterate over a list of numbers with i, but I prefer ix and even then I fell lazy. If I have a list of names as above I might itterate with the singular, but usually i prefix it with i_ so:

for i_name in student_names
print( i_name )

= Comments =
Extreme programming trys to make the code so obvious that it is easy to tell what the code is doing without comments. If not taken too far I think this is a great idea. It requires really good names. But most of my comments do not tell what the code is doing, they tell either why the code is doing something or what the purpose is of doing what ever. But that is not all:
* Comments are left to indicate where the code might be made better:
** More careful error management.
** Where I am thinking about refactoring
** To make up for deliberately generic names -- ?? I need more explanation here
** To provide a search string so I can find a place in the code
** Where a little trap may lurk in the code:
For example most methods return at the end, but sometimes you discover in your processing that you are done
early. You could put some sort of if then structure in, but now you indent one level more making the
code somewhat more difficult. So just return. In these cases I may put a comment at the beginning of the method:

# beware of early return

I try to indicate that there may be an early return, but refactoring may remove it and leave the comment in place
** Of course no comment should be considered 100% reliable

= Copy and Paste =
some content may move to [[Copy and Paste Is Good]] or not

There are lots of arguments against copy and paste, but used carefully I think that it is extremely useful. But used carefully.

One of the biggest arguments against it is that you may be using code that you do not really understand. This can be true, but the
same is true when you use someone else's module.

So I have a procedure depending on where I copy from:

* My own code:
** I only take working code.
** I reread it and make appropriate changes.
** I own the results, if it does not work properly I am to blame
** I write code in a generic way to make it easy to copy and paste.

* Refactoring:
** Of course when I refactor I use copy and paste, because basically your are just rearranging code you already have that works.
** Many people use git to make sure they do not loose stuff in translation. I just use file copies, I have my own methods
** Sleep that is zzzzzzz: I put zzzz or similar around the place where I am making changes. It throws a quick syntax method if I foolishly try to run the code and is easy to find as zzzz is not anything I would normally use in code. Sometimes I copy a lot of junk in between a pair of zzz so I have all the names I need in easy view. Then I do the new code, remove the junk and finally the pair of zzzz'a.

* Other peoples code:
** I put there code in an example file.
** I change the code to my style and comment it, often keeping a url to the source.
** I run it to make sure it does what I want.
** I may make it generic in a way to make copying easier.
** I save the example.
**

= Python Code Example Files =
When I learn a new thing in Python I often keep an example file. I can then use it for reference and/or copy code out of it for other uses. I have a few "tricks". See: '''[[Python Code Example Files]]'''

= Tkinker =
== Complex Tkinker Windows ==
I found it really easy to get confused in coding Tkinter because it is not done in a visual interface.
One of my goal in coding is to make the code create the gui from top to bottom and from left to right. That way the layout of code and the layout of the gui are easier to match up in my mind. This has a benefit of making it relatively easy to:

* Cut and paste code to rearrange placement in the gui.
* Cut/paste/modify code to build new widgets.

So here are some tips:

* I do a sketch of what I want on paper.
* The GUI is built in a class.
* I break the sketch into Tkinter frames each of which will layout into the window in some fairly simple scheme, often the pack layout will work. When this is not enough I use grid.
* When using grids I always have variables for the row and column positions. These are typically managed with statements like lrow += 1. Coding this way make movement of the code much easier. Placement methods may also be used to manage the row and column variables.
* Each individual frame is built in its own method, it takes the parent frame as an argument and returns the frame that it builds. The returned frame is then placed in its parent.
* References to the widgets are often not needed once the GUI is built, so local variable are often used. Using a local variable makes it easier to copy/paste. I try to always use the name a_widget, thus code that places or otherwise manipulates the widget in a generic way ( like placement ) works well in a copy paste. If I need a reference, I typically will do that on the last line of the code for the widget. For widgets that need references you can use an instance variable of the class, or in some cases it it useful to store them in a dictionary.
* Building helper classes for either building the widgets, or placing them or both is often useful.
* You can see these techniques in GUI class of my various application documented on this wiki.
* See: '''[[Python Buttons Switch Case]]''' for some tricks on building Tkinter frames with lots of buttons linked to functions.

== Threading with Tkinker ==

Tkinker wants to own the processing of the application. If you make a button start a long running operation then the GUI blocks and becomes unresponsive. So you need some sort of threading. Here are some tips.

=== Polling withing Tkinker ===

You can poll in the Tkinter event loop and call any function ( no arguments I think ) using a Tkinter function. Use this to run something short. You can only run it once this way.
<pre>
self.gui.root.after( self.parameters.gt_delta_t, self.polling ) # self.gui.root = Tkinter root, .1 = .1 sec, self.polling = name of the function
# ( note no () which is a function call
</pre>

To overcome the fact that it only runs once, ask for it again at the end of the function.

<pre>
def polling( self, ):
..... do something quick

self.gui.root.after( .1, self.polling )

</pre>

If you function throws an exception it will stop running. Try Except works for me:

<pre>
def polling( self, ):

try:
..... do something quick
except Exception, ex_arg:
.... I log the error
finally:
self.gui.root.after( .1, self.polling )

</pre>

=== Use Threading ===

Use real threading. I inherit from threading.Thread and implement a override of the run method. Use threading mechanisms to "message" back and fourth to the gui, Tkinter, thread.
Seems to work fine.

== Calling across Threads ==

If you have objects in 2 different threads calling across the threads can be very dangerous. I have worked out a method that I find useful/safe/easy. It does make some assumptions.

*Both objects/threads have something resembling polling where checks can be made at a convient time to see if the other thread wants attention.

=== Step 1, Set Up Queues ===

<pre>
self.queue_to_helper = Queue.Queue( 20 ) # send from tkinker mainloop to helper here
self.queue_fr_helper = Queue.Queue( 20 ) # send back from helper thread to tkinker mainloop here

</pre>

So how does this help making calls across the threads? What I am doing in SmartTerminal ( could change, see the code ) is to always pass a tuple of 3 parts:

<pre>
( a_string, a_function, another_tuple_of_arguments_to_a_function )
</pre>

if a_string is "call" then the queue item is for a function call ( other cases not discussed here ). Then the function ( remember functions are first class objects math.sin( x ) call to a function, math sin a function ) is combined with the arguments to make the call: a_function( arguments_to_a_function ). Almost, it will not work because argument_to_a_function is itself a tuple. And even if the tuple has five elements you are only passing one argument, the tuple, to the function. You need to unpack the arguments. How do you do that:

<pre>

a_function( *another_tuple_of_arguments_to_a_function )

</pre>

Here is the code with a little more context ( for more see SmartTerminal smart_terminal_helper.HelperThread.polling ) but not actual production code.

<pre>
.........
( action, function, function_args ) = self.rec_from_queue()
if action == "call":
function( *function_args )
.........
</pre>

more coming......

== Starting a Tkinter App ==
These applications start fine but often remain in the background with their window behind other windows. It would be good to bring it to the top of your windows. This code, may not be the best, seems to work at least on the Windows.

<pre>
root.attributes("-topmost", True)
root.attributes("-topmost", False) # if left to True window always on top
</pre>

You need to get this to run once after the mainloop is started. You can do this with '''root.after()''' Some details left to you.

= Simple Techniques =
These are techniques I use that I have not often seen documented.

== Create a Local Reference ==

We often use "dotted" notation to reference non-local variables. If the variable is used several times we may want to create a local reference:

<pre>
graph_live_time_zero = self.parameters.graph_live_time_zero
if graph_live_time_zero = 1:
.....
elif graph_live_time_zero = 2:
.....
else:
......
</pre>
instead of:

<pre>

if self.parameters.graph_live_time_zero = 1:
.....
elif self.parameters.graph_live_time_zero = 2:
.....
else:
......
</pre>

Why:

*Well Python searches for local references first, they are faster so your code is faster.
*If something about the non-local reference changes, then changing the code is easier/less error prone.

[[Category:Python]]

Russ Python Tips and Techniques

2023-02-04T13:46:42Z

Russ hensel: /* Calling across Threads */

= What =
These are Tips and Techniques I have found useful in my Python programming [[User:Russ_hensel]]. I would be interested in your feedback. Let me know if you think the tip is useful/wrong/something everyone knows. A good set of this material relates to applications with a GUI. They are often not beginner techniques, but neither are they all advanced ones.
Just starting Feb 2017 check history tab above to see if progress is being made. If you find a tip not finished or working feel free to contact me.

== Ones Still To Be Written ==

* when division by 0 is useful
* code is multiple files - scratch file
* moving to 3.6 use fstrings
* example files with functions [[Python Example Code]]
* when you need a reference and when not
* dict based case statements
* choose names for cut and paste
* mark your code with unusual string * zzz in your code

=== Move these to a good place in the outline ===

==== Python Installation ====

I have a separate page [[Category:Python Installation]] about installation an maintenance, the first part is of general interest, the second on particular issues I have encountered. It may be useful to get some of my projects running [[Category:Python Projects]].

==== FStrings ====

FStrings are incredibly nice. New in 3.6, use it ( or 3.7.... ) They also are reputed to be really fast. Use them. At a later time I may have a bunch of examples, but for now just the basic statement:

<pre>
joe = "Joe Smith Jones Norton"
msg = f"Joe's name is actually {joe}"
print( msg 0
</pre>

==== Comments for Navigation ====

Spyder has a nice feature for code navigation: the "Outline Tab". This tab outlines the code nesting classes, methods.... and expands and contracts the tree much like the code folding show in the editor. The outline tab works both to help you navigate to a place in the code, or to show you where in the code the cursor currently lies. What is less obvious is that comments can also mark a section. I have not found documentation for this but here is what I have found. A comment like "# ------ frame building methods --" will create an outline section whose indentation in the outline depends on indentation of the comment. The space and the "-" characters are important. Start by using exactly what is shown here, and experiment to see how much you can change it before it disappears from the outline. I often use this to group a large number of similar methods that can then be folded out of view.

==== msg ====

A name I use over and over again for messages, often like:

<pre>
msg = "this is a message"
print( msg )
</pre>

Why two lines instead of one? Because I often change it to include logging or sending to the GUI. It might then become:

<pre>
msg = "this is a message"
print( msg )
AppGlobal.logger.debug( msg )
</pre>

I find this a nice way to manage code.

==== #rint ====

If you use print for debugging you may want to scan your code of "print" to remove unwanted statements. I do not delete them because sometimes I want them again for more debugging. I change "print" to "#rint"
to comment out the print but to stop it form showing up on searches.

==== Make Code Searchable ====

I like generic names to enable cut and paste but this runs against the idea of searchable code. The idea is that unusual names are easy to search for. It also helps if names are descriptive. Why searchable? So you can find the code you want to work on. One way to be both searchable and generic is to take instance references and make local ( or the reverse ) For example consider this tkinter code:

<pre>
a_list = list(self.sort_order_dict.keys())
a_widget = ttk.Combobox( a_frame, values = a_list, state='readonly')
a_widget.grid( row = lrow + 1, column = lcol, rowspan = 1, columnspan = 3, sticky = E + W + N + S )
a_widget.set( a_list[0] )
self.sort_order_widget = a_widget
lcol += 3
</pre>

The name a_widget is generic, but to see what it "really" is you have the none generic name "self.sort_order_widget"

If you do not see an easy way to do this with names use a comment. Using zzzz.... is a short term way of doing this.

==== Dict Based Case Statements ====

Python does not have a case statement, but it does have if....elif which can be used and is only a little more verbose. However if you have more than a few cases it can be cumbersome. Using a dict gives a very compact and fast case statement. Suppose you want to have a case statement based on strings:

<pre>
# set up, ideally only done onece, perhaps at module or class level
dispatch_dict = { "one": print_one,
"two": print_two,
"three": print_three,
}

# set a case for an example call:
key = "two"

# the slightly verbose case statement
function = dispatch_dict[ key ]
function()
</pre>

= Parameters for Applications =

There are various ways of storing start up parameters for applications. In the old days almost all windows programs had a "ini" file. Linux had/has "config" files. In both cases these are text files that are easily edited with a simple text editor. More recently xml files ( which i tend to hate ) have come into vogue. Finally some applications give you a gui for editing configuration values and then save them any way they want, perhaps in the "registry".

Using a gui is the easiest way for the user in particular the naive user. They are also a lot of work to implement and maintain. So I favor a flat, non-xml file. But what file? For Python my answere is a python.py file that has pretty much one class, Parameters, that is implemented as a singleton ( in what ever way you want to implement singletons ). These are easy to implement, easy to maintain, and very flexible. They can also do clever things like detecting what operating system they are running on and make automatic adjustments. There are no issues of converting type into strings for the file. Comments are easily included. Loading can print the progress of initialization.

I will put a brief sample here soon so you can see what a file looks like.

<pre>
code comming here
</pre>

= Logging =

I use the logging class that is part of standard python. I provide a button to view and edit the file. Why invent your own method. Here is some code:

<pre>
code comming
</pre>

= Restart =
When an application ( here I am thinking about GUI applications ) starts there can be a considerable delay as all the modules are imported. Typically a restart is done after an exception or when parameters are changed. So I include a restart button on the GUI to quickly restart the application. In my case applications are usually started by constructing some application class. So what I do is break up the __init__ method into 2 parts, only the second needs to be run to restart the application. Here is some sample code:

<pre>

def __init__(self ):
"""
create the application, its GUI is called self.gui which is
created in restart
"""
...... more code ......

self.restart( ) # continue in restart

# --------------------------------------------------------
def restart(self ):
"""
use to restart the app without ending it
parameters will be reloaded and the gui rebuilt
call from a button on the GUI
args: zip
ret: zip ... all sided effects
"""

self.no_restarts += 1 # if we want to keep track
if not( self.gui is None ): # determines if a restart or the start
# !! # need to shut down other thread
self.gui.root.destroy()
reload( parameters )

self.logger = None

.... and so on ......

</pre>

= Names =

I have heard it said that proper naming is the hardest problem in programming. Not sure if true, but it is not easy. So here is my take:

* Of course be consistent. It may help to make a vocabulary list of the terms you prefer. I have found that the values often come in pairs:

start_date / stop_date or low_temp / high_temp ( or hi_temp ) or start_date / end_date
then some style are:
date_start / date_stop

Note that the stop_date and end_date is an easy place for confusion. So decide on your style and stick to it.

* Do not be afraid of long names but consistent abbreviations are fine ( keep a list ).
* I generally think that methods should be named with verb like names: os_open_file.
* I find that people use the name '''file''' for both the '''file name''' ( often string like ) and for the '''file handle''' ( the thing you get when you open a file ), so my variables for file names are like:

input_file_name ( sometimes input_fn )

* Lists and other iteratables often get a name to indicate that: so a list of names might be called something like student_names

* Sometimes generic names are preferable especially if there scope is just a few lines. I am willing to iterate over a list of numbers with i, but I prefer ix and even then I fell lazy. If I have a list of names as above I might itterate with the singular, but usually i prefix it with i_ so:

for i_name in student_names
print( i_name )

= Comments =
Extreme programming trys to make the code so obvious that it is easy to tell what the code is doing without comments. If not taken too far I think this is a great idea. It requires really good names. But most of my comments do not tell what the code is doing, they tell either why the code is doing something or what the purpose is of doing what ever. But that is not all:
* Comments are left to indicate where the code might be made better:
** More careful error management.
** Where I am thinking about refactoring
** To make up for deliberately generic names -- ?? I need more explanation here
** To provide a search string so I can find a place in the code
** Where a little trap may lurk in the code:
For example most methods return at the end, but sometimes you discover in your processing that you are done
early. You could put some sort of if then structure in, but now you indent one level more making the
code somewhat more difficult. So just return. In these cases I may put a comment at the beginning of the method:

# beware of early return

I try to indicate that there may be an early return, but refactoring may remove it and leave the comment in place
** Of course no comment should be considered 100% reliable

= Copy and Paste =
some content may move to [[Copy and Paste Is Good]] or not

There are lots of arguments against copy and paste, but used carefully I think that it is extremely useful. But used carefully.

One of the biggest arguments against it is that you may be using code that you do not really understand. This can be true, but the
same is true when you use someone else's module.

So I have a procedure depending on where I copy from:

* My own code:
** I only take working code.
** I reread it and make appropriate changes.
** I own the results, if it does not work properly I am to blame
** I write code in a generic way to make it easy to copy and paste.

* Refactoring:
** Of course when I refactor I use copy and paste, because basically your are just rearranging code you already have that works.
** Many people use git to make sure they do not loose stuff in translation. I just use file copies, I have my own methods
** Sleep that is zzzzzzz: I put zzzz or similar around the place where I am making changes. It throws a quick syntax method if I foolishly try to run the code and is easy to find as zzzz is not anything I would normally use in code. Sometimes I copy a lot of junk in between a pair of zzz so I have all the names I need in easy view. Then I do the new code, remove the junk and finally the pair of zzzz'a.

* Other peoples code:
** I put there code in an example file.
** I change the code to my style and comment it, often keeping a url to the source.
** I run it to make sure it does what I want.
** I may make it generic in a way to make copying easier.
** I save the example.
**

= Python Code Example Files =
When I learn a new thing in Python I often keep an example file. I can then use it for reference and/or copy code out of it for other uses. I have a few "tricks". See: '''[[Python Code Example Files]]'''

= Tkinker =
== Complex Tkinker Windows ==
I found it really easy to get confused in coding Tkinter because it is not done in a visual interface.
One of my goal in coding is to make the code create the gui from top to bottom and from left to right. That way the layout of code and the layout of the gui are easier to match up in my mind. This has a benefit of making it relatively easy to:

* Cut and paste code to rearrange placement in the gui.
* Cut/paste/modify code to build new widgets.

So here are some tips:

* I do a sketch of what I want on paper.
* The GUI is built in a class.
* I break the sketch into Tkinter frames each of which will layout into the window in some fairly simple scheme, often the pack layout will work. When this is not enough I use grid.
* When using grids I always have variables for the row and column positions. These are typically managed with statements like lrow += 1. Coding this way make movement of the code much easier. Placement methods may also be used to manage the row and column variables.
* Each individual frame is built in its own method, it takes the parent frame as an argument and returns the frame that it builds. The returned frame is then placed in its parent.
* References to the widgets are often not needed once the GUI is built, so local variable are often used. Using a local variable makes it easier to copy/paste. I try to always use the name a_widget, thus code that places or otherwise manipulates the widget in a generic way ( like placement ) works well in a copy paste. If I need a reference, I typically will do that on the last line of the code for the widget. For widgets that need references you can use an instance variable of the class, or in some cases it it useful to store them in a dictionary.
* Building helper classes for either building the widgets, or placing them or both is often useful.
* You can see these techniques in GUI class of my various application documented on this wiki.
* See: '''[[Python Buttons Switch Case]]''' for some tricks on building Tkinter frames with lots of buttons linked to functions.

== Threading with Tkinker ==

Tkinker wants to own the processing of the application. If you make a button start a long running operation then the GUI blocks and becomes unresponsive. So you need some sort of threading. Here are some tips.

=== Polling withing Tkinker ===

You can poll in the Tkinter event loop and call any function ( no arguments I think ) using a Tkinter function. Use this to run something short. You can only run it once this way.
<pre>
self.gui.root.after( self.parameters.gt_delta_t, self.polling ) # self.gui.root = Tkinter root, .1 = .1 sec, self.polling = name of the function
# ( note no () which is a function call
</pre>

To overcome the fact that it only runs once, ask for it again at the end of the function.

<pre>
def polling( self, ):
..... do something quick

self.gui.root.after( .1, self.polling )

</pre>

If you function throws an exception it will stop running. Try Except works for me:

<pre>
def polling( self, ):

try:
..... do something quick
except Exception, ex_arg:
.... I log the error
finally:
self.gui.root.after( .1, self.polling )

</pre>

=== Use Threading ===

Use real threading. I inherit from threading.Thread and implement a override of the run method. Use threading mechanisms to "message" back and fourth to the gui, Tkinter, thread.
Seems to work fine.

== Calling across Threads ==

If you have objects in 2 different threads calling across the threads can be very dangerous. I have worked out a method that I find useful/safe/easy. It does make some assumptions.

*Both objects/threads have something resembling polling where checks can be made at a convient time to see if the other thread wants attention.

=== Step 1, Set Up Queues ===

<pre>
self.queue_to_helper = Queue.Queue( 20 ) # send from tkinker mainloop to helper here
self.queue_fr_helper = Queue.Queue( 20 ) # send back from helper thread to tkinker mainloop here

</pre>

So how does this help making calls across the threads? What I am doing in SmartTerminal ( could change, see the code ) is to always pass a tuple of 3 parts:

<pre>
( a_string, a_function, another_tuple_of_arguments_to_a_function )
</pre>

if a_string is "call" then the queue item is for a function call ( other cases not discussed here ). Then the function ( remember functions are first class objects math.sin( x ) call to a function, math sin a function ) is combined with the arguments to make the call: a_function( arguments_to_a_function ). Almost, it will not work because argument_to_a_function is itself a tuple. And even if the tuple has five elements you are only passing one argument, the tuple, to the function. You need to unpack the arguments. How do you do that:

<pre>

a_function( *another_tuple_of_arguments_to_a_function )

</pre>

Here is the code with a little more context ( for more see SmartTerminal smart_terminal_helper.HelperThread.polling ) but not actual production code.

<pre>
.........
( action, function, function_args ) = self.rec_from_queue()
if action == "call":
function( *function_args )
.........
</pre>

more coming......

= Starting a Tkinter App =
These applications start fine but often remain in the background with their window behind other windows. It would be good to bring it to the top of your windows. This code, may not be the best, seems to work at least on the Windows.

<pre>
root.attributes("-topmost", True)
root.attributes("-topmost", False) # if left to True window always on top
</pre>

You need to get this to run once after the mainloop is started. You can do this with '''root.after()''' Some details left to you.

= Simple Techniques =
These are techniques I use that I have not often seen documented.

== Create a Local Reference ==

We often use "dotted" notation to reference non-local variables. If the variable is used several times we may want to create a local reference:

<pre>
graph_live_time_zero = self.parameters.graph_live_time_zero
if graph_live_time_zero = 1:
.....
elif graph_live_time_zero = 2:
.....
else:
......
</pre>
instead of:

<pre>

if self.parameters.graph_live_time_zero = 1:
.....
elif self.parameters.graph_live_time_zero = 2:
.....
else:
......
</pre>

Why:

*Well Python searches for local references first, they are faster so your code is faster.
*If something about the non-local reference changes, then changing the code is easier/less error prone.

[[Category:Python]]

Russ Python Tips and Techniques

2023-02-04T13:44:20Z

Russ hensel: /* Complex Tkinker Windows */

= What =
These are Tips and Techniques I have found useful in my Python programming [[User:Russ_hensel]]. I would be interested in your feedback. Let me know if you think the tip is useful/wrong/something everyone knows. A good set of this material relates to applications with a GUI. They are often not beginner techniques, but neither are they all advanced ones.
Just starting Feb 2017 check history tab above to see if progress is being made. If you find a tip not finished or working feel free to contact me.

== Ones Still To Be Written ==

* when division by 0 is useful
* code is multiple files - scratch file
* moving to 3.6 use fstrings
* example files with functions [[Python Example Code]]
* when you need a reference and when not
* dict based case statements
* choose names for cut and paste
* mark your code with unusual string * zzz in your code

=== Move these to a good place in the outline ===

==== Python Installation ====

I have a separate page [[Category:Python Installation]] about installation an maintenance, the first part is of general interest, the second on particular issues I have encountered. It may be useful to get some of my projects running [[Category:Python Projects]].

==== FStrings ====

FStrings are incredibly nice. New in 3.6, use it ( or 3.7.... ) They also are reputed to be really fast. Use them. At a later time I may have a bunch of examples, but for now just the basic statement:

<pre>
joe = "Joe Smith Jones Norton"
msg = f"Joe's name is actually {joe}"
print( msg 0
</pre>

==== Comments for Navigation ====

Spyder has a nice feature for code navigation: the "Outline Tab". This tab outlines the code nesting classes, methods.... and expands and contracts the tree much like the code folding show in the editor. The outline tab works both to help you navigate to a place in the code, or to show you where in the code the cursor currently lies. What is less obvious is that comments can also mark a section. I have not found documentation for this but here is what I have found. A comment like "# ------ frame building methods --" will create an outline section whose indentation in the outline depends on indentation of the comment. The space and the "-" characters are important. Start by using exactly what is shown here, and experiment to see how much you can change it before it disappears from the outline. I often use this to group a large number of similar methods that can then be folded out of view.

==== msg ====

A name I use over and over again for messages, often like:

<pre>
msg = "this is a message"
print( msg )
</pre>

Why two lines instead of one? Because I often change it to include logging or sending to the GUI. It might then become:

<pre>
msg = "this is a message"
print( msg )
AppGlobal.logger.debug( msg )
</pre>

I find this a nice way to manage code.

==== #rint ====

If you use print for debugging you may want to scan your code of "print" to remove unwanted statements. I do not delete them because sometimes I want them again for more debugging. I change "print" to "#rint"
to comment out the print but to stop it form showing up on searches.

==== Make Code Searchable ====

I like generic names to enable cut and paste but this runs against the idea of searchable code. The idea is that unusual names are easy to search for. It also helps if names are descriptive. Why searchable? So you can find the code you want to work on. One way to be both searchable and generic is to take instance references and make local ( or the reverse ) For example consider this tkinter code:

<pre>
a_list = list(self.sort_order_dict.keys())
a_widget = ttk.Combobox( a_frame, values = a_list, state='readonly')
a_widget.grid( row = lrow + 1, column = lcol, rowspan = 1, columnspan = 3, sticky = E + W + N + S )
a_widget.set( a_list[0] )
self.sort_order_widget = a_widget
lcol += 3
</pre>

The name a_widget is generic, but to see what it "really" is you have the none generic name "self.sort_order_widget"

If you do not see an easy way to do this with names use a comment. Using zzzz.... is a short term way of doing this.

==== Dict Based Case Statements ====

Python does not have a case statement, but it does have if....elif which can be used and is only a little more verbose. However if you have more than a few cases it can be cumbersome. Using a dict gives a very compact and fast case statement. Suppose you want to have a case statement based on strings:

<pre>
# set up, ideally only done onece, perhaps at module or class level
dispatch_dict = { "one": print_one,
"two": print_two,
"three": print_three,
}

# set a case for an example call:
key = "two"

# the slightly verbose case statement
function = dispatch_dict[ key ]
function()
</pre>

= Parameters for Applications =

There are various ways of storing start up parameters for applications. In the old days almost all windows programs had a "ini" file. Linux had/has "config" files. In both cases these are text files that are easily edited with a simple text editor. More recently xml files ( which i tend to hate ) have come into vogue. Finally some applications give you a gui for editing configuration values and then save them any way they want, perhaps in the "registry".

Using a gui is the easiest way for the user in particular the naive user. They are also a lot of work to implement and maintain. So I favor a flat, non-xml file. But what file? For Python my answere is a python.py file that has pretty much one class, Parameters, that is implemented as a singleton ( in what ever way you want to implement singletons ). These are easy to implement, easy to maintain, and very flexible. They can also do clever things like detecting what operating system they are running on and make automatic adjustments. There are no issues of converting type into strings for the file. Comments are easily included. Loading can print the progress of initialization.

I will put a brief sample here soon so you can see what a file looks like.

<pre>
code comming here
</pre>

= Logging =

I use the logging class that is part of standard python. I provide a button to view and edit the file. Why invent your own method. Here is some code:

<pre>
code comming
</pre>

= Restart =
When an application ( here I am thinking about GUI applications ) starts there can be a considerable delay as all the modules are imported. Typically a restart is done after an exception or when parameters are changed. So I include a restart button on the GUI to quickly restart the application. In my case applications are usually started by constructing some application class. So what I do is break up the __init__ method into 2 parts, only the second needs to be run to restart the application. Here is some sample code:

<pre>

def __init__(self ):
"""
create the application, its GUI is called self.gui which is
created in restart
"""
...... more code ......

self.restart( ) # continue in restart

# --------------------------------------------------------
def restart(self ):
"""
use to restart the app without ending it
parameters will be reloaded and the gui rebuilt
call from a button on the GUI
args: zip
ret: zip ... all sided effects
"""

self.no_restarts += 1 # if we want to keep track
if not( self.gui is None ): # determines if a restart or the start
# !! # need to shut down other thread
self.gui.root.destroy()
reload( parameters )

self.logger = None

.... and so on ......

</pre>

= Names =

I have heard it said that proper naming is the hardest problem in programming. Not sure if true, but it is not easy. So here is my take:

* Of course be consistent. It may help to make a vocabulary list of the terms you prefer. I have found that the values often come in pairs:

start_date / stop_date or low_temp / high_temp ( or hi_temp ) or start_date / end_date
then some style are:
date_start / date_stop

Note that the stop_date and end_date is an easy place for confusion. So decide on your style and stick to it.

* Do not be afraid of long names but consistent abbreviations are fine ( keep a list ).
* I generally think that methods should be named with verb like names: os_open_file.
* I find that people use the name '''file''' for both the '''file name''' ( often string like ) and for the '''file handle''' ( the thing you get when you open a file ), so my variables for file names are like:

input_file_name ( sometimes input_fn )

* Lists and other iteratables often get a name to indicate that: so a list of names might be called something like student_names

* Sometimes generic names are preferable especially if there scope is just a few lines. I am willing to iterate over a list of numbers with i, but I prefer ix and even then I fell lazy. If I have a list of names as above I might itterate with the singular, but usually i prefix it with i_ so:

for i_name in student_names
print( i_name )

= Comments =
Extreme programming trys to make the code so obvious that it is easy to tell what the code is doing without comments. If not taken too far I think this is a great idea. It requires really good names. But most of my comments do not tell what the code is doing, they tell either why the code is doing something or what the purpose is of doing what ever. But that is not all:
* Comments are left to indicate where the code might be made better:
** More careful error management.
** Where I am thinking about refactoring
** To make up for deliberately generic names -- ?? I need more explanation here
** To provide a search string so I can find a place in the code
** Where a little trap may lurk in the code:
For example most methods return at the end, but sometimes you discover in your processing that you are done
early. You could put some sort of if then structure in, but now you indent one level more making the
code somewhat more difficult. So just return. In these cases I may put a comment at the beginning of the method:

# beware of early return

I try to indicate that there may be an early return, but refactoring may remove it and leave the comment in place
** Of course no comment should be considered 100% reliable

= Copy and Paste =
some content may move to [[Copy and Paste Is Good]] or not

There are lots of arguments against copy and paste, but used carefully I think that it is extremely useful. But used carefully.

One of the biggest arguments against it is that you may be using code that you do not really understand. This can be true, but the
same is true when you use someone else's module.

So I have a procedure depending on where I copy from:

* My own code:
** I only take working code.
** I reread it and make appropriate changes.
** I own the results, if it does not work properly I am to blame
** I write code in a generic way to make it easy to copy and paste.

* Refactoring:
** Of course when I refactor I use copy and paste, because basically your are just rearranging code you already have that works.
** Many people use git to make sure they do not loose stuff in translation. I just use file copies, I have my own methods
** Sleep that is zzzzzzz: I put zzzz or similar around the place where I am making changes. It throws a quick syntax method if I foolishly try to run the code and is easy to find as zzzz is not anything I would normally use in code. Sometimes I copy a lot of junk in between a pair of zzz so I have all the names I need in easy view. Then I do the new code, remove the junk and finally the pair of zzzz'a.

* Other peoples code:
** I put there code in an example file.
** I change the code to my style and comment it, often keeping a url to the source.
** I run it to make sure it does what I want.
** I may make it generic in a way to make copying easier.
** I save the example.
**

= Python Code Example Files =
When I learn a new thing in Python I often keep an example file. I can then use it for reference and/or copy code out of it for other uses. I have a few "tricks". See: '''[[Python Code Example Files]]'''

= Tkinker =
== Complex Tkinker Windows ==
I found it really easy to get confused in coding Tkinter because it is not done in a visual interface.
One of my goal in coding is to make the code create the gui from top to bottom and from left to right. That way the layout of code and the layout of the gui are easier to match up in my mind. This has a benefit of making it relatively easy to:

* Cut and paste code to rearrange placement in the gui.
* Cut/paste/modify code to build new widgets.

So here are some tips:

* I do a sketch of what I want on paper.
* The GUI is built in a class.
* I break the sketch into Tkinter frames each of which will layout into the window in some fairly simple scheme, often the pack layout will work. When this is not enough I use grid.
* When using grids I always have variables for the row and column positions. These are typically managed with statements like lrow += 1. Coding this way make movement of the code much easier. Placement methods may also be used to manage the row and column variables.
* Each individual frame is built in its own method, it takes the parent frame as an argument and returns the frame that it builds. The returned frame is then placed in its parent.
* References to the widgets are often not needed once the GUI is built, so local variable are often used. Using a local variable makes it easier to copy/paste. I try to always use the name a_widget, thus code that places or otherwise manipulates the widget in a generic way ( like placement ) works well in a copy paste. If I need a reference, I typically will do that on the last line of the code for the widget. For widgets that need references you can use an instance variable of the class, or in some cases it it useful to store them in a dictionary.
* Building helper classes for either building the widgets, or placing them or both is often useful.
* You can see these techniques in GUI class of my various application documented on this wiki.
* See: '''[[Python Buttons Switch Case]]''' for some tricks on building Tkinter frames with lots of buttons linked to functions.

= Threading with Tkinker =

Tkinker wants to own the processing of the application. If you make a button start a long running operation then the GUI blocks and becomes unresponsive. So you need some sort of threading. Here are some tips.

== Polling withing Tkinker ==

You can poll in the Tkinter event loop and call any function ( no arguments I think ) using a Tkinter function. Use this to run something short. You can only run it once this way.
<pre>
self.gui.root.after( self.parameters.gt_delta_t, self.polling ) # self.gui.root = Tkinter root, .1 = .1 sec, self.polling = name of the function
# ( note no () which is a function call
</pre>

To overcome the fact that it only runs once, ask for it again at the end of the function.

<pre>
def polling( self, ):
..... do something quick

self.gui.root.after( .1, self.polling )

</pre>

If you function throws an exception it will stop running. Try Except works for me:

<pre>
def polling( self, ):

try:
..... do something quick
except Exception, ex_arg:
.... I log the error
finally:
self.gui.root.after( .1, self.polling )

</pre>

== Use Threading ==

Use real threading. I inherit from threading.Thread and implement a override of the run method. Use threading mechanisms to "message" back and fourth to the gui, Tkinter, thread.
Seems to work fine.

= Calling across Threads =

If you have objects in 2 different threads calling across the threads can be very dangerous. I have worked out a method that I find useful/safe/easy. It does make some assumptions.

*Both objects/threads have something resembling polling where checks can be made at a convient time to see if the other thread wants attention.

== Step 1, Set Up Queues ==

<pre>
self.queue_to_helper = Queue.Queue( 20 ) # send from tkinker mainloop to helper here
self.queue_fr_helper = Queue.Queue( 20 ) # send back from helper thread to tkinker mainloop here

</pre>

So how does this help making calls across the threads? What I am doing in SmartTerminal ( could change, see the code ) is to always pass a tuple of 3 parts:

<pre>
( a_string, a_function, another_tuple_of_arguments_to_a_function )
</pre>

if a_string is "call" then the queue item is for a function call ( other cases not discussed here ). Then the function ( remember functions are first class objects math.sin( x ) call to a function, math sin a function ) is combined with the arguments to make the call: a_function( arguments_to_a_function ). Almost, it will not work because argument_to_a_function is itself a tuple. And even if the tuple has five elements you are only passing one argument, the tuple, to the function. You need to unpack the arguments. How do you do that:

<pre>

a_function( *another_tuple_of_arguments_to_a_function )

</pre>

Here is the code with a little more context ( for more see SmartTerminal smart_terminal_helper.HelperThread.polling ) but not actual production code.

<pre>
.........
( action, function, function_args ) = self.rec_from_queue()
if action == "call":
function( *function_args )
.........
</pre>

more coming......

= Starting a Tkinter App =
These applications start fine but often remain in the background with their window behind other windows. It would be good to bring it to the top of your windows. This code, may not be the best, seems to work at least on the Windows.

<pre>
root.attributes("-topmost", True)
root.attributes("-topmost", False) # if left to True window always on top
</pre>

You need to get this to run once after the mainloop is started. You can do this with '''root.after()''' Some details left to you.

= Simple Techniques =
These are techniques I use that I have not often seen documented.

== Create a Local Reference ==

We often use "dotted" notation to reference non-local variables. If the variable is used several times we may want to create a local reference:

<pre>
graph_live_time_zero = self.parameters.graph_live_time_zero
if graph_live_time_zero = 1:
.....
elif graph_live_time_zero = 2:
.....
else:
......
</pre>
instead of:

<pre>

if self.parameters.graph_live_time_zero = 1:
.....
elif self.parameters.graph_live_time_zero = 2:
.....
else:
......
</pre>

Why:

*Well Python searches for local references first, they are faster so your code is faster.
*If something about the non-local reference changes, then changing the code is easier/less error prone.

[[Category:Python]]

Mushroom Resources

2022-10-12T17:26:16Z

Russ hensel:

== 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"
|*'''[https://eol.org/ Encyclopedia of Life ]'''
|*'''[https://eol.org/ Encyclopedia of Life ]'''
|Links to almost all the information known about a mushroom once you have an id or tentative id. Can be quite technical. Some learning curve on how to navigate the site.

|-valign="top"
|*'''[https://picturemushroom.com/ Picture Mushroom - Online mushroom encyclopedia and mushroom identifier ]'''
|*'''[https://picturemushroom.com/ Picture Mushroom - Online mushroom encyclopedia and mushroom identifier ]'''
|This is a website for the phone app, but is good for looking up characteristics of mushrooms once you know the name

|-valign="top"
|Picture Mushroom: Phone App
|222
|3333


|-valign="top"
|*'''[https://mushroomobserver.org/info/how_to_use Mushroom Observer: How to Use Mushroom Observer ]'''
|*'''[https://mushroomobserver.org/info/how_to_use Mushroom Observer: How to Use Mushroom Observer ]'''
|

|-valign="top"
|*'''[https://play.google.com/store/apps/details?id=org.plantnet PlantNet Plant Identification - Apps on Google Play ]'''
|222
|3333


|-valign="top"
|*'''[https://fungusid.com/ FungusID | AI-powered Wild Mushroom Identifier ]'''
|222
|3333


|-valign="top"
|How to pronounce websites
|*'''[https://www.howtopronounce.com/amanita-muscaria How to pronounce Amanita muscaria | HowToPronounce.com ]'''
*'''[https://forvo.com/word/amanita_muscaria/ Amanita muscaria pronunciation: How to pronounce Amanita muscaria in Latin, Spanish, French, English ]'''
*'''[https://www.pronouncekiwi.com/Amanita%20Muscaria How To Pronounce Amanita Muscaria: Amanita Muscaria pronunciation ]'''
|Learn the right way to pronounce the botanical ( Latin ) name.


|}

[[Category:Mushroom]]

Mushroom Resources

2022-10-12T17:17:49Z

Russ hensel: /* BoostC Wiki */

== 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"
|*'''[https://eol.org/ Encyclopedia of Life ]'''
|*'''[https://eol.org/ Encyclopedia of Life ]'''
|Links to almost all the information known about a mushroom once you have an id or tentative id. Can be quite technical. Some learning curve on how to navigate the site.

|-valign="top"
|*'''[https://picturemushroom.com/ Picture Mushroom - Online mushroom encyclopedia and mushroom identifier ]'''
|*'''[https://picturemushroom.com/ Picture Mushroom - Online mushroom encyclopedia and mushroom identifier ]'''
|This is a website for the phone app, but is good for looking up characteristics of mushrooms once you know the name

|-valign="top"
|Picture Mushroom: Phone App
|222
|3333


|-valign="top"
|*'''[https://mushroomobserver.org/info/how_to_use Mushroom Observer: How to Use Mushroom Observer ]'''
|*'''[https://mushroomobserver.org/info/how_to_use Mushroom Observer: How to Use Mushroom Observer ]'''
|

|-valign="top"
|*'''[https://play.google.com/store/apps/details?id=org.plantnet PlantNet Plant Identification - Apps on Google Play ]'''
|222
|3333


|-valign="top"
|*'''[https://fungusid.com/ FungusID | AI-powered Wild Mushroom Identifier ]'''
|222
|3333


|-valign="top"
|555
|222
|



|}

[[Category:Mushroom]]

Mushroom Resources

2022-10-12T17:13:51Z

Russ hensel:

== 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"
|*'''[https://eol.org/ Encyclopedia of Life ]'''
|*'''[https://eol.org/ Encyclopedia of Life ]'''
|Links to almost all the information known about a mushroom once you have an id or tentative id. Can be quite technical. Some learning curve on how to navigate the site.

|-valign="top"
|*'''[https://picturemushroom.com/ Picture Mushroom - Online mushroom encyclopedia and mushroom identifier ]'''
|*'''[https://picturemushroom.com/ Picture Mushroom - Online mushroom encyclopedia and mushroom identifier ]'''
|This is a website for the phone app, but is good for looking up characteristics of mushrooms once you know the name

|-valign="top"
|Picture Mushroom: Phone App
|222
|3333


|-valign="top"
|*'''[https://mushroomobserver.org/info/how_to_use Mushroom Observer: How to Use Mushroom Observer ]'''
|*'''[https://mushroomobserver.org/info/how_to_use Mushroom Observer: How to Use Mushroom Observer ]'''
|

|-valign="top"
|*'''[https://play.google.com/store/apps/details?id=org.plantnet PlantNet Plant Identification - Apps on Google Play ]'''
|222
|3333


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


|-valign="top"
|555
|222
|



|}

[[Category:Mushroom]]

Mushroom Resources

2022-10-12T17:07:06Z

Russ hensel: /* BoostC Wiki */

== 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"
|*'''[https://eol.org/ Encyclopedia of Life ]'''
|*'''[https://eol.org/ Encyclopedia of Life ]'''
|Links to almost all the information known about a mushroom once you have an id or tentative id. Can be quite technical. Some learning curve on how to navigate the site.

|-valign="top"
|*'''[https://picturemushroom.com/ Picture Mushroom - Online mushroom encyclopedia and mushroom identifier ]'''
|*'''[https://picturemushroom.com/ Picture Mushroom - Online mushroom encyclopedia and mushroom identifier ]'''
|This is a website for the phone app, but is good for looking up characteristics of mushrooms once you know the name

|-valign="top"
|Picture Mushroom: Phone App
|222
|3333


|-valign="top"
|*'''[https://mushroomobserver.org/info/how_to_use Mushroom Observer: How to Use Mushroom Observer ]'''
|*'''[https://mushroomobserver.org/info/how_to_use Mushroom Observer: How to Use Mushroom Observer ]'''
|3333

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


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


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


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

*'''[https://mushroomobserver.org/info/how_to_use Mushroom Observer: How to Use Mushroom Observer ]'''



|}

[[Category:Mushroom]]

Mushroom Resources

2022-10-12T17:05:03Z

Russ hensel: /* BoostC Wiki */

Mushroom Resources

2022-10-12T17:02:28Z

Russ hensel:

Mushroom Resources

2022-10-12T16:47:06Z

Russ hensel: Created page with " == BoostC Wiki == {| class="wikitable" |-valign="top" |What |Where |Comment  |-valign="Use C for PIC Programming!top" |BoostC tiny..."

== BoostC Wiki ==

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

|-valign="[[Use C for PIC Programming!]]top"
|[[BoostC tiny Wiki]]
|An experiment as a possible wiki for BoostC, If it gets big it should find its own home somewhere else.
|[[Special:Export/BoostC tiny Wiki]]

|-valign="top"
|[[111]]
|2222
|33333

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


|-valign="top"
|[[BoostC Forum Extracts 2007]]
|
|[[Special:Export/BoostC Forum Extracts 2007]]


|-valign="top"
|[[A C Program Header Example]]
|
|[[Special:Export/---]]


|-valign="top"
|[[BoostC Optimizations]]
|
|[[Special:Export/---]]


|-valign="top"
|[[BoostC Floating Point]]
|
|[[Special:Export/BoostC Optimizations]]

|-valign="top"
|[[BoostC Inline C Functions]]
|
|[[Special:Export/---]]


|-valign="top"
|[[BoostC Explaining BoostC.h]]
|
|[[Special:Export/---]]


|-valign="top"
|[[BoostC Wiki Help Needed]]
|
|[[Special:Export/---]]



|}

[[Category:Mushroom]]

Mushrrom Documentation

2022-10-12T16:44:09Z

Russ hensel:

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)
*
[[Category:Mushroom]]

Russ hensel

2022-10-12T16:42:55Z

Russ hensel: /* My Editing Links */

= About Me =
I am a once upon a time high school teacher and database programmer/software engineer. My hobbies now are gardening, Python programming, microcontrollers, Physics/Math, my cats and whatnot. I have a nice wood shop, some metal working tools, and am learning to weld. I have a fairly large collection of scientific antiques, mostly microscopes, surveying instruments, and electronics test equipment. Online my name is often russ_hensel, gives me a pretty unique id on Google. I live in Dartmouth Ma.

I am now on Facebook, but do not post much.

I have posted a few Instructables, find me there at: [http://www.instructables.com/member/russ_hensel/ Instructables member: russ_hensel]

I have done a fair amount in Python. I am now keeping my files at github: https://github.com/russ-hensel For some there may be info here, other not.

You can reach me ( EMAIL ) at: no_spam_please_666 at comcast dot net (REFORMAT FOR A VALID EMAIL ADDRESS). This address is just for first contact, I will respond with a better address after first contact.

On this site I tend to write about the following topics

* Electronics in general ( still doing it at home, but not writing about it much ).
* Microcontrollers, PIC in the past now the Arduino
* Python and my Python Projects
* Raspberry Pi
* 3D Printing and FreeCad ( bought first printer in 2017, second one too )
* BoostC - now replaced by C++ in context of the Arduino
* Stepper Motors -- used in several of my projects. Usually in catagories with Arduino

= About My Articles =

I write about items as they interest me. Too often I start on something and drop either the article or the project for short or long periods befor picking it up again. Sorry. I am open to email with questions, this may make me complete or improve some article. If you are interested please let me know.

You may find that some pages say something like:

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. The page is only partly finished

== My Editing Links ==

These links are for me to navigate to pages I have done quite a bit of work on or want to look at frequently. They are not for you, but you can use them if you want.

*[[Mushroom Resources]]
*[[Vivek]]

*[[Russ Page Links]]

*[[Russ Editing Links]] probably dead

= Articles posted here on Open Circuits =

== Serial Communications and Microcontrollers ==

*[[Python Smart Terminal]] As of Sept 2016 still and active project.
*[http://www.opencircuits.com/Category:Microcontroller Category:Serial_Communications] Most of these have at least large input from me. Some are general, some for the Arduino, and some for the PIC microcontroller.
*[http://www.opencircuits.com/Category:PIC Category:PIC] I have mostly converted to the Arduino, but before that I used the PIC, still think it is a nice micro controller, but building the boards and finding a coding environment.... is more of a pain than I want.

*[http://www.opencircuits.com/Category:Arduino Category:Arduino] After my conversion from PIC.

= Articles posted on Instructables =

== Related to Python ==

*'''[http://www.instructables.com/id/Python-Terminal-for-Cheap-Pi-Arduino-Connection/ Python Terminal for Cheap Pi Arduino Connection - All ]'''
*'''[http://www.instructables.com/id/Experiments-in-Advanced-Data-Logging-Using-Python-/ Experiments in Advanced Data Logging ( Using Python ) - All ]'''
*'''[http://www.instructables.com/id/Incredibility-Powerful-Resistance-Calculator/ Incredibility Powerful Resistance Calculator - All ]'''
*'''[http://www.instructables.com/id/Use-Sage-and-Sell-Your-Calculator-before-it-is-Too/ Use Sage and Sell Your Calculator before it is Too Late - All ]'''
*'''[http://www.instructables.com/id/Python-Autoexec-for-Your-Raspberry-Pi/ Python Autoexec for Your Raspberry Pi - All ]'''
*'''[http://www.instructables.com/id/ClipBoard-Communication-PC-Pi-With-Python/ ClipBoard Communication PC ↔ Pi With Python - All ]'''
*'''[http://www.instructables.com/id/Graph-Your-Solar-Power/ Graph Your Solar Power - All ]'''
*'''[http://www.instructables.com/id/Graph-Instructable-Views-with-Pypthon-Screen-Scrap/ Graph Instructable Views with Python Screen Scraping - All ]'''
*'''[http://www.instructables.com/id/Digital-Picture-Management-Eliminate-Weak-Photos-w/ Digital Picture Management - Del Weak Pics with Python - All ]'''

== Related to Arduino ==

[[Pi Setup Nov 2016]]

*'''[http://www.instructables.com/id/Backup-Your-Pi/ Backup Your Pi - All ]'''
*'''[http://www.instructables.com/id/Python-Autoexec-for-Your-Raspberry-Pi/ Python Autoexec for Your Raspberry Pi - All ]'''
*'''[http://www.instructables.com/id/ClipBoard-Communication-PC-Pi-With-Python/ ClipBoard Communication PC ↔ Pi With Python - All ]'''

== Related to Electronics ==

[[PiSetup]]

*'''[http://www.instructables.com/id/Electronics-Building-Tips-in-21-Plus-Steps-/ Electronics Building Tips ( in 21 Plus Steps ) - All ]'''
*'''[http://www.instructables.com/id/More-Electronics-Building-Tips-in-21-plus-more-ste/ More Electronics Building Tips ( in 21 plus more steps ) - All ]'''
*'''[http://www.instructables.com/id/Comprehensive-Guide-to-Electronic-Breadboards-A-Me/ Comprehensive Guide to Electronic Breadboards: A Meta Instructable - All ]'''
*'''[http://www.instructables.com/id/Three-in-One-IC-Continuity-Tester-Signal-Generator/ Three in One: IC/ Continuity Tester, & Signal Generator - All ]'''

us double brackes for categories

category:Member Page
category:salvage
category:Test Instrument
category:Serial Communications
category:Microcontroller
category:PIC
category:Test Instrument
category:Test Instrument
[[category:BoostC]]

Chemical Etchants

2022-10-02T21:02:24Z

Russ hensel: Reverted edits by 82.165.115.89 (talk) to last revision by DavidCary

Russ Page Links

2022-09-16T14:22:24Z

Russ hensel: /* 2021 */

= My Links =

These links are for me to navigate to pages I have done quite a bit of work on or want to look at frequently. They are not for you, but you can use them if you want.
[[Special:CreateAccount]]

You may find that some pages say something like:

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. The page is only partly finished

== Sticky ==

*[[Russ Page Template]]

== 2022 ==

*[[Mushrrom Documentation]]

== 2021 ==
*[[Command Assistant Help File]]

*[[Delete Duplicates Help File]]

== New 2020 ==

* smart_clipboard [[Python Smart ClipBoard]] https://github.com/russ-hensel/smart_clipboard/tree/master
* [[Python Button Dictionary Case Statement]]
* [[Twitter Analysis DB]]
* [[Copy and Paste Is Good]]
*[[Python Installation]]

* [[‎Adoptions]]



== New 2019 ==

*[[Python Desk Top Applications]]
*[[BullDog Notes]]
*[[Python Control of Smart Plugs]]
*[[My Python Coding Conventions]]
*[[Python Backup Program]]
*[[Python Easy DataBase Project]]
*[[My Linux Mint Install]]

== New 2018 ==

*[[Russ's Pi Recipie]]
*[[Raspbery Pi Mounting Platform and Bracket]]

*[[Fastening Objects in 3D Printing]]
*[[Parametric 3D Printed Electronics Case/Enclosure]]
*[[Arduino/Raspberry Pi based Dancing Clock]]
*[[FreeCad Tips for Beginners]]
*[[Raspberry Pi Stretch - 2018 Tricks ]]
*[[No Tools Garden Hose Connect]]
*[[Smarter Arduino Programming - Tips and Tricks]]
*[[Arduino Socket]]
*[[Configuration Files For Python]]
*[[Cookbook of Raspberry Pi Commands]]
*[[Python Scheduling Application]]
*[[Setup Toga with Spyder]]
*[[Almost Orphans]]
*[[new page]]

== New 2017 ==
*[[200 Dollar 3D Printer Club]]

*[[3D Printer Kit]]
*[[Two Axis Stepper Controller]]
*[[3D Printed Mechanisms]]
*[[FreeCad Gear Box]]
*[[Install Kivy]]
*[[Russ Python Tips and Techniques]]
*[[Russ Page Template]]

*[[Python Smart Terminal]]
*[[Blinking Blues]]

*[[Arduino Kit - Cheap]]

*[[Blinking Blues]]

== New 2016 ==

*[[Russ Page Template]]

*[[Python Smart Terminal]]

*[https://github.com/russ-hensel My profile at github]
*[[Instrumentino Notes]]

*[[Pi Setup Nov 2016]]
*[[Russ Wiki Links]] delete it ??

*[[FreeCad Notes]]

*[[Blinking Blues]]

== SCIL and Makerspace ==

*[[SCIL at OpenCircuits]]
*[[Maker Space SC]]
*[[Maker Space Monitor]]
*[[Python Lists]]

== Misc ==

* [[Python Resources for Math 499]] --> [[Special:Export/Python Resources for Math 499]]
* [[499 Projects]] --> [[Special:Export/499 Projects]]
* [[Python Installation On Your System]] --> [[Special:Export/Python Installation On Your System]]

*[[R Pi Notes]]
*[[Running a DreamHost Wiki]]
*[[SageMath]]
*[[Python]]
*[[Electronics Software with SageMath]]
*[[Russ Page Template]]
*[[The EggBot]]
*[[Buying an Arduino for the Robotics Club]]
*[[LTSpice Links]]
*[[Arduino Theremin]]
*[[Arduino Command Interpreter]]
*[[Arduino Laser Cannon]]
*[[Solid State Drive Issues]]
*[[Orphans To Link]]

*[[Real Time Clock -- Keeping Time with a Microcontroller]]

*[[All About Salvage]]
*[[Projects From Salvage]]

*[[Debouncing Microcontroller Inputs]]

*[[Spam Attack 2011]]

== BoostC Wiki ==

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

|-valign="[[Use C for PIC Programming!]]top"
|[[BoostC tiny Wiki]]
|An experiment as a possible wiki for BoostC, If it gets big it should find its own home somewhere else.
|[[Special:Export/BoostC tiny Wiki]]

|-valign="top"
|[[Playing With PIC Pack]]
|
|[[Special:Export/---]]

|-valign="top"
|[[BoostC from the Fourm]]
|
|[[Special:Export/BoostC from the Fourm]]


|-valign="top"
|[[BoostC Forum Extracts 2007]]
|
|[[Special:Export/BoostC Forum Extracts 2007]]


|-valign="top"
|[[A C Program Header Example]]
|
|[[Special:Export/---]]


|-valign="top"
|[[BoostC Optimizations]]
|
|[[Special:Export/---]]


|-valign="top"
|[[BoostC Floating Point]]
|
|[[Special:Export/BoostC Optimizations]]

|-valign="top"
|[[BoostC Inline C Functions]]
|
|[[Special:Export/---]]


|-valign="top"
|[[BoostC Explaining BoostC.h]]
|
|[[Special:Export/---]]


|-valign="top"
|[[BoostC Wiki Help Needed]]
|
|[[Special:Export/---]]



|}

== Example Code In Projects ==

These examples are imbeded in projects and may be easier or not to extract the fragment you want. On the otherhand these suckers should have been compiled and tested.....

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

|-valign="[[Use C for PIC Programming!]]top"
|Serial Comm. RS232
|[[Serial Communications (RS232) in BoostC]] and the older [[Serial Communications Library -- BoostC and 16F877A]] and [[PIC based Stepper Motor Dancing Analog Clock]]
|Not using BoostC Library ( sorry ). Hardware based.

|-valign="[[Use C for PIC Programming!]]top"
|Simple Command Interperter
|[[PIC based Stepper Motor Dancing Analog Clock]]
|Assumes a PC terminal program or something similar. Single letter commands with numeric parameters. Caps insensitive. Supports backspace.

|-valign="top"
|Stepper Motor Drive
|[[Stepper Motor Tester]]
|Half step, forward reverse, variable speed.

|-valign="top"
|Stepper Motor Drive
|[[Stepper Motor Demonstration and Tester]]
|Half step, forward reverse, variable speed. For PIC and Arduino


|}

=== Export ===

[[Special:Export/Basic Circuits and Circuit Building Blocks]]

[[Special:Export/Oscilloscope]]

[[Special:Export/Techniques ‎]]

[[Special:Export/]]

[[Special:Export/]]

[[Special:Export/]]

[[Special:Export/]]

[[Special:Export/]]

[[Special:Export/BitWacker PIC and Other Microcontroller to Java Communications]]
[[Special:Export/BitWacker PIC and Other Microcontroller to Java Communications]]

=== PIC Related ===

*[[Index of sample code pages]]
*[[A Note on My BoostC Projects and Libraries]]
*[[Using I2C Memory]]
*[[The C Preprocessor and #Define]]
*[[Kit Suppliers]]
*[[Microcontroller User Interfaces]]

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

|-valign="top"
|[[A Really Basic Guide to the PIC Microprocessor and BoostC]]
|
|[[Special:Export/A Really Basic Guide to the PIC Microprocessor and BoostC]]

|-valign="top"
|[[PIC Programmers, In Circuit Programming and BootLoaders]]
|
|[[Special:Export/PIC Programmers, In Circuit Programming and BootLoaders]]

|-valign="top"
|[[A Note on My BoostC Projects and Libraries]]
|
|[[Special:Export/A Really Basic Guide to the PIC Microprocessor and BoostC]]

|-valign="top"
|[[BitWacker PIC USB Development Board]]
|
|[[Special:Export/BitWacker PIC USB Development Board]]

|-valign="top"
|[[BitWacker Java Communications]]
|
|[[Special:Export/BitWacker Java Communications]]

|-valign="top"
|[[BitWacker PIC and Other Microcontroller to Java Communications]]
|
|[[Special:Export/BitWacker PIC and Other Microcontroller to Java Communications]]

|-valign="top"
|[[BitWacker Command GUI]]
|
|[[Special:Export/BitWacker Command GUI]]

|-valign="top"
|[[EL Wire]]
|
|[[Special:Export/EL Wire]]

|-valign="top"
|[[Experimenting with IR Remotes using a PIC running BoostC Project]]
|in process
|[[Special:Export/Experimenting with IR Remotes using a PIC running BoostC Project]]

|-valign="top"
|[[Experimenting with Stepper Motors as Rotary Encoders using a PIC running BoostC Project]]
|not linked in yet in process
|[[Special:Export/Experimenting with Stepper Motors as Rotary Encoders using a PIC running BoostC Project]]

|-valign="top"
|[[Graphical Data Logger]]
|
|[[Special:Export/Graphical Data Logger]]

|-valign="top"
|[[Making Your Own Microcontroller Serial Communications Application]]
|
|[[Special:Export/Making Your Own Microcontroller Serial Communications Application]]

|-valign="top"
|[[MC_RS232_Comm]]
|
|[[Special:Export/MC_RS232_Comm]]

|-valign="top"
|[[Microcontroller Serial Communications Articles]]
|
|[[Special:Export/Microcontroller Serial Communications Articles]]

|-valign="top"
|[[PIC based Stepper Motor Dancing Analog Clock]]
|
|[[Special:Export/PIC based Stepper Motor Dancing Analog Clock]]

|-valign="top"
|[[PIC Links]]
|
|[[Special:Export/PIC Links]]

|-valign="top"
|[[PointLess LED Array]]
|
|[[Special:Export/PointLess LED Array]]

|-valign="top"
|[[RS232/USB Probe]]
|
|[[Special:Export/RS232/USB Probe]]

|-valign="top"
|[[Russ_Hensel's EL Wire Project]]
|
|[[russ_hensel]]

|-valign="top"
|[[Smart Battery Charger with Graphical Data Logger]]
|
|

|-valign="top"
|[[Semiconductor Analyzer Review]]
|
|Semiconductor Analyzer Review from M Cubed Electronix, Inc.

|-valign="top"
|[[Stepper Motor Tester]]
|
|[[Special:Export/Stepper Motor Tester]]

|-valign="top"
|[[DraftDocSerialComm]]
|
|[[Special:Export/---]]

|-valign="top"
|[[Serial Communications Library -- BoostC and 16F877A]]
|
|[[Special:Export/Serial Communications Library -- BoostC and 16F877A]]

|-valign="top"
|[[USB Bit Whacker]]
|
|[[Special:Export/USB Bit Whacker]]

|-valign="top"
|[[Use C for PIC Programming!]]
|Use C for PIC Programming!
|[[Special:Export/Use C for PIC Programming!]]

|-valign="top"
|[[A a Tutorial on PIC interrupts using BoostC including Example Programs]]
|
|[[Special:Export/A Tutorial on PIC interrupts using BoostC including Example Programs]]

|-valign="top"
|[[PIC based Power Use Timer]]
|
|[[Special:Export/PIC based Power Use Timer]]


|}

== Not PIC ==

Some pages I have done quite a bit of work on.

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

|-valign="top"
|[[Arduino Links]]
|
|[[Special:Export/Arduino Links]]

|-valign="top"
|[[Tips on Using Open Circuits]]
|
|[[Special:Export/Tips on Using Open Circuits]]

|-valign="top"
|[[AVR Links]]
|
|[[Special:Export/AVR Links]]


|-valign="top"
|[[Blank Table]]
|
|[[Special:Export/BitWacker PIC and Other Microcontroller to Java Communications]]

|-valign="top"
|[[BitWacker Command GUI]]
|
|[[Special:Export/BitWacker Command GUI]]

|-valign="top"
|[[Bargains]]
|
|[[Special:Export/Bargains]]

|-valign="top"
|[[Basic Circuits and Circuit Building Blocks]]
|
|[[Special:Export/Eagle Links]]

|-valign="top"
|[[Chemical Etchants]]
|
|

|-valign="top"
|[[Eagle Links]]
|
|[[Special:Export/Eagle Links]]

|-valign="top"
|[[EL Wire]]
|
|[[Special:Export/EL Wire]]

|-valign="top"
|[[Graphical Data Logger]]
|
|[[Special:Export/Graphical Data Logger]]

|-valign="top"
|[[hardware tool]]s
|
|[[Special:Export/hardware tool]]

|-valign="top"
|[[Making Your Own Microcontroller Serial Communications Application]]
|
|[[Special:Export/Making Your Own Microcontroller Serial Communications Application]]

|-valign="top"
|[[MC_RS232_Comm]]
|
|[[Special:Export/MC_RS232_Comm]]

|-valign="top"
|[[Microcontrollers]]
|
|[[Special:Export/Microcontrollers]]

|-valign="top"
|[[Meta Open Source]]
|
|[[Special:Export/Meta Open Source]]

|-valign="top"
|[[How I Do Eagle]]
|
|[[Special:Export/How I Do Eagle]]

|-valign="top"
|[[Microcontroller Serial Communications Articles]]
|
|[[Special:Export/Microcontroller Serial Communications Articles]]


|-valign="top"
|[[PC Serial Communications Programs]]
|
|[[Special:Export/PC Serial Communications Programs]]

|-valign="top"
|[[Obscure Eagle]]
|
|[[Special:Export/---]]

|-valign="top"
|[[Other Projects]]
|
|[[Special:Export/Other Projects]]

|-valign="top"
|[[OpAmp Links]]
|
|[[Special:Export/OpAmp Links]]

|-valign="top"
|[[Project DYI Whiteboard]]
|
|[[Special:Export/---]]

|-valign="top"
|[[RS232/USB Probe]]
|
|[[Special:Export/RS232/USB Probe]]

|-valign="top"
|[[Russ_Hensel's EL Wire Project]]
|
|[[russ_hensel]]

|-valign="top"
|[[Salvage Parts and Sources]]
|For ideas on different ways to use some parts see [[Salvage Ideas]]. You may also find [[Free From Salvage]] useful.
|[[Special:Export/Salvage Parts and Sources]]

|-valign="top"
|[[Salvage Topics]]
|
|[[Special:Export/---]]

|-valign="top"
|[[Salvage Challenges]]
|Parts that should be Useful if we could Just figure out How
|[[Special:Export/---]]

|-valign="top"
|[[Free From Salvage]]
|
|[[Special:Export/---]]

|-valign="top"
|[[Solderless protoboard]]
|
|[[Special:Export/Solderless protoboard]]

|-valign="top"
|[[Supplier Quick Reference]]
|
|[[Special:Supplier Quick Reference]]

|-valign="top"
|[[Tutorials]]
|
|[[Special:Export/Tutorials]]

|-valign="top"
|[[Toner Transfer]]
|
|[[Special:Export/Toner Transfer]]

|-valign="top"
|[[DraftDocSerialComm]]
|
|[[Special:Export/---]]

|-valign="top"
|[[USB Bit Whacker]]
|
|[[Special:Export/USB Bit Whacker]]


|-valign="top"
|[[Westport High School Page]]
|A page for the Westport High School Robotics Club
|[[Special:Export/---]]


|-valign="top"
|[[Tools and Techniques]]
|
|[[Special:Export/---]]

|-valign="top"
|[[Microcontrollers for Beginners]]
|
|[[Special:Export/---]]

|-valign="top"
|[[New Project]]
|
|[[Special:Export/---]]



|}

[[Printed Circuit Etchants]] no use instead: ???

[[How Should We Deal With Spam]]

=== Image Example ===

[[Image:RS232ProbeMainxx.png | Screen Shot ]]

us double brackes for categories

category:Member Page
category:salvage
category:Test Instrument
category:Serial Communications
category:Microcontroller
category:PIC
category:Test Instrument
category:Test Instrument
[[category:BoostC]]

Python Smart Terminal

2022-08-29T15:59:28Z

Russ hensel: /* My Environment/Your Environment */

= 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. One nice feature is multiple places for user input, each of which is remembed until changed.

* 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 via remote terminal to a raspberry pi.
** 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 as projects of my own.

= 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.

|}

= More on What and 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 3.6 because of fstrings.

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.
There is an informal requirements.txt in the repository that may be helpful.

== 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]]

Python Smart Terminal

2022-08-29T15:57:54Z

Russ hensel: /* What/Why */

= 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. One nice feature is multiple places for user input, each of which is remembed until changed.

* 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 via remote terminal to a raspberry pi.
** 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 as projects of my own.

= 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.

|}

= More on What and 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]]

Python Smart Terminal

2022-08-28T20:16:09Z

Russ hensel: /* 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. One nice feature is multiple places for user input, each of which is remembed until changed.

* 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 via remote terminal to a raspberry pi.
** 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 as projects of my own.

= 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]]

Python Smart Terminal

2022-08-28T20:14:16Z

Russ hensel: /* 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. One nice feature is multiple places for user input, each of which is remembed until changed.

* 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]]

Python Smart Terminal Technical Details

2022-08-28T20:11:13Z

Russ hensel: /* What are the Possible Comm Ports */

This page is for some fairly fine scale detail on how things are implemented in the Smart Terminal, they may be useful as techniques in other applications. See also: [[Russ Python Tips and Techniques]]

= GUI Construction =
This is one of the earlier GUIs that I worked on and the code has been worked over a lot. It still has some early features that I would not write now, I have left them in because they work well enough.
......... more as I get to it......

= Some Thread Details =

There are two threads set up in the application, one meant to communicate from the gui to the helper thread and one the other way around. Queues are supposed to be thread save so we should be ok so far. Thread processing is quite localized in the code so you should be able to check it out pretty easily: search for '''queue_to_helper''' and '''queue_fr_helper'''. Generally what is posted to the queues is a tuple with three parts: (action, function, function_args ). In this tuple action is a string ( like "call"..."stop" ) function is a function reference, and function_args are arguments to the function. Not all parts may be used for each action. You should read the code to see what happens.

One example that exists at, this time of writing, is how the helper thread outputs to the gui thread since it is not supposed to interact with direct calls. What happens is that the helper thread posts a tuple: ( "info", None, ( "print me", ) ). "info" indicates that the helper thread wants to post an "info message" to the gui. None indicates that there is no explicit function call involved ( it is implied in the action "info" and ("print me") is the data that is to be displayed.

This is all I will document for now because smaller detail may change. Since the code is localized you should be able to figure out more details yourself, if no email me.

= Finding the Arduino - Comm Port Details =

In the parameter file there is a setting for the comm port, this is typical of all communications programs. Other parameters hold other comm port values. Again typical. There are however, some less typical additions.

== Comm Port Validation ==

In the "manual" mode you would press the Open button on the GUI and hopefully the port will open ( it will if the port exists and is available for opening ). Then typically you will send something to the micro controller and look for a reasonable response. This is fine. You can also automate the process by using the method find_arduino( ) in HelperThread instance. Here is what it does.

* Works through your list of comm ports as specified in '''parameters.port'''.
* For each port try to open it with the other comm parameters in '''parameters.py'''
* If a port opens waits a bit ( for the arduino to reset ... time specified by: parameters.not_done_yet ...... now hardcoded
* The second level of validation is that the port can send and receive to the desired arduino, this is checked by sending a text string ( as specified in parameters.get_arduino_version) and looking for a response.
* The third level is to look at the received string. If it contains the correct substring ( as specified in parameters.arduino_version) then the port is valid.
* Stops looking at the port list if a comm port passes this validation test.

For example the terminal may send "v<cr>", recieve "GreenHouse Monitor v3 2017 01 24.01<cr>", and look for "GreenHouse" in the received string. This would validate the port.

So what does the terminal send and what does it look for -- see the parameter file; you should find something like this:

<pre>
# next used in a port probe routine to help identify the port with an arduino
# the arduino is supposed to respond to a version request with a string
# containing this, they are part of the name of an Arduino application

self.get_arduino_version = "v" # send to the port to get a response from the arduino.

self.arduino_version = "GreenHouse" # the received response from the arduino should contain this as a substring if the comm port is valid.
</pre>

Note that the find_arduino() method does not try different baud rates, you need to get that one right yourself.

== What are the Possible Comm Ports ==

The SmartTerminal uses two methods for this. One is just back to the parameter file:

<pre>
# used to probe around for ports
if self.os_win:
self.port_list = [ "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8", "COM9", "COM10",
"COM11", "COM12", "COM13", "COM14", "COM15", "COM16", "COM17", "COM18", "COM19", "COM20",
]

else:
self.port_list = [ "/dev/ttyUSB0", "/dev/ttyUSB1", "/dev/ttyUSB2",
"/dev/ttyACM0", "/dev/ttyACM1", "/dev/ttyACM2",

</pre>

The above uses the automatic detection of the operating system. You could of course skip that part of the implementation.

The second method. There is a Python function for detecting ports. It is documented as not always being right. Here it is:

<pre>
list(serial.tools.list_ports.comports())
</pre>

So finally when making a list of ports to probe I make a list ( in the order the ports will be tested ):

* Start with port in the parameter file.
* Add the ports reported by python ( no duplicates ).
* Add the ports in the parameter port list ( no duplicates ).

If no ports are actually present you can test 20 ports in seconds. Sending and receiving strings takes longer. Note that all of this is done using the baud rate and other parameters in the parameter file, we do not probe using variations on them. Actually, in most cases, the baud rate.... are part of the identification of the arduino.

So with this list we loop through it trying to validate each port.



[[Category:SmartTerminal]] [[Category:Python]]

Category:SmartTerminal

2022-08-28T20:10:32Z

Russ hensel:

Pages that relate to '''[[Python Smart Terminal]]''' and its related Arduino apps. The main, starting page is '''[[Python Smart Terminal]]'''

[[Category:Python]] [[Category:Arduino/RaspberryPi]] [[Category:Serial Communications‏‎]]

Python Smart Terminal

2022-08-28T19:57:18Z

Russ hensel: /* 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 carrige 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 remembed untill changed.
( note: I do not have a graphing module for this case though
one could be added. )

* Base Case Plus
Typically the microcontroller 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 intened for projects that juse "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 suport -- either Desktop GUI or ssh terminal

I have exaple 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]]

Python Smart Terminal

2022-08-28T15:24:46Z

Russ hensel:

= 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 carrige 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 remembed untill changed.
( note: I do not have a graphing module for this case though
one could be added. )

* Base Case Plus
Typically the microcontroller 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 intened for projects that juse "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 suport -- either Desktop GUI or ssh terminal

I have exaple 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]]

SmartTerminal Features

2022-08-25T16:34:53Z

Russ hensel: /* Send Suffix */

= 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 ).

= GUI =
uses Tkinter

== 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 =
It is assumed that messages end with a special character, this character may be set in the parameter file.

= 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]]

SmartTerminal Features

2022-08-25T16:33:57Z

Russ hensel: /* Modify GUI from Parameters */

= 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 ).

= GUI =
uses Tkinter

== 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]]

SmartTerminal Features

2022-08-25T16:33:34Z

Russ hensel: /* Appearance */

= 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 ).

= GUI =
uses Tkinter

= 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]]

SmartTerminal Features

2022-08-25T16:32:54Z

Russ hensel: /* Modify GUI from Parameters */

= 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]]

GreenHouse Monitor Program

2022-08-25T16:30:11Z

Russ hensel: /* What */

= What =
This project uses the Python Smart Terminal program to communicate with an arduino and monitor, record, and graph conditions in the green house. 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]]''' ).

This is really 2 programs: 1) an arduino program intended to monitor the environment in a green house and 2) its PC side ( often for a Raspberry Pi ) written in Python. The Arduino has a simple command driven interface. It is designed to run with [[Python Smart Terminal]] and an extension to it which is added when the terminal is set to the mode = GreenHouse. Documentation on the construction of a Smart Terminal extension to support the green house monitor and save its data to a csv file are also part of this project and the documentation here. Another adaptation for the SmartTerminal is described in [[SmartTerminal for Controlino]]

Note that since this was written the SmartTerminal has been updated and its operation and parameter set up have been upgraded and in some ways simplified. I will be updating this documentation ( hopefully soon Feb 2018 -- did not hapen ). Another update the python side of the Green House Monitor used to be ext_process_gh.py but has now been absorbed into ( and is a mode ) in ext_process_env_monitor.py. This documentation will perhaps be revised at some point to reflect that change.

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.

= Source Code =
Still working on where I will keep the source. It is open source, email me in the meantime: [[User:Russ_hensel]] The code is pretty straight forward, the heavy lifting is all left to the [[Python Smart Terminal]]. There is nothing very fancy or special about the arduino program, get the source, read it. Email me if there are issuses. Also look at this wiki's category SmartTerminal (link at bottom of this page).

= Arduino GreenHouse Commands =
Commands are single letter strings, in some cases followed by numbers. All end with a <cr>. All envoke responses all of which also end with <cr>

{| class="wikitable"
|-valign="top"
|Command Purpose
|Send
|Example Response
|Comment

|-valign="top"
|Get version of arduino software
|v
|GreenHouse Monitor v3 2017 01 24.01
|Of course exact string changes with version. This string is used by the SmartTerminal to verify the arduino connection.


|-valign="top"
|Aquire the data.
|a
|ok
|Data is buffered in the arduino


|-valign="top"
|Get the Temperature
|t
|33.0 60.0
|In this version there are 2 sensors, data separated by spaces.

|-valign="top"
|Get the Humidity
|h
|43.0 55.0
|In this version there are 2 sensors.
|}

= Smart Terminal Extension =

In general when you want to make an extension you should find one that is similar to the one you want, copy it, then tweak the code. This description will not quite do that because the extension ( and arduino program ) are already written.

== Copy Some Code ==

All the extensions that are written are in modules with names of the form xxx_processing. Look at the file headers .... and pick one to copy. If you run this copy it should start up without too much trouble. But how do you get the code to execute? Say your module ( file ) is my_processing.py and the class name ( which you will probably change when you make the copy ) is MyProcessing. You do not run your module, you run SmartTerminal. The trick is to first make some changes to the parameter file. What you need is to make sure that at the end of creating a Parameter class the final setting reflect something like:

<pre>
self.ext_processing_module = "my_processing"
self.ext_processing_class = "MYProcessing"
</pre>

are the setting that are made last. More documentation the on the parameters is found in [[Smart Terminal Parameter Examples]].

== SmartTerminal Code Explanation ==

I will explain the green house code, use this explanation to build your own code. This code is gh_csv_processing.py The really fine details are in the code comments, this documentation is at a higher level. To activate the code have your parameter file ( this is automatic in the intermediate file by setting mode = "GreenHouseCSV" )

<pre>
self.ext_processing_module = "gh_csv_processing"
self.ext_processing_class = "GHCSVProcessing"
</pre>

=== What Is the Point ===

It is always nice to know when code is being explained what the code is supposed to do. So here it is.

The idea is that the arduino will be set up in an environment like a green house and its job is to measure and report on variables like temperature and humidity. The job of the smart terminal is to control that data acquisition and log it to a csv file.

=== Details ===

*The smart terminal need not be used in its smart mode, all the dumb terminal stuff still works and let you issue commands to the arduino and inspect the results.
*In addition the smart function that are added include:

** Automatic probe of comm ports to find the arduino.
** Opening the comm port and logging the data to a csv file.

Lets get an overview of the methods ( for the detail read the code, and to actually understand all this you will eventually need to '''read the code''' ):

* __init__() builds the class, gathers references to other objects in the application, and finally defines some instance variables for data processing later
* add_gui() builds gui components and returns a reference to the GUI components, for Tkinter this is a frame, for Kivy it will probably be a layout.

Now a complexity of the application is that it is running in 2 different threads. When the application starts up it has a single thread that after a bit of time creates the gui and runs its main method. I call that the GUI thread. The GUI thread starts another thread, ( the class SmartTerminalHelper ) which has its own methods and attributes. In a multi threaded application you have to be careful what calls what. Calls between the threads are particularly tricky once both are running. For the more difficult issues of this type communication between the threads is managed by pushing data into queues which are thread safe and allow the threads to communicate safely with each other. All this is in the code. The GHCSVProcessing class is a bit complicated since parts of it run in one thread, parts in the other. How do you tell what is what. There are two ways one is to reason it out, one is to read the comments, this discussion should help. Init is called from the GUI thread which is the one that is "in charge" of the application. It also calls __add_gui__ which since it adds to the GUI will create objects that are also executed in the GUI thread. All the functions in the class are commented so you know what class they should be called from ( run in )

==== Additional Functions that Run in the GIU ====
Both of these are call back function called from the GUI we have created in add_gui, so they run in the GUI thread. However both want to call functions in the helper thread. There code is very simple, each one pushes its request into a queue which is processed by the helper thread when it get to it.

*cb_find_and_monitor_arduino()
*cb_end_helper( )

==== Rest of Functions Run in Helper ====

*find_and_monitor_arduino( ) This is the most important function in this class. Typically it is an infinite loop unless it encounters an unrecoverable error, or the GUI asks it to stop. It has the following functions:

** find work through the comm ports to find ones that ope.
** validate the port
** ask the arduino for data and save the data to a csv file
** keep displaying the received data in the GUI
** watch out to see if the GUI wants to interrupt ( and stop ) this routine.

Supporting functions for the above are:

*set_time() saves the time of data acquisition for saving to the csv file
*process_temp_line() takes a string ( one line ) of temperature and parses out the numbers on it ( as floats ) for saving to the csv file
*process_humid_line() like process_temp_line() but for humidity

== Deeper Dive into find_and_monitor_arduino( ) ==

The functions in the GUI thread, including this one, are responsible for the receive function of the terminal when they are active. They also need to see if the GUI needs to interrupt them. To do this they will often poll the com port and check the queue_to_helper. Now most of the time they are more or less sleeping waiting for the next time to acquire data. They should not use time.sleep() as that will stop their polling. Instead they call: check_queue_for( a_time ) in the HelperThread instance which acts like sleep() + the required polling. All the functions called here should call this method often to keep the receive and interrupt alive. ( there is a method for the helper to pass the receive processing back to the GUI thread, see the code for the details ) Other than this pooling the coding here is pretty straight forward.

* to find the arduino there is a method in the HelperThread instance that takes care of it, a couple of parameters control the details.
* set_time() is called to record the time of data acquisition
* the string requesting data acquisition is sent to the arduino
* the string requesting the temperature data is sent to the arduino, the received string is parsed by process_temp_line()
* the same process is repeated for the humidity.
* a function is called in the HelperThread instance to save the data to the csv file ( controlled in part by the parameters ).
* the function sleeps until it is time to repeat the cycle.

== Interrupt and Error Management in the Helper Thread ==

This is proving to be one of the more difficult aspects of the program, an I am still working on it. I have however decided upon an approach which seems promising. The plan, and what is implemented so far is to use various exceptions ( or exceptions with instance variables ) to unwind the code back to some recovery point.

The code for interrupting the helper thread is currently working as intended. When the queue_to_helper is detected as being non empty during a helper function ( except the main polling one ) an exception is thrown which is caught back in HelperThread.polling. ( interrupt is not used in the sense of suspending then returning to an activity, the function that is interrupted is over )

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

Smart Terminal GUI

2022-08-25T16:26:56Z

Russ hensel: /* Overview */

= Overview =
The GUI or graphical user interface is the key to using the SmartTerminal ( 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]]

Chemical Etchants

2022-02-14T21:59:35Z

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

removed spam, working to restore page

Command Assistant Help File

2022-01-31T15:59:47Z

Russ hensel: /* Use */

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 =

*Issue Linux commands including starting GUI applications.
*Runs as a GUI application.
*Highly configurable.
*Built to be extensible

= Use =
Note: the application is still a moving target, details are in flux.

The application is designed to help you find and issue Linux commands to get some computer task done.
( if you also open the app, or the page for the Graphical User Interface (GUI) the following will be easier to follow )

The general workflow is:

* In the key word field enter one or more key words for your task like "list files" an hit enter or press select. "List files" will select the CommandLs set of commands.

* To activate a selected command click on it ( the first command will be automatically selected, particularly useful when only one command is selected). This will build a GUI area, mid window, just to run this set of commands.

* In the most general case the command to be issued will consist of 3 parts:
** A base command ( like "ls" ).
** A field for options to the command ( like ..... )
** A filed for further options to the command ( like a file prototype "*.py" )
* When you have filled out the 3 parts you can:
** Press <Run It> Which will open a terminal, run the command, and leave the terminal open so you can choose to continue to use it ( or not ).
** Press <Preview> Previews the command in the "message area" at the bottom of the window.
** Press <Script> Writes the command to a shell script an opens in an editor
** Press <Web Help> Open a Linux Cheat Sheet, possibly positioned to the relevant place on the page.
** Press <Txt Help> Get help from a text file on some details of the command set.

Note that:
* Each of the three part of the command can end with a command ( starting with a # ). These comments are generally stripped when the command is run.
* When a command is build additional material may be added to maintain a default directory or keep the terminal open.

= Download and Install =

There is really no install program. Currently the application is intended for those who have a fair familitry familiarity with Python coding and can just insert the downloaded code into their development environment and run it. You should also have a general idea of how to use the Linux Command Line. Code at *'''[https://gitlab.com/russhensel/cmd_assist Russell Hensel / cmd_assist · GitLab ]'''. 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.

Much of the application is configurable through the parameter.py file, but the default should give you an application that runs,

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]]

Command Assistant Help File

2022-01-31T15:57:24Z

Russ hensel: /* Use */

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 =

*Issue Linux commands including starting GUI applications.
*Runs as a GUI application.
*Highly configurable.
*Built to be extensible

= Use =
Note: the application is still a moving target, details are in flux.

The application is designed to help you find and issue Linux commands to get some computer task done.
( if you also open the app, or the page for the Graphical User Interface (GUI) the following will be easier to follow )

The general workflow is:

* In the key word field enter one or more key words for your task like "list files" an hit enter or press select. "List files" will select the CommandLs set of commands.

* To activate a selected command click on it ( the first command will be automatically selected, particularly useful when only one command is selected). This will build a GUI area, mid window, just to run this set of commands.

* In the most general case the command to be issued will consist of 3 parts:
** A base command ( like "ls" ).
** A field for options to the command ( like ..... )
** A filed for further options to the command ( like a file prototype "*.py" )
* When you have filled out the 3 parts you can:
** Press <Run It> Which will open a terminal, run the command, and leave the terminal open so you can choose to continue to use it ( or not ).
** Press <Preview> Previews the command in the "message area" at the bottom of the window.
** Press <Script> Writes the command to a shell script an opens in an editor
** Press <Web Help> Open a Linux Cheat Sheet, possibly positioned to the relevant place on the page.
** Press <Txt Help> Get help from a text file on some details of the command set.

= Download and Install =

There is really no install program. Currently the application is intended for those who have a fair familitry familiarity with Python coding and can just insert the downloaded code into their development environment and run it. You should also have a general idea of how to use the Linux Command Line. Code at *'''[https://gitlab.com/russhensel/cmd_assist Russell Hensel / cmd_assist · GitLab ]'''. 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.

Much of the application is configurable through the parameter.py file, but the default should give you an application that runs,

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]]