Add interrupts for HW limit switches.

Add ability to add SW limits (challenge mode).
Add result file reporting (currently using date-time for the test, which we can assume will be unique per test).

1 files changed, 85 insertions, 4 deletions

diff --git a/System_Python/system.py b/System_Python/system.py
index 1e532fa..20e9844 100644
--- a/System_Python/system.py
+++ b/System_Python/system.py
@@ -2,6 +2,8 @@
 from motor import Motor

 from encoder import Encoder

 import math

+from datetime import datetime

+import RPi.GPIO as GPIO

 

 # IO pin definitions

 ### Motor pins

@@ -15,12 +17,14 @@ encoder_data_pin = 3
 encoder_angular_cs_pin = 4

 ### Linear encoder pins

 encoder_linear_cs_pin = 5

-

+### Limit switch pins (configured to PULLUP)

+limit_negative_pin = 19

+limit_positive_pin = 26

 

 # System Class

 # This is the primary interface a student will use to control the pendulum.

 class System:

-    def __init__(self):

+    def __init__(self, negative_limit=float('nan'), positive_limit=float('nan')):

         # Initialize the motor.

         self.motor = Motor(motor_speed_pin, motor_forward_pin, motor_reverse_pin)

         # Initialize the angular encoder.

@@ -29,6 +33,31 @@ class System:
         # Initialize the linear encoder.

         self.encoder_linear = Linear_Encoder(encoder_clock_pin, encoder_linear_cs_pin, encoder_data_pin)

         self.encoder_linear.set_zero()

+		

+		# Enable hardware interrupts for hardware limit switches

+		GPIO.setup(limit_negative_pin, GPIO.IN, pull_up_down=GPIO.PUD_UP)

+		GPIO.add_event_detect(limit_negative_pin, GPIO.FALLING, callback=negative_limit_callback, bouncetime=300)

+		GPIO.setup(limit_positive_pin, GPIO.IN, pull_up_down=GPIO.PUD_UP)

+		GPIO.add_event_detect(limit_positive_pin, GPIO.FALLING, callback=positive_limit_callback, bouncetime=300)

+		

+		# Setup soft limits if defined by the user (this is "challenge mode" for the user, making the constraints more difficult).

+		# By default, the soft limits will not be used (when set NaN), and the whole extent of the system is available (to the HW limits).

+		self.negative_soft_limit = negative_limit

+		self.positive_soft_limit = positive_limit

+		# If both limits have been defined, verify that they are valid (i.e. positive limit must be greater than the negative limit)

+		if not math.isnan(negative_limit) and not math.isnan(positive_limit) and not negative_limit < positive_limit

+			print("ERROR: Invalid software limits provided. Must be valid floating-point numbers and positive limit must be greater than negative limit. Software limits will be disabled.")

+			self.negative_soft_limit = float('nan')

+			self.positive_soft_limit = float('nan')

+		# NOTE: If only one limit has been defined, this should always work (hardware limits will be the absolute edge on the undefined side, although this would be difficult for users to utilize unless we provide the position of the hardware limits on each side

+		# NOTE: If neither limit is defined, the hardware limits will be the only limits in effect.

+		

+		# Create and setup results file (to be sent back to the server and displayed/downloaded to the user)

+		# Results file is a CSV with the following entries: angle, position, speed

+		self.result_filename = "~/test_results/" + datetime.now().strftime("%d-%m-%Y_%H:%M:%S") + ".csv"

+		result_file = open(self.result_filename, "w+")

+		result_file.write("angle(degrees),position(inches),speed(percentage)\n")

+		result_file.close()

     # END __init__()

     

     # Get the values of the encoders to determine the angular and linear position of the pendulum.

@@ -46,6 +75,21 @@ class System:
             angular_position = angular_position - 360

         #linear_position = self.encoder_linear.read_position()

         linear_position = 0

+		# Check soft limits

+		if not math.isnan(self.negative_soft_limit) and linear_position < self.negative_soft_limit:

+			# Print negative soft limit violation to the results file.

+			result_file = open(self.result_filename, "a")

+			result_file.write("Negative software limit %f has been reached!" % self.negative_soft_limit)

+			result_file.close()

+			# Fire the limit trigger method (stops motor, kills program immediately).

+			self.limit_triggered()

+		if not math.isnan(self.positive_soft_limit) and linear_position > self.positive_soft_limit:

+			# Print positive soft limit violation to the results file.

+			result_file = open(self.result_filename, "a")

+			result_file.write("Positive software limit %f has been reached!" % self.positive_soft_limit)

+			result_file.close()

+			# Fire the limit trigger method (stops motor, kills program immediately).

+			self.limit_triggered()

         return (angular_position, linear_position)

     # END measure()

     

@@ -64,13 +108,50 @@ class System:
         self.motor.coast()

         self.motor.move(speed)

     # END adjust()

+	

+	# Append data to the results file

+	def add_results(self, angle, position, speed):

+		# open the results file

+		result_file = open(self.result_filename, "a")

+		# Write the results

+		result_file.write("%d," % angle)	# Write angle

+		result_file.write("%d," % position) # Write position

+		result_file.write("%d\n" % speed)	# Write speed (end of line)

+		# Close the results file

+		result_file.close()

+	# END add_results

+	

+	# Callback for when negative limit switch is triggered.

+	def negative_limit_callback(self, channel):

+		# Print negative limit trigger to the results file.

+		result_file = open(self.result_filename, "a")

+		result_file.write("Negative hardware limit has been reached!")

+		result_file.close()

+		# Fire the limit trigger method (stops motor, kills program immediately).

+		self.limit_triggered()

+	# END negative_limit_callback

+	# Callback for when positive limit switch is triggered.

+	def positive_limit_callback(self, channel):

+		# Print positive limit trigger to the results file.

+		result_file = open(self.result_filename, "a")

+		result_file.write("Positive hardware limit has been reached!")

+		result_file.close()

+		# Fire the limit trigger method (stops motor, kills program immediately).

+		self.limit_triggered()

+	# END positive_limit_callback

+	def limit_triggered(self):

+		self.motor.brake()

+		sys.exit(1)

 # END System

 

 # Linear Encoder class

 # This class is to help with using an absolute encoder for linear position sensing as assembled in the physical system.

 # The function definitions here are the same as with the regular encoder (pseudo-interface).

 class Linear_Encoder:

-    DIAMETER = 4.0 # MEASURE THIS

+    # MEASURE THIS on the assembled physical system.

+	# Measure the distance moved by the cart for exactly 1 rotation of the encoder. Try to be as exact as possible (but shouldn't be a big deal if we are off a little).

+	# Determine the units we want to measure and report (probably inches?)

+	DISTANCE_PER_ROTATION = 4.0 # MEASURE THIS!!!!!!

     

     def __init__(self, clk_pin, cs_pin, data_pin):

         self.encoder = Encoder(clk_pin, cs_pin, data_pin)

@@ -99,4 +180,4 @@ class Linear_Encoder:
             

         # compute the position based on the system parameters

         # linear position = (2pi*r)(n) + (2pi*r)(position/1024) = (2pi*r)(n + position/1024) = (pi*d)(n + position/1024)

-        return (math.pi*DIAMETER)*(self.rotations + position/1024)

+        return (DISTANCE_PER_ROTATION)*(self.rotations + position/1024)