def test_do_command_in_address_mode(self):
""" Test the behavior of do_command in address mode."""
action = power_api.get_voltage(power_api.POWER_API_8_PORTS)
sad = power_api.set_addressmode()
serial_mock = RS485(SerialMock(
[sin(sad.create_input(power_api.BROADCAST_ADDRESS, 1, power_api.ADDRESS_MODE)),
sout(''), # Timeout read after 1 second
sin(sad.create_input(power_api.BROADCAST_ADDRESS, 2, power_api.NORMAL_MODE)),
sin(action.create_input(1, 3)),
sout(action.create_output(1, 3, 49.5))],
1
))
comm = self.__get_communicator(serial_mock)
comm.start()
comm.start_address_mode()
try:
comm.do_command(1, action)
self.assertFalse(True)
except InAddressModeException:
pass
comm.stop_address_mode()
self.assertEquals((49.5, ), comm.do_command(1, action))
def test_address_mode_timeout(self):
""" Test address mode timeout. """
action = power_api.get_voltage(power_api.POWER_MODULE)
sad = power_api.set_addressmode(power_api.POWER_MODULE)
sad_p1c = power_api.set_addressmode(power_api.P1_CONCENTRATOR)
serial_mock = RS485(
SerialMock(
[
sin(
sad.create_input(power_api.BROADCAST_ADDRESS, 1,
power_api.ADDRESS_MODE)),
sin(
sad_p1c.create_input(power_api.BROADCAST_ADDRESS, 2,
power_api.ADDRESS_MODE)),
sout(''), # Timeout read after 1 second
sin(
sad.create_input(power_api.BROADCAST_ADDRESS, 3,
power_api.NORMAL_MODE)),
sin(
sad_p1c.create_input(power_api.BROADCAST_ADDRESS, 4,
power_api.NORMAL_MODE)),
sin(action.create_input(1, 5)),
sout(action.create_output(1, 5, 49.5))
],
1))
comm = PowerCommunicatorTest._get_communicator(serial_mock,
address_mode_timeout=1)
comm.start()
comm.start_address_mode()
time.sleep(1.1)
self.assertEquals((49.5, ), comm.do_command(1, action))
def test_address_mode(self):
""" Test the address mode. """
sad = power_api.set_addressmode()
serial_mock = RS485(SerialMock(
[sin(sad.create_input(power_api.BROADCAST_ADDRESS, 1, power_api.ADDRESS_MODE)),
sout(power_api.want_an_address(power_api.POWER_API_8_PORTS).create_output(0, 0)),
sin(power_api.set_address().create_input(0, 0, 1)),
sout(power_api.want_an_address(power_api.POWER_API_12_PORTS).create_output(0, 0)),
sin(power_api.set_address().create_input(0, 0, 2)),
sout(''), # Timeout read after 1 second
sin(sad.create_input(power_api.BROADCAST_ADDRESS, 2, power_api.NORMAL_MODE))],
1
))
SetUpTestInjections(power_db=PowerCommunicatorTest.FILE)
controller = PowerController()
comm = self.__get_communicator(serial_mock, power_controller=controller)
comm.start()
self.assertEqual(controller.get_free_address(), 1)
comm.start_address_mode()
self.assertTrue(comm.in_address_mode())
time.sleep(0.5)
comm.stop_address_mode()
self.assertEqual(controller.get_free_address(), 3)
self.assertFalse(comm.in_address_mode())
def test_timekeeper(self):
""" Test the TimeKeeper. """
SetUpTestInjections(power_db=PowerCommunicatorTest.FILE)
power_controller = PowerController()
power_controller.register_power_module(1, power_api.POWER_MODULE)
time_action = power_api.set_day_night(power_api.POWER_MODULE)
times = [power_api.NIGHT for _ in range(8)]
action = power_api.get_voltage(power_api.POWER_MODULE)
serial_mock = RS485(
SerialMock([
sin(time_action.create_input(1, 1, *times)),
sout(time_action.create_output(1, 1)),
sin(action.create_input(1, 2)),
sout(action.create_output(1, 2, 243))
], 1))
comm = PowerCommunicatorTest._get_communicator(
serial_mock, 1, power_controller=power_controller)
comm.start()
time.sleep(1.5)
self.assertEquals((243, ), comm.do_command(1, action))
def setUp(self):
self.pubsub = PubSub()
SetUpTestInjections(pubsub=self.pubsub)
self.power_data = [] # type: list
SetUpTestInjections(power_db=':memory:')
self.serial = RS485(SerialMock(self.power_data))
self.store = PowerStore()
SetUpTestInjections(power_serial=self.serial,
power_store=self.store)
self.communicator = PowerCommunicator()
def test_do_command_timeout_once(self):
""" Test for timeout in PowerCommunicator.do_command. """
action = power_api.get_voltage(power_api.POWER_API_8_PORTS)
serial_mock = RS485(SerialMock([sin(action.create_input(1, 1)), sout(''),
sin(action.create_input(1, 2)),
sout(action.create_output(1, 2, 49.5))]))
comm = self.__get_communicator(serial_mock)
comm.start()
output = comm.do_command(1, action)
self.assertEquals((49.5, ), output)
def test_do_command_split_data(self):
""" Test PowerCommunicator.do_command when the data is split over multiple reads. """
action = power_api.get_voltage(power_api.POWER_API_8_PORTS)
out = action.create_output(1, 1, 49.5)
serial_mock = RS485(SerialMock(
[sin(action.create_input(1, 1)),
sout(out[:5]), sout(out[5:])]))
comm = self.__get_communicator(serial_mock)
comm.start()
output = comm.do_command(1, action)
self.assertEquals((49.5, ), output)
def test_wrong_response(self):
""" Test PowerCommunicator.do_command when the power module returns a wrong response. """
action_1 = power_api.get_voltage(power_api.POWER_MODULE)
action_2 = power_api.get_frequency(power_api.POWER_MODULE)
serial_mock = RS485(
SerialMock([
sin(action_1.create_input(1, 1)),
sout(action_2.create_output(3, 2, 49.5))
]))
comm = PowerCommunicatorTest._get_communicator(serial_mock)
comm.start()
with self.assertRaises(Exception):
comm.do_command(1, action_1)
def test_do_command_timeout_twice(self):
""" Test for timeout in PowerCommunicator.do_command. """
action = power_api.get_voltage(power_api.POWER_API_8_PORTS)
serial_mock = RS485(SerialMock([sin(action.create_input(1, 1)), sout(''),
sin(action.create_input(1, 2)),
sout('')]))
comm = self.__get_communicator(serial_mock)
comm.start()
try:
comm.do_command(1, action)
self.fail("Should receive timed out exception !")
except CommunicationTimedOutException:
pass # Ok !
def test_wrong_response(self):
""" Test PowerCommunicator.do_command when the power module returns a wrong response. """
action_1 = power_api.get_voltage(power_api.POWER_API_8_PORTS)
action_2 = power_api.get_frequency(power_api.POWER_API_8_PORTS)
serial_mock = RS485(SerialMock([sin(action_1.create_input(1, 1)),
sout(action_2.create_output(3, 2, 49.5))]))
comm = self.__get_communicator(serial_mock)
comm.start()
try:
comm.do_command(1, action_1)
self.assertTrue(False)
except Exception:
pass
def test_do_command_timeout_twice(self):
""" Test for timeout in PowerCommunicator.do_command. """
action = power_api.get_voltage(power_api.POWER_MODULE)
serial_mock = RS485(
SerialMock([
sin(action.create_input(1, 1)),
sout(''),
sin(action.create_input(1, 2)),
sout('')
]))
comm = PowerCommunicatorTest._get_communicator(serial_mock)
comm.start()
with self.assertRaises(CommunicationTimedOutException):
comm.do_command(1, action)
def test_do_command(self):
""" Test for standard behavior PowerCommunicator.do_command. """
action = power_api.get_voltage(power_api.POWER_API_8_PORTS)
serial_mock = RS485(SerialMock(
[sin(action.create_input(1, 1)),
sout(action.create_output(1, 1, 49.5))]))
comm = self.__get_communicator(serial_mock)
comm.start()
output = comm.do_command(1, action)
self.assertEquals((49.5, ), output)
self.assertEquals(14, comm.get_bytes_written())
self.assertEquals(18, comm.get_bytes_read())
def setup_minimal_power_platform():
# type: () -> None
config = ConfigParser()
config.read(constants.get_config_file())
power_serial_port = config.get('OpenMotics', 'power_serial')
if power_serial_port:
Injectable.value(power_db=constants.get_power_database_file())
Injectable.value(power_store=PowerStore())
Injectable.value(power_serial=RS485(
Serial(power_serial_port, 115200, timeout=None)))
Injectable.value(power_communicator=PowerCommunicator())
Injectable.value(power_controller=PowerController())
Injectable.value(p1_controller=P1Controller())
else:
Injectable.value(power_store=None)
Injectable.value(power_communicator=None)
Injectable.value(power_controller=None)
Injectable.value(p1_controller=None)
Injectable.value(power_serial=None)
def test_do_command(self):
""" Test for standard behavior PowerCommunicator.do_command. """
action = power_api.get_voltage(power_api.POWER_MODULE)
serial_mock = RS485(
SerialMock([
sin(action.create_input(1, 1)),
sout(action.create_output(1, 1, 49.5))
]))
comm = PowerCommunicatorTest._get_communicator(serial_mock)
comm.start()
output = comm.do_command(1, action)
self.assertEquals((49.5, ), output)
self.assertEquals(14,
comm.get_communication_statistics()['bytes_written'])
self.assertEquals(18,
comm.get_communication_statistics()['bytes_read'])
def test_do_command_in_address_mode(self):
""" Test the behavior of do_command in address mode."""
action = power_api.get_voltage(power_api.POWER_MODULE)
sad = power_api.set_addressmode(power_api.POWER_MODULE)
sad_p1c = power_api.set_addressmode(power_api.P1_CONCENTRATOR)
serial_mock = RS485(
SerialMock(
[
sin(
sad.create_input(power_api.BROADCAST_ADDRESS, 1,
power_api.ADDRESS_MODE)),
sin(
sad_p1c.create_input(power_api.BROADCAST_ADDRESS, 2,
power_api.ADDRESS_MODE)),
sout(''), # Timeout read after 1 second
sin(
sad.create_input(power_api.BROADCAST_ADDRESS, 3,
power_api.NORMAL_MODE)),
sin(
sad_p1c.create_input(power_api.BROADCAST_ADDRESS, 4,
power_api.NORMAL_MODE)),
sin(action.create_input(1, 5)),
sout(action.create_output(1, 5, 49.5))
],
1))
comm = PowerCommunicatorTest._get_communicator(serial_mock)
comm.start()
comm.start_address_mode()
with self.assertRaises(InAddressModeException):
comm.do_command(1, action)
comm.stop_address_mode()
self.assertEquals((49.5, ), comm.do_command(1, action))
the character + 1 is send on transmit channel of the serial port.
"""
while True:
try:
data = serial.read(1)
if bool(data) and data[0] != '\x00':
print "Read '%s' from %s" % (data, name)
serial.write(chr((ord(data[0]) + 1) % 256))
except Exception:
traceback.print_exc()
def start_echo_plus_one(name, serial):
""" Runs echo_plus_one in a separate thread. """
thread = threading.Thread(target=echo_plus_one, args=(name, serial))
thread.setName("Echo thread %s" % name)
thread.start()
if __name__ == "__main__":
print "Starting tty echo's..."
for tty in ["/dev/ttyO1", "/dev/ttyO2", "/dev/ttyO5"]:
sys.stdout.write("Starting tty echo on %s... " % tty)
start_echo_plus_one(tty, Serial(tty, 115200))
sys.stdout.write("Done\n")
for rs485 in ["/dev/ttyO4"]:
sys.stdout.write("Starting rs485 echo on %s... " % rs485)
start_echo_plus_one(rs485, RS485(Serial(rs485, 115200)))
sys.stdout.write("Done\n")
def main():
""" Main function. """
config = ConfigParser()
config.read(constants.get_config_file())
defaults = {
'username': config.get('OpenMotics', 'cloud_user'),
'password': config.get('OpenMotics', 'cloud_pass')
}
controller_serial_port = config.get('OpenMotics', 'controller_serial')
passthrough_serial_port = config.get('OpenMotics', 'passthrough_serial')
power_serial_port = config.get('OpenMotics', 'power_serial')
gateway_uuid = config.get('OpenMotics', 'uuid')
config_lock = threading.Lock()
user_controller = UserController(constants.get_config_database_file(),
config_lock, defaults, 3600)
config_controller = ConfigurationController(
constants.get_config_database_file(), config_lock)
led_service = LedService()
controller_serial = Serial(controller_serial_port, 115200)
power_serial = RS485(Serial(power_serial_port, 115200, timeout=None))
master_communicator = MasterCommunicator(controller_serial)
if passthrough_serial_port:
passthrough_serial = Serial(passthrough_serial_port, 115200)
passthrough_service = PassthroughService(master_communicator,
passthrough_serial)
passthrough_service.start()
master_communicator.start(
) # A running master_communicator is required for the startup of services below
power_controller = PowerController(constants.get_power_database_file())
power_communicator = PowerCommunicator(power_serial, power_controller)
gateway_api = GatewayApi(master_communicator, power_communicator,
power_controller)
scheduling_controller = SchedulingController(
constants.get_scheduling_database_file(), config_lock, gateway_api)
maintenance_service = MaintenanceService(
gateway_api, constants.get_ssl_private_key_file(),
constants.get_ssl_certificate_file())
web_interface = WebInterface(user_controller, gateway_api,
maintenance_service,
led_service.in_authorized_mode,
config_controller, scheduling_controller)
scheduling_controller.set_webinterface(web_interface)
plugin_controller = PluginController(web_interface, config_controller)
web_interface.set_plugin_controller(plugin_controller)
gateway_api.set_plugin_controller(plugin_controller)
# Metrics
metrics_cache_controller = MetricsCacheController(
constants.get_metrics_database_file(), threading.Lock())
metrics_collector = MetricsCollector(gateway_api)
metrics_controller = MetricsController(plugin_controller,
metrics_collector,
metrics_cache_controller,
config_controller, gateway_uuid)
metrics_collector.set_controllers(metrics_controller, plugin_controller)
metrics_collector.set_plugin_intervals(plugin_controller.metric_intervals)
metrics_controller.add_receiver(metrics_controller.receiver)
metrics_controller.add_receiver(web_interface.distribute_metric)
plugin_controller.set_metrics_controller(metrics_controller)
web_interface.set_metrics_collector(metrics_collector)
web_interface.set_metrics_controller(metrics_controller)
web_service = WebService(web_interface, config_controller)
def _on_output(*args, **kwargs):
metrics_collector.on_output(*args, **kwargs)
gateway_api.on_outputs(*args, **kwargs)
def _on_input(*args, **kwargs):
metrics_collector.on_input(*args, **kwargs)
gateway_api.on_inputs(*args, **kwargs)
master_communicator.register_consumer(
BackgroundConsumer(master_api.output_list(), 0, _on_output, True))
master_communicator.register_consumer(
BackgroundConsumer(master_api.input_list(), 0, _on_input))
power_communicator.start()
plugin_controller.start_plugins()
metrics_controller.start()
scheduling_controller.start()
metrics_collector.start()
web_service.start()
led_thread = threading.Thread(target=led_driver,
args=(led_service, master_communicator,
power_communicator))
led_thread.setName("Serial led driver thread")
led_thread.daemon = True
led_thread.start()
def stop(signum, frame):
""" This function is called on SIGTERM. """
_ = signum, frame
sys.stderr.write("Shutting down")
web_service.stop()
metrics_collector.stop()
metrics_controller.stop()
plugin_controller.stop()
signal(SIGTERM, stop)
def setup_target_platform(target_platform, message_client_name):
# type: (str, Optional[str]) -> None
config = ConfigParser()
config.read(constants.get_config_file())
config_lock = Lock()
metrics_lock = Lock()
config_database_file = constants.get_config_database_file()
# Debugging options
try:
debug_logger = config.get('OpenMotics', 'debug_logger')
if debug_logger:
logging.getLogger(debug_logger).setLevel(logging.DEBUG)
except NoOptionError:
pass
# Webserver / Presentation layer
try:
https_port = int(config.get('OpenMotics', 'https_port'))
except NoOptionError:
https_port = 443
try:
http_port = int(config.get('OpenMotics', 'http_port'))
except NoOptionError:
http_port = 80
Injectable.value(https_port=https_port)
Injectable.value(http_port=http_port)
Injectable.value(ssl_private_key=constants.get_ssl_private_key_file())
Injectable.value(ssl_certificate=constants.get_ssl_certificate_file())
# TODO: Clean up dependencies more to reduce complexity
# IOC announcements
# When below modules are imported, the classes are registerd in the IOC graph. This is required for
# instances that are used in @Inject decorated functions below, and is also needed to specify
# abstract implementations depending on e.g. the platform (classic vs core) or certain settings (classic
# thermostats vs gateway thermostats)
from plugins import base
from gateway import (metrics_controller, webservice, scheduling, observer,
gateway_api, metrics_collector,
maintenance_controller, user_controller,
pulse_counter_controller, metrics_caching, watchdog,
output_controller, room_controller, sensor_controller,
shutter_controller, group_action_controller,
module_controller, ventilation_controller)
from cloud import events
_ = (metrics_controller, webservice, scheduling, observer, gateway_api,
metrics_collector, maintenance_controller, base, events,
user_controller, pulse_counter_controller, metrics_caching, watchdog,
output_controller, room_controller, sensor_controller,
shutter_controller, group_action_controller, module_controller,
ventilation_controller)
# IPC
message_client = None
if message_client_name is not None:
message_client = MessageClient(message_client_name)
Injectable.value(message_client=message_client)
# Cloud API
Injectable.value(gateway_uuid=config.get('OpenMotics', 'uuid'))
try:
parsed_url = urlparse(config.get('OpenMotics', 'vpn_check_url'))
except NoOptionError:
parsed_url = urlparse('')
Injectable.value(cloud_endpoint=parsed_url.hostname)
Injectable.value(cloud_port=parsed_url.port)
Injectable.value(cloud_ssl=parsed_url.scheme == 'https')
Injectable.value(cloud_api_version=0)
cloud_url = urlunparse(
(parsed_url.scheme, parsed_url.netloc, '', '', '', ''))
Injectable.value(cloud_url=cloud_url or None)
try:
firmware_url = config.get('OpenMotics', 'firmware_url')
except NoOptionError:
path = '/portal/firmware_metadata'
firmware_url = urlunparse(
(parsed_url.scheme, parsed_url.netloc, path, '', '', ''))
Injectable.value(firmware_url=firmware_url or None)
# User Controller
Injectable.value(user_db=config_database_file)
Injectable.value(user_db_lock=config_lock)
Injectable.value(token_timeout=3600)
Injectable.value(
config={
'username': config.get('OpenMotics', 'cloud_user'),
'password': config.get('OpenMotics', 'cloud_pass')
})
# Metrics Controller
Injectable.value(metrics_db=constants.get_metrics_database_file())
Injectable.value(metrics_db_lock=metrics_lock)
# Energy Controller
try:
power_serial_port = config.get('OpenMotics', 'power_serial')
except NoOptionError:
power_serial_port = ''
if power_serial_port:
Injectable.value(power_db=constants.get_power_database_file())
Injectable.value(power_store=PowerStore())
# TODO: make non blocking?
Injectable.value(power_serial=RS485(
Serial(power_serial_port, 115200, timeout=None)))
Injectable.value(power_communicator=PowerCommunicator())
Injectable.value(power_controller=PowerController())
Injectable.value(p1_controller=P1Controller())
else:
Injectable.value(power_serial=None)
Injectable.value(power_store=None)
Injectable.value(
power_communicator=None) # TODO: remove from gateway_api
Injectable.value(power_controller=None)
Injectable.value(p1_controller=None)
# Pulse Controller
Injectable.value(pulse_db=constants.get_pulse_counter_database_file())
# Master Controller
try:
controller_serial_port = config.get('OpenMotics', 'controller_serial')
except NoOptionError:
controller_serial_port = ''
if controller_serial_port:
Injectable.value(controller_serial=Serial(
controller_serial_port, 115200, exclusive=True))
if target_platform in [Platform.Type.DUMMY, Platform.Type.ESAFE]:
Injectable.value(maintenance_communicator=None)
Injectable.value(passthrough_service=None)
Injectable.value(master_controller=MasterDummyController())
Injectable.value(eeprom_db=None)
from gateway.hal.master_controller_dummy import DummyEepromObject
Injectable.value(eeprom_extension=DummyEepromObject())
elif target_platform in Platform.CoreTypes:
# FIXME don't create singleton for optional controller?
from master.core import ucan_communicator, slave_communicator
_ = ucan_communicator, slave_communicator
core_cli_serial_port = config.get('OpenMotics', 'cli_serial')
Injectable.value(cli_serial=Serial(core_cli_serial_port, 115200))
Injectable.value(passthrough_service=None) # Mark as "not needed"
# TODO: Remove; should not be needed for Core
Injectable.value(
eeprom_db=constants.get_eeprom_extension_database_file())
Injectable.value(master_communicator=CoreCommunicator())
Injectable.value(
maintenance_communicator=MaintenanceCoreCommunicator())
Injectable.value(memory_file=MemoryFile())
Injectable.value(master_controller=MasterCoreController())
elif target_platform in Platform.ClassicTypes:
# FIXME don't create singleton for optional controller?
from master.classic import eeprom_extension
_ = eeprom_extension
leds_i2c_address = config.get('OpenMotics', 'leds_i2c_address')
passthrough_serial_port = config.get('OpenMotics',
'passthrough_serial')
Injectable.value(
eeprom_db=constants.get_eeprom_extension_database_file())
Injectable.value(leds_i2c_address=int(leds_i2c_address, 16))
if passthrough_serial_port:
Injectable.value(
passthrough_serial=Serial(passthrough_serial_port, 115200))
from master.classic.passthrough import PassthroughService
_ = PassthroughService # IOC announcement
else:
Injectable.value(passthrough_service=None)
Injectable.value(master_communicator=MasterCommunicator())
Injectable.value(
maintenance_communicator=MaintenanceClassicCommunicator())
Injectable.value(master_controller=MasterClassicController())
else:
logger.warning('Unhandled master implementation for %s',
target_platform)
if target_platform in [Platform.Type.DUMMY, Platform.Type.ESAFE]:
Injectable.value(frontpanel_controller=None)
elif target_platform in Platform.CoreTypes:
Injectable.value(frontpanel_controller=FrontpanelCoreController())
elif target_platform in Platform.ClassicTypes:
Injectable.value(frontpanel_controller=FrontpanelClassicController())
else:
logger.warning('Unhandled frontpanel implementation for %s',
target_platform)
# Thermostats
thermostats_gateway_feature = Feature.get_or_none(
name='thermostats_gateway')
thermostats_gateway_enabled = thermostats_gateway_feature is not None and thermostats_gateway_feature.enabled
if target_platform not in Platform.ClassicTypes or thermostats_gateway_enabled:
Injectable.value(thermostat_controller=ThermostatControllerGateway())
else:
Injectable.value(thermostat_controller=ThermostatControllerMaster())
def main():
""" Main function. """
config = ConfigParser()
config.read(constants.get_config_file())
defaults = {
'username': config.get('OpenMotics', 'cloud_user'),
'password': config.get('OpenMotics', 'cloud_pass')
}
user_controller = UserController(constants.get_user_database_file(),
defaults, 3600)
led_service = LedService()
controller_serial_port = config.get('OpenMotics', 'controller_serial')
passthrough_serial_port = config.get('OpenMotics', 'passthrough_serial')
power_serial_port = config.get('OpenMotics', 'power_serial')
controller_serial = Serial(controller_serial_port, 115200)
passthrough_serial = Serial(passthrough_serial_port, 115200)
power_serial = RS485(Serial(power_serial_port, 115200, timeout=None))
master_communicator = MasterCommunicator(controller_serial)
master_communicator.start()
power_controller = PowerController(constants.get_power_database_file())
power_communicator = PowerCommunicator(power_serial, power_controller)
power_communicator.start()
gateway_api = GatewayApi(master_communicator, power_communicator,
power_controller)
maintenance_service = MaintenanceService(
gateway_api, constants.get_ssl_private_key_file(),
constants.get_ssl_certificate_file())
passthrough_service = PassthroughService(master_communicator,
passthrough_serial)
passthrough_service.start()
web_interface = WebInterface(user_controller, gateway_api,
constants.get_scheduling_database_file(),
maintenance_service,
led_service.in_authorized_mode)
plugin_controller = PluginController(web_interface)
plugin_controller.start_plugins()
web_interface.set_plugin_controller(plugin_controller)
gateway_api.set_plugin_controller(plugin_controller)
web_service = WebService(web_interface)
web_service.start()
led_service.set_led('stat2', True)
led_thread = threading.Thread(target=led_driver,
args=(led_service, master_communicator,
power_communicator))
led_thread.setName("Serial led driver thread")
led_thread.daemon = True
led_thread.start()
def stop(signum, frame):
""" This function is called on SIGTERM. """
sys.stderr.write("Shutting down")
led_service.set_led('stat2', False)
web_service.stop()
signal(SIGTERM, stop)
def main():
""" The main function. """
logger.info('Energy/Power Module bootloader')
logger.info('Command: {0}'.format(' '.join(sys.argv)))
parser = argparse.ArgumentParser(
description='Tool to bootload a power module.')
parser.add_argument('--address',
dest='address',
type=int,
help='the address of the power module to bootload')
parser.add_argument('--all',
dest='all',
action='store_true',
help='bootload all power modules')
parser.add_argument('--file',
dest='file',
help='the filename of the hex file to bootload')
parser.add_argument('--8',
dest='old',
action='store_true',
help='bootload for the 8-port power modules')
parser.add_argument('--verbose',
dest='verbose',
action='store_true',
help='show the serial output')
args = parser.parse_args()
if not args.file:
parser.print_help()
return
config = ConfigParser()
config.read(constants.get_config_file())
port = config.get('OpenMotics', 'power_serial')
power_serial = RS485(Serial(port, 115200))
Injectable.value(power_serial=power_serial)
Injectable.value(power_db=constants.get_power_database_file())
power_controller = PowerController()
power_communicator = PowerCommunicator(time_keeper_period=0,
verbose=args.verbose)
power_communicator.start()
def _bootload(_module, _module_address, filename, is_power_module):
try:
if is_power_module and _module['version'] == POWER_API_8_PORTS:
bootload_8(_module_address, filename, power_communicator)
elif not is_power_module and _module[
'version'] == POWER_API_12_PORTS:
bootload_12(_module_address, filename, power_communicator)
except CommunicationTimedOutException:
logger.warning(
'E{0} - Module unavailable. Skipping...'.format(address))
except Exception:
logger.exception(
'E{0} - Unexpected exception during bootload. Skipping...'.
format(address))
if args.address or args.all:
power_modules = power_controller.get_power_modules()
if args.all:
for module_id in power_modules:
module = power_modules[module_id]
address = module['address']
_bootload(module, address, args.file, is_power_module=args.old)
else:
address = args.address
modules = [
module for module in power_modules.values()
if module['address'] == address
]
if len(modules) != 1:
logger.info(
'ERROR: Cannot find a module with address {0}'.format(
address))
sys.exit(0)
module = modules[0]
_bootload(module, address, args.file, is_power_module=args.old)
else:
parser.print_help()
def main():
""" The main function. """
parser = argparse.ArgumentParser(
description='Tool to bootload a power module.')
parser.add_argument('--address',
dest='address',
type=int,
help='the address of the power module to bootload')
parser.add_argument('--all',
dest='all',
action='store_true',
help='bootload all power modules')
parser.add_argument('--file',
dest='file',
help='the filename of the hex file to bootload')
parser.add_argument('--8',
dest='old',
action='store_true',
help='bootload for the 8-port power modules')
parser.add_argument('--version',
dest='version',
action='store_true',
help='display the version of the power module(s)')
parser.add_argument('--verbose',
dest='verbose',
action='store_true',
help='show the serial output')
args = parser.parse_args()
config = ConfigParser()
config.read(constants.get_config_file())
port = config.get('OpenMotics', 'power_serial')
power_serial = RS485(Serial(port, 115200))
power_communicator = PowerCommunicator(power_serial,
None,
time_keeper_period=0,
verbose=args.verbose)
power_communicator.start()
if args.address or args.all:
power_controller = PowerController(constants.get_power_database_file())
power_modules = power_controller.get_power_modules()
if args.all:
for module_id in power_modules:
module = power_modules[module_id]
addr = module['address']
if args.version:
print "E%d - Version: %s" % (
addr, version(addr, power_communicator))
if args.file:
if args.old and module['version'] == POWER_API_8_PORTS:
bootload_8(addr,
args.file,
power_communicator,
verbose=args.verbose)
elif not args.old and module[
'version'] == POWER_API_12_PORTS:
bootload_12(addr,
args.file,
power_communicator,
verbose=args.verbose)
else:
addr = args.address
modules = [
module for module in power_modules.keys()
if module['address'] == addr
]
if len(modules) != 1:
print 'ERROR: Could not determine energy module version. Aborting'
sys.exit(1)
if args.version:
print "E%d - Version: %s" % (addr,
version(addr, power_communicator))
if args.file:
if args.old and module['version'] == POWER_API_8_PORTS:
bootload_8(addr,
args.file,
power_communicator,
verbose=args.verbose)
elif not args.old and module['version'] == POWER_API_12_PORTS:
bootload_12(addr,
args.file,
power_communicator,
verbose=args.verbose)
else:
parser.print_help()
def main():
""" The main function. """
logger.info('Bootloader for Energy/Power Modules and P1 Concentrator')
logger.info('Command: {0}'.format(' '.join(sys.argv)))
parser = argparse.ArgumentParser(description='Tool to bootload a module.')
parser.add_argument('--address',
dest='address',
type=int,
help='the address of the module to bootload')
parser.add_argument('--all',
dest='all',
action='store_true',
help='bootload all modules')
parser.add_argument('--file',
dest='file',
help='the filename of the hex file to bootload')
parser.add_argument('--8',
dest='old',
action='store_true',
help='bootload for the 8-port power modules')
parser.add_argument('--p1c',
dest='p1c',
action='store_true',
help='bootload for the P1 concentrator modules')
parser.add_argument('--verbose',
dest='verbose',
action='store_true',
help='show the serial output')
parser.add_argument('--scan',
dest='scan',
action='store_true',
help='Scan the energy bus for modules')
args = parser.parse_args()
if not args.file and not args.scan:
parser.print_help()
return
config = ConfigParser()
config.read(constants.get_config_file())
port = config.get('OpenMotics', 'power_serial')
power_serial = RS485(Serial(port, 115200))
Injectable.value(power_serial=power_serial)
Injectable.value(power_db=constants.get_power_database_file())
power_controller = PowerController()
power_communicator = PowerCommunicator(time_keeper_period=0,
verbose=args.verbose)
power_communicator.start()
if args.scan:
logger.info('Scanning addresses 0-255...')
for address in xrange(256):
for module_type, version in {
'E/P': power_api.ENERGY_MODULE,
'C': power_api.P1_CONCENTRATOR
}.iteritems():
try:
logger.info('{0}{1} - Version: {2}'.format(
module_type, address,
get_module_firmware_version(address, version,
power_communicator)))
except Exception:
pass
logger.info('Scan completed')
return
version = power_api.ENERGY_MODULE
if args.old:
version = power_api.POWER_MODULE
elif args.p1c:
version = power_api.P1_CONCENTRATOR
def _bootload(_module, _module_address, filename):
try:
if version == _module['version'] == power_api.POWER_MODULE:
bootload_power_module(_module_address, filename,
power_communicator)
elif version == _module['version'] == power_api.ENERGY_MODULE:
bootload_energy_module(_module_address, filename,
power_communicator)
elif version == _module['version'] == power_api.P1_CONCENTRATOR:
bootload_p1_concentrator(_module_address, filename,
power_communicator)
except CommunicationTimedOutException:
logger.warning(
'E{0} - Module unavailable. Skipping...'.format(address))
except Exception:
logger.exception(
'E{0} - Unexpected exception during bootload. Skipping...'.
format(address))
if args.address or args.all:
power_modules = power_controller.get_power_modules()
if args.all:
for module_id in power_modules:
module = power_modules[module_id]
address = module['address']
_bootload(module, address, args.file)
else:
address = args.address
modules = [
module for module in power_modules.values()
if module['address'] == address
]
if len(modules) != 1:
logger.info(
'ERROR: Cannot find a module with address {0}'.format(
address))
sys.exit(0)
module = modules[0]
_bootload(module, address, args.file)
else:
parser.print_help()
def build_graph():
config = ConfigParser()
config.read(constants.get_config_file())
config_lock = Lock()
scheduling_lock = Lock()
metrics_lock = Lock()
config_database_file = constants.get_config_database_file()
# TODO: Clean up dependencies more to reduce complexity
# IOC announcements
# When below modules are imported, the classes are registerd in the IOC graph. This is required for
# instances that are used in @Inject decorated functions below, and is also needed to specify
# abstract implementations depending on e.g. the platform (classic vs core) or certain settings (classic
# thermostats vs gateway thermostats)
from power import power_communicator, power_controller
from plugins import base
from gateway import (metrics_controller, webservice, scheduling,
observer, gateway_api, metrics_collector,
maintenance_controller, comm_led_controller,
users, pulses, config as config_controller,
metrics_caching, watchdog)
from cloud import events
_ = (metrics_controller, webservice, scheduling, observer, gateway_api,
metrics_collector, maintenance_controller, base, events,
power_communicator, comm_led_controller, users, power_controller,
pulses, config_controller, metrics_caching, watchdog)
if Platform.get_platform() == Platform.Type.CORE_PLUS:
from gateway.hal import master_controller_core
from master_core import maintenance, core_communicator, ucan_communicator
from master import eeprom_extension # TODO: Obsolete, need to be removed
_ = master_controller_core, maintenance, core_communicator, ucan_communicator
else:
from gateway.hal import master_controller_classic
from master import maintenance, master_communicator, eeprom_extension
_ = master_controller_classic, maintenance, master_communicator, eeprom_extension
thermostats_gateway_feature = Feature.get_or_none(
name='thermostats_gateway')
thermostats_gateway_enabled = thermostats_gateway_feature is not None and thermostats_gateway_feature.enabled
if Platform.get_platform(
) == Platform.Type.CORE_PLUS or thermostats_gateway_enabled:
from gateway.thermostat.gateway import thermostat_controller_gateway
_ = thermostat_controller_gateway
else:
from gateway.thermostat.master import thermostat_controller_master
_ = thermostat_controller_master
# IPC
Injectable.value(message_client=MessageClient('openmotics_service'))
# Cloud API
parsed_url = urlparse(config.get('OpenMotics', 'vpn_check_url'))
Injectable.value(gateway_uuid=config.get('OpenMotics', 'uuid'))
Injectable.value(cloud_endpoint=parsed_url.hostname)
Injectable.value(cloud_port=parsed_url.port)
Injectable.value(cloud_ssl=parsed_url.scheme == 'https')
Injectable.value(cloud_api_version=0)
# User Controller
Injectable.value(user_db=config_database_file)
Injectable.value(user_db_lock=config_lock)
Injectable.value(token_timeout=3600)
Injectable.value(
config={
'username': config.get('OpenMotics', 'cloud_user'),
'password': config.get('OpenMotics', 'cloud_pass')
})
# Configuration Controller
Injectable.value(config_db=config_database_file)
Injectable.value(config_db_lock=config_lock)
# Energy Controller
power_serial_port = config.get('OpenMotics', 'power_serial')
Injectable.value(power_db=constants.get_power_database_file())
if power_serial_port:
Injectable.value(power_serial=RS485(
Serial(power_serial_port, 115200, timeout=None)))
else:
Injectable.value(power_serial=None)
Injectable.value(power_communicator=None)
Injectable.value(power_controller=None)
# Pulse Controller
Injectable.value(pulse_db=constants.get_pulse_counter_database_file())
# Scheduling Controller
Injectable.value(
scheduling_db=constants.get_scheduling_database_file())
Injectable.value(scheduling_db_lock=scheduling_lock)
# Master Controller
controller_serial_port = config.get('OpenMotics', 'controller_serial')
Injectable.value(
controller_serial=Serial(controller_serial_port, 115200))
if Platform.get_platform() == Platform.Type.CORE_PLUS:
from master_core.memory_file import MemoryFile, MemoryTypes
core_cli_serial_port = config.get('OpenMotics', 'cli_serial')
Injectable.value(cli_serial=Serial(core_cli_serial_port, 115200))
Injectable.value(passthrough_service=None) # Mark as "not needed"
Injectable.value(
memory_files={
MemoryTypes.EEPROM: MemoryFile(MemoryTypes.EEPROM),
MemoryTypes.FRAM: MemoryFile(MemoryTypes.FRAM)
})
# TODO: Remove; should not be needed for Core
Injectable.value(
eeprom_db=constants.get_eeprom_extension_database_file())
else:
passthrough_serial_port = config.get('OpenMotics',
'passthrough_serial')
Injectable.value(
eeprom_db=constants.get_eeprom_extension_database_file())
if passthrough_serial_port:
Injectable.value(
passthrough_serial=Serial(passthrough_serial_port, 115200))
from master.passthrough import PassthroughService
_ = PassthroughService # IOC announcement
else:
Injectable.value(passthrough_service=None)
# Metrics Controller
Injectable.value(metrics_db=constants.get_metrics_database_file())
Injectable.value(metrics_db_lock=metrics_lock)
# Webserver / Presentation layer
Injectable.value(ssl_private_key=constants.get_ssl_private_key_file())
Injectable.value(ssl_certificate=constants.get_ssl_certificate_file())
