Line follower (DexterInd#276)

* Attempt at making easygopigo thread_safe

First, before each read, wait till the bus is available
Second, confirm the bus is open before doing the read (in case another thread got it)
Third, grab the read flag
Fourth do the read
Fifth, release the read flag asap for other threads

This only works for one process and only if all readings go through easygopigo

More than one process would still experience issues, but a single multi threaded process would be safe.

* Install line follower in a standard way.
To import use:
from line_follower import line_sensor
and it works!

* get rid of double self. One ego is enough

* Some phantom lines had reappeared. I must have goofed in Github again

* Change the way the IR Receiver behaves on GPG2.
By default, the behaviour is the same as before, but now we can have a "consume" stauts.
When 'consume' is set to False, the key is not erased and can be returned more than once.

* remove extra blank line

* Limit percent readings to 100. Mostly for sound and loudness sensors. We don't want to encourage classrooms into noise contests

* feature - assembly instructions for the GoPiGo2 (DexterInd#274)

feature - assembly instructions for the GoPiGo2

* Make the line follower returns all lowercase letters. Easier for string manipulation
Needed for DexterOS

* _is_read_open() is obsolete

Author: CleoQc

Software/Python/easygopigo.py

@@ -73,7 +73,7 @@ def _release_read():
         pass
     read_is_open = True
     # print("released")
-    
+
 
 class EasyGoPiGo():
     '''
@@ -83,12 +83,12 @@ class EasyGoPiGo():
     '''
     def __init__(self):
         '''
-        On Init, set speed to half-way, so GoPiGo is predictable 
+        On Init, set speed to half-way, so GoPiGo is predictable
             and not too fast.
         '''
         DEFAULT_SPEED = 128
         gopigo.set_speed(DEFAULT_SPEED)
-        
+
     def volt(self):
         _grab_read()
         try:
@@ -122,13 +122,13 @@ def backward(self):
             print("easygopigo bwd: {}".format(e))
             pass
         _release_read()
-            
+
     def left(self):
         _grab_read()
         try:
             gopigo.left()
         except:
-            pass    
+            pass
         _release_read()
 
     def right(self):
@@ -146,15 +146,15 @@ def set_speed(self,new_speed):
         except:
             pass
         _release_read()
-        
+
     def reset_speed(self):
         _grab_read()
         try:
             gopigo.set_speed(DEFAULT_SPEED)
         except:
             pass
-        _release_read()       
-        
+        _release_read()
+
     def set_left_speed(self,new_speed):
         _grab_read()
         try:
@@ -170,32 +170,32 @@ def set_right_speed(self,new_speed):
         except:
             pass
         _release_read()
-        
+
     def led_on(self,led_id):
         _grab_read()
         try:
             gopigo.led_on(led_id)
         except:
             pass
         _release_read()
-        
+
     def led_off(self,led_id):
         _grab_read()
         try:
             gopigo.led_off(led_id)
         except:
             pass
         _release_read()
-        
+
     def trim_read(self):
         _grab_read()
         try:
-            current_trim = int(gopigo.trim_read()) 
+            current_trim = int(gopigo.trim_read())
         except:
             pass
         _release_read()
         return current_trim
-        
+
     def trim_write(self,set_trim_to):
         _grab_read()
         try:
@@ -345,15 +345,15 @@ def read(self):
         try:
             self.value = gopigo.analogRead(self.getPortID())
         except:
-            pass            
+            pass
         _release_read()
         return self.value
 
     def percent_read(self):
         value = int(self.read()) * 100 // self._max_value
-
-        # limit percent_read to a max of 100%. We don't want to encourage
-        # classrooms into shouting matches with the sound sensor
+        # Some sensors - like the loudness_sensor -
+        # can actually return higher than 100% so let's clip it
+        # and keep classrooms within an acceptable noise level
         if value > 100:
             value = 100
         # print(value)
@@ -556,7 +556,7 @@ class ButtonSensor(DigitalSensor):
     def __init__(self, port="D11",gpg=None):
         DigitalSensor.__init__(self, port, "INPUT")
         self.set_descriptor("Button sensor")
-        
+
     def is_button_pressed(self):
         return self.read() == 1
 ##########################
@@ -588,13 +588,15 @@ def get_remote_code(self):
         You have to check that length > 0
             before handling the code value
         '''
+
         if IR_RECEIVER_ENABLED:
             import ir_receiver
             key = ir_receiver.nextcode(consume=False)
         else:
             key = ""
-        
+
         return key
+
 ##########################
 
 
@@ -695,17 +697,17 @@ def follow_line(self,fwd_speed=80):
         while True:
             pos = self.read_position()
             debug(pos)
-            if pos == "Center":
+            if pos == "center":
                 gopigo.forward()
-            elif pos == "Left":
+            elif pos == "left":
                 gopigo.set_right_speed(0)
                 gopigo.set_left_speed(slight_turn_speed)
-            elif pos == "Right":
+            elif pos == "right":
                 gopigo.set_right_speed(slight_turn_speed)
                 gopigo.set_left_speed(0)
-            elif pos == "Black":
+            elif pos == "black":
                 gopigo.stop()
-            elif pos == "White":
+            elif pos == "white":
                 gopigo.stop()
 
     def read_position(self):
@@ -716,32 +718,29 @@ def read_position(self):
         May return "Unknown"
         This method is not intelligent enough to handle intersections.
         '''
-        five_vals = [-1,-1,-1,-1,-1]
-
-        if _is_read_open():
-            five_vals = self.read()
+        five_vals = self.read()
 
         if five_vals == [0, 0, 1, 0, 0] or five_vals == [0, 1, 1, 1, 0]:
-            return "Center"
+            return "center"
         if five_vals == [1, 1, 1, 1, 1]:
-            return "Black"
+            return "black"
         if five_vals == [0, 0, 0, 0, 0]:
-            return "White"
+            return "white"
         if five_vals == [0, 1, 1, 0, 0] or \
            five_vals == [0, 1, 0, 0, 0] or \
            five_vals == [1, 0, 0, 0, 0] or \
            five_vals == [1, 1, 0, 0, 0] or \
            five_vals == [1, 1, 1, 0, 0] or \
            five_vals == [1, 1, 1, 1, 0]:
-            return "Left"
+            return "left"
         if five_vals == [0, 0, 0, 1, 0] or \
            five_vals == [0, 0, 1, 1, 0] or \
            five_vals == [0, 0, 0, 0, 1] or \
            five_vals == [0, 0, 0, 1, 1] or \
            five_vals == [0, 0, 1, 1, 1] or \
            five_vals == [0, 1, 1, 1, 1]:
-            return "Right"
-        return "Unknown"
+            return "right"
+        return "unknown"
 
 
 #######################################################################
@@ -751,23 +750,23 @@ def read_position(self):
 #######################################################################
 
 class Servo(Sensor):
-    
+
     def __init__(self, port="SERVO", gpg=None):
         Sensor.__init__(self, port, "SERVO")
         gopigo.enable_servo()
         self.set_descriptor("Servo Motor")
-        
+
     def rotate_servo(self, servo_position):
         if servo_position > 180:
             servo_position = 180
         if servo_position < 0:
             servo_position = 0
         gopigo.servo(servo_position)
-        
-            
+
+
 #######################################################################
 #
-# DistanceSensor 
+# DistanceSensor
 #
 #######################################################################
 try:
@@ -791,18 +790,18 @@ def __init__(self, port="I2C",gpg=None):
             except Exception as e:
                 print(e)
                 raise ValueError("Distance Sensor not found")
-                
+
         # Returns the values in mm
         readings = []
         def read_mm(self):
-            
+
             # 8190 is what the sensor sends when it's out of range
             # we're just setting a default value
             mm = 8190
             readings = []
             attempt = 0
-            
-            # try 3 times to have a reading that is 
+
+            # try 3 times to have a reading that is
             # smaller than 8m or bigger than 5 mm.
             # if sensor insists on that value, then pass it on
             while (mm > 8000 or mm < 5) and attempt < 3:
@@ -814,26 +813,26 @@ def read_mm(self):
                 _release_read()
                 attempt = attempt + 1
                 time.sleep(0.001)
-                
+
             # add the reading to our last 3 readings
             # a 0 value is possible when sensor is not found
             if (mm < 8000 and mm > 5) or mm == 0:
                 readings.append(mm)
             if len(readings) > 3:
                 readings.pop(0)
-            
+
             # calculate an average and limit it to 5 > X > 3000
             if len(readings) > 1: # avoid division by 0
                 mm = round(sum(readings) / float(len(readings)))
             if mm > 3000:
                 mm = 3000
-                
+
             return mm
-            
+
         def read(self):
             cm = self.read_mm()//10
             return (cm)
-            
+
         def read_inches(self):
             cm = self.read()
             return cm / 2.54

Software/Python/ir_remote_control/server/ir_receiver.py

@@ -61,6 +61,7 @@ def nextcode(consume=True):
     global previous_keypress
 
     send_back=last_recv_or_code
+
     # print("send_back: {} previous_keypress: {}".format(send_back,previous_keypress))
 
     if consume:

Software/Python/line_follower/line_sensor.py

@@ -124,8 +124,12 @@ def read_sensor():
     try:
         output_values = []
         bus.write_i2c_block_data(address, 1, aRead_cmd + [unused, unused, unused])
+        
+        # for some unknown reason we need to discard the first reading
+        # otherwise we're not up to date
         number = bus.read_i2c_block_data(address, 1)
-
+        number = bus.read_i2c_block_data(address, 1)
+        
         # for each IR sensor on the line follower
         for i in range(5):
             # calculate the 2-byte number we got