208 IX: IX_menu_i and Improvised Programs (208.html)

Keywords

IX or (IX by DC) or "|><"

Introduction

	IX_menu_i
	---------
	1 test1_i:
	2 test2_i:
	3 exit_i:
	

An example using IX_menu_i.py

IX_init_i
test1_i
test2_i
IX_exit_i
IX_list_i
IX_menu_i

$python3 IX_menu_i.py
This program is part of the IX group of programs
Source: https://www.ePhotoCaption.com/a/208/208.html
hit CR to NOT select the menu item

IX_menu_i
---------
1 test1_i:
2 test2_i:
3 exit_i:

IX_menu_i
---------
1 test1_i:
2 test2_i:
3 exit_i:Y
Do you really want to exit?Y
Normal Exit
Exit Code 1

IX_menu_i
---------
1 test1_i:Y
This runs test1_i
2 test2_i:
3 exit_i:

What Python programming is needed?

moduleList=[ test1_i , test2_i, IX_exit_i ]

Example Use of IX_menu_i.py

requires("IX_init_i()")
requires("test1_i(v)")
requires("test2_i(v)")
requires("IX_exit_i(v)")
moduleList=[ test1_i , test2_i, IX_exit_i ]
requires("IX_menu_i()")
#/main_i.py   #then convert to main.py before using python3 to run it.

Future Functionality of IX_menu_i

• Because some devices do not have a keyboard, it is impossible to type the "Enter" key or any other key on the keyboard. This is true of the bare Wio Terminal when not accompanied by any peripherals. To permit a minimum of functionality in these cases, a future version of the IX_menu_i program will wait for keyboard input for 5 to 30 seconds. If a null answer (just the Enter key) is received before 5 seconds, then it will presume that the user wishes that the program act as if the user had hit the Enter key. If it takes 30 seconds or if any character is received, the answer will be presumed to be "Y". Therefore the first submenu item will be run to completion. Control will then return to the menu and the next menu item will wait for keyboard input. Using the same logic, this next submenu item will be run to completion or not run etc. In this manner each of the submenu tasks can be run in turn. If the last submenu item receives a "Y", it will ask "Do you really wish to exit". Eventually it should receive a "Y" (or its equivalent) and then exit. To prematurely stop this cycle, the user can simply turn the power off.
  
  
• When using the Wio Terminal, it is possible to "talk" to it using the 3 buttons on top or by using the tiny joystick in the bottom right corner. Simply depressing the "joystick" button can be interpreted as the equivalent of an Enter key. Most other small devices have absolutely no means of communicating with them unless some sort of peripheral is attached. In these cases, the author suggests that a pair of tiny photocells be carried by the user when using his Raspberry Pi computers. The double photocells can function as an input peripheral as described in the paragraph after the photos (below).
  
  double photocells (CD2 dongle©)
  
  

  (To enlarge .....Click it) CD2: two photocells in series between pins 38 & 40 on a Pi400

  (To enlarge .....Click it) CD2 dongle©: two photocells soldered in series to a 2-pin female GPIO connector

  Because they have no active components, the two photocells in series are quite safe to plug into the GPIO on a Raspberry Pi. Furthermore because they are powered by a GPIO data output pin, their current draw should not adversely affect the Raspberry Pi. The double photocells are more useful on other Raspberry Pi board computers than on a Pi400 (that always has a keyboard). However, a Pi400 can be used to test this "CD2 dongle©". The author and ICH180RR retain copyright to the name "CD2 dongle©".
  
  When using a Raspberry Pi, if 2 photocells are connected in series to 2 specific adjacent GPIO pins: physical pin 40 (as GPIO 21 input) and physical pin 38 (as GPIO 20 output), the RPi can detect whether or not the photocells are covered by your finger. Physical pin 40 is always located diagonally across from physical Pin 1 (which is marked by a small square). [Take care identifying the physical pins, one of the early GPIO diagrams labelled 2 different pins as pin 37.] First, connect the photocells in series between the 2 specific pins previously mentioned. Polarity is unimportant when connecting photocells. Then the Python program must connect an internal pull-down resistor between GPIO 21 and ground. The Python program should set GPIO 20 high (making it approximately 3v3). Then the Python program should read the input on GPIO 21. When the user covers both photocells (even with a finger), the program should be able to detect it on GPIO 21. To facilitate their connection, the photocells can be soldered in series to two female Dupont connectors which can be easily slid onto the 2 GPIO male connectors on the Raspberry Pi GPIO. The double photocells (right above) are even better, having been soldered onto a 2-pin female GPIO connector. The Python program named Test_readCD2.py can be found in Source 12. It uses the function named readCD2(). Prior to using this function, the GPIO pins must be initialized using the function initCD2(). These functions must be told the number of the higher physical RPi input pin (not the GPIO pin). Often a single CD photocell might work, but sometimes it takes 2 photocells (recommended) in series to be sure.
  
  
• The double photo-cell mentioned above would be especially useful when booting up a tiny Raspberry Pi board (or most other computers that don't have any peripherals attached). They should finish the boot up process by starting a program called main.py. To indicate that it is running, this main.py program will flash an onboard led to "display" the value of the first 3 digits of pi which is of course, 3.14. This flash pattern is 3 flashes on, 1 long flash for the dot, then 1 flash then 4 flashes. Most Raspberry Pi users will recognise this as meaning 'pi'. This pattern also demonstrates to the user the nature (syntax) of the flash pattern. The author has NOT yet written the IX_boot.py program mentioned herein.
  
  A user can control a headless Raspberry Pi using the Remote Desktop Connection (RDC) in Microsoft Windows on a laptop. However, to do this, the user must know the exact IP (IPv4) address of the Raspberry Pi. The author plans to use a double photocell to communicate with a recently booted headless Raspberry Pi. The menu that boots up will start up a special main.py program. This program will monitor the double photocell connected between physical pins 38 and 40 for communication from the user. It will watch to see if the double photocell gets covered. While it is covered, the little main program will start flashing the onboard LED once per second. The user will count the number of LED flashes and will uncover the double photocell after 1, 2, 3 or 4 flashes. The number of flashes selected will have the following meaning:
  

  	IX_boot up: LED flashes
  	----------------------
  	1 a request to "see" the IPv4 address of the Raspberry Pi
  	2 a reply of "No" ("No" is 2 letters long)
  	3 a reply of "Yes" ("Yes" is 3 letters long)
  	4 a request to start up a specific predefined program (eg the pir2 control system).
  	

  The replies of "No" and "Yes" will serve in the future when the "IX_boot" program becomes more complex. Many other existing boot-up procedures simply flash the full lengthy IP address. The full IPv4 address contains as many as 12 digits separated by 3 dots. However, the leftmost 3 numbers are usually the same for most devices on a single wifi router. Therefore, often, only the rightmost number(s) need to be known to identify the IP address of the specific Raspberry Pi being booted up. The IX_boot up sequence will therefore provide the IPv4 address starting from the right, not the left. To convey an IPv4 address of 0.0.11.28, the IX_boot up main program will flash the on-board led 8 times, then 2 times, then one long flash (for the dot) then once, then once again, after which it will pause. Then it will resend the series of flashes that signify the 3 digits of pi. This means that it is again waiting for input from the user. [After all, the usual name of the Pi user is "Pi"! LOL]. If the user asks for the IP address a second time, IX_boot will send the full IP address via the on-board flashing led in the normal order from left to right. To send a zero, the onboard led will be flashed 10 times. . . Ugh!
  
  The author has developed a Raspberry Pi program (named pir2) to monitor and control the environment in an area of a building. It runs from the Terminal command line (CLI) and can be started by the IX_boot program once the Raspberry Pi has been booted up. When starting up, the pir2 system asks a number of questions that can be answered by a "Yes" or "No". Often, the pir2 system will be running in a situation devoid of both keyboard and mouse. The existing pir2 system can make use of a hdmi monitor and/or BlueTooth audio speaker. The IX_boot program with the double photocell seems to be a great complement to the pir2. Perhaps the IX_menu_i system will also become part of the pir2 system along with the IX_boot program. Another program that must be occasionally initiated by the user upon boot up is a program that will upload log files from the pir2 system to the http://www.MehInCharge.com (MIC) database in Source 13. Note that the MIC database system was also written by this same author.
  
  
• Most Raspberry Pi users have either headphones to plug into an audio jack, or they have a BlueTooth speaker or a monitor. Most Raspberry Pi computers can communicate verbally using either headphones or a BlueTooth speaker. When this is possible, an improved IX_boot program should make use of them to audibly communicate to the user. If a monitor or TV set is connected to the Raspberry Pi, the double photocell can be used to reply to the commands displayed by the IX_boot program. An On-Board keyboard on a GUI screen is sometimes useful when no keyboard is available. But this situation is a CLI interface, not a GUI user interface. Some users have a wireless keyboard that can be connected by wifi. The author has one that also incorporates a mouse. Operating a Raspberry Pi without a physical mouse is always very problematic. Fortunately wireless mice exist, but they still need a dongle plugged into a USB port on the Raspberry Pi. The Wio Terminal addresses this need for a mouse by providing a tiny joystick. No such thing is yet available on the bare Raspberry Pi. The double photocell only addresses (albeit very poorly) the absence of a keyboard.

	#include 
	void setup() {
	  pinMode(WIO_LIGHT, INPUT);
	  Serial.begin(115200);
	
	}
	
	void loop() {
	   int light = analogRead(WIO_LIGHT);
	   Serial.print("Light value: ");
	   Serial.println(light);
	   delay(200);
	}
	

WioClock

(To enlarge .....Click it) The tiny Wio Terminal

(To enlarge .....Click it) WioTerminal with WioClock.py v2o11

The IX Family of Python Software For the Raspberry Pi

A. the IX macro preprocessor (Source 04).
B. "requires" (operates along with the Python import) modules See Source 16.
   ("requests" is an alternative verb to "requires") See Source 06.
C. optional embedded MD5 hash totals in IX software modules (Source 05).
D. improvised program menu system (the IX_menu_i system in this article).
E. programs stored in Packages e.g. IX_textpack_pkg.py (Source 15).

IX_textpack.py      packs a list of files into a package
IX_textunpack.py    unpacks ALL the files from an existing package
IX_textselect.py    selects (unpacks) a SINGLE file from an existing package
IX_textpack.txt     explains HOW to use IX_textpackPkg_py.txt
IX_textnames.py     lists the filenamess in a package (deprecated . . . use  n.py]
IX_textadd.py       adds a file to the package (deprecated. . . use IX_textpack.py with ">>" instead)
n.py                lists the various contents of the package

Complex Vectored Readings: RUPasc

	eg "(0x10000.000+1621625066.713j),"
	

Sources

Video Sources

www

Pi Pico - Review etc (18m 31s)

Web Sources

www

IX_menu_i_py.txt

www

RUPasc: A Format for ADC Reading Samples

www

ReadingsVectorTimeInterval.txt

www

IT: IX/IXc - A General Purpose Macro Processor (183.html)

www

IT: Hash Totals using md5_IX (206.html)

www

IT: prepIX (196.html)

www

Wio: Readying A Wio Terminal for IX systems (198.html)

www

Wio: WioClock (189.html)

www

Getting Started with Light Sensor

www

Using FreeRTOS with the Raspberry Pi Pico

www

Test_isTrueIfDark_py.txt

www

Test_readCD2_py.txt

www

A&C: MIC-Meh In Charge .com (128.html)

www

How to use FreeRTOS . . .

www

IX: Creating Python Packages of Functions (174.html)

www

IX Family of Software: requires( function. . .) (209.html)