def test_max_value(self):
validator = validators.IntegerValidator(name='max_delay', max_value=2)
self.assertEqual(validator(2), Decimal('2'))
with self.assertRaises(ValidationError) as ctx:
validator(3)
self.assertEqual(ctx.exception.message,
'Ensure max_delay is less than or equal to 2.000000')
def test_min_value(self):
validator = validators.IntegerValidator(name='max_delay', min_value=2)
self.assertEqual(validator(2), 2)
with self.assertRaises(ValidationError) as ctx:
validator(1)
self.assertEqual(
ctx.exception.message,
'Ensure max_delay is greater than or equal to 2.000000')
class Button(Device):
hardware_list = DIGITAL_INPUT
debounce_validator = validators.IntegerValidator(name='debounce',
min_value=0)
def __init__(self,
debounce=50,
long_click=None,
on_press=[],
on_release=[],
on_single_click=[],
on_long_click=[],
**kwargs):
self.debounce = self.debounce_validator(debounce)
self.hardware_config_extra = dict(delay=self.debounce)
super().__init__(**kwargs)
self.delay = self.debounce / 1000
self.on_single_click = on_single_click
self.on_long_click = on_long_click
self.message_lists = dict(
begin=self.clean_message_list(on_press),
end=self.clean_message_list(on_release),
single=self.clean_message_list(on_single_click),
long=self.clean_message_list(on_long_click),
)
if long_click:
self.handler = LongClickHandler(long_click=int(long_click))
else:
self.handler = SingleClickHandler()
def clean_message_list(self, message_list):
if message_list:
if not isinstance(message_list[0], list):
message_list = [message_list]
return message_list
async def setup(self):
await self.hardware.setup()
async def loop(self):
# If pressed on start wait until release
while await self.hardware.is_pressed():
await asyncio.sleep(self.delay)
while True:
for event in self.handler.get_events(await
self.hardware.is_pressed()):
self.event_handler(event)
await asyncio.sleep(self.delay)
def event_handler(self, event):
self.log.debug('click {}'.format(event))
message_list = self.message_lists[event]
if message_list:
for component, topic, payload in message_list:
self.broker.send(component, topic, payload)
self.broker.publish(topic='click', payload=event)
self.broker.publish(topic='click', payload='none')
class NumericSensor(Sensor):
scale_validator = validators.DecimalValidator(name='scale')
precision_validator = validators.IntegerValidator(name='precision')
def __init__(self,
scale=1,
precision=0,
change_margin=0,
unit_of_measurement='',
**kwargs):
super().__init__(**kwargs)
self.scale = self.scale_validator(scale)
self.precision = self.precision_validator(precision)
self.change_margin_validator = validators.DecimalValidator(
name='change_margin', precision=self.precision)
self.change_margin = self.change_margin_validator(change_margin)
self.unit_of_measurement = unit_of_measurement
self.value_validator = validators.DecimalValidator(
name='value', precision=self.precision)
async def setup(self):
await super().setup()
self.set_state('scale', self.scale)
self.set_state('precision', self.precision)
self.set_state('change_margin', self.change_margin)
self.set_state('unit_of_measurement', self.unit_of_measurement)
def clean_value(self, value):
return self.value_validator(Decimal(value) * self.scale)
def is_changed(self, value, previous_value):
if previous_value is None:
return True
if self.change_margin == 0:
return not (value == previous_value)
return bool(abs(value - previous_value) >= self.change_margin)
async def message_received(self, sender=None, topic=None, payload=None):
await super().message_received(sender=sender,
topic=topic,
payload=payload)
if self.config_mode and bool(payload):
if topic == 'scale':
self.scale = self.scale_validator(payload)
self.set_state('scale', self.scale)
if topic == 'precision':
self.precision = self.precision_validator(payload)
self.set_state('precision', self.precision)
if topic == 'change_margin':
self.change_margin = self.change_margin_validator(payload)
self.set_state('change_margin', self.change_margin)
def test_simple(self):
validator = validators.IntegerValidator(name='max_delay')
self.assertEqual(validator(0), 0)
self.assertEqual(validator(-0), 0)
self.assertEqual(validator(123), 123)
self.assertEqual(validator(-45), -45)
self.assertEqual(validator(1.1), 1)
self.assertEqual(validator('0'), 0)
self.assertEqual(validator('-0'), 0)
self.assertEqual(validator('123'), 123)
self.assertEqual(validator('-45'), -45)
with self.assertRaises(ValidationError) as ctx:
validator('1.1')
self.assertEqual(ctx.exception.message,
'Ensure max_delay is an integer number.')
with self.assertRaises(ValidationError) as ctx:
validator('text')
self.assertEqual(ctx.exception.message,
'Ensure max_delay is an integer number.')
class Relay(Device):
hardware_list = DIGITAL_OUTPUT
debounce_validator = validators.IntegerValidator(name='debounce',
min_value=0)
initial_validator = validators.OnOffValidator(name='initial', null=True)
def __init__(self, initial=None, **kwargs):
super().__init__(**kwargs)
self.initial = self.initial_validator(initial)
async def setup(self):
await self.hardware.setup()
if self.initial is None:
await self.get_power()
else:
await self.set_power(self.initial)
async def get_power(self):
value = await self.hardware.get_state()
self.set_state('power', value)
async def set_power(self, value):
if value == 'on':
await self.hardware.set_state(value)
self.set_state('power', value)
self.log.debug(value)
elif value == 'off':
await self.hardware.set_state(value)
self.set_state('power', value)
self.log.debug(value)
elif value == 'toggle':
power = self.get_state('power')
if power == 'on':
await self.set_power('off')
if power == 'off':
await self.set_power('on')
async def message_received(self, sender=None, topic=None, payload=None):
if topic == 'power':
await self.set_power(payload)
import gpiozero
from brick import validators
from brick.hardware.base import DigitalInput, DigitalOutput
pin_validator = validators.IntegerValidator('pin', min_value=0)
class GPIOInput(DigitalInput):
def __init__(self, pin=None, **kwargs):
super().__init__(**kwargs)
self.pin = pin_validator(pin)
async def setup(self):
self.input = gpiozero.Button(self.pin)
async def is_pressed(self):
return self.input.is_pressed
async def get_state(self):
return 'on' if self.input.is_pressed else 'off'
class GPIOOutput(DigitalOutput):
def __init__(self, pin=None, **kwargs):
super().__init__(**kwargs)
self.pin = pin_validator(pin)
async def setup(self):
self.output = gpiozero.LED(self.pin)
async def get_state(self):