Merge git://github.com/dfluff/icm20948-python into dfluff-master

Author: Gadgetoid

examples/magnetometer.py

@@ -3,10 +3,65 @@
 from icm20948 import ICM20948
 import time
 import math
+import argparse
+import os
+import signal
+import sys
+
+BAR_CHAR = u'\u2588' # Unicode FULL BLOCK
+
+running = True
+mingraphval = 0
+maxgraphval = 360
+
+# Terminal bar-graph adapted from examples/graph.py file from
+# https://github.com/pimoroni/vl53l1x-python
+def graphValue(value):
+    global cols, mingraphval, maxgraphval
+    if( value > maxgraphval ):
+        value = maxgraphval
+    elif( value < mingraphval):
+        value = mingraphval
+
+    graphvalue = value - mingraphval
+
+    bar_size = int((graphvalue / float(maxgraphval-mingraphval)) * (cols-10)) # Scale bar_size to our terminal width
+    bar = BAR_CHAR * bar_size # Create a bar out of `bar_size` unicode FULL BLOCK characters
+    bar = bar.ljust(cols - 7, u' ') # Pad the bar to the full with of the terminal, minus the value prefix
+    sys.stdout.write("\r") # Return the cursor to the beginning of the current line
+    sys.stdout.write(u"{:05.1f} {}".format(value, bar)) # Output our measurement and bar
+    sys.stdout.flush() # Flush the output buffer, since we're overdrawing the last line
+
+
+
+def exit_handler(signal, frame):
+    global running,args
+    running = False
+    if( args.graph == True ):
+        # Clean up terminal after using --graph output
+        sys.stdout.write("\n")
+    sys.exit(0)
+
+signal.signal(signal.SIGINT, exit_handler)
+
+
+parser = argparse.ArgumentParser()
+parser.add_argument( '--axis',  choices=['xy','yz','xz'],  default='yz',  help="Axis to measure (default: yz)")
+parser.add_argument( '--graph', '-g', action="store_true", default=False, help="Display heading as terminal-graph")
+args = parser.parse_args()
+
+
+if( args.graph == True):
+    try:
+        rows, cols = [int(c) for c in os.popen("stty size", "r").read().split()]
+    except ValueError:
+        print("Cannot get size of tty! Try running in Terminal.")
+        sys.exit(1)
+
 
 print("""magnetometer.py - Convert raw values to heading
 
-Rotate the sensor (X-axis upwards) through 360 degrees to calibrate.
+Rotate the sensor through 360 degrees to calibrate.
 
 Press Ctrl+C to exit!
 
@@ -16,61 +71,52 @@
 Y = 1
 Z = 2
 
-# The two axes which relate to heading, depends on orientation of the sensor
-# Think Left & Right, Forwards and Back, ignoring Up and Down
-AXES = Y, Z
+if(   args.axis == 'xy' ):
+    AXES = X, Y
+elif( args.axis == 'yz' ):
+    AXES = Y, Z
+elif( args.axis == 'xz' ):
+    AXES = X, Z
+
+
+if( args.graph == True ):
+    sys.stdout.write("\n")
+
 
-# Initialise the imu
 imu = ICM20948()
 
-# Store an initial two readings from the Magnetometer
 amin = list(imu.read_magnetometer_data())
 amax = list(imu.read_magnetometer_data())
 
-while True:
-    # Read the current, uncalibrated, X, Y & Z magnetic values from the magnetometer and save as a list
+while running:
     mag = list(imu.read_magnetometer_data())
-    
-    # Step through each uncalibrated X, Y & Z magnetic value and calibrate them the best we can
-    for i in range(3):
+    for i in AXES:
         v = mag[i]
-        # If our current reading (mag) is less than our stored minimum reading (amin), then save a new minimum reading
-        # ie save a new lowest possible value for our calibration of this axis
         if v < amin[i]:
             amin[i] = v
-        # If our current reading (mag) is greater than our stored maximum reading (amax), then save a new maximum reading
-        # ie save a new highest possible value for our calibration of this axis
         if v > amax[i]:
             amax[i] = v
-        
-        # Calibrate value by removing any offset when compared to the lowest reading seen for this axes
         mag[i] -= amin[i]
-        
-        # Scale value based on the higest range of values seen for this axes
-        # Creates a calibrated value between 0 and 1 representing magnetic value
         try:
             mag[i] /= amax[i] - amin[i]
         except ZeroDivisionError:
             pass
-        # Shift magnetic values to between -0.5 and 0.5 to enable the trig to work
         mag[i] -= 0.5
 
-    # Convert from Gauss values in the appropriate 2 axis to a heading in Radians using trig
-    # Note this does not compensate for tilt
     heading = math.atan2(
             mag[AXES[0]],
             mag[AXES[1]])
 
-    # If heading is negative, convert to positive, 2 x pi is a full circle in Radians
     if heading < 0:
         heading += 2 * math.pi
-        
-    # Convert heading from Radians to Degrees
     heading = math.degrees(heading)
-    # Round heading to nearest full degree
-    heading = round(heading)
 
-    # Note: Headings will not be correct until a full 360 deg calibration turn has been completed to generate amin and amax data
-    print("Heading: {}".format(heading))
+    if( args.graph == True ):
+        # Display the heading as a bar-graph in the terminal
+        graphValue(heading)
+    else:
+        # Round the heading value and print out directly
+        heading = round(heading)
+        print("Heading: {}".format(heading))
 
     time.sleep(0.1)