def __init__(self, config=..., *args, **kwargs):
self.config = config if config is not ... else {}
self._name = self.config.get('name', 'default_name')
self._default_publication_channel = self.config.get('default_publication_channel', 'default_channel')
self._subscriptions = self.config.get('subscriptions', [])
rpi_detected = False
try:
with open('/proc/cpuinfo', 'r') as f:
rpi_detected = any(['Raspberry Pi' in line for line in f.readlines()])
except Exception:
pass
if not rpi_detected:
logger.warning("The detected platform is not a raspberry pi: mocking gpiozero library pin interfaces")
Device.pin_factory = MockFactory()
Device.pin_factory.pin_class = MockPWMPin
serials = self.config.get('serials', [])
self._serials = {}
for serial in serials:
port = serial['port']
baud_rate = serial.get('baud_rate', 9600)
buffering_interval = serial.get('buffering_interval', 0.1)
self._serials[serial['port']] = Serial(port, baud_rate, buffering_interval)
self._serials[serial['port']].process_event = self.process_event # magic
self._first_connection = False
EventFilterMixin.__init__(self)
Node.__init__(self, *args, **kwargs)
def __init__(self, pin, state_manager, **kwargs):
Device.pin_factory = MockFactory()
# btn = GPIOButton(pin, **kwargs)
self.btn_pin = Device.pin_factory.pin(pin)
self._drive_low = True
super().__init__(pin, state_manager, **kwargs)
signal.signal(signal.SIGINT, self.handle_interrupt)
def __init__(self, pin_number=17):
self.pin_number = pin_number
try:
self.pin = LED(self.pin_number)
except Exception as e:
logging.error(e)
self.pin = LED(self.pin_number, pin_factory=MockFactory())
class Command(BaseCommand):
help = 'Handle I/O'
# Set the default pin factory to a mock factory
Device.pin_factory = MockFactory()
led = LED(17)
drive_white_led(17)
def dispatch(self, running):
print(running.content_type)
if running is None:
self.stdout.write('none')
elif (running.content_type == 'api | alarm'):
self.stdout.write('alarm')
elif (running.content_type == 'api | color'):
self.stdout.write('color')
def handle(self, *args, **options):
self.stdout.write('foo')
try:
running = Running.objects.first()
self.dispatch(running)
except ObjectDoesNotExist:
self.dispatch(None)
def __init__(self):
self.testMode = platform == "win32" or platform == "win64"
self.pollIntervalSec = 0.5
self.verifyIntervalSec = 0.1
self.currentPollIntervalSec = 10
self.powerGpio = 24
self.waterGpio = 23
if platform == "win32" or platform == "win64":
Device.pin_factory = MockFactory()
self.powerClient = PowerClient(self.powerGpio)
self.waterClient = WaterClient(self.waterGpio)
self.kasaClient = KasaClient("Laundry Machine")
self.serverClient = ServerClient(self.testMode)
self.currentState = "on"
self.machineIsRunning = False
self.connected = False
self.currentLastPollTime = 0
self.numConsecutiveChanges = 0
if platform == "win32" or platform == "win64":
self.powerPin = Device.pin_factory.pin(self.powerGpio)
self.waterPin = Device.pin_factory.pin(self.waterGpio)
self.waterPin.drive_high()
time.sleep(1.5)
t = Timer(5.0, self.setWaterPin, [0])
t.start()
def test_oled_interface_oled(setup_test):
cf = """
[camera]
tmv_root = "."
interval = 60
[interface.mode_button]
button = 20
[interface.speed_button]
button = 16
[interface]
screen = "OLEDScreen"
"""
def _init_display_emulated(self):
""" Enumlate a screen : write to GIF instead of physical screen"""
self._gif = ''.join(
random.choices(string.ascii_uppercase + string.digits,
k=3)) + ".gif"
self._display = gifanim(filename=self._gif,
duration=0.1,
max_frames=100,
mode="1")
if not running_on_pi():
# mock GPIO
tmv.interface.screen.OLEDScreen._init_display = _init_display_emulated
from gpiozero import Device
from gpiozero.pins.mock import MockFactory
Device.pin_factory = MockFactory()
interface = Interface()
interface.configs(cf)
for i in range(10):
sleep(.1)
# test paging, mode and speed buttons
assert interface.screen.page == 1
press(interface.screen.key_right)
assert interface.screen.page == 2
press(interface.screen.key_left)
assert interface.screen.page == 1
modefile = Path("camera-mode")
assert not modefile.exists()
assert interface.mode_button.value == AUTO
press(interface.mode_button.button) # video
press(interface.mode_button.button) # ON
assert interface.mode_button.value == ON
assert modefile.exists()
speedfile = Path("camera-speed")
assert not speedfile.exists()
assert interface.speed_button.value == MEDIUM
press(interface.speed_button.button)
assert interface.speed_button.value == FAST
assert speedfile.exists()
if not running_on_pi() and show_images:
interface.screen._display.write_animation()
subprocess.run(["gnome-open", interface.screen._gif])
def mock_gpio(self):
import os
if os.name == 'nt':
print('Mocking GPIOs')
from gpiozero import Device
from gpiozero.pins.mock import MockFactory
Device.pin_factory = MockFactory()
def init_system():
"""initial setup steps"""
global nps_export_fn, relays, activityLED
# global sem.schedule_html_fn, sem.schedule_fn, sem.prices_fn,
logger("init control module..")
sem.set_dir_path()
nps_export_fn = sem.dirpath + nps_export_fn # prepend dir to original name
sem.schedule_html_fn = sem.dirpath + sem.schedule_html_fn
sem.prices_fn = sem.dirpath + sem.prices_fn
sem.schedule_fn = sem.dirpath + sem.schedule_fn
if os.name == 'posix':
os.system('echo none | sudo tee /sys/class/leds/led0/trigger')
else: # windows for dev
Device.pin_factory = MockFactory(
) # Set the default pin factory to a mock factory
for load in loads:
relay = LED(load["gpioPin"]) # init output objects for relays
relays.append(relay)
# powerLED = LED(35) # /sys/class/leds/led1
activityLED = LED(
16
) # /sys/class/leds/led0 #16 on original Pi 1, todo-3: make dynamic based on Pi version
def _connectPins(cls):
"""Creates gpiozero objects for components based on pins specified at class level"""
if not Pins.pins_initialized:
logger.debug("Connecting Pins")
if IS_RASPBERRY_PI:
logger.info(W1ThermSensor.get_available_sensors())
cls.adc = ADS1115()
cls.tempsensors = [W1ThermSensor(W1ThermSensor.THERM_SENSOR_DS18B20, id) for id in Pins.TEMP_SENSOR_IDS]
for sensor in cls.tempsensors:
logger.info(f'Sensor ID: {sensor.id}')
cls.servo = Ax12()
else:
cls.adc = None
cls.servoconnection = None
cls.tempsensors = None
try:
# this little bit of weirdness is a consequence of gpiozero's fake pin code being goofy
cls.pwmPinFactory = Device.pin_factory
if not IS_RASPBERRY_PI:
Device.pin_factory = MockFactory()
cls.pwmPinFactory = MockFactory(pin_class=MockPWMPin)
cls.heatingElements = [
PWMOutputDevice(n, pin_factory=cls.pwmPinFactory)
for n in Pins.heatingElementGPIOs]
cls.ballValves = [OutputDevice(n) for n in Pins.ballValveGPIOs]
for index, valve in enumerate(cls.ballValves):
if (index >4):
valve.close()
cls.airPump = OutputDevice(Pins.airPumpGPIO)
cls.airPump.close()
cls.pumps = [PWMOutputDevice(n, pin_factory=cls.pwmPinFactory)
for n in Pins.pumpGPIOs]
for pump in cls.pumps:
pump.toggle()
logger.debug(f'Pump states: {[x.value for x in cls.pumps]}')
cls.heatingElementSwitch = OutputDevice(Pins.heatingElementSwitchGPIO)
cls.GPZeroComponents = (
cls.ballValves + cls.heatingElements + cls.pumps
)
except GPIOPinInUse as e:
print(e)
def test_look_for_motion(self):
Device.pin_factory = MockFactory()
test_pir = PirSensor(4)
pin = Device.pin_factory.pin(4)
self.assertEqual(test_pir.look_for_motion(), None)
pin.drive_high()
sleep(0.5) #give time for state switch
self.assertNotEqual(test_pir.look_for_motion(), None)
def mock_factory(request):
save_factory = Device.pin_factory
Device.pin_factory = MockFactory()
yield Device.pin_factory
if Device.pin_factory is not None:
Device.pin_factory.reset()
Device.pin_factory = save_factory
def activate(load):
if (config.loads[load]["state"] != 1):
if config.diverters_io[load][0] == "gpio":
gpiozero.Device.pin_factory = MockFactory(
) ######### disable for actual use
relay = LED(config.diverters_io[load][1])
relay.on()
print("turning on ", load)
def build_power_detector() -> InputDevice:
""" Creates a device for detecting power activity """
is_dev = get_config('dev_mode')
if is_dev:
Device.pin_factory = MockFactory()
power_pin = get_config('device.power_pin')
return InputDevice(power_pin)
def mock_factory(request):
save_factory = Device.pin_factory
Device.pin_factory = MockFactory()
yield Device.pin_factory
# This reset() may seem redundant given we're re-constructing the factory
# for each function that requires it but MockFactory (via LocalFactory)
# stores some info at the class level which reset() clears.
if Device.pin_factory is not None:
Device.pin_factory.reset()
Device.pin_factory = save_factory
def build_led() -> LED:
""" Builds the LED for showing activities """
is_dev = get_config('dev_mode')
if is_dev:
_LOG.info('dev mode active')
Device.pin_factory = MockFactory()
led_pin = get_config('device.light_pin')
return LED(led_pin)
def __init__(self, factory=MockFactory()):
if len(PUMPS) != 8:
LOGGER.warning(Warning().wrong_pump_count(8, len(PUMPS)))
Device.pin_factory = factory
self.pumps = []
for pump_pin in PUMPS:
self.pumps.append(LED(pump_pin))
def pin_factory(request):
try:
factory = pkg_resources.load_entry_point('gpiozero',
'gpiozero_pin_factories',
request.param)()
except Exception as e:
pytest.skip("skipped factory %s: %s" % (request.param, str(e)))
else:
Device.pin_factory = factory
yield factory
Device.pin_factory = MockFactory()
def connectToPin(self, withclass, pin, *args, mock=None, **kwargs):
global globalMockFactory
from gpiozero import Device
import gpiozero
kwargs = kwargs.copy()
# Rename because this was very confusing
if "pull" in kwargs:
kwargs['pull_up'] = kwargs['pull']
del kwargs['pull']
if mock:
if self.realGpio:
try:
self.realGpio.close()
except:
pass
self.realGpio = None
if not self.fakeGpio:
from gpiozero.pins.mock import MockFactory
if not globalMockFactory:
globalMockFactory = MockFactory()
if not globalMockFactory:
raise RuntimeError("problem")
self.fakeGpio = withclass(pin,
*args,
**kwargs,
pin_factory=globalMockFactory)
self.gpio = self.fakeGpio
else:
if self.fakeGpio:
try:
self.fakeGpio.close()
except:
pass
self.fakeGpio = None
try:
if not self.realGpio:
self.gpio = withclass(pin, *args, **kwargs)
self.realGpio = self.gpio
except gpiozero.exc.BadPinFactory:
global alreadySentMockWarning
if not alreadySentMockWarning:
messagebus.postMessage(
"/system/notifications/warnings",
"No real GPIO found, using mock pins")
# Redo in mock mode
self.connectToPin(withclass, pin, *args, mock=True, **kwargs)
alreadySentMockWarning = True
def get_fan_controller_pin():
pin_factory = None
if 'linux' not in platform:
from gpiozero.pins.mock import MockFactory
config.logger.info('not running on pi, will use mock gpio pins')
pin_factory = MockFactory()
return OutputDevice(pin=config.FC_GPIO_PIN, pin_factory=pin_factory)
return PWMOutputDevice(pin=config.FC_GPIO_PIN,
frequency=config.FC_PWM_FREQ_HZ,
pin_factory=pin_factory)
def setUp(self):
self.__patcher = patch('camguard.raspi_gpio_sensor.LED', spec=True)
self.__led_mock = self.__patcher.start()
Device.pin_factory = MockFactory()
self.__sensor_settings_mock = create_autospec(spec=RaspiGpioSensorSettings, spec_set=True)
type(self.__sensor_settings_mock).gpio_pin_number = PropertyMock(return_value=13)
type(self.__sensor_settings_mock).queue_length = PropertyMock(return_value=1)
type(self.__sensor_settings_mock).sample_rate = PropertyMock(return_value=10.0)
type(self.__sensor_settings_mock).threshold = PropertyMock(return_value=0.5)
type(self.__sensor_settings_mock).led_gpio_pin_number = PropertyMock(return_value=16)
self.sut = RaspiGpioSensor(self.__sensor_settings_mock)
def __init__(self,
pin_number=None,
*,
active_high=True,
initial_value=False):
super().__init__(pin_number,
active_high=active_high,
initial_value=initial_value,
pin_factory=MockFactory())
LOGGER.info("Initializing mraa LED on pin %s" % pin_number)
self.mraa_pin = init_mraa_pin(pin_number, True)
def __init__(self, host, port, name, channel, environment, node_params, *args, **kwargs):
self.host = host
self.port = port
self.name = name
self.factory = JustSockClientFactory(self, name, channel)
self.node_params = node_params
if environment != "rpi":
Device.pin_factory = MockFactory()
Device.pin_factory.pin_class = MockPWMPin
super(JustSockClientService, self).__init__(host, port, self.factory, *args, **kwargs)
def test__init__(self):
Device.pin_factory = MockFactory()
test_controller = Controller()
self.assertIsNotNone(test_controller.com_handler)
self.assertIsNotNone(test_controller.pir)
test_controller.com_handler = MagicMock()
test_controller.pir = MagicMock()
test_controller.com_handler.send_payload = MagicMock(return_value=1)
test_controller.pir.look_for_motion = MagicMock(
return_value="TestMessage")
test_controller.run()
self.assertEqual(test_controller.payload, "TestMessage")
test_controller.pir.look_for_motion = MagicMock(return_value="")
test_controller.run()
self.assertEqual(test_controller.payload, "")
def update_pin_bindings(self):
bindings = self._settings.get(["bindings"])
self._logger.error(str(bindings))
for gpio in bindings:
pin = int(gpio["gpio"])
if gpio["type"][0] == "OUTPUT":
self._logger.error(
"Binding DigitalOutputDevice to pin {pin}".format(pin=pin))
self.pins[pin] = DigitalOutputDevice(pin,
active_high=True,
initial_value=True,
pin_factory=MockFactory())
if gpio["type"][0] == "INPUT":
self._logger.error(
"Binding Button to pin {pin}".format(pin=pin))
self.pins[pin] = Button(pin,
active_state=None,
pull_up=True,
bounce_time=0.01,
pin_factory=MockFactory())
if gpio["type"][0] == "PWM":
self._logger.error("Binding PWM to pin {pin}".format(pin=pin))
self.pins[pin] = PWMOutputDevice(pin,
active_high=True,
initial_value=0.0,
frequency=100,
pin_factory=MockFactory())
if gpio["type"][0] == "SERVO":
self._logger.error(
"Binding Servo to pin {pin}".format(pin=pin))
self.pins[pin] = Servo(pin,
initial_value=0.0,
min_pulse_width=1 / 1000,
max_pulse_width=2 / 1000,
frame_width=20 / 1000,
pin_factory=MockFactory())
def simulate_windows(self):
from gpiozero.pins.mock import MockFactory
Device.pin_factory = MockFactory()
if platform.system() == "Windows":
def simulate():
print("Running on Windows - Mock Pins generated")
pins = [Device.pin_factory.pin(x) for x in self.input_pins]
pins[0].drive_high()
while 1:
for pin in pins[1:]:
pin.drive_high()
sleep(0.01)
pin.drive_low()
sleep(0.99)
simulator = Thread(target=simulate)
simulator.start()
def mock_gpio():
import gpiozero
from gpiozero import Device
from gpiozero.pins.mock import MockFactory, MockPWMPin
class LoggingMockPWMPin(MockPWMPin):
def _set_state(self, value):
super()._set_state(value)
logger.debug(f'{self}._set_state({value})')
def _set_frequency(self, value):
super()._set_frequency(value)
if value is not None:
logger.debug(f'{self}._set_frequency({value})')
Device.pin_factory = MockFactory()
Device.pin_factory.pin_class = LoggingMockPWMPin
return gpiozero
def setup_buttons(dev=False):
if dev:
Device.pin_factory = MockFactory()
global btn_next
global btn_prev
global btn_play
btn_next = Button(BTN_NEXT, bounce_time=BOUNCE_TIME, hold_time=HOLD_TIME)
btn_next.when_released = next_released
btn_next.when_held = next_held
btn_prev = Button(BTN_PREV, bounce_time=BOUNCE_TIME, hold_time=HOLD_TIME)
btn_prev.when_released = prev_released
btn_prev.when_held = prev_held
btn_play = Button(BTN_PLAY, bounce_time=BOUNCE_TIME, hold_time=HOLD_TIME)
btn_play.when_released = play_released
btn_play.when_held = play_held
def main(topic: str, pressed_msg: str, released_msg: str, hostname: str,
gpio_pin: int, mocked: bool, inverted: bool):
""" GPIO initialization and registering signal event handlers. """
pin_factory = MockFactory() if mocked else None
button = Button(gpio_pin, pin_factory=pin_factory)
if inverted:
pressed_msg, released_msg = released_msg, pressed_msg
def pressed_handler():
event(topic=topic, event=pressed_msg, hostname=hostname)
def released_handler():
event(topic=topic, event=released_msg, hostname=hostname)
button.when_pressed = pressed_handler
button.when_released = released_handler
print("Button is ready!")
pause()
class TestBasicos(unittest.TestCase):
# Set the default pin factory to a mock factory
Device.pin_factory = MockFactory()
def test_right(self):
with LED(20) as left, LED(21) as right:
steering = Steering(left, right)
self.assertEqual(right, steering.right)
def test_left(self):
with LED(20) as left, LED(21) as right:
steering = Steering(left, right)
self.assertEqual(left, steering.left)
def test_get_status(self):
with LED(20) as left, LED(21) as right:
steering = Steering(left, right)
left.on()
self.assertEqual(1, left.value)
self.assertEqual(1, steering.status())
def test_straight(self):
with LED(20) as left, LED(21) as right:
steering = Steering(left, right)
left.on()
right.off()
self.assertEqual(True, steering.straight())
self.assertEqual(0, left.value)
def test_turn_left(self):
with LED(20) as left, LED(21) as right:
steering = Steering(left, right)
right.off()
left.on()
self.assertEqual(left.is_active, steering.turn_left().is_active)
def test_turn_right(self):
with LED(20) as left, LED(21) as right:
steering = Steering(left, right)
left.off()
right.on()
self.assertEqual(right.is_active, steering.turn_right().is_active)
def check_module_status():
'''
Check all connections are working and return back report in message.
This will be called daily at an set time during the day as a standard
report helping with maintenance.
os.getenv('ENVIRONMENT')
# Set the default pin factory to a mock factory
# Construct a couple of devices attached to mock pins 16 and 17, and link the
# devices
led = LED(17)
btn = Button(16)
led.source = btn
# Here the button isn't "pushed" so the LED's value should be False
print(led.value)
# Get a reference to mock pin 16 (used by the button)
btn_pin = Device.pin_factory.pin(16)
# Drive the pin low (this is what would happen electrically when the button is
# pushed)
btn_pin.drive_low()
sleep(0.1) # give source some time to re-read the button state
print(led.value)
btn_pin.drive_high()
sleep(0.1)
print(led.value)
'''
if os.getenv('ENVIRONMENT') == "DEV":
Device.pin_factory = MockFactory()
led = LED(17)
print(led.value)
checking_device_msg = "Everything is connected and working"
return checking_device_msg
