higher level API for analogue output

npryce · npryce · commit 306906d2f458 · 2013-01-30T22:29:20.000Z
diff --git a/quick2wire/parts/pcf8591.py b/quick2wire/parts/pcf8591.py
@@ -28,7 +28,7 @@ def open(self):
         self.bank._enable_output()
     
     def close(self):
-        self.bank._close_output()
+        self.bank._disable_output()
     
     def __enter__(self):
         self.open()
@@ -81,7 +81,9 @@ def __exit__(self, *exc):
         return False
 
 
-class PinBank(object):
+class PCF8591(object):
+    """Access to the PCF8591 A/D and D/A converter"""
+    
     def __init__(self, master, mode, address=0x48, samples=3):
         self.master = master
         self.address = address
@@ -104,13 +106,27 @@ def input_pin(self, n):
     
     def _enable_output(self):
         self._control_flags |= ANALOGUE_OUTPUT_ENABLE_FLAG
+        self._write_control_flags()
     
     def _disable_output(self):
         self._control_flags &= ~ANALOGUE_OUTPUT_ENABLE_FLAG
+        self._write_control_flags()
     
+    def _write_control_flags(self):
+        if self._last_channel_read is None:
+            self._last_channel_read = 0
+        
+        self.master.transaction(
+            writing_bytes(self.address, self._control_flags|self._last_channel_read))
+        
     def write(self, value):
+        int_value = min(max(0, int(value*255)), 0xFF)
+        
+        if self._last_channel_read is None:
+            self._last_channel_read = 0
+        
         self.master.transaction(
-            writing_bytes(control_flags, (value*255) & 0xFF))
+            writing_bytes(self.address, self._control_flags|self._last_channel_read, int_value))
     
     def read(self, channel):
         if channel != self._last_channel_read:
@@ -122,74 +138,3 @@ def read(self, channel):
         
         return results[0][0] / 255.0
 
-
-class PCF8591:
-    """Access to the PCF8591 A/D and D/A converter"""
-    
-    def __init__ (self, master, address = 0x48):
-        self.master = master
-        self.address = address
-        self._control = 0
-    
-    @property
-    def input_channel(self):
-        """
-        Channel that will be converted on next read command 
-        """
-        return self._control & 7
-    
-    @property
-    def autoincrement(self):
-        """
-        Enables the auto increment flag for reads
-        """
-        return self._control & 8 == 8
-
-    @property
-    def inputs(self):
-        """ 
-        Selects the input configuration. Supply one of FOUR_SINGLE_ENDED, 
-        THREE_DIFFERENTIAL, SINGLE_ENDED_AND_DIFFERENTIAL, or TWO_DIFFERENTIAL
-        """
-        return self._control & 0x30 >> 4
-
-    def begin_analogue_read(self, channel, set=FOUR_SINGLE_ENDED):
-        """
-        Selects an analogue input configuration. The specified channel
-        will be enabled in the configuration set (which defaults to FOUR_SINGLE_ENDED)
-        """
-
-        self._control = ANALOGUE_OUTPUT_ENABLE_FLAG | set << 4 | channel
-        self.master.transaction(writing_bytes(self.address, self._control))
-        return SingleInputPin(self, self._control & 0x3f)
-
-    def read(self, count=1):
-        """ 
-        Read the next conversion with the current input channel and 
-        programming
-        """
-        return self.master.transaction(reading(self.address, count))[0]
-
-    def analogue_out(self, value):
-        self._control = ANALOGUE_OUTPUT_ENABLE_FLAG | self._control
-        self.master.transaction(writing_bytes(self.address, self._control, value))
-
-    def _validate_input(self, config):
-        """Resets the input configuration to the supplied configuration"""
-        if (self._control & 0x3f) != config:
-            self._control = self._control & 0x40 | config
-            self.master.transaction(writing_bytes(self.address, self._control))
-
-class SingleInputPin:
-    def __init__(self, chip, input_config):
-        self._chip = chip
-        self._input_config = input_config
-
-    @property
-    def chip(self):
-        return self._chip
-
-    def read(self):
-        """Read a single value from the PCF8591"""
-        self.chip._validate_input(self._input_config)
-        return self.chip.read(1)[0]
diff --git a/quick2wire/parts/test_pcf8591.py b/quick2wire/parts/test_pcf8591.py
@@ -1,7 +1,6 @@
 
 from quick2wire.i2c_ctypes import I2C_M_RD
-from quick2wire.parts.pcf8591 import PinBank as PCF8591
-from quick2wire.parts.pcf8591 import FOUR_SINGLE_ENDED, THREE_DIFFERENTIAL, SINGLE_ENDED_AND_DIFFERENTIAL, TWO_DIFFERENTIAL
+from quick2wire.parts.pcf8591 import PCF8591, FOUR_SINGLE_ENDED, THREE_DIFFERENTIAL, SINGLE_ENDED_AND_DIFFERENTIAL, TWO_DIFFERENTIAL
 from factcheck import forall, from_range
 
 class FakeI2CMaster:
@@ -172,5 +171,75 @@ def test_does_not_write_control_byte_to_switch_channel_if_multiple_reads_from_sa
     assert ctl2.buf[0][0] == 0b00010001
 
 
+def test_opening_and_closing_the_output_pin_turns_the_digital_to_analogue_converter_on_and_off():
+    adc = PCF8591(i2c, FOUR_SINGLE_ENDED)
+    
+    adc.output_pin.open()
+    assert i2c.request_count == 1
+    m1, = i2c.request(0)
+    assert is_write(m1)
+    assert m1.addr == adc.address
+    assert m1.len == 1
+    assert m1.buf[0][0] == 0b01000000
+    
+    adc.output_pin.close()
+    assert i2c.request_count == 2
+    m2, = i2c.request(1)
+    assert is_write(m2)
+    assert m2.addr == adc.address
+    assert m2.len == 1
+    assert m2.buf[0][0] == 0b00000000
+
+
+def test_output_pin_opens_and_closes_itself_when_used_as_a_context_manager():
+    adc = PCF8591(i2c, FOUR_SINGLE_ENDED)
+    
+    with adc.output_pin:
+        assert i2c.request_count == 1
     
+    assert i2c.request_count == 2
+
+
+def test_setting_value_of_output_pin_sends_value_as_second_written_byte():
+    adc = PCF8591(i2c, FOUR_SINGLE_ENDED, samples=1)
+    
+    with adc.output_pin as pin:
+        pin.value = 0.5
+        
+        assert i2c.request_count == 2
+        m1, = i2c.request(1)
+        assert m1.addr == adc.address
+        assert m1.len == 2
+        assert m1.buf[0][0] == 0b01000000
+        assert m1.buf[1][0] == 127
+
+        pin.value = 0.25
+        
+        assert i2c.request_count == 3
+        m2, = i2c.request(2)
+        assert m2.addr == adc.address
+        assert m2.len == 2
+        assert m2.buf[0][0] == 0b01000000
+        assert m2.buf[1][0] == 63
+
 
+
+def test_setting_value_of_output_pin_does_not_affect_currently_selected_input_pin():
+    adc = PCF8591(i2c, FOUR_SINGLE_ENDED, samples=1)
+    
+    with adc.output_pin as opin:
+        assert i2c.request_count == 1
+        
+        adc.input_pin(1).get()
+        assert i2c.request_count == 3
+        
+        opin.value = 0.5
+        assert i2c.request_count == 4
+        assert i2c.request(3)[0].buf[0][0] == 0b01000001
+        
+        adc.input_pin(2).get()
+        assert i2c.request_count == 6
+        
+        opin.value = 0.5
+        assert i2c.request_count == 7
+        assert i2c.request(6)[0].buf[0][0] == 0b01000010
