Add logging support, turn off unconditional debug output

Author: dplanella

Adafruit_BBIO/Encoder.py

@@ -1,7 +1,9 @@
 #!/usr/bin/python
 
-from subprocess import call
+from subprocess import check_output, STDOUT, CalledProcessError
 import os
+import logging
+
 
 class QEP :
 
@@ -48,48 +50,64 @@ class RotaryEncoder(object):
   EQEP1 = 1
   EQEP2 = 2
   EQEP2b = 3
- 
+
+  def _run_cmd(self, cmd):
+    '''Runs a command. If not successful (i.e. error code different than zero),
+    print the stderr output as a warning.
+    '''
+
+    try:
+      output = check_output(cmd, stderr=STDOUT)
+      self._logger.info("_run_cmd(): cmd='{}' return code={} output={}".format(
+        " ".join(cmd), 0, output))
+    except CalledProcessError as e:
+      self._logger.warning(
+        "_run_cmd(): cmd='{}' return code={} output={}".format(
+          " ".join(cmd), e.returncode, e.output))
+
   def config_pin(self, pin):
     '''
     config_pin()
     Config pin for QEP
     '''
-    result = call(["config-pin", pin, "qep"])
-    print("config_pin> pin={0} result={1}".format(pin, result))
-    return result
-  
+
+    self._run_cmd(["config-pin", pin, "qep"])
+
   def cat_file(self, path):
     '''
     cat_file()
     Print contents of file
     '''
-    result = call(["cat", path])
-    print("cat_file> path={0} result={1}".format(path, result))
-    return result
-   
+
+    self._run_cmd(["cat", path])
+
   def __init__(self, eqep_num):
     '''
     RotaryEncoder(eqep_num)
-    Creates an instance of the class RotaryEncoder. 
-    eqep_num determines which eQEP pins are set up. 
+    Creates an instance of the class RotaryEncoder.
+    eqep_num determines which eQEP pins are set up.
     eqep_num can be: EQEP0, EQEP1, EQEP2 or EQEP2b based on which pins \
     the rotary encoder is connected to.
     '''
-    print(">>>>>>>> TEST CALL BEGIN")
 
-    ###################################
-    print(">>>>>> eqep0: P9_27, P9_92")
+    self._logger = logging.getLogger(__name__)
+    self._logger.addHandler(logging.NullHandler())
+    #self._logger.setLevel(logging.DEBUG)
+
+    # Configure eqep0
+    self._logger.info("Configuring eqep0, pins: P9.27, P9.92")
+
     pin = "P9_27"
     self.config_pin(pin)
 
     pin = "P9_92"
     self.config_pin(pin)
 
     path = "/sys/devices/platform/ocp/48300000.epwmss/48300180.eqep/position"
-    self.cat_file(path);
+    self.cat_file(path)
 
-    ###################################
-    print(">>>>>>> eqep1: P8.33, P8.35")
+    # Configure eqep1
+    self._logger.info("Configuring eqep1, pins: P8.33, P8.35")
 
     pin = "P8.33"
     self.config_pin(pin)
@@ -100,8 +118,8 @@ def __init__(self, eqep_num):
     path = "/sys/devices/platform/ocp/48302000.epwmss/48302180.eqep/position"
     self.cat_file(path);
 
-    ###################################
-    print(">>>>>>> eqep2: P8.11, P8.12")
+    # Configure eqep2
+    self._logger.info("Configuring eqep2, pins: P8.11, P8.12")
 
     pin = "P8.11"
     self.config_pin(pin)
@@ -112,8 +130,8 @@ def __init__(self, eqep_num):
     path = "/sys/devices/platform/ocp/48304000.epwmss/48304180.eqep/position"
     self.cat_file(path);
 
-    ###################################
-    print(">>>>>>> eqep2b: P8.41, P8.42")
+    # Configure eqep2b
+    self._logger.info("Configuring eqep2, pins: P8.41, P8.42")
 
     pin = "P8.41"
     self.config_pin(pin)
@@ -124,17 +142,17 @@ def __init__(self, eqep_num):
     path = "/sys/devices/platform/ocp/48304000.epwmss/48304180.eqep/position"
     self.cat_file(path);
 
-    ###################################
-    print(">>>>>>>> TEST CALL END")
+    self._logger.debug("RotaryEncoder(): eqep_num: {0}".format(eqep_num))
+    self._logger.debug("RotaryEncoder(): self._eqep_dirs[0]: {0}".format(self._eqep_dirs[0]))
+    self._logger.debug("RotaryEncoder(): self._eqep_dirs[1]: {0}".format(self._eqep_dirs[1]))
+    self._logger.debug("RotaryEncoder(): self._eqep_dirs[2]: {0}".format(self._eqep_dirs[2]))
+    self._logger.debug("RotaryEncoder(): self._eqep_dirs[eqep_num: {0}]: {1}".format(eqep_num, self._eqep_dirs[eqep_num]))
 
-    print("RotaryEncoder(): eqep_num: {0}".format(eqep_num))
-    print("RotaryEncoder(): self._eqep_dirs[0]: {0}".format(self._eqep_dirs[0]))
-    print("RotaryEncoder(): self._eqep_dirs[1]: {0}".format(self._eqep_dirs[1]))
-    print("RotaryEncoder(): self._eqep_dirs[2]: {0}".format(self._eqep_dirs[2]))
-    print("RotaryEncoder(): self._eqep_dirs[eqep_num: {0}]: {1}".format(eqep_num, self._eqep_dirs[eqep_num]))
     assert 0 <= eqep_num <= 3 , "eqep_num must be between 0 and 3"
+
     self.base_dir = self._eqep_dirs[eqep_num]
-    print("RotaryEncoder(): self.base_dir: {0}".format(self.base_dir))
+    self._logger.debug("RotaryEncoder(): self.base_dir: {0}".format(self.base_dir))
+
     self.enable()
 
   def enable(self):
@@ -143,93 +161,102 @@ def enable(self):
     Turns the eQEP hardware ON
     '''
     enable_file = "%s/enabled" % self.base_dir
-    print("enable(): enable_file: {0}".format(enable_file))
-    print("enable(): TODO: write 1 to enable_file")
-    #return sysfs.kernelFileIO(enable_file, '1') 
-    
+    self._logger.debug("enable(): enable_file: {0}".format(enable_file))
+    self._logger.warning(
+      "enable(): TODO: not implemented, write 1 to {}".format(enable_file))
+    #return sysfs.kernelFileIO(enable_file, '1')
+
   def disable(self):
     '''
     disable()
     Turns the eQEP hardware OFF
     '''
     enable_file = "%s/enabled" % self.base_dir
-    print("disable(): enable_file: {0}".format(enable_file))
-    print("disable(): TODO: write 0 to enable_file")
+    self._logger.debug("disable(): enable_file: {0}".format(enable_file))
+    self._logger.warning(
+      "disable(): TODO: not implemented, write 0 to {}".format(enable_file))
     #return sysfs.kernelFileIO(enable_file, '0')
 
   def setAbsolute(self):
     '''
     setAbsolute()
     Set mode as Absolute
-    The position starts at zero and is incremented or 
+    The position starts at zero and is incremented or
     decremented by the encoder's movement
     '''
     mode_file = "%s/mode" % self.base_dir
-    print("setAbsolute(): mode_file: {0}".format(mode_file))
-    print("setAbsolute(): TODO: write 0 to mode_file")
+    self._logger.debug("setAbsolute(): mode_file: {0}".format(mode_file))
+    self._logger.warning(
+      "setAbsolute(): TODO: not implemented, write 0 to {}".format(mode_file))
     #return sysfs.kernelFileIO(mode_file, '0')
-    
+
   def setRelative(self):
     '''
     setRelative()
     Set mode as Relative
     The position is reset when the unit timer overflows.
     '''
     mode_file = "%s/mode" % self.base_dir
-    print("setRelative(): mode_file: {0}".format(mode_file))
-    print("setRelative(): TODO: write 1 to mode_file")
+    self._logger.debug("setRelative(): mode_file: {0}".format(mode_file))
+    self._logger.warning(
+      "setRelative(): TODO: not implemented, write 1 to {}".format(mode_file))
     #return sysfs.kernelFileIO(mode_file, '1')
-    
+
   def getMode(self):
     '''
     getMode()
     Returns the mode the eQEP hardware is in.
     '''
     mode_file = "%s/mode" % self.base_dir
-    print("getMode(): mode_file: {0}".format(mode_file))
-    print("getMode(): TODO: read mode_file")
+    self._logger.debug("getMode(): mode_file: {0}".format(mode_file))
+    self._logger.warning("getMode(): TODO: read mode_file")
     #return sysfs.kernelFileIO(mode_file)
 
   def getPosition(self):
     '''
     getPosition()
     Get the current position of the encoder.
-    In absolute mode, this attribute represents the current position 
-    of the encoder. 
-    In relative mode, this attribute represents the position of the 
+    In absolute mode, this attribute represents the current position
+    of the encoder.
+    In relative mode, this attribute represents the position of the
     encoder at the last unit timer overflow.
     '''
     position_file = "%s/position" % self.base_dir
-    print("getPosition(): position_file: {0}".format(position_file))
+    self._logger.debug("getPosition(): position_file: {0}".format(position_file))
     position_handle = open(position_file, 'r')
-    print("getPosition(): position_handle: {0}".format(position_handle))
+    self._logger.debug("getPosition(): position_handle: {0}".format(position_handle))
     position = position_handle.read()
-    print("getPosition(): position: {0}".format(position))
+    self._logger.debug("getPosition(): position: {0}".format(position))
     #return sysfs.kernelFileIO(position_file)
+
     return position
-    
-  def setFrequency(self,freq):
+
+  def setFrequency(self, freq):
     '''
     setFrequency(freq)
     Set the frequency in Hz at which the driver reports new positions.
     '''
     period_file = "%s/period" % self.base_dir
-    print("setFrequency(): period_file: {0}".format(period_file))
-    print("setFrequency(): freq: {0}".format(period_file))
-    print("setFrequency(): freq: {0}".format(freq))
-    print("setFrequency(): 1000000000/freq: {0}".format(1000000000/freq))
-    print("setFrequency(): str(1000000000/freq)): {0}".format(str(1000000000/freq)))
-    print("setFrequency(): TODO: set period_file: {0}".format(str(1000000000/freq)))
+    self._logger.debug("setFrequency(): period_file: {0}".format(period_file))
+    self._logger.debug("setFrequency(): freq: {0}".format(freq))
+    self._logger.debug("setFrequency(): 1000000000/freq: {0}".format(1000000000/freq))
+    self._logger.debug("setFrequency(): str(1000000000/freq)): {0}".format(str(1000000000/freq)))
+    self._logger.warning(
+      "setFrequency(): TODO: not implemented, set {} to {}".format(
+        period_file, str(1000000000/freq)))
     #return sysfs.kernelFileIO(period_file, str(1000000000/freq))
-    
-  def setPosition(self,val):
-    ''' 
+
+  def setPosition(self, val):
+    '''
     setPosition(value)
     Give a new value to the current position
     '''
     position_file = "%s/position" % self.base_dir
+    self._logger.warning(
+      "setPosition(): TODO: not implemented, write position to {}".format(
+        position_file))
     #return sysfs.kernelFileIO(position_file, str(val))
-    
+
   def zero(self):
     '''
     zero()s
@@ -239,7 +266,7 @@ def zero(self):
 
 
 #"""
-# encoder_test.py 
+# encoder_test.py
 # Rekha Seethamraju
 # An example to demonstrate the use of the eQEP library
 # for PyBBIO.
@@ -253,9 +280,9 @@ def zero(self):
 #def setup():
 #  encoder.setAbsolute()
 #  encoder.zero()
-#  
+#
 #def loop():
 #  print("encoder position : "+encoder.getPosition())
 #  delay(1000)
-#  
+#
 #run(setup, loop)