Fix ADC scaling to voltages, GUI: chart autoscale, labels, units

rpi-scripts/examples/read_analog_inputs.py

@@ -9,14 +9,15 @@ import time
 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
 from interface_board_libs.adc_mcp3208 import MCP3208 # custom driver for ADC-IC
 from interface_board_pins import ( 
-    ADC_CHANNELS,
+    # mapping of ADC channels to terminals + max value:
-
+    ADC_TERMINALS,
+    # mapping of ADC channels to terminals:
     ADC_CHANNEL_T0__0_TO_3V3,
     ADC_CHANNEL_T1__0_TO_3V3,
     ADC_CHANNEL_T2__0_TO_5V,
     ADC_CHANNEL_T3__0_TO_5V,
     ADC_CHANNEL_T4__0_TO_12V,
-    ADC_CHANNEL_T5__0_TO_12V,
+    ADC_CHANNEL_T5__0_TO_24V,
     ADC_CHANNEL_T6__0_TO_20MA,
     ADC_CHANNEL_T7__0_TO_20MA,
 ) # mapping of ADC channels to terminals
@@ -36,13 +37,15 @@ def adc2value(adc_value, max_value):
 
 
 while True:
-        print ("")
+        print("-" * 40)  
 
         # Read all available channels in a loop according to terminal order / map
         values = []
-        for terminal, adc_channel in ADC_CHANNELS.items():
+        for terminal, config in ADC_TERMINALS.items():
+            adc_channel = config["adc_channel"]
+            max_value = config["max_value"]
             value = adc.read(adc_channel)
-            print(f"T{terminal}: ADC={value:04d}  => U_ADC = {adc2value(value, 3.3):5.3f}V")
+            print(f"T{terminal}: ADC={value:04d}  => U_ADC = {adc2value(value, max_value):5.3f}V")
         
 
         # Read channels one by one using defined constants (more intuitive)
@@ -62,8 +65,8 @@ while True:
         value = adc.read(ADC_CHANNEL_T4__0_TO_12V)  
         print(f"Terminal 4 (0 to 12V):  ADC={value:04d} => Terminal={adc2value(value, 12):05.2f}V")  
 
-        value = adc.read(ADC_CHANNEL_T5__0_TO_12V)  
+        value = adc.read(ADC_CHANNEL_T5__0_TO_24V)  
-        print(f"Terminal 5 (0 to 12V):  ADC={value:04d} => Terminal={adc2value(value, 12):05.2f}V")  
+        print(f"Terminal 5 (0 to 24V):  ADC={value:04d} => Terminal={adc2value(value, 24):05.2f}V")  
 
         value = adc.read(ADC_CHANNEL_T6__0_TO_20MA)  
         print(f"Terminal 6 (0 to 20mA): ADC={value:04d} => Terminal={adc2value(value, 20):05.2f}mA")  

rpi-scripts/gui/main.py

@@ -19,10 +19,12 @@ from tab_digital_plot import create_digital_plot_tab
 from tab_digital_plot import set_updating_enabled as tab_digital_plot__set_updating_enabled
 from tab_exit import create_exit_tab
 
+
 # Initialize ADC & Shift Register
 adc = MCP3208()
 shift_reg = ShiftRegister(GPIO_SHIFT_REG_DATA, GPIO_SHIFT_REG_LATCH, GPIO_SHIFT_REG_CLOCK)
 
+
 # GPIO Setup
 GPIO.setmode(GPIO.BCM)
 for pin in GPIO_DIGITAL_INPUTS.values():
@@ -34,16 +36,19 @@ pwm2 = GPIO.PWM(GPIO_PWM2, 1000)
 pwm1.start(0)
 pwm2.start(0)
 
+
 # Tkinter GUI
 root = tk.Tk()
 root.title("Raspberry Pi Interface Board")
 root.attributes('-fullscreen', True)
 root.configure(bg="black")
 
+
 # Tabbed Interface
 notebook = ttk.Notebook(root)
 notebook.pack(expand=True, fill="both")
 
+
 # Track active tab
 def on_tab_change(event):
     active_tab = event.widget.tab(event.widget.index("current"), "text")
@@ -61,16 +66,25 @@ def on_tab_change(event):
             tab_control__set_updating_enabled(True)
             tab_analog_plot__set_updating_enabled(False)
             tab_digital_plot__set_updating_enabled(False)
+        case "EXIT":
+            pass
         case _:
             print(f"unhandled change to tab {active_tab}")
 
 notebook.bind("<<NotebookTabChanged>>", on_tab_change)
 
+
 # Add tabs
 create_control_tab(notebook, adc, shift_reg, pwm1, pwm2)
 create_adc_plot_tab(notebook, adc)
 create_digital_plot_tab(notebook)
 create_exit_tab(notebook, root, pwm1, pwm2)
 
+
 # Run GUI
-root.mainloop()
+try:
+    root.mainloop()
+
+except KeyboardInterrupt:
+    print('Keyboard interrupt -> exiting')
+    exit()

rpi-scripts/gui/tab_adc_plot.py

@@ -1,17 +1,30 @@
+import sys
+import os
 import tkinter as tk
 from tkinter import ttk
 from matplotlib.figure import Figure
 from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
 import time
 
-ADC_PLOT_UPDATE_INTERVAL = 50  # 20 FPS, smooth and efficient
+# Add the parent directory to the module search path
-NOT_ACTIVE_CHECK_INTERVAL = 2000
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
-MAX_HISTORY = 100
+from interface_board_pins import ADC_TERMINALS  # Import pin assignments
 
+
+# CONFIG
+ADC_PLOT_UPDATE_DELAY_MS = 50  # note: delay is additional to time it takes to update the chart
+TAB_NOT_ACTIVE_CHECK_INTERVAL_MS = 2000
+MAX_X_HISTORY_VALUES = 150
+AUTO_SCALE_ENABLED = True
+DEBUG = False
+
+
+# Variables
 updating_enabled = False
 adc_channels = list(range(8))
-data = {ch: [0] * MAX_HISTORY for ch in adc_channels}  # Preallocate lists
+data = {ch: [0] * MAX_X_HISTORY_VALUES for ch in adc_channels}  # Preallocate lists
-time_data = list(range(-MAX_HISTORY, 0))  # Simulated time axis
+time_data = list(range(-MAX_X_HISTORY_VALUES, 0))  # Simulated time axis
+
 
 def create_adc_plot_tab(notebook, adc):
     frame = ttk.Frame(notebook)
@@ -19,34 +32,55 @@ def create_adc_plot_tab(notebook, adc):
 
     figure = Figure(figsize=(8, 5), dpi=100)
     ax = figure.add_subplot(1, 1, 1)
-    ax.set_ylim(0, 12)
+
-    ax.set_xlim(-MAX_HISTORY, 0)  # Keep time axis fixed
+    ax.set_title("ADC Inputs")  # Set title
+    ax.set_xlabel("Time (s)")  # X-axis label
+    ax.set_ylabel("Voltage / Current (V / mA)")  # Y-axis label
+
+    ax.set_xlim(-MAX_X_HISTORY_VALUES, 0)  # Keep time axis fixed
     canvas = FigureCanvasTkAgg(figure, master=frame)
     canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True)
 
     # Initialize lines for fast updates
-    lines = {ch: ax.plot(time_data, data[ch], label=f"ADC {ch+1}")[0] for ch in adc_channels}
+    lines = {}
+    for terminal, config in ADC_TERMINALS.items():
+        label = f"T{terminal} ({config['max_value']} {config['unit']})"  # Format: T1 (3.3V)
+        lines[terminal] = ax.plot(time_data, data[terminal], label=label)[0]
+
+    ax.legend()  # Show legend
 
     def update_plot():
         if not updating_enabled:
-            frame.after(NOT_ACTIVE_CHECK_INTERVAL, update_plot)
+            frame.after(TAB_NOT_ACTIVE_CHECK_INTERVAL_MS, update_plot)
             return
 
-        # Shift existing data left
+        for terminal, config in ADC_TERMINALS.items():
-        for ch in adc_channels:
+            adc_channel = config["adc_channel"]
-            data[ch].pop(0)
+            max_value = config["max_value"]
-            data[ch].append(round(adc.read(ch) * 12 / 4095, 2))
+            # Shift existing data left and
+            # read new data + scale based on the correct max voltage
+            data[terminal].pop(0)
+            data[terminal].append(round(adc.read(adc_channel) * max_value / 4095, 2))
 
-        # Update only the y-data for efficiency
+        # Recalculate limits (autoscale)
-        for ch in adc_channels:
+        if AUTO_SCALE_ENABLED:
-            lines[ch].set_ydata(data[ch])
+            ax.set_ylim(bottom=0)  # Lower limit always 0
+            ax.autoscale(enable=True, axis='y', tight=False)  # Enable autoscale for upper limit
+            ax.relim()  # Recalculate limits
+            ax.autoscale_view(scalex=False, scaley=True)  # Autoscale only y-axis
+        else:
+            ax.set_ylim(0, 24)  # Fixed range if autoscale is disabled
+
+        for terminal in ADC_TERMINALS:
+            lines[terminal].set_ydata(data[terminal])
 
         canvas.draw_idle()  # Efficient redraw
-        frame.after(ADC_PLOT_UPDATE_INTERVAL, update_plot)
+        frame.after(ADC_PLOT_UPDATE_DELAY_MS, update_plot)
 
     update_plot()
 
+
 def set_updating_enabled(is_active):
     global updating_enabled
     updating_enabled = is_active
-    print(f"adc_plot tab: set updating_enabled to {updating_enabled}")
+    if DEBUG: print(f"adc_plot tab: set updating_enabled to {updating_enabled}")

rpi-scripts/gui/tab_control.py

@@ -8,11 +8,17 @@ import RPi.GPIO as GPIO
 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
 from interface_board_pins import *  # Import pin assignments
 
+
+# CONFIG
+ADC_VALUES_UPDATE_INTERVAL_MS = 500
+DIGITAL_INPUTS_UPDATE_INTERVAL_MS = 200
+TAB_NOT_ACTIVE_CHECK_INTERVAL_MS = 2000
+DEBUG = False
+
+
+# Variables
 updating_enabled = False
 
-ADC_VALUES_UPDATE_INTERVAL = 500
-DIGITAL_INPUTS_UPDATE_INTERVAL = 200
-NOT_ACTIVE_CHECK_INTERVAL = 2000
 
 def create_control_tab(notebook, adc, shift_reg, pwm1, pwm2):
     frame = ttk.Frame(notebook)
@@ -20,26 +26,36 @@ def create_control_tab(notebook, adc, shift_reg, pwm1, pwm2):
 
     digital_input_states = [tk.StringVar(value="LOW") for _ in range(8)]
     digital_output_states = [tk.BooleanVar(value=False) for _ in range(8)]
-    adc_values = [tk.StringVar(value="0.00V") for _ in range(8)]
+    adc_values = [tk.StringVar(value=" --- ") for _ in range(8)]
     pwm_values = [tk.IntVar(value=0), tk.IntVar(value=0)]
     output_buttons = {}  # Store button references to change colors
 
+
     def update_inputs():
         if not updating_enabled:
-            frame.after(NOT_ACTIVE_CHECK_INTERVAL, update_inputs)
+            frame.after(TAB_NOT_ACTIVE_CHECK_INTERVAL_MS, update_inputs)
             return
         for i, pin in enumerate(GPIO_DIGITAL_INPUTS.values()):
             digital_input_states[i].set("HIGH" if GPIO.input(pin) else "LOW")
-        frame.after(DIGITAL_INPUTS_UPDATE_INTERVAL, update_inputs)
+        frame.after(DIGITAL_INPUTS_UPDATE_INTERVAL_MS, update_inputs)
+
 
     def update_adc():
         if not updating_enabled:
-            frame.after(NOT_ACTIVE_CHECK_INTERVAL, update_adc)
+            frame.after(TAB_NOT_ACTIVE_CHECK_INTERVAL_MS, update_adc)
             return
-        for i, adc_channel in enumerate(ADC_CHANNELS.values()):
+
+        for terminal, config in ADC_TERMINALS.items():
+            adc_channel = config["adc_channel"]
+            max_value = config["max_value"]
+            unit = config["unit"]
+
+            # Read ADC value and scale to the correct voltage
             value = adc.read(adc_channel)
-            adc_values[i].set(f"{round(value * 12 / 4095, 2)}V")
+            adc_values[terminal].set(f"{value * max_value / 4095:4.2f} {unit}")
-        frame.after(ADC_VALUES_UPDATE_INTERVAL, update_adc)
+
+        frame.after(ADC_VALUES_UPDATE_INTERVAL_MS, update_adc)
+
 
     def toggle_output(index):
         """ Toggle shift register output and update button color. """
@@ -51,6 +67,7 @@ def create_control_tab(notebook, adc, shift_reg, pwm1, pwm2):
             for btn in output_buttons[index]:
                 btn.configure(bg="green" if new_state else "red", activebackground="green" if new_state else "red")
 
+
     style = ttk.Style()
     style.configure("TScale", thickness=60)
     style.configure("TButton", font=("Arial", 18), padding=5)
@@ -63,12 +80,12 @@ def create_control_tab(notebook, adc, shift_reg, pwm1, pwm2):
     frame.grid_columnconfigure(0, weight=1)
 
     for i in range(8):
-        ttk.Label(control_frame, text=f"ADC {i}:", font=("Arial", 18)).grid(row=i, column=0, sticky="e")
+        ttk.Label(control_frame, text=f"ADC-{i}: ", font=("Arial", 18)).grid(row=i, column=0, sticky="e")
         ttk.Label(control_frame, textvariable=adc_values[i], width=10, font=("Arial", 18)).grid(row=i, column=1, sticky="w")
-        ttk.Label(control_frame, text=f"IN {i}:", font=("Arial", 18)).grid(row=i, column=2, sticky="e", padx=20)
+        ttk.Label(control_frame, text=f"IN-{i}:", font=("Arial", 18)).grid(row=i, column=2, sticky="e", padx=20)
         ttk.Label(control_frame, textvariable=digital_input_states[i], width=6, font=("Arial", 18)).grid(row=i, column=3, sticky="w")
 
-        btn = tk.Button(control_frame, text=f"OUT {i}", font=("Arial", 16), width=10, bg="red", activebackground="red", command=lambda i=i: toggle_output(i))
+        btn = tk.Button(control_frame, text=f"OUT-{i}", font=("Arial", 16), width=10, bg="red", activebackground="red", command=lambda i=i: toggle_output(i))
         btn.grid(row=i, column=4, sticky="w", padx=20)
 
         output_buttons.setdefault(i, []).append(btn)
@@ -95,7 +112,7 @@ def create_control_tab(notebook, adc, shift_reg, pwm1, pwm2):
     pwm_frame.columnconfigure(1, weight=1)
     pwm_frame.columnconfigure(2, weight=0)
     
-    pwm1_label = ttk.Label(pwm_frame, text="PWM1:", font=("Arial", 18))
+    pwm1_label = ttk.Label(pwm_frame, text="PWM-1:", font=("Arial", 18))
     pwm1_label.grid(row=0, column=0, padx=20, sticky="e")
     
     pwm1_slider = ttk.Scale(
@@ -104,7 +121,7 @@ def create_control_tab(notebook, adc, shift_reg, pwm1, pwm2):
     )
     pwm1_slider.grid(row=0, column=1, columnspan=2, sticky="we", padx=10)
     
-    pwm2_label = ttk.Label(pwm_frame, text="PWM2:", font=("Arial", 18))
+    pwm2_label = ttk.Label(pwm_frame, text="PWM-2:", font=("Arial", 18))
     pwm2_label.grid(row=1, column=0, padx=20, sticky="e")
     
     pwm2_slider = ttk.Scale(
@@ -116,7 +133,9 @@ def create_control_tab(notebook, adc, shift_reg, pwm1, pwm2):
     update_inputs()
     update_adc()
 
+
+
 def set_updating_enabled(is_active):
     global updating_enabled
     updating_enabled = is_active
-    print(f"control tab: set updating_enabled to {updating_enabled}")
+    if DEBUG: print(f"control tab: set updating_enabled to {updating_enabled}")

rpi-scripts/gui/tab_digital_plot.py

@@ -11,15 +11,19 @@ import time
 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
 from interface_board_pins import *  # Import pin assignments
 
-# Adjusted Constants
-DIGITAL_PLOT_UPDATE_INTERVAL = 50  # 50ms (20 FPS) is smooth enough
-NOT_ACTIVE_CHECK_INTERVAL = 2000   # Check inactive tabs less frequently
-MAX_HISTORY = 100                  # Keep last 100 values for scrolling
 
+# CONFIG
+DIGITAL_PLOT_UPDATE_DELAY_MS = 50  # note: delay is additional to time it takes to update the chart
+TAB_NOT_ACTIVE_CHECK_INTERVAL_MS = 2000   # Check inactive tabs less frequently
+MAX_X_HISTORY_VALUES = 100         # Keep last 100 values for scrolling
+DEBUG = False
+
+
+# Variables
 updating_enabled = False  # Track if the tab is active
 input_channels = list(range(8))
-data = {ch: [0] * MAX_HISTORY for ch in input_channels}  # Preallocate data
+data = {ch: [0] * MAX_X_HISTORY_VALUES for ch in input_channels}  # Preallocate data
-time_data = list(range(-MAX_HISTORY, 0))  # Simulated time axis
+time_data = list(range(-MAX_X_HISTORY_VALUES, 0))  # Simulated time axis
 
 
 def create_digital_plot_tab(notebook):
@@ -28,17 +32,27 @@ def create_digital_plot_tab(notebook):
 
     figure = Figure(figsize=(8, 5), dpi=100)
     ax = figure.add_subplot(1, 1, 1)
+
+    ax.set_title("Digital Inputs")  # Set title
+    ax.set_xlabel("Time (s)")  # X-axis label
+    ax.set_ylabel("State (1=HIGH / 0=LOW)")  # Y-axis label
+
     ax.set_ylim(-0.2, 1.2)
-    ax.set_xlim(-MAX_HISTORY, 0)  # Keep time axis fixed
+    ax.set_xlim(-MAX_X_HISTORY_VALUES, 0)  # Keep time axis fixed
     canvas = FigureCanvasTkAgg(figure, master=frame)
     canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True)
 
     # Initialize lines for fast updates
-    lines = {ch: ax.step(time_data, data[ch], where="post")[0] for ch in input_channels}
+    lines = {}
+    for ch in input_channels:
+        label = f"Digital In {ch}"
+        lines[ch] = ax.step(time_data, data[ch], where="post", label=label)[0]
+
+    ax.legend()  # Show legend
 
     def update_plot():
         if not updating_enabled:
-            frame.after(NOT_ACTIVE_CHECK_INTERVAL, update_plot)
+            frame.after(TAB_NOT_ACTIVE_CHECK_INTERVAL_MS, update_plot)
             return
         
         # Shift existing data left
@@ -51,13 +65,14 @@ def create_digital_plot_tab(notebook):
             lines[ch].set_ydata(data[ch])
 
         canvas.draw_idle()  # More efficient than draw()
-        frame.after(DIGITAL_PLOT_UPDATE_INTERVAL, update_plot)
+        frame.after(DIGITAL_PLOT_UPDATE_DELAY_MS, update_plot)
 
     update_plot()
 
 
+
 def set_updating_enabled(is_active):
     global updating_enabled
     updating_enabled = is_active
-    print(f"digital_plot tab: set updating_enabled to {updating_enabled}")
+    if DEBUG: print(f"digital_plot tab: set updating_enabled to {updating_enabled}")
 

rpi-scripts/interface_board_pins.py

@@ -49,25 +49,26 @@ ADC_SPI_CS_PIN = 8  # SPI Chip Select for MCP3208
 # SCLK_0: GPIO_11
 # CE_0:   GPIO# MCP3208 (ADC)
 
-# Pin mappings for Terminal number to actual ADC channels (due to routing they do not match)
+# Pin mappings for Terminal number to actual ADC channels, including max voltage range
-ADC_CHANNELS = {
+ADC_TERMINALS = {
-    0: 1,  # Terminal 0 = ADC channel 1
+    0: {"adc_channel": 1, "max_value": 3.3, "unit": "V"},  # Terminal 0 -> ADC channel 1, max 3.3V
-    1: 0,  # Terminal 1 = ADC channel 0
+    1: {"adc_channel": 0, "max_value": 3.3, "unit": "V"},  # Terminal 1 -> ADC channel 0, max 3.3V
-    2: 3,  # ...
+    2: {"adc_channel": 3, "max_value": 5,   "unit": "V"},  # Terminal 2 -> ADC channel 3, max 5V
-    3: 2,
+    3: {"adc_channel": 2, "max_value": 5,   "unit": "V"},
-    4: 5,
+    4: {"adc_channel": 5, "max_value": 12,  "unit": "V"},
-    5: 4,
+    5: {"adc_channel": 4, "max_value": 24,  "unit": "V"},
-    6: 7,
+    6: {"adc_channel": 7, "max_value": 20,  "unit": "mA"}, # Terminal 6 -> ADC channel 7, max 20mA
-    7: 6
+    7: {"adc_channel": 6, "max_value": 20,  "unit": "mA"},
 }
 
+
 # Alternative to ADC_CHANNELS list have separate constants for the channels (more intuitive)
 ADC_CHANNEL_T0__0_TO_3V3  = 1
 ADC_CHANNEL_T1__0_TO_3V3  = 0
 ADC_CHANNEL_T2__0_TO_5V   = 3
 ADC_CHANNEL_T3__0_TO_5V   = 2
 ADC_CHANNEL_T4__0_TO_12V  = 5
-ADC_CHANNEL_T5__0_TO_12V  = 4
+ADC_CHANNEL_T5__0_TO_24V  = 4
 ADC_CHANNEL_T6__0_TO_20MA = 7
 ADC_CHANNEL_T7__0_TO_20MA = 6