KevinMidboe/python-gpiozero
1
0
Fork 0
mirror of https://github.com/KevinMidboe/python-gpiozero.git synced 2025-10-29 09:40:36 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
master
python-gpiozero/tests/test_boards.py
Dave Jones c820636fcb Fix #279 once and for all (ha! ;) 
This implements the proposal discussed in the re-opened #279 to add a
pin_factory argument at the device level and remove the ability to
specify a pin instance to device constructors (they now only accept a
pin specification).

Note: there's still a couple of bits to tidy up (tests on "real" Pis,
and pin_factory.release_all needs refinement) but the test suite is now
at least capable of passing on a PC.
2017-07-04 00:26:41 +01:00

892 lines
32 KiB
Python
Raw Permalink Blame History

from __future__ import (
unicode_literals,
absolute_import,
print_function,
division,
)
str = type('')
import sys
import pytest
from time import sleep
from gpiozero import *
from gpiozero.pins.mock import MockPWMPin, MockPin
def setup_function(function):
# dirty, but it does the job
Device.pin_factory.pin_class = MockPWMPin if function.__name__ in (
'test_robot',
'test_ryanteck_robot',
'test_camjam_kit_robot',
'test_led_borg',
'test_led_board_pwm_value',
'test_led_board_pwm_bad_value',
'test_snow_pi_initial_value_pwm',
'test_led_board_pwm_initial_value',
'test_led_board_pwm_bad_initial_value',
'test_led_board_fade_background',
'test_led_bar_graph_pwm_value',
'test_led_bar_graph_pwm_initial_value',
'test_statusboard_kwargs',
'test_statuszero_kwargs',
) else MockPin
def teardown_function(function):
Device.pin_factory.reset()
def teardown_module(module):
# make sure we reset the default
Device.pin_factory.pwm = False
def test_composite_output_on_off():
pin1 = Device.pin_factory.pin(2)
pin2 = Device.pin_factory.pin(3)
pin3 = Device.pin_factory.pin(4)
with CompositeOutputDevice(OutputDevice(2), OutputDevice(3), foo=OutputDevice(4)) as device:
device.on()
assert all((pin1.state, pin2.state, pin3.state))
device.off()
assert not any((pin1.state, pin2.state, pin3.state))
def test_composite_output_toggle():
pin1 = Device.pin_factory.pin(2)
pin2 = Device.pin_factory.pin(3)
pin3 = Device.pin_factory.pin(4)
with CompositeOutputDevice(OutputDevice(2), OutputDevice(3), foo=OutputDevice(4)) as device:
device.toggle()
assert all((pin1.state, pin2.state, pin3.state))
device[0].off()
device.toggle()
assert pin1.state
assert not pin2.state
assert not pin3.state
def test_composite_output_value():
pin1 = Device.pin_factory.pin(2)
pin2 = Device.pin_factory.pin(3)
pin3 = Device.pin_factory.pin(4)
with CompositeOutputDevice(OutputDevice(2), OutputDevice(3), foo=OutputDevice(4)) as device:
assert device.value == (0, 0, 0)
device.toggle()
assert device.value == (1, 1, 1)
device.value = (1, 0, 1)
assert device[0].is_active
assert not device[1].is_active
assert device[2].is_active
def test_led_board_on_off():
pin1 = Device.pin_factory.pin(2)
pin2 = Device.pin_factory.pin(3)
pin3 = Device.pin_factory.pin(4)
with LEDBoard(2, 3, foo=4) as board:
assert isinstance(board[0], LED)
assert isinstance(board[1], LED)
assert isinstance(board[2], LED)
assert board.active_high
assert board[0].active_high
assert board[1].active_high
assert board[2].active_high
board.on()
assert all((pin1.state, pin2.state, pin3.state))
board.off()
assert not any((pin1.state, pin2.state, pin3.state))
board[0].on()
assert board.value == (1, 0, 0)
assert pin1.state
assert not pin2.state
assert not pin3.state
board.toggle()
assert board.value == (0, 1, 1)
assert not pin1.state
assert pin2.state
assert pin3.state
board.toggle(0,1)
assert board.value == (1, 0, 1)
assert pin1.state
assert not pin2.state
assert pin3.state
board.off(2)
assert board.value == (1, 0, 0)
assert pin1.state
assert not pin2.state
assert not pin3.state
board.on(1)
assert board.value == (1, 1, 0)
assert pin1.state
assert pin2.state
assert not pin3.state
board.off(0,1)
assert board.value == (0, 0, 0)
assert not pin1.state
assert not pin2.state
assert not pin3.state
board.on(1,2)
assert board.value == (0, 1, 1)
assert not pin1.state
assert pin2.state
assert pin3.state
board.toggle(0)
assert board.value == (1, 1, 1)
assert pin1.state
assert pin2.state
assert pin3.state
def test_led_board_active_low():
pin1 = Device.pin_factory.pin(2)
pin2 = Device.pin_factory.pin(3)
pin3 = Device.pin_factory.pin(4)
with LEDBoard(2, 3, foo=4, active_high=False) as board:
assert not board.active_high
assert not board[0].active_high
assert not board[1].active_high
assert not board[2].active_high
board.on()
assert not any ((pin1.state, pin2.state, pin3.state))
board.off()
assert all((pin1.state, pin2.state, pin3.state))
board[0].on()
assert board.value == (1, 0, 0)
assert not pin1.state
assert pin2.state
assert pin3.state
board.toggle()
assert board.value == (0, 1, 1)
assert pin1.state
assert not pin2.state
assert not pin3.state
def test_led_board_value():
pin1 = Device.pin_factory.pin(2)
pin2 = Device.pin_factory.pin(3)
pin3 = Device.pin_factory.pin(4)
with LEDBoard(2, 3, foo=4) as board:
assert board.value == (0, 0, 0)
board.value = (0, 1, 0)
assert board.value == (0, 1, 0)
board.value = (1, 0, 1)
assert board.value == (1, 0, 1)
def test_led_board_pwm_value():
pin1 = Device.pin_factory.pin(2)
pin2 = Device.pin_factory.pin(3)
pin3 = Device.pin_factory.pin(4)
with LEDBoard(2, 3, foo=4, pwm=True) as board:
assert board.value == (0, 0, 0)
board.value = (0, 1, 0)
assert board.value == (0, 1, 0)
board.value = (0.5, 0, 0.75)
assert board.value == (0.5, 0, 0.75)
def test_led_board_pwm_bad_value():
pin1 = Device.pin_factory.pin(2)
pin2 = Device.pin_factory.pin(3)
pin3 = Device.pin_factory.pin(4)
with LEDBoard(2, 3, foo=4, pwm=True) as board:
with pytest.raises(ValueError):
board.value = (-1, 0, 0)
with pytest.raises(ValueError):
board.value = (0, 2, 0)
def test_led_board_initial_value():
pin1 = Device.pin_factory.pin(2)
pin2 = Device.pin_factory.pin(3)
pin3 = Device.pin_factory.pin(4)
with LEDBoard(2, 3, foo=4, initial_value=0) as board:
assert board.value == (0, 0, 0)
with LEDBoard(2, 3, foo=4, initial_value=1) as board:
assert board.value == (1, 1, 1)
def test_led_board_pwm_initial_value():
pin1 = Device.pin_factory.pin(2)
pin2 = Device.pin_factory.pin(3)
pin3 = Device.pin_factory.pin(4)
with LEDBoard(2, 3, foo=4, pwm=True, initial_value=0) as board:
assert board.value == (0, 0, 0)
with LEDBoard(2, 3, foo=4, pwm=True, initial_value=1) as board:
assert board.value == (1, 1, 1)
with LEDBoard(2, 3, foo=4, pwm=True, initial_value=0.5) as board:
assert board.value == (0.5, 0.5, 0.5)
def test_led_board_pwm_bad_initial_value():
pin1 = Device.pin_factory.pin(2)
pin2 = Device.pin_factory.pin(3)
pin3 = Device.pin_factory.pin(4)
with pytest.raises(ValueError):
LEDBoard(2, 3, foo=4, pwm=True, initial_value=-1)
with pytest.raises(ValueError):
LEDBoard(2, 3, foo=4, pwm=True, initial_value=2)
def test_led_board_nested():
pin1 = Device.pin_factory.pin(2)
pin2 = Device.pin_factory.pin(3)
pin3 = Device.pin_factory.pin(4)
with LEDBoard(2, LEDBoard(3, 4)) as board:
assert list(led.pin for led in board.leds) == [pin1, pin2, pin3]
assert board.value == (0, (0, 0))
board.value = (1, (0, 1))
assert pin1.state
assert not pin2.state
assert pin3.state
def test_led_board_bad_blink():
pin1 = Device.pin_factory.pin(2)
pin2 = Device.pin_factory.pin(3)
pin3 = Device.pin_factory.pin(4)
with LEDBoard(2, LEDBoard(3, 4)) as board:
with pytest.raises(ValueError):
board.blink(fade_in_time=1, fade_out_time=1)
with pytest.raises(ValueError):
board.blink(fade_out_time=1)
with pytest.raises(ValueError):
board.pulse()
@pytest.mark.skipif(hasattr(sys, 'pypy_version_info'),
reason='timing is too random on pypy')
def test_led_board_blink_background():
pin1 = Device.pin_factory.pin(4)
pin2 = Device.pin_factory.pin(5)
pin3 = Device.pin_factory.pin(6)
with LEDBoard(4, LEDBoard(5, 6)) as board:
# Instantiation takes a long enough time that it throws off our timing
# here!
pin1.clear_states()
pin2.clear_states()
pin3.clear_states()
board.blink(0.1, 0.1, n=2)
board._blink_thread.join() # naughty, but ensures no arbitrary waits in the test
test = [
(0.0, False),
(0.0, True),
(0.1, False),
(0.1, True),
(0.1, False)
]
pin1.assert_states_and_times(test)
pin2.assert_states_and_times(test)
pin3.assert_states_and_times(test)
@pytest.mark.skipif(hasattr(sys, 'pypy_version_info'),
reason='timing is too random on pypy')
def test_led_board_blink_foreground():
pin1 = Device.pin_factory.pin(4)
pin2 = Device.pin_factory.pin(5)
pin3 = Device.pin_factory.pin(6)
with LEDBoard(4, LEDBoard(5, 6)) as board:
pin1.clear_states()
pin2.clear_states()
pin3.clear_states()
board.blink(0.1, 0.1, n=2, background=False)
test = [
(0.0, False),
(0.0, True),
(0.1, False),
(0.1, True),
(0.1, False)
]
pin1.assert_states_and_times(test)
pin2.assert_states_and_times(test)
pin3.assert_states_and_times(test)
@pytest.mark.skipif(hasattr(sys, 'pypy_version_info'),
reason='timing is too random on pypy')
def test_led_board_blink_control():
pin1 = Device.pin_factory.pin(4)
pin2 = Device.pin_factory.pin(5)
pin3 = Device.pin_factory.pin(6)
with LEDBoard(4, LEDBoard(5, 6)) as board:
pin1.clear_states()
pin2.clear_states()
pin3.clear_states()
board.blink(0.1, 0.1, n=2)
# make sure the blink thread's started
while not board._blink_leds:
sleep(0.00001) # pragma: no cover
board[1][0].off() # immediately take over the second LED
board._blink_thread.join() # naughty, but ensures no arbitrary waits in the test
test = [
(0.0, False),
(0.0, True),
(0.1, False),
(0.1, True),
(0.1, False)
]
pin1.assert_states_and_times(test)
pin3.assert_states_and_times(test)
print(pin2.states)
pin2.assert_states_and_times([(0.0, False), (0.0, True), (0.0, False)])
@pytest.mark.skipif(hasattr(sys, 'pypy_version_info'),
reason='timing is too random on pypy')
def test_led_board_blink_take_over():
pin1 = Device.pin_factory.pin(4)
pin2 = Device.pin_factory.pin(5)
pin3 = Device.pin_factory.pin(6)
with LEDBoard(4, LEDBoard(5, 6)) as board:
pin1.clear_states()
pin2.clear_states()
pin3.clear_states()
board[1].blink(0.1, 0.1, n=2)
board.blink(0.1, 0.1, n=2) # immediately take over blinking
board[1]._blink_thread.join()
board._blink_thread.join()
test = [
(0.0, False),
(0.0, True),
(0.1, False),
(0.1, True),
(0.1, False)
]
pin1.assert_states_and_times(test)
pin2.assert_states_and_times(test)
pin3.assert_states_and_times(test)
@pytest.mark.skipif(hasattr(sys, 'pypy_version_info'),
reason='timing is too random on pypy')
def test_led_board_blink_control_all():
pin1 = Device.pin_factory.pin(4)
pin2 = Device.pin_factory.pin(5)
pin3 = Device.pin_factory.pin(6)
with LEDBoard(4, LEDBoard(5, 6)) as board:
pin1.clear_states()
pin2.clear_states()
pin3.clear_states()
board.blink(0.1, 0.1, n=2)
# make sure the blink thread's started
while not board._blink_leds:
sleep(0.00001) # pragma: no cover
board[0].off() # immediately take over all LEDs
board[1][0].off()
board[1][1].off()
board._blink_thread.join() # blink should terminate here anyway
test = [
(0.0, False),
(0.0, True),
(0.0, False),
]
pin1.assert_states_and_times(test)
pin2.assert_states_and_times(test)
pin3.assert_states_and_times(test)
def test_led_board_blink_interrupt_on():
pin1 = Device.pin_factory.pin(4)
pin2 = Device.pin_factory.pin(5)
pin3 = Device.pin_factory.pin(6)
with LEDBoard(4, LEDBoard(5, 6)) as board:
board.blink(1, 0.1)
sleep(0.2)
board.off() # should interrupt while on
pin1.assert_states([False, True, False])
pin2.assert_states([False, True, False])
pin3.assert_states([False, True, False])
def test_led_board_blink_interrupt_off():
pin1 = Device.pin_factory.pin(4)
pin2 = Device.pin_factory.pin(5)
pin3 = Device.pin_factory.pin(6)
with LEDBoard(4, LEDBoard(5, 6)) as board:
pin1.clear_states()
pin2.clear_states()
pin3.clear_states()
board.blink(0.1, 1)
sleep(0.2)
board.off() # should interrupt while off
pin1.assert_states([False, True, False])
pin2.assert_states([False, True, False])
pin3.assert_states([False, True, False])
@pytest.mark.skipif(hasattr(sys, 'pypy_version_info'),
reason='timing is too random on pypy')
def test_led_board_fade_background():
pin1 = Device.pin_factory.pin(4)
pin2 = Device.pin_factory.pin(5)
pin3 = Device.pin_factory.pin(6)
with LEDBoard(4, LEDBoard(5, 6, pwm=True), pwm=True) as board:
pin1.clear_states()
pin2.clear_states()
pin3.clear_states()
board.blink(0, 0, 0.2, 0.2, n=2)
board._blink_thread.join()
test = [
(0.0, 0),
(0.04, 0.2),
(0.04, 0.4),
(0.04, 0.6),
(0.04, 0.8),
(0.04, 1),
(0.04, 0.8),
(0.04, 0.6),
(0.04, 0.4),
(0.04, 0.2),
(0.04, 0),
(0.04, 0.2),
(0.04, 0.4),
(0.04, 0.6),
(0.04, 0.8),
(0.04, 1),
(0.04, 0.8),
(0.04, 0.6),
(0.04, 0.4),
(0.04, 0.2),
(0.04, 0),
]
pin1.assert_states_and_times(test)
pin2.assert_states_and_times(test)
pin3.assert_states_and_times(test)
def test_led_bar_graph_value():
pin1 = Device.pin_factory.pin(2)
pin2 = Device.pin_factory.pin(3)
pin3 = Device.pin_factory.pin(4)
with LEDBarGraph(2, 3, 4) as graph:
assert isinstance(graph[0], LED)
assert isinstance(graph[1], LED)
assert isinstance(graph[2], LED)
assert graph.active_high
assert graph[0].active_high
assert graph[1].active_high
assert graph[2].active_high
graph.value = 0
assert graph.value == 0
assert not any((pin1.state, pin2.state, pin3.state))
graph.value = 1
assert graph.value == 1
assert all((pin1.state, pin2.state, pin3.state))
graph.value = 1/3
assert graph.value == 1/3
assert pin1.state and not (pin2.state or pin3.state)
graph.value = -1/3
assert graph.value == -1/3
assert pin3.state and not (pin1.state or pin2.state)
pin1.state = True
pin2.state = True
assert graph.value == 1
pin3.state = False
assert graph.value == 2/3
pin3.state = True
pin1.state = False
assert graph.value == -2/3
def test_led_bar_graph_active_low():
pin1 = Device.pin_factory.pin(2)
pin2 = Device.pin_factory.pin(3)
pin3 = Device.pin_factory.pin(4)
with LEDBarGraph(2, 3, 4, active_high=False) as graph:
assert not graph.active_high
assert not graph[0].active_high
assert not graph[1].active_high
assert not graph[2].active_high
graph.value = 0
assert graph.value == 0
assert all((pin1.state, pin2.state, pin3.state))
graph.value = 1
assert graph.value == 1
assert not any((pin1.state, pin2.state, pin3.state))
graph.value = 1/3
assert graph.value == 1/3
assert not pin1.state and pin2.state and pin3.state
graph.value = -1/3
assert graph.value == -1/3
assert not pin3.state and pin1.state and pin2.state
def test_led_bar_graph_pwm_value():
pin1 = Device.pin_factory.pin(2)
pin2 = Device.pin_factory.pin(3)
pin3 = Device.pin_factory.pin(4)
with LEDBarGraph(2, 3, 4, pwm=True) as graph:
assert isinstance(graph[0], PWMLED)
assert isinstance(graph[1], PWMLED)
assert isinstance(graph[2], PWMLED)
graph.value = 0
assert graph.value == 0
assert not any((pin1.state, pin2.state, pin3.state))
graph.value = 1
assert graph.value == 1
assert all((pin1.state, pin2.state, pin3.state))
graph.value = 1/3
assert graph.value == 1/3
assert pin1.state and not (pin2.state or pin3.state)
graph.value = -1/3
assert graph.value == -1/3
assert pin3.state and not (pin1.state or pin2.state)
graph.value = 1/2
assert graph.value == 1/2
assert (pin1.state, pin2.state, pin3.state) == (1, 0.5, 0)
pin1.state = 0
pin3.state = 1
assert graph.value == -1/2
def test_led_bar_graph_bad_value():
pin1 = Device.pin_factory.pin(2)
pin2 = Device.pin_factory.pin(3)
pin3 = Device.pin_factory.pin(4)
with LEDBarGraph(2, 3, 4) as graph:
with pytest.raises(ValueError):
graph.value = -2
with pytest.raises(ValueError):
graph.value = 2
def test_led_bar_graph_bad_init():
pin1 = Device.pin_factory.pin(2)
pin2 = Device.pin_factory.pin(3)
pin3 = Device.pin_factory.pin(4)
with pytest.raises(TypeError):
LEDBarGraph(2, 3, foo=4)
with pytest.raises(ValueError):
LEDBarGraph(2, 3, 4, initial_value=-2)
with pytest.raises(ValueError):
LEDBarGraph(2, 3, 4, initial_value=2)
def test_led_bar_graph_initial_value():
pin1 = Device.pin_factory.pin(2)
pin2 = Device.pin_factory.pin(3)
pin3 = Device.pin_factory.pin(4)
with LEDBarGraph(2, 3, 4, initial_value=1/3) as graph:
assert graph.value == 1/3
assert pin1.state and not (pin2.state or pin3.state)
with LEDBarGraph(2, 3, 4, initial_value=-1/3) as graph:
assert graph.value == -1/3
assert pin3.state and not (pin1.state or pin2.state)
def test_led_bar_graph_pwm_initial_value():
pin1 = Device.pin_factory.pin(2)
pin2 = Device.pin_factory.pin(3)
pin3 = Device.pin_factory.pin(4)
with LEDBarGraph(2, 3, 4, pwm=True, initial_value=0.5) as graph:
assert graph.value == 0.5
assert (pin1.state, pin2.state, pin3.state) == (1, 0.5, 0)
with LEDBarGraph(2, 3, 4, pwm=True, initial_value=-0.5) as graph:
assert graph.value == -0.5
assert (pin1.state, pin2.state, pin3.state) == (0, 0.5, 1)
def test_led_borg():
pins = [Device.pin_factory.pin(n) for n in (17, 27, 22)]
with LedBorg() as board:
assert [device.pin for device in board._leds] == pins
def test_pi_liter():
pins = [Device.pin_factory.pin(n) for n in (4, 17, 27, 18, 22, 23, 24, 25)]
with PiLiter() as board:
assert [device.pin for device in board] == pins
def test_pi_liter_graph():
pins = [Device.pin_factory.pin(n) for n in (4, 17, 27, 18, 22, 23, 24, 25)]
with PiLiterBarGraph() as board:
board.value = 0.5
assert [pin.state for pin in pins] == [1, 1, 1, 1, 0, 0, 0, 0]
pins[4].state = 1
assert board.value == 5/8
def test_traffic_lights():
red_pin = Device.pin_factory.pin(2)
amber_pin = Device.pin_factory.pin(3)
green_pin = Device.pin_factory.pin(4)
with TrafficLights(2, 3, 4) as board:
board.red.on()
assert board.red.value
assert not board.amber.value
assert not board.yellow.value
assert not board.green.value
assert red_pin.state
assert not amber_pin.state
assert not green_pin.state
board.amber.on()
assert amber_pin.state
board.yellow.off()
assert not amber_pin.state
with TrafficLights(red=2, yellow=3, green=4) as board:
board.yellow.on()
assert not board.red.value
assert board.amber.value
assert board.yellow.value
assert not board.green.value
assert not red_pin.state
assert amber_pin.state
assert not green_pin.state
board.amber.off()
assert not amber_pin.state
def test_traffic_lights_bad_init():
with pytest.raises(ValueError):
TrafficLights()
red_pin = Device.pin_factory.pin(2)
amber_pin = Device.pin_factory.pin(3)
green_pin = Device.pin_factory.pin(4)
yellow_pin = Device.pin_factory.pin(5)
with pytest.raises(ValueError):
TrafficLights(red=2, amber=3, yellow=5, green=4)
def test_pi_traffic():
pins = [Device.pin_factory.pin(n) for n in (9, 10, 11)]
with PiTraffic() as board:
assert [device.pin for device in board] == pins
def test_pi_stop():
with pytest.raises(ValueError):
PiStop()
with pytest.raises(ValueError):
PiStop('E')
pins_a = [Device.pin_factory.pin(n) for n in (7, 8, 25)]
with PiStop('A') as board:
assert [device.pin for device in board] == pins_a
pins_aplus = [Device.pin_factory.pin(n) for n in (21, 20, 16)]
with PiStop('A+') as board:
assert [device.pin for device in board] == pins_aplus
pins_b = [Device.pin_factory.pin(n) for n in (10, 9, 11)]
with PiStop('B') as board:
assert [device.pin for device in board] == pins_b
pins_bplus = [Device.pin_factory.pin(n) for n in (13, 19, 26)]
with PiStop('B+') as board:
assert [device.pin for device in board] == pins_bplus
pins_c = [Device.pin_factory.pin(n) for n in (18, 15, 14)]
with PiStop('C') as board:
assert [device.pin for device in board] == pins_c
pins_d = [Device.pin_factory.pin(n) for n in (2, 3, 4)]
with PiStop('D') as board:
assert [device.pin for device in board] == pins_d
def test_snow_pi():
pins = [Device.pin_factory.pin(n) for n in (23, 24, 25, 17, 18, 22, 7, 8, 9)]
with SnowPi() as board:
assert [device.pin for device in board.leds] == pins
def test_snow_pi_initial_value():
with SnowPi() as board:
assert all(device.pin.state == False for device in board.leds)
with SnowPi(initial_value=False) as board:
assert all(device.pin.state == False for device in board.leds)
with SnowPi(initial_value=True) as board:
assert all(device.pin.state == True for device in board.leds)
with SnowPi(initial_value=0.5) as board:
assert all(device.pin.state == True for device in board.leds)
def test_snow_pi_initial_value_pwm():
pins = [Device.pin_factory.pin(n) for n in (23, 24, 25, 17, 18, 22, 7, 8, 9)]
with SnowPi(pwm=True, initial_value=0.5) as board:
assert [device.pin for device in board.leds] == pins
assert all(device.pin.state == 0.5 for device in board.leds)
def test_traffic_lights_buzzer():
red_pin = Device.pin_factory.pin(2)
amber_pin = Device.pin_factory.pin(3)
green_pin = Device.pin_factory.pin(4)
buzzer_pin = Device.pin_factory.pin(5)
button_pin = Device.pin_factory.pin(6)
with TrafficLightsBuzzer(
TrafficLights(2, 3, 4),
Buzzer(5),
Button(6)) as board:
board.lights.red.on()
board.buzzer.on()
assert red_pin.state
assert not amber_pin.state
assert not green_pin.state
assert buzzer_pin.state
button_pin.drive_low()
assert board.button.is_active
def test_fish_dish():
pins = [Device.pin_factory.pin(n) for n in (9, 22, 4, 8, 7)]
with FishDish() as board:
assert [led.pin for led in board.lights] + [board.buzzer.pin, board.button.pin] == pins
def test_traffic_hat():
pins = [Device.pin_factory.pin(n) for n in (24, 23, 22, 5, 25)]
with TrafficHat() as board:
assert [led.pin for led in board.lights] + [board.buzzer.pin, board.button.pin] == pins
def test_robot():
pins = [Device.pin_factory.pin(n) for n in (2, 3, 4, 5)]
with Robot((2, 3), (4, 5)) as robot:
assert (
[device.pin for device in robot.left_motor] +
[device.pin for device in robot.right_motor]) == pins
assert robot.value == (0, 0)
robot.forward()
assert [pin.state for pin in pins] == [1, 0, 1, 0]
assert robot.value == (1, 1)
robot.backward()
assert [pin.state for pin in pins] == [0, 1, 0, 1]
assert robot.value == (-1, -1)
robot.forward(0.5)
assert [pin.state for pin in pins] == [0.5, 0, 0.5, 0]
assert robot.value == (0.5, 0.5)
robot.left()
assert [pin.state for pin in pins] == [0, 1, 1, 0]
assert robot.value == (-1, 1)
robot.right()
assert [pin.state for pin in pins] == [1, 0, 0, 1]
assert robot.value == (1, -1)
robot.reverse()
assert [pin.state for pin in pins] == [0, 1, 1, 0]
assert robot.value == (-1, 1)
robot.stop()
assert [pin.state for pin in pins] == [0, 0, 0, 0]
assert robot.value == (0, 0)
robot.value = (-1, -1)
assert robot.value == (-1, -1)
robot.value = (0.5, 1)
assert robot.value == (0.5, 1)
robot.value = (0, -0.5)
assert robot.value == (0, -0.5)
def test_ryanteck_robot():
pins = [Device.pin_factory.pin(n) for n in (17, 18, 22, 23)]
with RyanteckRobot() as board:
assert [device.pin for motor in board for device in motor] == pins
def test_camjam_kit_robot():
pins = [Device.pin_factory.pin(n) for n in (9, 10, 7, 8)]
with CamJamKitRobot() as board:
assert [device.pin for motor in board for device in motor] == pins
def test_energenie_bad_init():
with pytest.raises(ValueError):
Energenie()
with pytest.raises(ValueError):
Energenie(0)
with pytest.raises(ValueError):
Energenie(5)
def test_energenie():
pins = [Device.pin_factory.pin(n) for n in (17, 22, 23, 27, 24, 25)]
with Energenie(1, initial_value=True) as device1, \
Energenie(2, initial_value=False) as device2:
assert repr(device1) == '<gpiozero.Energenie object on socket 1>'
assert repr(device2) == '<gpiozero.Energenie object on socket 2>'
assert device1.value
assert not device2.value
[pin.clear_states() for pin in pins]
device1.on()
assert device1.value
pins[0].assert_states_and_times([(0.0, False), (0.0, True)])
pins[1].assert_states_and_times([(0.0, True), (0.0, True)])
pins[2].assert_states_and_times([(0.0, True), (0.0, True)])
pins[3].assert_states_and_times([(0.0, False), (0.0, True)])
pins[4].assert_states_and_times([(0.0, False)])
pins[5].assert_states_and_times([(0.0, False), (0.1, True), (0.25, False)])
[pin.clear_states() for pin in pins]
device2.on()
assert device2.value
pins[0].assert_states_and_times([(0.0, True), (0.0, False)])
pins[1].assert_states_and_times([(0.0, True), (0.0, True)])
pins[2].assert_states_and_times([(0.0, True), (0.0, True)])
pins[3].assert_states_and_times([(0.0, True), (0.0, True)])
pins[4].assert_states_and_times([(0.0, False)])
pins[5].assert_states_and_times([(0.0, False), (0.1, True), (0.25, False)])
device1.close()
assert repr(device1) == '<gpiozero.Energenie object closed>'
def test_statuszero_init():
with StatusZero() as sz:
assert sz.namedtuple._fields == ('one', 'two', 'three')
with StatusZero('a') as sz:
assert sz.namedtuple._fields == ('a',)
with StatusZero('a', 'b') as sz:
assert sz.namedtuple._fields == ('a', 'b')
with StatusZero('a', 'b', 'c') as sz:
assert sz.namedtuple._fields == ('a', 'b', 'c')
with pytest.raises(ValueError):
StatusZero('a', 'b', 'c', 'd')
with pytest.raises(ValueError):
StatusZero('0')
with pytest.raises(ValueError):
StatusZero('foo', 'hello world')
with pytest.raises(ValueError):
StatusZero('foo', 'foo')
def test_statuszero():
with StatusZero() as sz:
assert isinstance(sz.one, LEDBoard)
assert isinstance(sz.two, LEDBoard)
assert isinstance(sz.three, LEDBoard)
assert isinstance(sz.one.red, LED)
assert isinstance(sz.one.green, LED)
assert sz.value == ((False, False), (False, False), (False, False))
sz.on()
assert sz.value == ((True, True), (True, True), (True, True))
sz.one.green.off()
assert sz.one.value == (True, False)
def test_statuszero_kwargs():
with StatusZero(pwm=True, initial_value=True) as sz:
assert isinstance(sz.one, LEDBoard)
assert isinstance(sz.two, LEDBoard)
assert isinstance(sz.three, LEDBoard)
assert isinstance(sz.one.red, PWMLED)
assert isinstance(sz.one.green, PWMLED)
assert sz.value == ((1, 1), (1, 1), (1, 1))
sz.off()
assert sz.value == ((0, 0), (0, 0), (0, 0))
def test_statuszero_named():
with StatusZero('a') as sz:
assert isinstance(sz.a, LEDBoard)
assert isinstance(sz.a.red, LED)
with pytest.raises(AttributeError):
sz.one
def test_statusboard_init():
with StatusBoard() as sb:
assert sb.namedtuple._fields == ('one', 'two', 'three', 'four', 'five')
with StatusBoard('a') as sb:
assert sb.namedtuple._fields == ('a',)
with StatusBoard('a', 'b') as sb:
assert sb.namedtuple._fields == ('a', 'b',)
with StatusBoard('a', 'b', 'c', 'd', 'e') as sb:
assert sb.namedtuple._fields == ('a', 'b', 'c', 'd', 'e')
with pytest.raises(ValueError):
StatusBoard('a', 'b', 'c', 'd', 'e', 'f')
with pytest.raises(ValueError):
StatusBoard('0')
with pytest.raises(ValueError):
StatusBoard('foo', 'hello world')
with pytest.raises(ValueError):
StatusBoard('foo', 'foo')
def test_statusboard():
with StatusBoard() as sb:
assert isinstance(sb.one, CompositeOutputDevice)
assert isinstance(sb.two, CompositeOutputDevice)
assert isinstance(sb.five, CompositeOutputDevice)
assert isinstance(sb.one.button, Button)
assert isinstance(sb.one.lights, LEDBoard)
assert isinstance(sb.one.lights.red, LED)
assert isinstance(sb.one.lights.green, LED)
assert sb.value == ((False, (False, False)), (False, (False, False)),
(False, (False, False)), (False, (False, False)),
(False, (False, False)))
sb.on()
assert sb.value == ((False, (True, True)), (False, (True, True)),
(False, (True, True)), (False, (True, True)),
(False, (True, True)))
sb.one.lights.green.off()
assert sb.one.value == (False, (True, False))
def test_statusboard_kwargs():
with StatusBoard(pwm=True, initial_value=True) as sb:
assert isinstance(sb.one, CompositeOutputDevice)
assert isinstance(sb.two, CompositeOutputDevice)
assert isinstance(sb.five, CompositeOutputDevice)
assert isinstance(sb.one.button, Button)
assert isinstance(sb.one.lights, LEDBoard)
assert isinstance(sb.one.lights.red, PWMLED)
assert isinstance(sb.one.lights.green, PWMLED)
assert sb.value == ((False, (1, 1)), (False, (1, 1)), (False, (1, 1)),
(False, (1, 1)), (False, (1, 1)))
sb.off()
assert sb.value == ((False, (0, 0)), (False, (0, 0)), (False, (0, 0)),
(False, (0, 0)), (False, (0, 0)))
def test_statusboard_named():
with StatusBoard('a') as sb:
assert isinstance(sb.a, CompositeOutputDevice)
assert isinstance(sb.a.button, Button)
assert isinstance(sb.a.lights, LEDBoard)
assert isinstance(sb.a.lights.red, LED)
with pytest.raises(AttributeError):
sb.one
Reference in New Issue View Git Blame Copy Permalink