mirror of
https://github.com/KevinMidboe/python-gpiozero.git
synced 2025-10-29 09:40:36 +00:00
a99e0746c3
Permit replacement of pin_factory without closing old factory. However, continue closing devices associated with extant pin factory at script termination.
348 lines
12 KiB
Python
348 lines
12 KiB
Python
from __future__ import (
|
|
unicode_literals,
|
|
absolute_import,
|
|
print_function,
|
|
division,
|
|
)
|
|
str = type('')
|
|
|
|
|
|
import sys
|
|
import pytest
|
|
from mock import patch
|
|
from collections import namedtuple
|
|
try:
|
|
from math import isclose
|
|
except ImportError:
|
|
from gpiozero.compat import isclose
|
|
|
|
from gpiozero.pins.mock import MockSPIDevice, MockPin
|
|
from gpiozero import *
|
|
|
|
|
|
def teardown_function(function):
|
|
Device.pin_factory.reset()
|
|
|
|
def clamp(v, min_value, max_value):
|
|
return min(max_value, max(min_value, v))
|
|
|
|
def scale(v, ref, bits):
|
|
v /= ref
|
|
vmin = -(2 ** bits)
|
|
vmax = -vmin - 1
|
|
vrange = vmax - vmin
|
|
return int(((v + 1) / 2.0) * vrange + vmin)
|
|
|
|
|
|
class MockMCP3xxx(MockSPIDevice):
|
|
def __init__(
|
|
self, clock_pin, mosi_pin, miso_pin, select_pin=None,
|
|
channels=8, bits=10):
|
|
super(MockMCP3xxx, self).__init__(
|
|
clock_pin, mosi_pin, miso_pin, select_pin)
|
|
self.vref = 3.3
|
|
self.channels = [0.0] * channels
|
|
self.channel_bits = 3
|
|
self.bits = bits
|
|
self.state = 'idle'
|
|
|
|
def on_start(self):
|
|
super(MockMCP3xxx, self).on_start()
|
|
self.state = 'idle'
|
|
|
|
def on_bit(self):
|
|
if self.state == 'idle':
|
|
if self.rx_buf[-1]:
|
|
self.state = 'mode'
|
|
self.rx_buf = []
|
|
elif self.state == 'mode':
|
|
if self.rx_buf[-1]:
|
|
self.state = 'single'
|
|
else:
|
|
self.state = 'diff'
|
|
self.rx_buf = []
|
|
elif self.state in ('single', 'diff'):
|
|
if len(self.rx_buf) == self.channel_bits:
|
|
self.on_result(self.state == 'diff', self.rx_word())
|
|
self.state = 'result'
|
|
elif self.state == 'result':
|
|
if not self.tx_buf:
|
|
self.state = 'idle'
|
|
self.rx_buf = []
|
|
else:
|
|
assert False
|
|
|
|
def on_result(self, differential, channel):
|
|
if differential:
|
|
pos_channel = channel
|
|
neg_channel = pos_channel ^ 1
|
|
result = self.channels[pos_channel] - self.channels[neg_channel]
|
|
result = clamp(result, 0, self.vref)
|
|
else:
|
|
result = clamp(self.channels[channel], 0, self.vref)
|
|
result = scale(result, self.vref, self.bits)
|
|
self.tx_word(result, self.bits + 2)
|
|
|
|
|
|
class MockMCP3xx1(MockMCP3xxx):
|
|
def __init__(self, clock_pin, mosi_pin, miso_pin, select_pin=None, bits=10):
|
|
super(MockMCP3xx1, self).__init__(
|
|
clock_pin, mosi_pin, miso_pin, select_pin, channels=2, bits=bits)
|
|
|
|
def on_start(self):
|
|
super(MockMCP3xx1, self).on_start()
|
|
result = self.channels[0] - self.channels[1]
|
|
result = clamp(result, 0, self.vref)
|
|
result = scale(result, self.vref, self.bits)
|
|
self.tx_word(result, self.bits + 3)
|
|
|
|
def on_bit(self):
|
|
pass
|
|
|
|
|
|
class MockMCP3xx2(MockMCP3xxx):
|
|
def __init__(
|
|
self, clock_pin, mosi_pin, miso_pin, select_pin=None,
|
|
bits=10):
|
|
super(MockMCP3xx2, self).__init__(
|
|
clock_pin, mosi_pin, miso_pin, select_pin, channels=2, bits=bits)
|
|
self.channel_bits = 1
|
|
|
|
|
|
class MockMCP33xx(MockMCP3xxx):
|
|
def __init__(
|
|
self, clock_pin, mosi_pin, miso_pin, select_pin=None,
|
|
channels=8):
|
|
super(MockMCP33xx, self).__init__(
|
|
clock_pin, mosi_pin, miso_pin, select_pin, channels, 12)
|
|
|
|
def on_result(self, differential, channel):
|
|
if differential:
|
|
pos_channel = channel
|
|
neg_channel = pos_channel ^ 1
|
|
result = self.channels[pos_channel] - self.channels[neg_channel]
|
|
result = clamp(result, -self.vref, self.vref)
|
|
else:
|
|
result = clamp(self.channels[channel], 0, self.vref)
|
|
result = scale(result, self.vref, self.bits)
|
|
if result < 0:
|
|
result += 8192
|
|
self.tx_word(result, self.bits + 3)
|
|
|
|
|
|
class MockMCP3001(MockMCP3xx1):
|
|
def __init__(self, clock_pin, mosi_pin, miso_pin, select_pin=None):
|
|
super(MockMCP3001, self).__init__(
|
|
clock_pin, mosi_pin, miso_pin, select_pin, bits=10)
|
|
|
|
|
|
class MockMCP3002(MockMCP3xx2):
|
|
def __init__(self, clock_pin, mosi_pin, miso_pin, select_pin=None):
|
|
super(MockMCP3002, self).__init__(
|
|
clock_pin, mosi_pin, miso_pin, select_pin, bits=10)
|
|
|
|
|
|
class MockMCP3004(MockMCP3xxx):
|
|
def __init__(self, clock_pin, mosi_pin, miso_pin, select_pin=None):
|
|
super(MockMCP3004, self).__init__(
|
|
clock_pin, mosi_pin, miso_pin, select_pin, channels=4, bits=10)
|
|
|
|
|
|
class MockMCP3008(MockMCP3xxx):
|
|
def __init__(self, clock_pin, mosi_pin, miso_pin, select_pin=None):
|
|
super(MockMCP3008, self).__init__(
|
|
clock_pin, mosi_pin, miso_pin, select_pin, channels=8, bits=10)
|
|
|
|
|
|
class MockMCP3201(MockMCP3xx1):
|
|
def __init__(self, clock_pin, mosi_pin, miso_pin, select_pin=None):
|
|
super(MockMCP3201, self).__init__(
|
|
clock_pin, mosi_pin, miso_pin, select_pin, bits=12)
|
|
|
|
|
|
class MockMCP3202(MockMCP3xx2):
|
|
def __init__(self, clock_pin, mosi_pin, miso_pin, select_pin=None):
|
|
super(MockMCP3202, self).__init__(
|
|
clock_pin, mosi_pin, miso_pin, select_pin, bits=12)
|
|
|
|
|
|
class MockMCP3204(MockMCP3xxx):
|
|
def __init__(self, clock_pin, mosi_pin, miso_pin, select_pin=None):
|
|
super(MockMCP3204, self).__init__(
|
|
clock_pin, mosi_pin, miso_pin, select_pin, channels=4, bits=12)
|
|
|
|
|
|
class MockMCP3208(MockMCP3xxx):
|
|
def __init__(self, clock_pin, mosi_pin, miso_pin, select_pin=None):
|
|
super(MockMCP3208, self).__init__(
|
|
clock_pin, mosi_pin, miso_pin, select_pin, channels=8, bits=12)
|
|
|
|
|
|
class MockMCP3301(MockMCP3xxx):
|
|
def __init__(self, clock_pin, mosi_pin, miso_pin, select_pin=None):
|
|
super(MockMCP3301, self).__init__(
|
|
clock_pin, mosi_pin, miso_pin, select_pin, channels=2, bits=12)
|
|
|
|
def on_start(self):
|
|
super(MockMCP3301, self).on_start()
|
|
result = self.channels[0] - self.channels[1]
|
|
result = clamp(result, -self.vref, self.vref)
|
|
result = scale(result, self.vref, self.bits)
|
|
if result < 0:
|
|
result += 8192
|
|
self.tx_word(result, self.bits + 4)
|
|
|
|
|
|
class MockMCP3302(MockMCP33xx):
|
|
def __init__(self, clock_pin, mosi_pin, miso_pin, select_pin=None):
|
|
super(MockMCP3302, self).__init__(
|
|
clock_pin, mosi_pin, miso_pin, select_pin, channels=4)
|
|
|
|
|
|
class MockMCP3304(MockMCP33xx):
|
|
def __init__(self, clock_pin, mosi_pin, miso_pin, select_pin=None):
|
|
super(MockMCP3304, self).__init__(
|
|
clock_pin, mosi_pin, miso_pin, select_pin, channels=8)
|
|
|
|
|
|
def single_mcp_test(mock, pot, channel, bits):
|
|
scale = 2**bits
|
|
tolerance = 1 / scale
|
|
mock.channels[channel] = 0.0
|
|
assert pot.raw_value == 0
|
|
assert isclose(pot.value, 0.0, abs_tol=tolerance)
|
|
mock.channels[channel] = mock.vref / 2
|
|
assert pot.raw_value == (scale / 2) - 1
|
|
assert isclose(pot.value, 0.5, abs_tol=tolerance)
|
|
mock.channels[channel] = mock.vref
|
|
assert pot.raw_value == scale - 1
|
|
assert isclose(pot.value, 1.0, abs_tol=tolerance)
|
|
|
|
def differential_mcp_test(mock, pot, pos_channel, neg_channel, bits, full=False):
|
|
scale = 2**bits
|
|
tolerance = 1 / scale
|
|
mock.channels[pos_channel] = 0.0
|
|
mock.channels[neg_channel] = 0.0
|
|
assert pot.raw_value == 0
|
|
assert isclose(pot.value, 0.0, abs_tol=tolerance)
|
|
mock.channels[pos_channel] = mock.vref / 2
|
|
assert pot.raw_value == (scale / 2) - 1
|
|
assert isclose(pot.value, 0.5, abs_tol=tolerance)
|
|
mock.channels[pos_channel] = mock.vref
|
|
assert pot.raw_value == scale - 1
|
|
assert isclose(pot.value, 1.0, abs_tol=tolerance)
|
|
mock.channels[neg_channel] = mock.vref / 2
|
|
assert pot.raw_value == (scale / 2) - 1
|
|
assert isclose(pot.value, 0.5, abs_tol=tolerance)
|
|
mock.channels[pos_channel] = mock.vref / 2
|
|
assert pot.raw_value == 0
|
|
assert isclose(pot.value, 0.0, abs_tol=tolerance)
|
|
mock.channels[pos_channel] = 0.0
|
|
mock.channels[neg_channel] = mock.vref
|
|
if full:
|
|
assert pot.raw_value == -scale
|
|
assert isclose(pot.value, -1.0, abs_tol=tolerance)
|
|
else:
|
|
assert pot.raw_value == 0
|
|
assert isclose(pot.value, 0.0, abs_tol=tolerance)
|
|
|
|
|
|
def test_MCP3001():
|
|
with patch('gpiozero.pins.local.SpiDev', None):
|
|
mock = MockMCP3001(11, 10, 9, 8)
|
|
with MCP3001() as pot:
|
|
differential_mcp_test(mock, pot, 0, 1, 10)
|
|
|
|
def test_MCP3002():
|
|
with patch('gpiozero.pins.local.SpiDev', None):
|
|
mock = MockMCP3002(11, 10, 9, 8)
|
|
with pytest.raises(ValueError):
|
|
MCP3002(channel=5)
|
|
with MCP3002(channel=1) as pot:
|
|
single_mcp_test(mock, pot, 1, 10)
|
|
with MCP3002(channel=1, differential=True) as pot:
|
|
differential_mcp_test(mock, pot, 1, 0, 10)
|
|
|
|
def test_MCP3004():
|
|
with patch('gpiozero.pins.local.SpiDev', None):
|
|
mock = MockMCP3004(11, 10, 9, 8)
|
|
with pytest.raises(ValueError):
|
|
MCP3004(channel=5)
|
|
with MCP3004(channel=3) as pot:
|
|
single_mcp_test(mock, pot, 3, 10)
|
|
with MCP3004(channel=3, differential=True) as pot:
|
|
differential_mcp_test(mock, pot, 3, 2, 10)
|
|
|
|
def test_MCP3008():
|
|
with patch('gpiozero.pins.local.SpiDev', None):
|
|
mock = MockMCP3008(11, 10, 9, 8)
|
|
with pytest.raises(ValueError):
|
|
MCP3008(channel=9)
|
|
with MCP3008(channel=0) as pot:
|
|
single_mcp_test(mock, pot, 0, 10)
|
|
with MCP3008(channel=0, differential=True) as pot:
|
|
differential_mcp_test(mock, pot, 0, 1, 10)
|
|
|
|
def test_MCP3201():
|
|
with patch('gpiozero.pins.local.SpiDev', None):
|
|
mock = MockMCP3201(11, 10, 9, 8)
|
|
with MCP3201() as pot:
|
|
differential_mcp_test(mock, pot, 0, 1, 12)
|
|
|
|
def test_MCP3202():
|
|
with patch('gpiozero.pins.local.SpiDev', None):
|
|
mock = MockMCP3202(11, 10, 9, 8)
|
|
with pytest.raises(ValueError):
|
|
MCP3202(channel=5)
|
|
with MCP3202(channel=1) as pot:
|
|
single_mcp_test(mock, pot, 1, 12)
|
|
with MCP3202(channel=1, differential=True) as pot:
|
|
differential_mcp_test(mock, pot, 1, 0, 12)
|
|
|
|
def test_MCP3204():
|
|
with patch('gpiozero.pins.local.SpiDev', None):
|
|
mock = MockMCP3204(11, 10, 9, 8)
|
|
with pytest.raises(ValueError):
|
|
MCP3204(channel=5)
|
|
with MCP3204(channel=1) as pot:
|
|
single_mcp_test(mock, pot, 1, 12)
|
|
with MCP3204(channel=1, differential=True) as pot:
|
|
differential_mcp_test(mock, pot, 1, 0, 12)
|
|
|
|
def test_MCP3208():
|
|
with patch('gpiozero.pins.local.SpiDev', None):
|
|
mock = MockMCP3208(11, 10, 9, 8)
|
|
with pytest.raises(ValueError):
|
|
MCP3208(channel=9)
|
|
with MCP3208(channel=7) as pot:
|
|
single_mcp_test(mock, pot, 7, 12)
|
|
with MCP3208(channel=7, differential=True) as pot:
|
|
differential_mcp_test(mock, pot, 7, 6, 12)
|
|
|
|
def test_MCP3301():
|
|
with patch('gpiozero.pins.local.SpiDev', None):
|
|
mock = MockMCP3301(11, 10, 9, 8)
|
|
with MCP3301() as pot:
|
|
differential_mcp_test(mock, pot, 0, 1, 12, full=True)
|
|
|
|
def test_MCP3302():
|
|
with patch('gpiozero.pins.local.SpiDev', None):
|
|
mock = MockMCP3302(11, 10, 9, 8)
|
|
with pytest.raises(ValueError):
|
|
MCP3302(channel=4)
|
|
with MCP3302(channel=0) as pot:
|
|
single_mcp_test(mock, pot, 0, 12)
|
|
with MCP3302(channel=0, differential=True) as pot:
|
|
differential_mcp_test(mock, pot, 0, 1, 12, full=True)
|
|
|
|
def test_MCP3304():
|
|
with patch('gpiozero.pins.local.SpiDev', None):
|
|
mock = MockMCP3304(11, 10, 9, 8)
|
|
with pytest.raises(ValueError):
|
|
MCP3304(channel=9)
|
|
with MCP3304(channel=5) as pot:
|
|
single_mcp_test(mock, pot, 5, 12)
|
|
with MCP3304(channel=5, differential=True) as pot:
|
|
differential_mcp_test(mock, pot, 5, 4, 12, full=True)
|
|
|