From d6851cfed3c482e8a36b28b7ec8c4818663d95aa Mon Sep 17 00:00:00 2001
From: Joel Bender <joel@carrickbender.com>
Date: Wed, 1 Nov 2017 22:21:04 -0400
Subject: [PATCH 01/21] sample application for mutable schedule obejct

---
 sandbox/mutable_schedule_object.py | 70 ++++++++++++++++++++++++++++++
 1 file changed, 70 insertions(+)
 create mode 100644 sandbox/mutable_schedule_object.py

diff --git a/sandbox/mutable_schedule_object.py b/sandbox/mutable_schedule_object.py
new file mode 100644
index 00000000..f2cf2880
--- /dev/null
+++ b/sandbox/mutable_schedule_object.py
@@ -0,0 +1,70 @@
+#!/usr/bin/python
+
+"""
+Muteable Schedule Object
+"""
+
+from bacpypes.debugging import bacpypes_debugging, ModuleLogger
+from bacpypes.consolelogging import ArgumentParser
+
+from bacpypes.primitivedata import Unsigned
+from bacpypes.constructeddata import ArrayOf
+from bacpypes.basetypes import DailySchedule
+from bacpypes.object import WritableProperty, ScheduleObject, register_object_type
+
+# some debugging
+_debug = 0
+_log = ModuleLogger(globals())
+
+#
+#   MyScheduleObject
+#
+
+@register_object_type(vendor_id=999)
+class MyScheduleObject(ScheduleObject):
+
+    properties = [
+        WritableProperty('weeklySchedule', ArrayOf(DailySchedule)),
+        WritableProperty('priorityForWriting', Unsigned),
+        ]
+
+    def __init__(self, **kwargs):
+        if _debug: MyScheduleObject._debug("__init__ %r", kwargs)
+        ScheduleObject.__init__(self, **kwargs)
+
+#
+#
+#
+
+# parse the command line arguments
+parser = ArgumentParser(usage=__doc__)
+args = parser.parse_args()
+
+if _debug: _log.debug("initialization")
+if _debug: _log.debug("    - args: %r", args)
+
+# create a schedule object
+mso = MyScheduleObject(
+    objectIdentifier=('schedule', 1),
+    objectName="myScheduleObject",
+    weeklySchedule=[],
+    priorityForWriting=1,
+    )
+
+print("getting value")
+print(mso.priorityForWriting)
+print("")
+
+print("setting value")
+mso.priorityForWriting = 2
+print("")
+
+print("reading value")
+value = mso.ReadProperty('priorityForWriting')
+print("{}".format(value))
+print("")
+
+print("writing value")
+mso.WriteProperty('priorityForWriting', 3)
+print("")
+

From de1d895c8715cd059fbce04b1b18a00a6cfedb03 Mon Sep 17 00:00:00 2001
From: Joel Bender <joel@carrickbender.com>
Date: Wed, 6 Dec 2017 22:49:46 -0500
Subject: [PATCH 02/21] bring in code from older branch #96

---
 py27/bacpypes/constructeddata.py |  15 +-
 py27/bacpypes/object.py          |   7 +
 samples/LocalScheduleObject.py   | 831 +++++++++++++++++++++++++++++++
 samples/ReadWriteProperty.py     |  26 +-
 tests/time_machine.py            | 107 +++-
 5 files changed, 977 insertions(+), 9 deletions(-)
 create mode 100644 samples/LocalScheduleObject.py

diff --git a/py27/bacpypes/constructeddata.py b/py27/bacpypes/constructeddata.py
index 88fe28de..029b4d2a 100755
--- a/py27/bacpypes/constructeddata.py
+++ b/py27/bacpypes/constructeddata.py
@@ -406,6 +406,9 @@ def __len__(self):
         def __getitem__(self, item):
             return self.value[item]
 
+        def __iter__(self):
+            return iter(self.value)
+
         def encode(self, taglist):
             if _debug: _SequenceOf._debug("(%r)encode %r", self.__class__.__name__, taglist)
             for value in self.value:
@@ -593,6 +596,9 @@ def __delitem__(self, item):
             del self.value[item]
             self.value[0] -= 1
 
+        def __iter__(self):
+            return iter(self.value[1:])
+
         def index(self, value):
             # only search through values
             for i in range(1, self.value[0] + 1):
@@ -1153,7 +1159,7 @@ def dict_contents(self, use_dict=None, as_class=dict):
 #
 
 @bacpypes_debugging
-class AnyAtomic:
+class AnyAtomic(Atomic):
 
     def __init__(self, arg=None):
         if _debug: AnyAtomic._debug("__init__ %r", arg)
@@ -1184,8 +1190,13 @@ def decode(self, tag):
         # get the data
         self.value = tag.app_to_object()
 
+    @classmethod
+    def is_valid(cls, arg):
+        """Return True if arg is valid value for the class."""
+        return isinstance(arg, Atomic) and not isinstance(arg, AnyAtomic)
+
     def __str__(self):
-        return "AnyAtomic(%s)" % (str(self.value), )
+        return "%s(%s)" % (self.__class__.__name__, str(self.value))
 
     def __repr__(self):
         desc = self.__module__ + '.' + self.__class__.__name__
diff --git a/py27/bacpypes/object.py b/py27/bacpypes/object.py
index 2cb56485..1c09e16e 100755
--- a/py27/bacpypes/object.py
+++ b/py27/bacpypes/object.py
@@ -211,6 +211,13 @@ def WriteProperty(self, obj, value, arrayIndex=None, priority=None, direct=False
                             ))
 
             # if it's atomic, make sure it's valid
+            if issubclass(self.datatype, AnyAtomic):
+                if _debug: Property._debug("    - property is any atomic, checking value")
+                if not isinstance(value, Atomic):
+                    raise InvalidParameterDatatype("%s must be an atomic instance" % (
+                            self.identifier,
+                            ))
+
             elif issubclass(self.datatype, Atomic):
                 if _debug: Property._debug("    - property is atomic, checking value")
                 if not self.datatype.is_valid(value):
diff --git a/samples/LocalScheduleObject.py b/samples/LocalScheduleObject.py
new file mode 100644
index 00000000..953157d0
--- /dev/null
+++ b/samples/LocalScheduleObject.py
@@ -0,0 +1,831 @@
+#!/usr/bin/env python
+
+"""
+Local Schedule Object
+"""
+
+import sys
+import calendar
+from time import mktime as _mktime, localtime as _localtime
+
+from bacpypes.debugging import bacpypes_debugging, ModuleLogger, xtob
+from bacpypes.consolelogging import ConfigArgumentParser
+from bacpypes.consolecmd import ConsoleCmd
+
+from bacpypes.core import run, deferred
+from bacpypes.task import OneShotTask
+
+from bacpypes.primitivedata import Atomic, Null, Integer, Unsigned, Real, Date, Time, CharacterString
+from bacpypes.constructeddata import Array, ArrayOf, SequenceOf, AnyAtomic
+from bacpypes.basetypes import CalendarEntry, DailySchedule, DateRange, \
+    DeviceObjectPropertyReference, SpecialEvent, SpecialEventPeriod, TimeValue
+from bacpypes.object import register_object_type, get_datatype, WritableProperty, ScheduleObject
+
+from bacpypes.app import BIPSimpleApplication
+from bacpypes.service.device import LocalDeviceObject
+
+# some debugging
+_debug = 0
+_log = ModuleLogger(globals())
+
+# globals
+schedule_objects = []
+
+#
+#   match_date
+#
+
+def match_date(date, date_pattern):
+    """
+    Match a specific date, a four-tuple with no special values, with a date
+    pattern, four-tuple possibly having special values.
+    """
+    # unpack the date and pattern
+    year, month, day, day_of_week = date
+    year_p, month_p, day_p, day_of_week_p = date_pattern
+
+    # check the year
+    if year_p == 255:
+        # any year
+        pass
+    elif year != year_p:
+        # specific year
+        return False
+
+    # check the month
+    if month_p == 255:
+        # any month
+        pass
+    elif month_p == 13:
+        # odd months
+        if (month % 2) == 0:
+            return False
+    elif month_p == 14:
+        # even months
+        if (month % 2) == 1:
+            return False
+    elif month != month_p:
+        # specific month
+        return False
+
+    # check the day
+    if day_p == 255:
+        # any day
+        pass
+    elif day_p == 32:
+        # last day of the month
+        last_day = calendar.monthrange(year + 1900, month)[1]
+        if day != last_day:
+            return False
+    elif day_p == 33:
+        # odd days of the month
+        if (day % 2) == 0:
+            return False
+    elif day_p == 34:
+        # even days of the month
+        if (day % 2) == 1:
+            return False
+    elif day != day_p:
+        # specific day
+        return False
+
+    # check the day of week
+    if day_of_week_p == 255:
+        # any day of the week
+        pass
+    elif day_of_week != day_of_week_p:
+        # specific day of the week
+        return False
+
+    # all tests pass
+    return True
+
+#
+#   match_date_range
+#
+
+def match_date_range(date, date_range):
+    """
+    Match a specific date, a four-tuple with no special values, with a DateRange
+    object which as a start date and end date.
+    """
+    return (date[:3] >= date_range.startDate[:3]) \
+        and (date[:3] <= date_range.endDate[:3])
+
+#
+#   match_weeknday
+#
+
+def match_weeknday(date, weeknday):
+    """
+    Match a specific date, a four-tuple with no special values, with a
+    BACnetWeekNDay, an octet string with three (unsigned) octets.
+    """
+    # unpack the date
+    year, month, day, day_of_week = date
+    last_day = calendar.monthrange(year + 1900, month)[1]
+
+    # unpack the date pattern octet string
+    if sys.version_info[0] == 2:
+        weeknday_unpacked = [ord(c) for c in weeknday]
+    elif sys.version_info[0] == 3:
+        weeknday_unpacked = [c for c in weeknday]
+    else:
+        raise NotImplementedError("match_weeknday requires Python 2.x or 3.x")
+    month_p, week_of_month_p, day_of_week_p = weeknday_unpacked
+
+    # check the month
+    if month_p == 255:
+        # any month
+        pass
+    elif month_p == 13:
+        # odd months
+        if (month % 2) == 0:
+            return False
+    elif month_p == 14:
+        # even months
+        if (month % 2) == 1:
+            return False
+    elif month != month_p:
+        # specific month
+        return False
+
+    # check the week of the month
+    if week_of_month_p == 255:
+        # any week
+        pass
+    elif week_of_month_p == 1:
+        # days numbered 1-7
+        if (day > 7):
+            return False
+    elif week_of_month_p == 2:
+        # days numbered 8-14
+        if (day < 8) or (day > 14):
+            return False
+    elif week_of_month_p == 3:
+        # days numbered 15-21
+        if (day < 15) or (day > 21):
+            return False
+    elif week_of_month_p == 4:
+        # days numbered 22-28
+        if (day < 22) or (day > 28):
+            return False
+    elif week_of_month_p == 5:
+        # days numbered 29-31
+        if (day < 29) or (day > 31):
+            return False
+    elif week_of_month_p == 6:
+        # last 7 days of this month
+        if (day < last_day - 6):
+            return False
+    elif week_of_month_p == 7:
+        # any of the 7 days prior to the last 7 days of this month
+        if (day < last_day - 13) or (day > last_day - 7):
+            return False
+    elif week_of_month_p == 8:
+        # any of the 7 days prior to the last 14 days of this month
+        if (day < last_day - 20) or (day > last_day - 14):
+            return False
+    elif week_of_month_p == 9:
+        # any of the 7 days prior to the last 21 days of this month
+        if (day < last_day - 27) or (day > last_day - 21):
+            return False
+
+    # check the day
+    if day_of_week_p == 255:
+        # any day
+        pass
+    elif day_of_week != day_of_week_p:
+        # specific day
+        return False
+
+    # all tests pass
+    return True
+
+#
+#   date_in_calendar_entry
+#
+
+@bacpypes_debugging
+def date_in_calendar_entry(date, calendar_entry):
+    if _debug: date_in_calendar_entry._debug("date_in_calendar_entry %r %r", date, calendar_entry)
+
+    match = False
+    if calendar_entry.date:
+        match = match_date(date, calendar_entry.date)
+    elif calendar_entry.dateRange:
+        match = match_date_range(date, calendar_entry.dateRange)
+    elif calendar_entry.weekNDay:
+        match = match_weeknday(date, calendar_entry.weekNDay)
+    else:
+        raise RuntimeError("")
+    if _debug: date_in_calendar_entry._debug("    - match: %r", match)
+
+    return match
+
+#
+#   datetime_to_time
+#
+
+def datetime_to_time(date, time):
+    """Take the date and time 4-tuples and return the time in seconds since
+    the epoch as a floating point number."""
+    if (255 in date) or (255 in time):
+        raise RuntimeError("specific date and time required")
+
+    time_tuple = (
+        date[0]+1900, date[1], date[2],
+        time[0], time[1], time[2],
+        0, 0, -1,
+        )
+    return _mktime(time_tuple)
+
+#
+#   LocalScheduleObject
+#
+
+@bacpypes_debugging
+@register_object_type(vendor_id=999)
+class LocalScheduleObject(ScheduleObject):
+
+    properties = [
+        WritableProperty('presentValue', AnyAtomic),
+        ]
+
+    def __init__(self, **kwargs):
+        if _debug: LocalScheduleObject._debug("__init__ %r", kwargs)
+        ScheduleObject.__init__(self, **kwargs)
+
+        # attach an interpreter task
+        self._task = LocalScheduleInterpreter(self)
+
+        # add some monitors
+        for prop in ('weeklySchedule', 'exceptionSchedule', 'scheduleDefault'):
+            self._property_monitors[prop].append(self._check_reliability)
+
+        # check it now
+        self._check_reliability()
+
+    def _check_reliability(self, old_value=None, new_value=None):
+        """This function is called when the object is created and after
+        one of its configuration properties has changed.  The new and old value
+        parameters are ignored, this is called after the property has been
+        changed and this is only concerned with the current value."""
+        if _debug: LocalScheduleObject._debug("_check_reliability %r %r", old_value, new_value)
+
+        try:
+            schedule_default = self.scheduleDefault
+
+            if schedule_default is None:
+                raise ValueError("scheduleDefault expected")
+            if not isinstance(schedule_default, Atomic):
+                raise TypeError("scheduleDefault must be an instance of an atomic type")
+
+            if (self.weeklySchedule is None) and (self.exceptionSchedule is None):
+                raise ValueError("schedule required")
+
+            schedule_datatype = schedule_default.__class__
+            if _debug: LocalScheduleObject._debug("    - schedule_datatype: %r", schedule_datatype)
+
+            # check the weekly schedule values
+            if self.weeklySchedule:
+                for daily_schedule in self.weeklySchedule:
+                    for time_value in daily_schedule.daySchedule:
+                        if _debug: LocalScheduleObject._debug("    - daily time_value: %r", time_value)
+                        if time_value is None:
+                            pass
+                        elif not isinstance(time_value.value, (Null, schedule_datatype)):
+                            if _debug: LocalScheduleObject._debug("    - wrong type: expected %r, got %r",
+                                schedule_datatype,
+                                time_value.__class__,
+                                )
+                            raise TypeError("wrong type")
+                        elif 255 in time_value.time:
+                            if _debug: LocalScheduleObject._debug("    - wildcard in time")
+                            raise ValueError("must be a specific time")
+
+            # check the exception schedule values
+            if self.exceptionSchedule:
+                for special_event in self.exceptionSchedule:
+                    for time_value in special_event.listOfTimeValues:
+                        if _debug: LocalScheduleObject._debug("    - special event time_value: %r", time_value)
+                        if time_value is None:
+                            pass
+                        elif not isinstance(time_value.value, (Null, schedule_datatype)):
+                            if _debug: LocalScheduleObject._debug("    - wrong type: expected %r, got %r",
+                                schedule_datatype,
+                                time_value.__class__,
+                                )
+                            raise TypeError("wrong type")
+
+            # check list of object property references
+            obj_prop_refs = self.listOfObjectPropertyReferences
+            if obj_prop_refs:
+                for obj_prop_ref in obj_prop_refs:
+                    obj_type = obj_prop_ref.objectIdentifier[0]
+
+                    # get the datatype of the property to be written
+                    datatype = get_datatype(obj_type, obj_prop_ref.propertyIdentifier)
+                    if _debug: LocalScheduleObject._debug("    - datatype: %r", datatype)
+
+                    if issubclass(datatype, Array) and (obj_prop_ref.propertyArrayIndex is not None):
+                        if obj_prop_ref.propertyArrayIndex == 0:
+                            datatype = Unsigned
+                        else:
+                            datatype = datatype.subtype
+                        if _debug: LocalScheduleObject._debug("    - datatype: %r", datatype)
+
+                    if datatype is not schedule_datatype:
+                        if _debug: LocalScheduleObject._debug("    - wrong type: expected %r, got %r",
+                            datatype,
+                            schedule_datatype,
+                            )
+                        raise TypeError("wrong type")
+
+            # all good
+            self.reliability = 'noFaultDetected'
+            if _debug: LocalScheduleObject._debug("    - no fault detected")
+
+        except Exception as err:
+            if _debug: LocalScheduleObject._debug("    - exception: %r", err)
+            self.reliability = 'configurationError'
+
+#
+#   LocalScheduleInterpreter
+#
+
+@bacpypes_debugging
+class LocalScheduleInterpreter(OneShotTask):
+
+    def __init__(self, sched_obj):
+        if _debug: LocalScheduleInterpreter._debug("__init__ %r", sched_obj)
+        OneShotTask.__init__(self)
+
+        # reference the schedule object to update
+        self.sched_obj = sched_obj
+
+        # add a monitor for the present value
+        sched_obj._property_monitors['presentValue'].append(self.present_value_changed)
+
+        # call to interpret the schedule
+        deferred(self.process_task)
+
+    def present_value_changed(self, old_value, new_value):
+        """This function is called when the presentValue of the local schedule
+        object has changed, both internally by this interpreter, or externally
+        by some client using WriteProperty."""
+        if _debug: LocalScheduleInterpreter._debug("present_value_changed %r %r", old_value, new_value)
+
+    def process_task(self):
+        if _debug: LocalScheduleInterpreter._debug("process_task(%s)", self.sched_obj.objectName)
+
+        # check for a valid configuration
+        if self.sched_obj.reliability != 'noFaultDetected':
+            return
+
+        # get the date and time from the device object
+        current_date = self.sched_obj._app.localDevice.localDate
+        if _debug: LocalScheduleInterpreter._debug("    - current_date: %r", current_date)
+
+        current_time = self.sched_obj._app.localDevice.localTime
+        if _debug: LocalScheduleInterpreter._debug("    - current_time: %r", current_time)
+
+        # evaluate the time
+        current_value, next_transition = self.eval(current_date, current_time)
+        if _debug: LocalScheduleInterpreter._debug("    - current_value, next_transition: %r, %r", current_value, next_transition)
+
+        # set the present value
+        self.sched_obj.presentValue = current_value
+
+        # compute the time of the next transition
+        transition_time = datetime_to_time(current_date, next_transition)
+
+        # install this to run again
+        self.install_task(transition_time)
+
+    def eval(self, edate, etime):
+        """Evaluate the schedule according to the provided date and time and
+        return the appropriate present value, or None if not in the effective
+        period."""
+        if _debug: LocalScheduleInterpreter._debug("eval %r %r", edate, etime)
+
+        # reference the schedule object
+        sched_obj = self.sched_obj
+        if _debug: LocalScheduleInterpreter._debug("    sched_obj: %r", sched_obj)
+
+        # verify the date falls in the effective period
+        if not match_date_range(edate, sched_obj.effectivePeriod):
+            return None
+
+        # the event priority is a list of values that are in effect for
+        # exception schedules with the special event priority, see 135.1-2013
+        # clause 7.3.2.23.10.3.8, Revision 4 Event Priority Test
+        event_priority = [None] * 16
+
+        next_day = (24, 0, 0, 0)
+        next_transition_time = [None] * 16
+
+        # check the exception schedule values
+        if sched_obj.exceptionSchedule:
+            for special_event in sched_obj.exceptionSchedule:
+                if _debug: LocalScheduleInterpreter._debug("    - special_event: %r", special_event)
+
+                # check the special event period
+                special_event_period = special_event.period
+                if special_event_period is None:
+                    raise RuntimeError("special event period required")
+
+                match = False
+                calendar_entry = special_event_period.calendarEntry
+                if calendar_entry:
+                    if _debug: LocalScheduleInterpreter._debug("    - calendar_entry: %r", calendar_entry)
+                    match = date_in_calendar_entry(edate, calendar_entry)
+                else:
+                    # get the calendar object from the application
+                    calendar_object = sched_obj._app.get_object_id(special_event_period.calendarReference)
+                    if not calendar_object:
+                        raise RuntimeError("invalid calendar object reference")
+                    if _debug: LocalScheduleInterpreter._debug("    - calendar_object: %r", calendar_object)
+
+                    for calendar_entry in calendar_object.dateList:
+                        if _debug: LocalScheduleInterpreter._debug("    - calendar_entry: %r", calendar_entry)
+                        match = date_in_calendar_entry(edate, calendar_entry)
+                        if match:
+                            break
+
+                # didn't match the period, try the next special event
+                if not match:
+                    if _debug: LocalScheduleInterpreter._debug("    - no matching calendar entry")
+                    continue
+
+                # event priority array index
+                priority = special_event.eventPriority - 1
+                if _debug: LocalScheduleInterpreter._debug("    - priority: %r", priority)
+
+                # look for all of the possible times
+                for time_value in special_event.listOfTimeValues:
+                    tval = time_value.time
+                    if tval <= etime:
+                        if isinstance(time_value.value, Null):
+                            if _debug: LocalScheduleInterpreter._debug("    - relinquish exception @ %r", tval)
+                            event_priority[priority] = None
+                            next_transition_time[priority] = None
+                        else:
+                            if _debug: LocalScheduleInterpreter._debug("    - consider exception @ %r", tval)
+                            event_priority[priority] = time_value.value
+                            next_transition_time[priority] = next_day
+                    else:
+                        next_transition_time[priority] = tval
+                        break
+
+        # assume the next transition will be at the start of the next day
+        earliest_transition = next_day
+
+        # check if any of the special events came up with something
+        for priority_value, next_transition in zip(event_priority, next_transition_time):
+            if next_transition is not None:
+                earliest_transition = min(earliest_transition, next_transition)
+            if priority_value is not None:
+                if _debug: LocalScheduleInterpreter._debug("    - priority_value: %r", priority_value)
+                return priority_value, earliest_transition
+
+        # start out with the default
+        daily_value = sched_obj.scheduleDefault
+
+        # check the daily schedule
+        if sched_obj.weeklySchedule:
+            daily_schedule = sched_obj.weeklySchedule[edate[3]]
+            if _debug: LocalScheduleInterpreter._debug("    - daily_schedule: %r", daily_schedule)
+
+            # look for all of the possible times
+            for time_value in daily_schedule.daySchedule:
+                if _debug: LocalScheduleInterpreter._debug("    - time_value: %r", time_value)
+
+                tval = time_value.time
+                if tval <= etime:
+                    if isinstance(time_value.value, Null):
+                        if _debug: LocalScheduleInterpreter._debug("    - back to normal @ %r", tval)
+                        daily_value = sched_obj.scheduleDefault
+                    else:
+                        if _debug: LocalScheduleInterpreter._debug("    - new value @ %r", tval)
+                        daily_value = time_value.value
+                else:
+                    earliest_transition = min(earliest_transition, tval)
+                    break
+
+        # return what was matched, if anything
+        return daily_value, earliest_transition
+
+#
+#   TestConsoleCmd
+#
+
+@bacpypes_debugging
+class TestConsoleCmd(ConsoleCmd):
+
+    def do_test(self, args):
+        """test <date> <time>"""
+        args = args.split()
+        if _debug: TestConsoleCmd._debug("do_test %r", args)
+
+        date_string, time_string = args
+        test_date = Date(date_string).value
+        test_time = Time(time_string).value
+
+        for so in schedule_objects:
+            v, t = so._task.eval(test_date, test_time)
+            print(so.objectName + ", " + repr(v and v.value) + " until " + str(t))
+
+    def do_now(self, args):
+        """now"""
+        args = args.split()
+        if _debug: TestConsoleCmd._debug("do_now %r", args)
+
+        y = _localtime()
+        print("y: {}".format(y))
+
+#
+#   __main__
+#
+
+def main():
+    global args, schedule_objects
+
+    # parse the command line arguments
+    parser = ConfigArgumentParser(description=__doc__)
+
+    # parse the command line arguments
+    args = parser.parse_args()
+
+    if _debug: _log.debug("initialization")
+    if _debug: _log.debug("    - args: %r", args)
+
+    # make a device object
+    this_device = LocalDeviceObject(
+        objectName=args.ini.objectname,
+        objectIdentifier=('device', int(args.ini.objectidentifier)),
+        maxApduLengthAccepted=int(args.ini.maxapdulengthaccepted),
+        segmentationSupported=args.ini.segmentationsupported,
+        vendorIdentifier=int(args.ini.vendoridentifier),
+        )
+
+    # make a sample application
+    this_application = BIPSimpleApplication(this_device, args.ini.address)
+
+    # get the services supported
+    services_supported = this_application.get_services_supported()
+    if _debug: _log.debug("    - services_supported: %r", services_supported)
+
+    # let the device object know
+    this_device.protocolServicesSupported = services_supported.value
+
+    #
+    #   Simple daily schedule (actually a weekly schedule with every day
+    #   being identical.
+    #
+    so = LocalScheduleObject(
+        objectIdentifier=('schedule', 1),
+        objectName='Schedule 1',
+        presentValue=Integer(8),
+        effectivePeriod=DateRange(
+            startDate=(0, 1, 1, 1),
+            endDate=(254, 12, 31, 2),
+            ),
+        weeklySchedule=ArrayOf(DailySchedule)([
+            DailySchedule(
+                daySchedule=[
+                    TimeValue(time=(8,0,0,0), value=Integer(8)),
+                    TimeValue(time=(14,0,0,0), value=Null()),
+                    TimeValue(time=(17,0,0,0), value=Integer(42)),
+#                   TimeValue(time=(0,0,0,0), value=Null()),
+                    ]
+                ),
+            ] * 7),
+        scheduleDefault=Integer(0),
+        )
+    _log.debug("    - so: %r", so)
+    this_application.add_object(so)
+    schedule_objects.append(so)
+
+    #
+    #   A special schedule when the Year 2000 problem was supposed to collapse
+    #   systems, the panic clears ten minutes later when it didn't.
+    #
+    so = LocalScheduleObject(
+        objectIdentifier=('schedule', 2),
+        objectName='Schedule 2',
+        presentValue=CharacterString(""),
+        effectivePeriod=DateRange(
+            startDate=(0, 1, 1, 1),
+            endDate=(254, 12, 31, 2),
+            ),
+        exceptionSchedule=ArrayOf(SpecialEvent)([
+            SpecialEvent(
+                period=SpecialEventPeriod(
+                    calendarEntry=CalendarEntry(
+                        date=Date("2000-01-01").value,
+                        ),
+                    ),
+                listOfTimeValues=[
+                    TimeValue(time=(0,0,0,0), value=CharacterString("Panic!")),
+                    TimeValue(time=(0,10,0,0), value=Null()),
+                    ],
+                eventPriority=1,
+                ),
+            ]),
+        scheduleDefault=CharacterString("Don't panic."),
+        )
+    _log.debug("    - so: %r", so)
+    this_application.add_object(so)
+    schedule_objects.append(so)
+
+    #
+    #   A special schedule when the Year 2000 problem was supposed to collapse
+    #   systems, the panic clears ten minutes later when it didn't.
+    #
+    so = LocalScheduleObject(
+        objectIdentifier=('schedule', 3),
+        objectName='Schedule 3',
+        presentValue=CharacterString(""),
+        effectivePeriod=DateRange(
+            startDate=(0, 1, 1, 1),
+            endDate=(254, 12, 31, 2),
+            ),
+        exceptionSchedule=ArrayOf(SpecialEvent)([
+            SpecialEvent(
+                period=SpecialEventPeriod(
+                    calendarEntry=CalendarEntry(
+                        weekNDay=xtob("FF.FF.05"),
+                        ),
+                    ),
+                listOfTimeValues=[
+                    TimeValue(time=(0,0,0,0), value=CharacterString("It's Friday!")),
+                    ],
+                eventPriority=1,
+                ),
+            ]),
+        scheduleDefault=CharacterString("Keep working."),
+        )
+    _log.debug("    - so: %r", so)
+    this_application.add_object(so)
+    schedule_objects.append(so)
+
+    #
+    #   A schedule object that refers to an AnalogValueObject in the test
+    #   device.
+    #
+    so = LocalScheduleObject(
+        objectIdentifier=('schedule', 4),
+        objectName='Schedule 4',
+        presentValue=Real(73.5),
+        effectivePeriod=DateRange(
+            startDate=(0, 1, 1, 1),
+            endDate=(254, 12, 31, 2),
+            ),
+        weeklySchedule=ArrayOf(DailySchedule)([
+            DailySchedule(
+                daySchedule=[
+                    TimeValue(time=(9,0,0,0), value=Real(78.0)),
+                    TimeValue(time=(10,0,0,0), value=Null()),
+                    ]
+                ),
+            ] * 7),
+        scheduleDefault=Real(72.0),
+        listOfObjectPropertyReferences=SequenceOf(DeviceObjectPropertyReference)([
+            DeviceObjectPropertyReference(
+                objectIdentifier=('analogValue', 1),
+                propertyIdentifier='presentValue',
+                ),
+            ]),
+        )
+    _log.debug("    - so: %r", so)
+    this_application.add_object(so)
+    schedule_objects.append(so)
+
+    #
+    #   The beast
+    #
+    so = LocalScheduleObject(
+        objectIdentifier=('schedule', 5),
+        objectName='Schedule 5',
+        presentValue=Integer(0),
+        effectivePeriod=DateRange(
+            startDate=(0, 1, 1, 1),
+            endDate=(254, 12, 31, 2),
+            ),
+        exceptionSchedule=ArrayOf(SpecialEvent)([
+            SpecialEvent(
+                period=SpecialEventPeriod(
+                    calendarEntry=CalendarEntry(
+                        weekNDay=xtob("FF.FF.FF"),
+                        ),
+                    ),
+                listOfTimeValues=[
+                    TimeValue(time=(5,0,0,0), value=Integer(5)),
+                    TimeValue(time=(6,0,0,0), value=Null()),
+                    ],
+                eventPriority=1,
+                ),
+            SpecialEvent(
+                period=SpecialEventPeriod(
+                    calendarEntry=CalendarEntry(
+                        weekNDay=xtob("FF.FF.FF"),
+                        ),
+                    ),
+                listOfTimeValues=[
+                    TimeValue(time=(4,0,0,0), value=Integer(4)),
+                    TimeValue(time=(7,0,0,0), value=Null()),
+                    ],
+                eventPriority=2,
+                ),
+            SpecialEvent(
+                period=SpecialEventPeriod(
+                    calendarEntry=CalendarEntry(
+                        weekNDay=xtob("FF.FF.FF"),
+                        ),
+                    ),
+                listOfTimeValues=[
+                    TimeValue(time=(3,0,0,0), value=Integer(3)),
+                    TimeValue(time=(8,0,0,0), value=Null()),
+                    ],
+                eventPriority=3,
+                ),
+            SpecialEvent(
+                period=SpecialEventPeriod(
+                    calendarEntry=CalendarEntry(
+                        weekNDay=xtob("FF.FF.FF"),
+                        ),
+                    ),
+                listOfTimeValues=[
+                    TimeValue(time=(2,0,0,0), value=Integer(2)),
+                    TimeValue(time=(9,0,0,0), value=Null()),
+                    ],
+                eventPriority=4,
+                ),
+            SpecialEvent(
+                period=SpecialEventPeriod(
+                    calendarEntry=CalendarEntry(
+                        weekNDay=xtob("FF.FF.FF"),
+                        ),
+                    ),
+                listOfTimeValues=[
+                    TimeValue(time=(1,0,0,0), value=Integer(1)),
+                    ],
+                eventPriority=5,
+                ),
+            ]),
+        scheduleDefault=Integer(0),
+        )
+    _log.debug("    - so: %r", so)
+    this_application.add_object(so)
+    schedule_objects.append(so)
+
+
+    ltv = []
+    for hr in range(24):
+        for mn in range(0, 60, 5):
+            ltv.append(TimeValue(time=(hr,mn,0,0), value=Integer(hr * 100 + mn)))
+
+    #
+    #   Every five minutes
+    #
+    so = LocalScheduleObject(
+        objectIdentifier=('schedule', 6),
+        objectName='Schedule 6',
+        presentValue=Integer(0),
+        effectivePeriod=DateRange(
+            startDate=(0, 1, 1, 1),
+            endDate=(254, 12, 31, 2),
+            ),
+        exceptionSchedule=ArrayOf(SpecialEvent)([
+            SpecialEvent(
+                period=SpecialEventPeriod(
+                    calendarEntry=CalendarEntry(
+                        weekNDay=xtob("FF.FF.FF"),
+                        ),
+                    ),
+                listOfTimeValues=ltv,
+                eventPriority=1,
+                ),
+            ]),
+        scheduleDefault=Integer(0),
+        )
+    _log.debug("    - so: %r", so)
+    this_application.add_object(so)
+    schedule_objects.append(so)
+
+
+    # make sure they are all there
+    _log.debug("    - object list: %r", this_device.objectList)
+
+    TestConsoleCmd()
+
+    _log.debug("running")
+
+    run()
+
+    _log.debug("fini")
+
+if __name__ == "__main__":
+    main()
+
diff --git a/samples/ReadWriteProperty.py b/samples/ReadWriteProperty.py
index 8c982f1d..25e334a7 100755
--- a/samples/ReadWriteProperty.py
+++ b/samples/ReadWriteProperty.py
@@ -22,8 +22,9 @@
 
 from bacpypes.apdu import SimpleAckPDU, \
     ReadPropertyRequest, ReadPropertyACK, WritePropertyRequest
-from bacpypes.primitivedata import Null, Atomic, Integer, Unsigned, Real
-from bacpypes.constructeddata import Array, Any
+from bacpypes.primitivedata import Null, Atomic, Boolean, Unsigned, Integer, \
+    Real, Double, OctetString, CharacterString, BitString, Date, Time
+from bacpypes.constructeddata import Array, Any, AnyAtomic
 
 from bacpypes.app import BIPSimpleApplication
 from bacpypes.service.device import LocalDeviceObject
@@ -149,6 +150,27 @@ def do_write(self, args):
             # change atomic values into something encodeable, null is a special case
             if (value == 'null'):
                 value = Null()
+            elif issubclass(datatype, AnyAtomic):
+                dtype, dvalue = value.split(':')
+                if _debug: ReadWritePropertyConsoleCmd._debug("    - dtype, dvalue: %r, %r", dtype, dvalue)
+
+                datatype = {
+                    'b': Boolean,
+                    'u': lambda x: Unsigned(int(x)),
+                    'i': lambda x: Integer(int(x)),
+                    'r': lambda x: Real(float(x)),
+                    'd': lambda x: Double(float(x)),
+                    'o': OctetString,
+                    'c': CharacterString,
+                    'bs': BitString,
+                    'date': Date,
+                    'time': Time,
+                    }[dtype]
+                if _debug: ReadWritePropertyConsoleCmd._debug("    - datatype: %r", datatype)
+
+                value = datatype(dvalue)
+                if _debug: ReadWritePropertyConsoleCmd._debug("    - value: %r", value)
+
             elif issubclass(datatype, Atomic):
                 if datatype is Integer:
                     value = int(value)
diff --git a/tests/time_machine.py b/tests/time_machine.py
index 140328b5..d8a71a8e 100755
--- a/tests/time_machine.py
+++ b/tests/time_machine.py
@@ -5,6 +5,8 @@
 --------------------
 """
 
+import re
+import time
 from heapq import heappop
 
 from bacpypes.debugging import bacpypes_debugging, ModuleLogger
@@ -19,6 +21,11 @@
 # time machine
 time_machine = None
 
+# some patterns
+_date_regex = re.compile("^(\d{4})[-](0?[1-9]|1[0-4])[-]([0-3]?\d)$")
+_time_regex = re.compile("^(\d+)[:](\d+)(?:[:](\d+)(?:[.](\d+))?)?$")
+_deltatime_regex = re.compile("^(\d+(?:[.]\d+))?$")
+
 
 # @bacpypes_debugging - implicit via metaclass
 class TimeMachine(_TaskManager):
@@ -142,20 +149,105 @@ def process_task(self, task):
 
 
 @bacpypes_debugging
-def reset_time_machine():
+def xdatetime(s, now):
+    """
+    Given a string of the form "[YYYY-MM-DD] [HR:MN[:SC[.HN]]]" where the
+    date or time or both are provided, return the seconds since the epoch.
+
+    If the date is provided and the time is not, assume the time is
+    midnight, e.g., 0:0:0.0.
+
+    If the time is provided but the date is not, assume the date is the same
+    as the date in 'now'.
+
+    If the time is provided as a floating point number, it is a deltatime
+    from 'now'.
+    """
+    if _debug: xdatetime._debug("xdatetime %r", s)
+
+    # assume there is no offset and nothing matches
+    seconds_offset = 0.0
+    date_match = time_match = deltatime_match = None
+
+    # split the string into two pieces
+    h, _, t = s.strip().partition(" ")
+    if not h:
+        raise RuntimeError("date and/or time required")
+    if _debug: xdatetime._debug("    - h, t: %r, %r", h, t)
+
+    if h and t:
+        date_match = _date_regex.match(h)
+        if not date_match:
+            raise RuntimeError("date not matching")
+
+        time_match = _time_regex.match(t)
+        if not time_match:
+            raise RuntimeError("time not matching")
+    else:
+        date_match = _date_regex.match(h)
+        if not date_match:
+            time_match = _time_regex.match(h)
+            if not time_match:
+                deltatime_match = _deltatime_regex.match(h)
+                if not deltatime_match:
+                    raise RuntimeError("no match")
+                seconds_offset = float(deltatime_match.groups()[0])
+                if _debug: xdatetime._debug("    - seconds_offset: %r", seconds_offset)
+
+                return now + seconds_offset
+
+    xtuple = []
+    if date_match:
+        xtuple.extend(int(v) for v in date_match.groups())
+    else:
+        xtuple.extend(time.localtime(now)[:3])
+    if _debug: xdatetime._debug("    - xtuple: %r", xtuple)
+
+    if time_match:
+        time_tuple = list(int(v or "0") for v in time_match.groups())
+        if _debug: xdatetime._debug("    - time_tuple: %r", time_tuple)
+
+        xtuple.extend(time_tuple[:3])
+
+        seconds_offset = float(time_tuple[3])
+        if seconds_offset:
+            seconds_offset /= 10.0 ** len(time_match.groups()[3])
+        if _debug: xdatetime._debug("    - seconds_offset: %r", seconds_offset)
+    else:
+        xtuple.extend([0, 0, 0])
+    if _debug: xdatetime._debug("    - xtuple: %r", xtuple)
+
+    # fill it out to length nine, unknown dst
+    xtuple.extend([0, 0, -1])
+    if _debug: xdatetime._debug("    - xtuple: %r", xtuple)
+
+    # convert it back to seconds since the epoch
+    xtime = time.mktime(xtuple) + seconds_offset
+    if _debug: xdatetime._debug("    - xtime: %r", xtime)
+
+    return xtime
+
+
+@bacpypes_debugging
+def reset_time_machine(start_time=0.0):
     """This function is called to reset the clock before running a set
     of tests.
     """
-    if _debug: reset_time_machine._debug("reset_time_machine")
+    if _debug: reset_time_machine._debug("reset_time_machine %r", start_time)
     global time_machine
 
     # a little error checking
     if not time_machine:
         raise RuntimeError("no time machine")
 
+    # the start might be a special string
+    if isinstance(start_time, str):
+        start_time = xdatetime(start_time, 0.0)
+        if _debug: reset_time_machine._debug("    - start_time: %r", start_time)
+
     # begin time at the beginning
     time_machine.tasks = []
-    time_machine.current_time = 0.0
+    time_machine.current_time = start_time
     time_machine.time_limit = None
 
 
@@ -172,11 +264,16 @@ def run_time_machine(time_limit):
     # a little error checking
     if not time_machine:
         raise RuntimeError("no time machine")
-    if time_limit <= 0.0:
-        raise ValueError("time limit required")
     if time_machine.current_time is None:
         raise RuntimeError("reset the time machine before running")
 
+    # the start might be a special string
+    if isinstance(time_limit, str):
+        time_limit = xdatetime(time_limit, time_machine.current_time)
+        if _debug: reset_time_machine._debug("    - time_limit: %r", time_limit)
+    if time_limit <= 0.0:
+        raise ValueError("time limit required")
+
     # pass the limit to the time machine
     time_machine.time_limit = time_machine.current_time + time_limit
 

From 5e19456e23727a049ad16efdd9c50cf6f5c3721d Mon Sep 17 00:00:00 2001
From: Joel Bender <joel@carrickbender.com>
Date: Wed, 6 Dec 2017 23:10:57 -0500
Subject: [PATCH 03/21] sync up the different python versions

---
 py25/bacpypes/constructeddata.py |  6 ++++++
 py25/bacpypes/object.py          |  8 ++++++++
 py25/bacpypes/primitivedata.py   | 22 ++++++++++++++++++++++
 py25/bacpypes/service/device.py  |  2 +-
 py27/bacpypes/primitivedata.py   | 22 ++++++++++++++++++++++
 py34/bacpypes/constructeddata.py |  6 ++++++
 py34/bacpypes/object.py          |  8 ++++++++
 py34/bacpypes/service/device.py  |  2 +-
 8 files changed, 74 insertions(+), 2 deletions(-)

diff --git a/py25/bacpypes/constructeddata.py b/py25/bacpypes/constructeddata.py
index f06d2eee..5a305538 100755
--- a/py25/bacpypes/constructeddata.py
+++ b/py25/bacpypes/constructeddata.py
@@ -405,6 +405,9 @@ def __len__(self):
         def __getitem__(self, item):
             return self.value[item]
 
+        def __iter__(self):
+            return iter(self.value)
+
         def encode(self, taglist):
             if _debug: _SequenceOf._debug("(%r)encode %r", self.__class__.__name__, taglist)
             for value in self.value:
@@ -595,6 +598,9 @@ def __delitem__(self, item):
             del self.value[item]
             self.value[0] -= 1
 
+        def __iter__(self):
+            return iter(self.value[1:])
+
         def index(self, value):
             # only search through values
             for i in range(1, self.value[0] + 1):
diff --git a/py25/bacpypes/object.py b/py25/bacpypes/object.py
index 3bbac83c..ed66fdc1 100755
--- a/py25/bacpypes/object.py
+++ b/py25/bacpypes/object.py
@@ -81,6 +81,7 @@ def _register(xcls):
     # build a property dictionary by going through the class and all its parents
     _properties = {}
     for c in cls.__mro__:
+        if _debug: register_object_type._debug("    - c: %r", c)
         for prop in getattr(c, 'properties', []):
             if prop.identifier not in _properties:
                 _properties[prop.identifier] = prop
@@ -209,6 +210,13 @@ def WriteProperty(self, obj, value, arrayIndex=None, priority=None, direct=False
                             ))
 
             # if it's atomic, make sure it's valid
+            if issubclass(self.datatype, AnyAtomic):
+                if _debug: Property._debug("    - property is any atomic, checking value")
+                if not isinstance(value, Atomic):
+                    raise InvalidParameterDatatype("%s must be an atomic instance" % (
+                            self.identifier,
+                            ))
+
             elif issubclass(self.datatype, Atomic):
                 if _debug: Property._debug("    - property is atomic, checking value")
                 if not self.datatype.is_valid(value):
diff --git a/py25/bacpypes/primitivedata.py b/py25/bacpypes/primitivedata.py
index 64070aa9..840a7b6f 100755
--- a/py25/bacpypes/primitivedata.py
+++ b/py25/bacpypes/primitivedata.py
@@ -449,6 +449,8 @@ class Atomic(object):
     _app_tag = None
 
     def __cmp__(self, other):
+        # sys.stderr.write("__cmp__ %r %r\n" % (self, other))
+
         # hoop jump it
         if not isinstance(other, self.__class__):
             other = self.__class__(other)
@@ -461,6 +463,26 @@ def __cmp__(self, other):
         else:
             return 0
 
+    def __lt__(self, other):
+        # sys.stderr.write("__lt__ %r %r\n" % (self, other))
+
+        # hoop jump it
+        if not isinstance(other, self.__class__):
+            other = self.__class__(other)
+
+        # now compare the values
+        return (self.value < other.value)
+
+    def __eq__(self, other):
+        # sys.stderr.write("__eq__ %r %r\n" % (self, other))
+
+        # hoop jump it
+        if not isinstance(other, self.__class__):
+            other = self.__class__(other)
+
+        # now compare the values
+        return self.value == other.value
+
     @classmethod
     def coerce(cls, arg):
         """Given an arg, return the appropriate value given the class."""
diff --git a/py25/bacpypes/service/device.py b/py25/bacpypes/service/device.py
index 87e618f3..94958bf5 100644
--- a/py25/bacpypes/service/device.py
+++ b/py25/bacpypes/service/device.py
@@ -103,7 +103,7 @@ def __init__(self, **kwargs):
                 raise RuntimeError("vendorIdentifier required to auto-register the LocalDeviceObject class")
             register_object_type(self.__class__, vendor_id=kwargs['vendorIdentifier'])
 
-        # check for local time
+        # check for properties this class implements
         if 'localDate' in kwargs:
             raise RuntimeError("localDate is provided by LocalDeviceObject and cannot be overridden")
         if 'localTime' in kwargs:
diff --git a/py27/bacpypes/primitivedata.py b/py27/bacpypes/primitivedata.py
index 91c10d7d..1bdb8f1a 100755
--- a/py27/bacpypes/primitivedata.py
+++ b/py27/bacpypes/primitivedata.py
@@ -453,6 +453,8 @@ class Atomic(object):
     _app_tag = None
 
     def __cmp__(self, other):
+        # sys.stderr.write("__cmp__ %r %r\n" % (self, other))
+
         # hoop jump it
         if not isinstance(other, self.__class__):
             other = self.__class__(other)
@@ -465,6 +467,26 @@ def __cmp__(self, other):
         else:
             return 0
 
+    def __lt__(self, other):
+        # sys.stderr.write("__lt__ %r %r\n" % (self, other))
+
+        # hoop jump it
+        if not isinstance(other, self.__class__):
+            other = self.__class__(other)
+
+        # now compare the values
+        return (self.value < other.value)
+
+    def __eq__(self, other):
+        # sys.stderr.write("__eq__ %r %r\n" % (self, other))
+
+        # hoop jump it
+        if not isinstance(other, self.__class__):
+            other = self.__class__(other)
+
+        # now compare the values
+        return self.value == other.value
+
     @classmethod
     def coerce(cls, arg):
         """Given an arg, return the appropriate value given the class."""
diff --git a/py34/bacpypes/constructeddata.py b/py34/bacpypes/constructeddata.py
index 88fe28de..56b66366 100755
--- a/py34/bacpypes/constructeddata.py
+++ b/py34/bacpypes/constructeddata.py
@@ -406,6 +406,9 @@ def __len__(self):
         def __getitem__(self, item):
             return self.value[item]
 
+        def __iter__(self):
+            return iter(self.value)
+
         def encode(self, taglist):
             if _debug: _SequenceOf._debug("(%r)encode %r", self.__class__.__name__, taglist)
             for value in self.value:
@@ -593,6 +596,9 @@ def __delitem__(self, item):
             del self.value[item]
             self.value[0] -= 1
 
+        def __iter__(self):
+            return iter(self.value[1:])
+
         def index(self, value):
             # only search through values
             for i in range(1, self.value[0] + 1):
diff --git a/py34/bacpypes/object.py b/py34/bacpypes/object.py
index 9f31dd90..87381184 100755
--- a/py34/bacpypes/object.py
+++ b/py34/bacpypes/object.py
@@ -81,6 +81,7 @@ def _register(xcls):
     # build a property dictionary by going through the class and all its parents
     _properties = {}
     for c in cls.__mro__:
+        if _debug: register_object_type._debug("    - c: %r", c)
         for prop in getattr(c, 'properties', []):
             if prop.identifier not in _properties:
                 _properties[prop.identifier] = prop
@@ -210,6 +211,13 @@ def WriteProperty(self, obj, value, arrayIndex=None, priority=None, direct=False
                             ))
 
             # if it's atomic, make sure it's valid
+            if issubclass(self.datatype, AnyAtomic):
+                if _debug: Property._debug("    - property is any atomic, checking value")
+                if not isinstance(value, Atomic):
+                    raise InvalidParameterDatatype("%s must be an atomic instance" % (
+                            self.identifier,
+                            ))
+
             elif issubclass(self.datatype, Atomic):
                 if _debug: Property._debug("    - property is atomic, checking value")
                 if not self.datatype.is_valid(value):
diff --git a/py34/bacpypes/service/device.py b/py34/bacpypes/service/device.py
index f8871c7b..647714bd 100644
--- a/py34/bacpypes/service/device.py
+++ b/py34/bacpypes/service/device.py
@@ -104,7 +104,7 @@ def __init__(self, **kwargs):
                 raise RuntimeError("vendorIdentifier required to auto-register the LocalDeviceObject class")
             register_object_type(self.__class__, vendor_id=kwargs['vendorIdentifier'])
 
-        # check for local time
+        # check for properties this class implements
         if 'localDate' in kwargs:
             raise RuntimeError("localDate is provided by LocalDeviceObject and cannot be overridden")
         if 'localTime' in kwargs:

From ebbf8016d0cfd2c7bd4189c0da4a62963083524d Mon Sep 17 00:00:00 2001
From: Joel Bender <joel@carrickbender.com>
Date: Wed, 6 Dec 2017 23:18:59 -0500
Subject: [PATCH 04/21] copy/paste error, tests now pass

---
 py25/bacpypes/object.py | 2 +-
 py27/bacpypes/object.py | 2 +-
 py34/bacpypes/object.py | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/py25/bacpypes/object.py b/py25/bacpypes/object.py
index ed66fdc1..a6e764fd 100755
--- a/py25/bacpypes/object.py
+++ b/py25/bacpypes/object.py
@@ -210,7 +210,7 @@ def WriteProperty(self, obj, value, arrayIndex=None, priority=None, direct=False
                             ))
 
             # if it's atomic, make sure it's valid
-            if issubclass(self.datatype, AnyAtomic):
+            elif issubclass(self.datatype, AnyAtomic):
                 if _debug: Property._debug("    - property is any atomic, checking value")
                 if not isinstance(value, Atomic):
                     raise InvalidParameterDatatype("%s must be an atomic instance" % (
diff --git a/py27/bacpypes/object.py b/py27/bacpypes/object.py
index 1c09e16e..21e824f7 100755
--- a/py27/bacpypes/object.py
+++ b/py27/bacpypes/object.py
@@ -211,7 +211,7 @@ def WriteProperty(self, obj, value, arrayIndex=None, priority=None, direct=False
                             ))
 
             # if it's atomic, make sure it's valid
-            if issubclass(self.datatype, AnyAtomic):
+            elif issubclass(self.datatype, AnyAtomic):
                 if _debug: Property._debug("    - property is any atomic, checking value")
                 if not isinstance(value, Atomic):
                     raise InvalidParameterDatatype("%s must be an atomic instance" % (
diff --git a/py34/bacpypes/object.py b/py34/bacpypes/object.py
index 87381184..c0e64ee4 100755
--- a/py34/bacpypes/object.py
+++ b/py34/bacpypes/object.py
@@ -211,7 +211,7 @@ def WriteProperty(self, obj, value, arrayIndex=None, priority=None, direct=False
                             ))
 
             # if it's atomic, make sure it's valid
-            if issubclass(self.datatype, AnyAtomic):
+            elif issubclass(self.datatype, AnyAtomic):
                 if _debug: Property._debug("    - property is any atomic, checking value")
                 if not isinstance(value, Atomic):
                     raise InvalidParameterDatatype("%s must be an atomic instance" % (

From 84a0e448472b99f1434a50687dc4b07b228f3cd0 Mon Sep 17 00:00:00 2001
From: Joel Bender <joel@carrickbender.com>
Date: Fri, 8 Dec 2017 00:00:51 -0500
Subject: [PATCH 05/21] use the new CurrentPropertyListMixIn

---
 samples/LocalScheduleObject.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/samples/LocalScheduleObject.py b/samples/LocalScheduleObject.py
index 953157d0..7706e9c0 100644
--- a/samples/LocalScheduleObject.py
+++ b/samples/LocalScheduleObject.py
@@ -22,6 +22,7 @@
 from bacpypes.object import register_object_type, get_datatype, WritableProperty, ScheduleObject
 
 from bacpypes.app import BIPSimpleApplication
+from bacpypes.service.object import CurrentPropertyListMixIn
 from bacpypes.service.device import LocalDeviceObject
 
 # some debugging
@@ -246,7 +247,7 @@ def datetime_to_time(date, time):
 
 @bacpypes_debugging
 @register_object_type(vendor_id=999)
-class LocalScheduleObject(ScheduleObject):
+class LocalScheduleObject(CurrentPropertyListMixIn, ScheduleObject):
 
     properties = [
         WritableProperty('presentValue', AnyAtomic),

From fa922479bf1158d585c7a285a433e71fa698776b Mon Sep 17 00:00:00 2001
From: Joel Bender <joel@carrickbender.com>
Date: Fri, 8 Dec 2017 00:04:56 -0500
Subject: [PATCH 06/21] problem decoding AnyAtomic in a Sequence

---
 py25/bacpypes/constructeddata.py | 25 ++++++++++++++++++++++++-
 py27/bacpypes/constructeddata.py | 25 ++++++++++++++++++++++++-
 py34/bacpypes/constructeddata.py | 25 ++++++++++++++++++++++++-
 3 files changed, 72 insertions(+), 3 deletions(-)

diff --git a/py25/bacpypes/constructeddata.py b/py25/bacpypes/constructeddata.py
index 5a305538..7b2fe552 100755
--- a/py25/bacpypes/constructeddata.py
+++ b/py25/bacpypes/constructeddata.py
@@ -141,6 +141,7 @@ def decode(self, taglist):
 
         for element in self.sequenceElements:
             tag = taglist.Peek()
+            if _debug: Sequence._debug("    - element, tag: %r, %r", element, tag)
 
             # no more elements
             if tag is None:
@@ -187,7 +188,29 @@ def decode(self, taglist):
                     if tag.tagClass != Tag.closingTagClass or tag.tagNumber != element.context:
                         raise InvalidTag("%s expected closing tag %d" % (element.name, element.context))
 
-            # check for an atomic element
+            # check for an any atomic element
+            elif issubclass(element.klass, AnyAtomic):
+                # convert it to application encoding
+                if element.context is not None:
+                    raise InvalidTag("%s any atomic with context tag %d" % (element.name, element.context))
+
+                if tag.tagClass != Tag.applicationTagClass:
+                    if not element.optional:
+                        raise InvalidParameterDatatype("%s expected any atomic application tag" % (element.name,))
+                    else:
+                        setattr(self, element.name, None)
+                        continue
+
+                # consume the tag
+                taglist.Pop()
+
+                # a helper cooperates between the atomic value and the tag
+                helper = element.klass(tag)
+
+                # now save the value
+                setattr(self, element.name, helper.value)
+
+            # check for specific kind of atomic element, or the context says what kind
             elif issubclass(element.klass, Atomic):
                 # convert it to application encoding
                 if element.context is not None:
diff --git a/py27/bacpypes/constructeddata.py b/py27/bacpypes/constructeddata.py
index 029b4d2a..bd527c0b 100755
--- a/py27/bacpypes/constructeddata.py
+++ b/py27/bacpypes/constructeddata.py
@@ -142,6 +142,7 @@ def decode(self, taglist):
 
         for element in self.sequenceElements:
             tag = taglist.Peek()
+            if _debug: Sequence._debug("    - element, tag: %r, %r", element, tag)
 
             # no more elements
             if tag is None:
@@ -188,7 +189,29 @@ def decode(self, taglist):
                     if tag.tagClass != Tag.closingTagClass or tag.tagNumber != element.context:
                         raise InvalidTag("%s expected closing tag %d" % (element.name, element.context))
 
-            # check for an atomic element
+            # check for an any atomic element
+            elif issubclass(element.klass, AnyAtomic):
+                # convert it to application encoding
+                if element.context is not None:
+                    raise InvalidTag("%s any atomic with context tag %d" % (element.name, element.context))
+
+                if tag.tagClass != Tag.applicationTagClass:
+                    if not element.optional:
+                        raise InvalidParameterDatatype("%s expected any atomic application tag" % (element.name,))
+                    else:
+                        setattr(self, element.name, None)
+                        continue
+
+                # consume the tag
+                taglist.Pop()
+
+                # a helper cooperates between the atomic value and the tag
+                helper = element.klass(tag)
+
+                # now save the value
+                setattr(self, element.name, helper.value)
+
+            # check for specific kind of atomic element, or the context says what kind
             elif issubclass(element.klass, Atomic):
                 # convert it to application encoding
                 if element.context is not None:
diff --git a/py34/bacpypes/constructeddata.py b/py34/bacpypes/constructeddata.py
index 56b66366..9c288428 100755
--- a/py34/bacpypes/constructeddata.py
+++ b/py34/bacpypes/constructeddata.py
@@ -142,6 +142,7 @@ def decode(self, taglist):
 
         for element in self.sequenceElements:
             tag = taglist.Peek()
+            if _debug: Sequence._debug("    - element, tag: %r, %r", element, tag)
 
             # no more elements
             if tag is None:
@@ -188,7 +189,29 @@ def decode(self, taglist):
                     if tag.tagClass != Tag.closingTagClass or tag.tagNumber != element.context:
                         raise InvalidTag("%s expected closing tag %d" % (element.name, element.context))
 
-            # check for an atomic element
+            # check for an any atomic element
+            elif issubclass(element.klass, AnyAtomic):
+                # convert it to application encoding
+                if element.context is not None:
+                    raise InvalidTag("%s any atomic with context tag %d" % (element.name, element.context))
+
+                if tag.tagClass != Tag.applicationTagClass:
+                    if not element.optional:
+                        raise InvalidParameterDatatype("%s expected any atomic application tag" % (element.name,))
+                    else:
+                        setattr(self, element.name, None)
+                        continue
+
+                # consume the tag
+                taglist.Pop()
+
+                # a helper cooperates between the atomic value and the tag
+                helper = element.klass(tag)
+
+                # now save the value
+                setattr(self, element.name, helper.value)
+
+            # check for specific kind of atomic element, or the context says what kind
             elif issubclass(element.klass, Atomic):
                 # convert it to application encoding
                 if element.context is not None:

From e13d6e23a44c26c7be2bd05e20849ff14e5fa48e Mon Sep 17 00:00:00 2001
From: Joel Bender <joel@betelgeuse>
Date: Fri, 8 Dec 2017 09:53:44 -0500
Subject: [PATCH 07/21] bring this branch up to date with `stage`

---
 doc/source/gettingstarted/gettingstarted001.rst | 4 ++--
 doc/source/gettingstarted/gettingstarted002.rst | 2 +-
 py25/bacpypes/__init__.py                       | 2 +-
 py25/bacpypes/appservice.py                     | 2 +-
 py27/bacpypes/__init__.py                       | 2 +-
 py27/bacpypes/appservice.py                     | 2 +-
 py34/bacpypes/__init__.py                       | 2 +-
 py34/bacpypes/appservice.py                     | 2 +-
 8 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/doc/source/gettingstarted/gettingstarted001.rst b/doc/source/gettingstarted/gettingstarted001.rst
index ed449efe..c88263a3 100644
--- a/doc/source/gettingstarted/gettingstarted001.rst
+++ b/doc/source/gettingstarted/gettingstarted001.rst
@@ -152,7 +152,7 @@ of the sample configuration file, and edit it for your site::
     communicate as peers, so it is not unusual for an application to 
     act as both a client and a server at the same time.
 
-A typical BACpypes.ini file contains 
+A typical BACpypes.ini file contains::
 
     [BACpypes]
     objectName: Betelgeuse
@@ -172,7 +172,7 @@ UDP Communications Issues
 
 BACnet devices communicate using UDP rather than TCP.  This is so 
 devices do not need to implement a full IP stack (although 
-many of them do becuase they support multiple protocols, including
+many of them do because they support multiple protocols, including
 having embedded web servers).
 
 There are two types of UDP messages; *unicast* which is a message 
diff --git a/doc/source/gettingstarted/gettingstarted002.rst b/doc/source/gettingstarted/gettingstarted002.rst
index 5af52c90..4d22180c 100644
--- a/doc/source/gettingstarted/gettingstarted002.rst
+++ b/doc/source/gettingstarted/gettingstarted002.rst
@@ -125,7 +125,7 @@ be specified, so this limits the output to one hundred files::
 
 .. caution::
 
-    The traffice.txt file will be saved in the local directory (pwd)
+    The traffic.txt file will be saved in the local directory (pwd)
 
 The definition of debug::
 
diff --git a/py25/bacpypes/__init__.py b/py25/bacpypes/__init__.py
index d605c957..477e6836 100755
--- a/py25/bacpypes/__init__.py
+++ b/py25/bacpypes/__init__.py
@@ -18,7 +18,7 @@
 #   Project Metadata
 #
 
-__version__ = '0.16.6'
+__version__ = '0.16.7'
 __author__ = 'Joel Bender'
 __email__ = 'joel@carrickbender.com'
 
diff --git a/py25/bacpypes/appservice.py b/py25/bacpypes/appservice.py
index 34303f86..942424e4 100755
--- a/py25/bacpypes/appservice.py
+++ b/py25/bacpypes/appservice.py
@@ -766,7 +766,7 @@ def confirmation(self, apdu):
                 if self.ssmSAP.segmentationSupported not in ('segmentedTransmit', 'segmentedBoth'):
                     if _debug: ServerSSM._debug("    - server can't send segmented responses")
                     abort = self.abort(AbortReason.segmentationNotSupported)
-                    self.reponse(abort)
+                    self.response(abort)
                     return
 
                 # make sure client supports segmented receive
diff --git a/py27/bacpypes/__init__.py b/py27/bacpypes/__init__.py
index d605c957..477e6836 100755
--- a/py27/bacpypes/__init__.py
+++ b/py27/bacpypes/__init__.py
@@ -18,7 +18,7 @@
 #   Project Metadata
 #
 
-__version__ = '0.16.6'
+__version__ = '0.16.7'
 __author__ = 'Joel Bender'
 __email__ = 'joel@carrickbender.com'
 
diff --git a/py27/bacpypes/appservice.py b/py27/bacpypes/appservice.py
index 1d09f48b..4a3b65da 100755
--- a/py27/bacpypes/appservice.py
+++ b/py27/bacpypes/appservice.py
@@ -765,7 +765,7 @@ def confirmation(self, apdu):
                 if self.ssmSAP.segmentationSupported not in ('segmentedTransmit', 'segmentedBoth'):
                     if _debug: ServerSSM._debug("    - server can't send segmented responses")
                     abort = self.abort(AbortReason.segmentationNotSupported)
-                    self.reponse(abort)
+                    self.response(abort)
                     return
 
                 # make sure client supports segmented receive
diff --git a/py34/bacpypes/__init__.py b/py34/bacpypes/__init__.py
index eff83a52..bd516040 100755
--- a/py34/bacpypes/__init__.py
+++ b/py34/bacpypes/__init__.py
@@ -18,7 +18,7 @@
 #   Project Metadata
 #
 
-__version__ = '0.16.6'
+__version__ = '0.16.7'
 __author__ = 'Joel Bender'
 __email__ = 'joel@carrickbender.com'
 
diff --git a/py34/bacpypes/appservice.py b/py34/bacpypes/appservice.py
index 1d09f48b..4a3b65da 100755
--- a/py34/bacpypes/appservice.py
+++ b/py34/bacpypes/appservice.py
@@ -765,7 +765,7 @@ def confirmation(self, apdu):
                 if self.ssmSAP.segmentationSupported not in ('segmentedTransmit', 'segmentedBoth'):
                     if _debug: ServerSSM._debug("    - server can't send segmented responses")
                     abort = self.abort(AbortReason.segmentationNotSupported)
-                    self.reponse(abort)
+                    self.response(abort)
                     return
 
                 # make sure client supports segmented receive

From dd922b6e01d4b50eb1f07a015e5cb2f230f686db Mon Sep 17 00:00:00 2001
From: Joel Bender <joel@carrickbender.com>
Date: Mon, 11 Dec 2017 00:23:50 -0500
Subject: [PATCH 08/21] poking around the edges at the API for the time machine

---
 tests/test_utilities/test_time_machine.py | 45 +++++++++++++++++++++--
 tests/time_machine.py                     | 42 +++++++++++++--------
 2 files changed, 68 insertions(+), 19 deletions(-)

diff --git a/tests/test_utilities/test_time_machine.py b/tests/test_utilities/test_time_machine.py
index c0ec6092..baf1a831 100644
--- a/tests/test_utilities/test_time_machine.py
+++ b/tests/test_utilities/test_time_machine.py
@@ -6,12 +6,14 @@
 ----------------------------
 """
 
+import time
 import unittest
 
 from bacpypes.debugging import bacpypes_debugging, ModuleLogger
 
 from bacpypes.task import OneShotTask, FunctionTask, RecurringTask
-from ..time_machine import TimeMachine, reset_time_machine, run_time_machine
+from ..time_machine import TimeMachine, reset_time_machine, run_time_machine, \
+    xdatetime
 
 # some debugging
 _debug = 0
@@ -99,7 +101,10 @@ def __init__(self):
 
     def process_task(self):
         global time_machine
-        if _debug: SampleRecurringTask._debug("process_task @ %r", time_machine.current_time)
+        if _debug: SampleRecurringTask._debug("process_task @ %r %s",
+            time_machine.current_time,
+            time.strftime("%x %X", time.gmtime(time_machine.current_time)),
+            )
 
         # add the current time
         self.process_task_called.append(time_machine.current_time)
@@ -126,8 +131,8 @@ def test_empty_run(self):
         # no time has passed
         assert time_machine.current_time == 0.0
 
-    def test_one_shot_immediate(self):
-        if _debug: TestTimeMachine._debug("test_one_shot_immediate")
+    def test_one_shot_immediate_1(self):
+        if _debug: TestTimeMachine._debug("test_one_shot_immediate_1")
 
         # create a function task
         ft = SampleOneShotTask()
@@ -141,6 +146,24 @@ def test_one_shot_immediate(self):
         assert almost_equal(ft.process_task_called, [0.0])
         assert time_machine.current_time == 0.0
 
+    def test_one_shot_immediate_2(self):
+        if _debug: TestTimeMachine._debug("test_one_shot_immediate_2")
+
+        # create a function task
+        ft = SampleOneShotTask()
+
+        # run the function sometime later
+        t1 = xdatetime("2000-06-06")
+        if _debug: TestTimeMachine._debug("    - t1: %r", t1)
+
+        # reset the time machine to midnight, install the task, let it run
+        reset_time_machine(start_time="2000-01-01")
+        ft.install_task(t1)
+        run_time_machine(stop_time="2001-01-01")
+
+        # function called at correct time
+        assert almost_equal(ft.process_task_called, [t1])
+
     def test_function_task_immediate(self):
         if _debug: TestTimeMachine._debug("test_function_task_immediate")
         global sample_task_function_called
@@ -240,3 +263,17 @@ def test_recurring_task_4(self):
         assert almost_equal(ft.process_task_called, [0.9, 1.9, 2.9, 3.9, 4.9])
         assert time_machine.current_time == 5.0
 
+    def test_recurring_task_5(self):
+        if _debug: TestTimeMachine._debug("test_recurring_task_5")
+
+        # create a function task
+        ft = SampleRecurringTask()
+
+        # reset the time machine, install the task, let it run
+        reset_time_machine(start_time="2000-01-01")
+        ft.install_task(86400.0 * 1000.0)
+        run_time_machine(stop_time="2000-02-01")
+
+        # function called every day
+        assert len(ft.process_task_called) == 31
+
diff --git a/tests/time_machine.py b/tests/time_machine.py
index d8a71a8e..109cbe72 100755
--- a/tests/time_machine.py
+++ b/tests/time_machine.py
@@ -149,7 +149,7 @@ def process_task(self, task):
 
 
 @bacpypes_debugging
-def xdatetime(s, now):
+def xdatetime(s, now=None):
     """
     Given a string of the form "[YYYY-MM-DD] [HR:MN[:SC[.HN]]]" where the
     date or time or both are provided, return the seconds since the epoch.
@@ -194,12 +194,18 @@ def xdatetime(s, now):
                 seconds_offset = float(deltatime_match.groups()[0])
                 if _debug: xdatetime._debug("    - seconds_offset: %r", seconds_offset)
 
+                if now is None:
+                    raise RuntimeError("'now' required for deltatime")
+
                 return now + seconds_offset
 
     xtuple = []
     if date_match:
         xtuple.extend(int(v) for v in date_match.groups())
     else:
+        if now is None:
+            raise RuntimeError("'now' required for deltatime")
+
         xtuple.extend(time.localtime(now)[:3])
     if _debug: xdatetime._debug("    - xtuple: %r", xtuple)
 
@@ -222,7 +228,7 @@ def xdatetime(s, now):
     if _debug: xdatetime._debug("    - xtuple: %r", xtuple)
 
     # convert it back to seconds since the epoch
-    xtime = time.mktime(xtuple) + seconds_offset
+    xtime = time.mktime(tuple(xtuple)) + seconds_offset
     if _debug: xdatetime._debug("    - xtime: %r", xtime)
 
     return xtime
@@ -242,7 +248,7 @@ def reset_time_machine(start_time=0.0):
 
     # the start might be a special string
     if isinstance(start_time, str):
-        start_time = xdatetime(start_time, 0.0)
+        start_time = xdatetime(start_time)
         if _debug: reset_time_machine._debug("    - start_time: %r", start_time)
 
     # begin time at the beginning
@@ -252,13 +258,13 @@ def reset_time_machine(start_time=0.0):
 
 
 @bacpypes_debugging
-def run_time_machine(time_limit):
+def run_time_machine(duration=None, stop_time=None):
     """This function is called after a set of tasks have been installed
-    and they should run.  The machine will stop when the limit has been
+    and they should run.  The machine will stop when the stop time has been
     reached (maybe the middle of some tests) and can be called again to
     continue running.
     """
-    if _debug: run_time_machine._debug("run_time_machine %r", time_limit)
+    if _debug: run_time_machine._debug("run_time_machine %r %r", duration, stop_time)
     global time_machine
 
     # a little error checking
@@ -267,15 +273,21 @@ def run_time_machine(time_limit):
     if time_machine.current_time is None:
         raise RuntimeError("reset the time machine before running")
 
-    # the start might be a special string
-    if isinstance(time_limit, str):
-        time_limit = xdatetime(time_limit, time_machine.current_time)
-        if _debug: reset_time_machine._debug("    - time_limit: %r", time_limit)
-    if time_limit <= 0.0:
-        raise ValueError("time limit required")
-
-    # pass the limit to the time machine
-    time_machine.time_limit = time_machine.current_time + time_limit
+    # check for duration, calculate the time limit
+    if duration is not None:
+        # pass the limit to the time machine
+        time_machine.time_limit = time_machine.current_time + duration
+
+    elif stop_time is not None:
+        # the start might be a special string
+        if isinstance(stop_time, str):
+            stop_time = xdatetime(stop_time, time_machine.current_time)
+            if _debug: reset_time_machine._debug("    - stop_time: %r", stop_time)
+
+        # pass the limit to the time machine
+        time_machine.time_limit = stop_time
+    else:
+        raise RuntimeError("duration or stop_time required")
 
     # check if there are deferred functions
     if _core.deferredFns:

From 8ceaa72f46a367b4952b05dfea473d8803d31351 Mon Sep 17 00:00:00 2001
From: Joel Bender <joel@carrickbender.com>
Date: Tue, 12 Dec 2017 18:36:41 -0500
Subject: [PATCH 09/21] convert dates and times to/from float

---
 py25/bacpypes/primitivedata.py | 59 ++++++++++++++++++++++++++++++----
 py27/bacpypes/primitivedata.py | 59 ++++++++++++++++++++++++++++++----
 py34/bacpypes/primitivedata.py | 59 ++++++++++++++++++++++++++++++----
 3 files changed, 159 insertions(+), 18 deletions(-)

diff --git a/py25/bacpypes/primitivedata.py b/py25/bacpypes/primitivedata.py
index 840a7b6f..602f4365 100755
--- a/py25/bacpypes/primitivedata.py
+++ b/py25/bacpypes/primitivedata.py
@@ -14,6 +14,9 @@
 from .errors import DecodingError, InvalidTag, InvalidParameterDatatype
 from .pdu import PDUData
 
+# import the task manager to get the "current" date and time
+from .task import TaskManager as _TaskManager
+
 # some debugging
 _debug = 0
 _log = ModuleLogger(globals())
@@ -1360,6 +1363,9 @@ def __init__(self, arg=None, year=255, month=255, day=255, day_of_week=255):
         elif isinstance(arg, Date):
             self.value = arg.value
 
+        elif isinstance(arg, float):
+            self.now(arg)
+
         else:
             raise TypeError("invalid constructor datatype")
 
@@ -1388,11 +1394,31 @@ def CalcDayOfWeek(self):
         # put it back together
         self.value = (year, month, day, day_of_week)
 
-    def now(self):
-        tup = time.localtime()
+    def now(self, when=None):
+        """Set the current value to the correct tuple based on the seconds
+        since the epoch.  If 'when' is not provided, get the current time
+        from the task manager.
+        """
+        if when is None:
+            when = _TaskManager().get_time()
+        tup = time.localtime(when)
+
         self.value = (tup[0]-1900, tup[1], tup[2], tup[6] + 1)
+
         return self
 
+    def __float__(self):
+        """Convert to seconds since the epoch."""
+        # rip apart the value
+        year, month, day, day_of_week = self.value
+
+        # check for special values
+        if (year == 255) or (month in _special_mon_inv) or (day in _special_day_inv):
+            raise ValueError("no wildcard values")
+
+        # convert to time.time() value
+        return time.mktime( (year + 1900, month, day, 0, 0, 0, 0, 0, -1) )
+
     def encode(self, tag):
         # encode the tag
         tag.set_app_data(Tag.dateAppTag, ''.join(chr(i) for i in self.value))
@@ -1472,19 +1498,40 @@ def __init__(self, arg=None, hour=255, minute=255, second=255, hundredth=255):
                 tup_list[3] = tup_list[3] * 10
 
             self.value = tuple(tup_list)
+
         elif isinstance(arg, Time):
             self.value = arg.value
+
+        elif isinstance(arg, float):
+            self.now(arg)
+
         else:
             raise TypeError("invalid constructor datatype")
 
-    def now(self):
-        now = time.time()
-        tup = time.localtime(now)
+    def now(self, when=None):
+        """Set the current value to the correct tuple based on the seconds
+        since the epoch.  If 'when' is not provided, get the current time
+        from the task manager.
+        """
+        if when is None:
+            when = _TaskManager().get_time()
+        tup = time.localtime(when)
 
-        self.value = (tup[3], tup[4], tup[5], int((now - int(now)) * 100))
+        self.value = (tup[3], tup[4], tup[5], int((when - int(when)) * 100))
 
         return self
 
+    def __float__(self):
+        """Return the current value as an offset from midnight."""
+        if 255 in self.value:
+            raise ValueError("no wildcard values")
+
+        # rip it apart
+        hour, minute, second, hundredth = self.value
+
+        # put it together
+        return (hour * 3600.0) + (minute * 60.0) + second + (hundredth / 100.0)
+
     def encode(self, tag):
         # encode the tag
         tag.set_app_data(Tag.timeAppTag, ''.join(chr(c) for c in self.value))
diff --git a/py27/bacpypes/primitivedata.py b/py27/bacpypes/primitivedata.py
index 1bdb8f1a..c3495dfb 100755
--- a/py27/bacpypes/primitivedata.py
+++ b/py27/bacpypes/primitivedata.py
@@ -14,6 +14,9 @@
 from .errors import DecodingError, InvalidTag, InvalidParameterDatatype
 from .pdu import PDUData
 
+# import the task manager to get the "current" date and time
+from .task import TaskManager as _TaskManager
+
 # some debugging
 _debug = 0
 _log = ModuleLogger(globals())
@@ -1366,6 +1369,9 @@ def __init__(self, arg=None, year=255, month=255, day=255, day_of_week=255):
         elif isinstance(arg, Date):
             self.value = arg.value
 
+        elif isinstance(arg, float):
+            self.now(arg)
+
         else:
             raise TypeError("invalid constructor datatype")
 
@@ -1394,11 +1400,31 @@ def CalcDayOfWeek(self):
         # put it back together
         self.value = (year, month, day, day_of_week)
 
-    def now(self):
-        tup = time.localtime()
+    def now(self, when=None):
+        """Set the current value to the correct tuple based on the seconds
+        since the epoch.  If 'when' is not provided, get the current time
+        from the task manager.
+        """
+        if when is None:
+            when = _TaskManager().get_time()
+        tup = time.localtime(when)
+
         self.value = (tup[0]-1900, tup[1], tup[2], tup[6] + 1)
+
         return self
 
+    def __float__(self):
+        """Convert to seconds since the epoch."""
+        # rip apart the value
+        year, month, day, day_of_week = self.value
+
+        # check for special values
+        if (year == 255) or (month in _special_mon_inv) or (day in _special_day_inv):
+            raise ValueError("no wildcard values")
+
+        # convert to time.time() value
+        return time.mktime( (year + 1900, month, day, 0, 0, 0, 0, 0, -1) )
+
     def encode(self, tag):
         # encode the tag
         tag.set_app_data(Tag.dateAppTag, bytearray(self.value))
@@ -1478,19 +1504,40 @@ def __init__(self, arg=None, hour=255, minute=255, second=255, hundredth=255):
                 tup_list[3] = tup_list[3] * 10
 
             self.value = tuple(tup_list)
+
         elif isinstance(arg, Time):
             self.value = arg.value
+
+        elif isinstance(arg, float):
+            self.now(arg)
+
         else:
             raise TypeError("invalid constructor datatype")
 
-    def now(self):
-        now = time.time()
-        tup = time.localtime(now)
+    def now(self, when=None):
+        """Set the current value to the correct tuple based on the seconds
+        since the epoch.  If 'when' is not provided, get the current time
+        from the task manager.
+        """
+        if when is None:
+            when = _TaskManager().get_time()
+        tup = time.localtime(when)
 
-        self.value = (tup[3], tup[4], tup[5], int((now - int(now)) * 100))
+        self.value = (tup[3], tup[4], tup[5], int((when - int(when)) * 100))
 
         return self
 
+    def __float__(self):
+        """Return the current value as an offset from midnight."""
+        if 255 in self.value:
+            raise ValueError("no wildcard values")
+
+        # rip it apart
+        hour, minute, second, hundredth = self.value
+
+        # put it together
+        return (hour * 3600.0) + (minute * 60.0) + second + (hundredth / 100.0)
+
     def encode(self, tag):
         # encode the tag
         tag.set_app_data(Tag.timeAppTag, bytearray(self.value))
diff --git a/py34/bacpypes/primitivedata.py b/py34/bacpypes/primitivedata.py
index d7d13065..976d0430 100755
--- a/py34/bacpypes/primitivedata.py
+++ b/py34/bacpypes/primitivedata.py
@@ -14,6 +14,9 @@
 from .errors import DecodingError, InvalidTag, InvalidParameterDatatype
 from .pdu import PDUData
 
+# import the task manager to get the "current" date and time
+from .task import TaskManager as _TaskManager
+
 # some debugging
 _debug = 0
 _log = ModuleLogger(globals())
@@ -1352,6 +1355,9 @@ def __init__(self, arg=None, year=255, month=255, day=255, day_of_week=255):
         elif isinstance(arg, Date):
             self.value = arg.value
 
+        elif isinstance(arg, float):
+            self.now(arg)
+
         else:
             raise TypeError("invalid constructor datatype")
 
@@ -1380,11 +1386,31 @@ def CalcDayOfWeek(self):
         # put it back together
         self.value = (year, month, day, day_of_week)
 
-    def now(self):
-        tup = time.localtime()
+    def now(self, when=None):
+        """Set the current value to the correct tuple based on the seconds
+        since the epoch.  If 'when' is not provided, get the current time
+        from the task manager.
+        """
+        if when is None:
+            when = _TaskManager().get_time()
+        tup = time.localtime(when)
+
         self.value = (tup[0]-1900, tup[1], tup[2], tup[6] + 1)
+
         return self
 
+    def __float__(self):
+        """Convert to seconds since the epoch."""
+        # rip apart the value
+        year, month, day, day_of_week = self.value
+
+        # check for special values
+        if (year == 255) or (month in _special_mon_inv) or (day in _special_day_inv):
+            raise ValueError("no wildcard values")
+
+        # convert to time.time() value
+        return time.mktime( (year + 1900, month, day, 0, 0, 0, 0, 0, -1) )
+
     def encode(self, tag):
         # encode the tag
         tag.set_app_data(Tag.dateAppTag, bytearray(self.value))
@@ -1464,19 +1490,40 @@ def __init__(self, arg=None, hour=255, minute=255, second=255, hundredth=255):
                 tup_list[3] = tup_list[3] * 10
 
             self.value = tuple(tup_list)
+
         elif isinstance(arg, Time):
             self.value = arg.value
+
+        elif isinstance(arg, float):
+            self.now(arg)
+
         else:
             raise TypeError("invalid constructor datatype")
 
-    def now(self):
-        now = time.time()
-        tup = time.localtime(now)
+    def now(self, when=None):
+        """Set the current value to the correct tuple based on the seconds
+        since the epoch.  If 'when' is not provided, get the current time
+        from the task manager.
+        """
+        if when is None:
+            when = _TaskManager().get_time()
+        tup = time.localtime(when)
 
-        self.value = (tup[3], tup[4], tup[5], int((now - int(now)) * 100))
+        self.value = (tup[3], tup[4], tup[5], int((when - int(when)) * 100))
 
         return self
 
+    def __float__(self):
+        """Return the current value as an offset from midnight."""
+        if 255 in self.value:
+            raise ValueError("no wildcard values")
+
+        # rip it apart
+        hour, minute, second, hundredth = self.value
+
+        # put it together
+        return (hour * 3600.0) + (minute * 60.0) + second + (hundredth / 100.0)
+
     def encode(self, tag):
         # encode the tag
         tag.set_app_data(Tag.timeAppTag, bytearray(self.value))

From 253740412f26cb42f0c0500a2a5321313912836b Mon Sep 17 00:00:00 2001
From: Joel Bender <joel@carrickbender.com>
Date: Tue, 12 Dec 2017 18:37:56 -0500
Subject: [PATCH 10/21] test updates to reflect new behavior

---
 tests/test_primitive_data/test_date.py    | 11 ++++++++---
 tests/test_primitive_data/test_time.py    |  4 +---
 tests/test_utilities/test_time_machine.py | 24 +++++++++++------------
 tests/time_machine.py                     | 10 +++++++---
 4 files changed, 28 insertions(+), 21 deletions(-)

diff --git a/tests/test_primitive_data/test_date.py b/tests/test_primitive_data/test_date.py
index 10cbf0cc..b79f64f9 100644
--- a/tests/test_primitive_data/test_date.py
+++ b/tests/test_primitive_data/test_date.py
@@ -81,8 +81,6 @@ def test_date(self):
 
         with self.assertRaises(ValueError):
             Date("some string")
-        with self.assertRaises(TypeError):
-            Date(1.0)
 
     def test_date_tuple(self):
         if _debug: TestDate._debug("test_date_tuple")
@@ -118,6 +116,12 @@ def test_date_copy(self):
         obj2 = Date(obj1)
         assert obj2.value == value
 
+    def test_date_now(self):
+        if _debug: TestDate._debug("test_date_now")
+
+        # obj = Date().now()
+        ### how to test?
+
     def test_date_endec(self):
         if _debug: TestDate._debug("test_date_endec")
 
@@ -175,4 +179,5 @@ def test_Date_from_str(self):
         def test_Wrong(self):
             with self.assertRaises(ValueError):        
                 for each in self.notEnoughPreciseOrWrong:
-                    new_date = Date(each[0])
\ No newline at end of file
+                    new_date = Date(each[0])
+
diff --git a/tests/test_primitive_data/test_time.py b/tests/test_primitive_data/test_time.py
index 2c5e84bf..72b42307 100644
--- a/tests/test_primitive_data/test_time.py
+++ b/tests/test_primitive_data/test_time.py
@@ -81,8 +81,6 @@ def test_time(self):
 
         with self.assertRaises(ValueError):
             Time("some string")
-        with self.assertRaises(TypeError):
-            Time(1.0)
 
     def test_time_tuple(self):
         if _debug: TestTime._debug("test_time_tuple")
@@ -141,4 +139,4 @@ def test_time_endec(self):
         time_endec((1, 0, 0, 0), '01000000')
         time_endec((0, 2, 0, 0), '00020000')
         time_endec((0, 0, 3, 0), '00000300')
-        time_endec((0, 0, 0, 4), '00000004')
\ No newline at end of file
+        time_endec((0, 0, 0, 4), '00000004')
diff --git a/tests/test_utilities/test_time_machine.py b/tests/test_utilities/test_time_machine.py
index baf1a831..69a769db 100644
--- a/tests/test_utilities/test_time_machine.py
+++ b/tests/test_utilities/test_time_machine.py
@@ -128,8 +128,8 @@ def test_empty_run(self):
         # let it run
         run_time_machine(60.0)
 
-        # no time has passed
-        assert time_machine.current_time == 0.0
+        # 60 seconds have passed
+        assert time_machine.current_time == 60.0
 
     def test_one_shot_immediate_1(self):
         if _debug: TestTimeMachine._debug("test_one_shot_immediate_1")
@@ -142,9 +142,9 @@ def test_one_shot_immediate_1(self):
         ft.install_task(0.0)
         run_time_machine(60.0)
 
-        # function called, no time has passed
+        # function called, 60 seconds have passed
         assert almost_equal(ft.process_task_called, [0.0])
-        assert time_machine.current_time == 0.0
+        assert time_machine.current_time == 60.0
 
     def test_one_shot_immediate_2(self):
         if _debug: TestTimeMachine._debug("test_one_shot_immediate_2")
@@ -177,9 +177,9 @@ def test_function_task_immediate(self):
         ft.install_task(0.0)
         run_time_machine(60.0)
 
-        # function called, no time has passed
+        # function called, 60 seconds have passed
         assert almost_equal(sample_task_function_called, [0.0])
-        assert time_machine.current_time == 0.0
+        assert time_machine.current_time == 60.0
 
     def test_function_task_delay(self):
         if _debug: TestTimeMachine._debug("test_function_task_delay")
@@ -196,9 +196,9 @@ def test_function_task_delay(self):
         ft.install_task(sample_delay)
         run_time_machine(60.0)
 
-        # function called, no time has passed
+        # function called, 60 seconds have passed
         assert almost_equal(sample_task_function_called, [sample_delay])
-        assert time_machine.current_time == sample_delay
+        assert time_machine.current_time == 60.0
 
     def test_recurring_task_1(self):
         if _debug: TestTimeMachine._debug("test_recurring_task_1")
@@ -211,7 +211,7 @@ def test_recurring_task_1(self):
         ft.install_task(1000.0)
         run_time_machine(5.0)
 
-        # function called, no time has passed
+        # function called, 5 seconds have passed
         assert almost_equal(ft.process_task_called, [1.0, 2.0, 3.0, 4.0])
         assert time_machine.current_time == 5.0
 
@@ -228,7 +228,7 @@ def test_recurring_task_2(self):
         ft2.install_task(1500.0)
         run_time_machine(5.0)
 
-        # function called, no time has passed
+        # function called, 5 seconds have passed
         assert almost_equal(ft1.process_task_called, [1.0, 2.0, 3.0, 4.0])
         assert almost_equal(ft2.process_task_called, [1.5, 3.0, 4.5])
         assert time_machine.current_time == 5.0
@@ -244,7 +244,7 @@ def test_recurring_task_3(self):
         ft.install_task(1000.0, offset=100.0)
         run_time_machine(5.0)
 
-        # function called, no time has passed
+        # function called, 5 seconds have passed
         assert almost_equal(ft.process_task_called, [0.1, 1.1, 2.1, 3.1, 4.1])
         assert time_machine.current_time == 5.0
 
@@ -259,7 +259,7 @@ def test_recurring_task_4(self):
         ft.install_task(1000.0, offset=-100.0)
         run_time_machine(5.0)
 
-        # function called, no time has passed
+        # function called, 5 seconds have passed
         assert almost_equal(ft.process_task_called, [0.9, 1.9, 2.9, 3.9, 4.9])
         assert time_machine.current_time == 5.0
 
diff --git a/tests/time_machine.py b/tests/time_machine.py
index 109cbe72..1408a011 100755
--- a/tests/time_machine.py
+++ b/tests/time_machine.py
@@ -82,7 +82,7 @@ def more_to_do(self):
         if _debug: TimeMachine._debug("    - tasks: %r", self.tasks)
 
         if (self.time_limit is not None) and (self.current_time >= self.time_limit):
-            if _debug: TimeMachine._debug("    - time limit reached")
+            if _debug: TimeMachine._debug("    - time limit reached or exceeded")
             return False
 
         if not self.tasks:
@@ -92,11 +92,12 @@ def more_to_do(self):
         # peek at the next task and see when it is supposed to run
         when, task = self.tasks[0]
         if when >= self.time_limit:
-            if _debug: TimeMachine._debug("    - time limit reached")
+            if _debug: TimeMachine._debug("    - next task at or exceeds time limit")
             return False
-        if _debug: TimeMachine._debug("    - task: %r", task)
 
         # there is a task to run
+        if _debug: TimeMachine._debug("    - task: %r", task)
+
         return True
 
     def get_next_task(self):
@@ -302,3 +303,6 @@ def run_time_machine(duration=None, stop_time=None):
             if _debug: run_time_machine._debug("    - no more to do")
             break
 
+    # update the current time to the time limit
+    time_machine.current_time = time_machine.time_limit
+

From d3833af2ef37d167840165c82dbb46a1fcfc55ba Mon Sep 17 00:00:00 2001
From: Joel Bender <joel@betelgeuse>
Date: Fri, 22 Dec 2017 11:07:11 -0500
Subject: [PATCH 11/21] bring branch up-to-date

---
 BACpypes~.ini                |   1 -
 py25/bacpypes/bvllservice.py |   2 +-
 py25/bacpypes/core.py        |   3 +
 py27/bacpypes/bvllservice.py |   2 +-
 py27/bacpypes/core.py        |   3 +
 py34/bacpypes/bvllservice.py |   2 +-
 py34/bacpypes/core.py        |   3 +
 samples/COVServer.py         | 217 ++++++++++++++++++++++++++++++++---
 samples/WhoIsIAmForeign.py   |  14 ++-
 setup.py                     |   2 +
 10 files changed, 228 insertions(+), 21 deletions(-)

diff --git a/BACpypes~.ini b/BACpypes~.ini
index 6740dc4d..dc8bac02 100644
--- a/BACpypes~.ini
+++ b/BACpypes~.ini
@@ -5,7 +5,6 @@ objectIdentifier: 599
 maxApduLengthAccepted: 1024
 segmentationSupported: segmentedBoth
 vendorIdentifier: 15
-foreignPort: 0
 foreignBBMD: 128.253.109.254
 foreignTTL: 30
 
diff --git a/py25/bacpypes/bvllservice.py b/py25/bacpypes/bvllservice.py
index af4128c0..e195d39a 100755
--- a/py25/bacpypes/bvllservice.py
+++ b/py25/bacpypes/bvllservice.py
@@ -542,7 +542,7 @@ def register(self, addr, ttl):
         self.bbmdTimeToLive = ttl
 
         # install this task to run when it gets a chance
-        self.install_task(delta=0)
+        self.install_task(when=0)
 
     def unregister(self):
         """Drop the registration with a BBMD."""
diff --git a/py25/bacpypes/core.py b/py25/bacpypes/core.py
index 5e52db4f..1614a53d 100755
--- a/py25/bacpypes/core.py
+++ b/py25/bacpypes/core.py
@@ -144,6 +144,9 @@ def run(spin=SPIN, sigterm=stop, sigusr1=print_stack):
                 time.sleep(sleeptime)
                 delta -= sleeptime
 
+            # delta should be no more than the spin value
+            delta = min(delta, spin)
+
             # if there are deferred functions, use a small delta
             if deferredFns:
                 delta = min(delta, 0.001)
diff --git a/py27/bacpypes/bvllservice.py b/py27/bacpypes/bvllservice.py
index 5abb24e0..8c01f05e 100755
--- a/py27/bacpypes/bvllservice.py
+++ b/py27/bacpypes/bvllservice.py
@@ -538,7 +538,7 @@ def register(self, addr, ttl):
         self.bbmdTimeToLive = ttl
 
         # install this task to run when it gets a chance
-        self.install_task(delta=0)
+        self.install_task(when=0)
 
     def unregister(self):
         """Drop the registration with a BBMD."""
diff --git a/py27/bacpypes/core.py b/py27/bacpypes/core.py
index b57bf795..b2c46e34 100755
--- a/py27/bacpypes/core.py
+++ b/py27/bacpypes/core.py
@@ -142,6 +142,9 @@ def run(spin=SPIN, sigterm=stop, sigusr1=print_stack):
                 time.sleep(sleeptime)
                 delta -= sleeptime
 
+            # delta should be no more than the spin value
+            delta = min(delta, spin)
+
             # if there are deferred functions, use a small delta
             if deferredFns:
                 delta = min(delta, 0.001)
diff --git a/py34/bacpypes/bvllservice.py b/py34/bacpypes/bvllservice.py
index 6abb5d7d..2a6285c5 100755
--- a/py34/bacpypes/bvllservice.py
+++ b/py34/bacpypes/bvllservice.py
@@ -537,7 +537,7 @@ def register(self, addr, ttl):
         self.bbmdTimeToLive = ttl
 
         # install this task to run when it gets a chance
-        self.install_task(delta=0)
+        self.install_task(when=0)
 
     def unregister(self):
         """Drop the registration with a BBMD."""
diff --git a/py34/bacpypes/core.py b/py34/bacpypes/core.py
index b57bf795..b2c46e34 100755
--- a/py34/bacpypes/core.py
+++ b/py34/bacpypes/core.py
@@ -142,6 +142,9 @@ def run(spin=SPIN, sigterm=stop, sigusr1=print_stack):
                 time.sleep(sleeptime)
                 delta -= sleeptime
 
+            # delta should be no more than the spin value
+            delta = min(delta, spin)
+
             # if there are deferred functions, use a small delta
             if deferredFns:
                 delta = min(delta, 0.001)
diff --git a/samples/COVServer.py b/samples/COVServer.py
index 68ef3118..c1c2de8e 100755
--- a/samples/COVServer.py
+++ b/samples/COVServer.py
@@ -6,11 +6,15 @@
 triggers the notifications.
 """
 
+import time
+from threading import Thread
+
 from bacpypes.debugging import bacpypes_debugging, ModuleLogger
 from bacpypes.consolelogging import ConfigArgumentParser
 from bacpypes.consolecmd import ConsoleCmd
 
-from bacpypes.core import run, enable_sleeping
+from bacpypes.core import run, deferred, enable_sleeping
+from bacpypes.task import RecurringTask
 
 from bacpypes.app import BIPSimpleApplication
 from bacpypes.object import AnalogValueObject, BinaryValueObject
@@ -22,6 +26,8 @@
 _log = ModuleLogger(globals())
 
 # test globals
+test_av = None
+test_bv = None
 test_application = None
 
 #
@@ -180,8 +186,147 @@ def do_write(self, args):
             print("exception: %s" % (err,))
 
 
+@bacpypes_debugging
+class TestAnalogValueTask(RecurringTask):
+
+    """
+    An instance of this class is created when '--avtask <interval>' is
+    specified as a command line argument.  Every <interval> seconds it
+    changes the value of the test_av present value.
+    """
+
+    def __init__(self, interval):
+        if _debug: TestAnalogValueTask._debug("__init__ %r", interval)
+        RecurringTask.__init__(self, interval * 1000)
+
+        # make a list of test values
+        self.test_values = list(float(i * 10) for i in range(10))
+
+    def process_task(self):
+        if _debug: TestAnalogValueTask._debug("process_task")
+        global test_av
+
+        # pop the next value
+        next_value = self.test_values.pop(0)
+        self.test_values.append(next_value)
+        if _debug: TestAnalogValueTask._debug("    - next_value: %r", next_value)
+
+        # change the point
+        test_av.presentValue = next_value
+
+
+@bacpypes_debugging
+class TestAnalogValueThread(Thread):
+
+    """
+    An instance of this class is created when '--avthread <interval>' is
+    specified as a command line argument.  Every <interval> seconds it
+    changes the value of the test_av present value.
+    """
+
+    def __init__(self, interval):
+        if _debug: TestAnalogValueThread._debug("__init__ %r", interval)
+        Thread.__init__(self)
+
+        # runs as a daemon
+        self.daemon = True
+
+        # save the interval
+        self.interval = interval
+
+        # make a list of test values
+        self.test_values = list(100.0 + float(i * 10) for i in range(10))
+
+    def run(self):
+        if _debug: TestAnalogValueThread._debug("run")
+        global test_av
+
+        while True:
+            # pop the next value
+            next_value = self.test_values.pop(0)
+            self.test_values.append(next_value)
+            if _debug: TestAnalogValueThread._debug("    - next_value: %r", next_value)
+
+            # change the point
+            test_av.presentValue = next_value
+
+            # sleep
+            time.sleep(self.interval)
+
+
+@bacpypes_debugging
+class TestBinaryValueTask(RecurringTask):
+
+    """
+    An instance of this class is created when '--bvtask <interval>' is
+    specified as a command line argument.  Every <interval> seconds it
+    changes the value of the test_bv present value.
+    """
+
+    def __init__(self, interval):
+        if _debug: TestBinaryValueTask._debug("__init__ %r", interval)
+        RecurringTask.__init__(self, interval * 1000)
+
+        # save the interval
+        self.interval = interval
+
+        # make a list of test values
+        self.test_values = [True, False]
+
+    def process_task(self):
+        if _debug: TestBinaryValueTask._debug("process_task")
+        global test_bv
+
+        # pop the next value
+        next_value = self.test_values.pop(0)
+        self.test_values.append(next_value)
+        if _debug: TestBinaryValueTask._debug("    - next_value: %r", next_value)
+
+        # change the point
+        test_bv.presentValue = next_value
+
+
+@bacpypes_debugging
+class TestBinaryValueThread(RecurringTask, Thread):
+
+    """
+    An instance of this class is created when '--bvthread <interval>' is
+    specified as a command line argument.  Every <interval> seconds it
+    changes the value of the test_bv present value.
+    """
+
+    def __init__(self, interval):
+        if _debug: TestBinaryValueThread._debug("__init__ %r", interval)
+        Thread.__init__(self)
+
+        # runs as a daemon
+        self.daemon = True
+
+        # save the interval
+        self.interval = interval
+
+        # make a list of test values
+        self.test_values = [True, False]
+
+    def run(self):
+        if _debug: TestBinaryValueThread._debug("run")
+        global test_bv
+
+        while True:
+            # pop the next value
+            next_value = self.test_values.pop(0)
+            self.test_values.append(next_value)
+            if _debug: TestBinaryValueThread._debug("    - next_value: %r", next_value)
+
+            # change the point
+            test_bv.presentValue = next_value
+
+            # sleep
+            time.sleep(self.interval)
+
+
 def main():
-    global test_application
+    global test_av, test_bv, test_application
 
     # make a parser
     parser = ConfigArgumentParser(description=__doc__)
@@ -191,6 +336,28 @@ def main():
         help="create a console",
         )
 
+    # analog value task and thread
+    parser.add_argument("--avtask", type=float,
+        help="analog value recurring task",
+        )
+    parser.add_argument("--avthread", type=float,
+        help="analog value thread",
+        )
+
+    # analog value task and thread
+    parser.add_argument("--bvtask", type=float,
+        help="binary value recurring task",
+        )
+    parser.add_argument("--bvthread", type=float,
+        help="binary value thread",
+        )
+
+    # provide a different spin value
+    parser.add_argument("--spin", type=float,
+        help="spin time",
+        default=1.0,
+        )
+
     # parse the command line arguments
     args = parser.parse_args()
 
@@ -209,18 +376,6 @@ def main():
     # make a sample application
     test_application = SubscribeCOVApplication(test_device, args.ini.address)
 
-    # make a binary value object
-    test_bv = BinaryValueObject(
-        objectIdentifier=('binaryValue', 1),
-        objectName='bv',
-        presentValue='inactive',
-        statusFlags=[0, 0, 0, 0],
-        )
-    _log.debug("    - test_bv: %r", test_bv)
-
-    # add it to the device
-    test_application.add_object(test_bv)
-
     # make an analog value object
     test_av = AnalogValueObject(
         objectIdentifier=('analogValue', 1),
@@ -235,6 +390,18 @@ def main():
     test_application.add_object(test_av)
     _log.debug("    - object list: %r", test_device.objectList)
 
+    # make a binary value object
+    test_bv = BinaryValueObject(
+        objectIdentifier=('binaryValue', 1),
+        objectName='bv',
+        presentValue='inactive',
+        statusFlags=[0, 0, 0, 0],
+        )
+    _log.debug("    - test_bv: %r", test_bv)
+
+    # add it to the device
+    test_application.add_object(test_bv)
+
     # get the services supported
     services_supported = test_application.get_services_supported()
     if _debug: _log.debug("    - services_supported: %r", services_supported)
@@ -250,9 +417,29 @@ def main():
         # enable sleeping will help with threads
         enable_sleeping()
 
+    # analog value task
+    if args.avtask:
+        test_av_task = TestAnalogValueTask(args.avtask)
+        test_av_task.install_task()
+
+    # analog value thread
+    if args.avthread:
+        test_av_thread = TestAnalogValueThread(args.avthread)
+        deferred(test_av_thread.start)
+
+    # binary value task
+    if args.bvtask:
+        test_bv_task = TestBinaryValueTask(args.bvtask)
+        test_bv_task.install_task()
+
+    # binary value thread
+    if args.bvthread:
+        test_bv_thread = TestBinaryValueThread(args.bvthread)
+        deferred(test_bv_thread.start)
+
     _log.debug("running")
 
-    run()
+    run(args.spin)
 
     _log.debug("fini")
 
diff --git a/samples/WhoIsIAmForeign.py b/samples/WhoIsIAmForeign.py
index 38e2917a..a2eb613d 100755
--- a/samples/WhoIsIAmForeign.py
+++ b/samples/WhoIsIAmForeign.py
@@ -4,6 +4,16 @@
 This application presents a 'console' prompt to the user asking for Who-Is and I-Am
 commands which create the related APDUs, then lines up the coorresponding I-Am
 for incoming traffic and prints out the contents.
+
+In addition to the usual INI parameters that are common to BACpypes applications,
+this application references two additional parameters:
+
+    foreignBBMD: the BACpypes IP Address of the BBMD to register
+    foreignTTL: the time-to-live to keep the registration alive
+
+The BBMDForeign class will send the BVLL registration request after the core
+starts up and maintain it.  If the device does not get an 'ack' then it will
+not send requests, even to devices that it would be able to talk otherwise.
 """
 
 import sys
@@ -115,7 +125,7 @@ def do_whois(self, args):
 
             # make an IOCB
             iocb = IOCB(request)
-            if _debug: WriteSomethingConsoleCmd._debug("    - iocb: %r", iocb)
+            if _debug: WhoIsIAmConsoleCmd._debug("    - iocb: %r", iocb)
 
             # give it to the application
             this_application.request_io(iocb)
@@ -142,7 +152,7 @@ def do_iam(self, args):
 
             # make an IOCB
             iocb = IOCB(request)
-            if _debug: WriteSomethingConsoleCmd._debug("    - iocb: %r", iocb)
+            if _debug: WhoIsIAmConsoleCmd._debug("    - iocb: %r", iocb)
 
             # give it to the application
             this_application.request_io(iocb)
diff --git a/setup.py b/setup.py
index 8386d4e0..9d732958 100644
--- a/setup.py
+++ b/setup.py
@@ -18,6 +18,7 @@
     (2, 7): 'py27',
     (3, 4): 'py34',
     (3, 5): 'py34',
+    (3, 6): 'py34',
     }.get(version_info, None)
 if not source_folder:
     raise EnvironmentError("unsupported version of Python")
@@ -75,6 +76,7 @@
         'Programming Language :: Python :: 3',
         'Programming Language :: Python :: 3.4',
         'Programming Language :: Python :: 3.5',
+        'Programming Language :: Python :: 3.6',
     ],
 
     setup_requires=setup_requirements,

From b09b66db3460c29d9682ebc79b023687c3c5c596 Mon Sep 17 00:00:00 2001
From: Joel Bender <joel@carrickbender.com>
Date: Fri, 12 Jan 2018 11:33:38 -0500
Subject: [PATCH 12/21] design/test applications

---
 sandbox/local_schedule_object_t1.py | 682 ++++++++++++++++++++++++++
 sandbox/local_schedule_object_t2.py | 733 ++++++++++++++++++++++++++++
 2 files changed, 1415 insertions(+)
 create mode 100644 sandbox/local_schedule_object_t1.py
 create mode 100644 sandbox/local_schedule_object_t2.py

diff --git a/sandbox/local_schedule_object_t1.py b/sandbox/local_schedule_object_t1.py
new file mode 100644
index 00000000..b5f9d2f7
--- /dev/null
+++ b/sandbox/local_schedule_object_t1.py
@@ -0,0 +1,682 @@
+#!/usr/bin/env python
+
+"""
+Local Schedule Object Test
+"""
+
+import sys
+import calendar
+from time import mktime as _mktime, localtime as _localtime
+
+from bacpypes.debugging import bacpypes_debugging, ModuleLogger, xtob
+from bacpypes.consolelogging import ConfigArgumentParser
+from bacpypes.consolecmd import ConsoleCmd
+
+from bacpypes.core import run, deferred
+from bacpypes.task import OneShotTask, TaskManager
+
+from bacpypes.primitivedata import Atomic, Null, Integer, Unsigned, Real, Date, Time, CharacterString
+from bacpypes.constructeddata import Array, ArrayOf, SequenceOf, AnyAtomic
+from bacpypes.basetypes import CalendarEntry, DailySchedule, DateRange, \
+    DeviceObjectPropertyReference, SpecialEvent, SpecialEventPeriod, TimeValue
+from bacpypes.object import register_object_type, get_datatype, WritableProperty, ScheduleObject
+
+from bacpypes.app import BIPSimpleApplication
+from bacpypes.service.object import CurrentPropertyListMixIn
+from bacpypes.service.device import LocalDeviceObject
+
+### testing
+import time
+
+sys.path[:0] = ['.']
+from tests.time_machine import TimeMachine, reset_time_machine, run_time_machine, xdatetime
+global timemachine
+###
+
+# some debugging
+_debug = 0
+_log = ModuleLogger(globals())
+
+### testing
+schedule_objects = []
+
+@bacpypes_debugging
+def setup_module(module=None):
+    if _debug: setup_module._debug("setup_module %r", module)
+    global time_machine
+
+    # this is a singleton
+    time_machine = TimeMachine()
+
+    # make sure this is the same one referenced by the functions
+    assert time_machine is reset_time_machine.__globals__['time_machine']
+    assert time_machine is run_time_machine.__globals__['time_machine']
+
+
+@bacpypes_debugging
+def teardown_module():
+    if _debug: teardown_module._debug("teardown_module")
+    global time_machine
+
+    # all done
+    time_machine = None
+###
+
+#
+#   match_date
+#
+
+def match_date(date, date_pattern):
+    """
+    Match a specific date, a four-tuple with no special values, with a date
+    pattern, four-tuple possibly having special values.
+    """
+    # unpack the date and pattern
+    year, month, day, day_of_week = date
+    year_p, month_p, day_p, day_of_week_p = date_pattern
+
+    # check the year
+    if year_p == 255:
+        # any year
+        pass
+    elif year != year_p:
+        # specific year
+        return False
+
+    # check the month
+    if month_p == 255:
+        # any month
+        pass
+    elif month_p == 13:
+        # odd months
+        if (month % 2) == 0:
+            return False
+    elif month_p == 14:
+        # even months
+        if (month % 2) == 1:
+            return False
+    elif month != month_p:
+        # specific month
+        return False
+
+    # check the day
+    if day_p == 255:
+        # any day
+        pass
+    elif day_p == 32:
+        # last day of the month
+        last_day = calendar.monthrange(year + 1900, month)[1]
+        if day != last_day:
+            return False
+    elif day_p == 33:
+        # odd days of the month
+        if (day % 2) == 0:
+            return False
+    elif day_p == 34:
+        # even days of the month
+        if (day % 2) == 1:
+            return False
+    elif day != day_p:
+        # specific day
+        return False
+
+    # check the day of week
+    if day_of_week_p == 255:
+        # any day of the week
+        pass
+    elif day_of_week != day_of_week_p:
+        # specific day of the week
+        return False
+
+    # all tests pass
+    return True
+
+#
+#   match_date_range
+#
+
+def match_date_range(date, date_range):
+    """
+    Match a specific date, a four-tuple with no special values, with a DateRange
+    object which as a start date and end date.
+    """
+    return (date[:3] >= date_range.startDate[:3]) \
+        and (date[:3] <= date_range.endDate[:3])
+
+#
+#   match_weeknday
+#
+
+def match_weeknday(date, weeknday):
+    """
+    Match a specific date, a four-tuple with no special values, with a
+    BACnetWeekNDay, an octet string with three (unsigned) octets.
+    """
+    # unpack the date
+    year, month, day, day_of_week = date
+    last_day = calendar.monthrange(year + 1900, month)[1]
+
+    # unpack the date pattern octet string
+    if sys.version_info[0] == 2:
+        weeknday_unpacked = [ord(c) for c in weeknday]
+    elif sys.version_info[0] == 3:
+        weeknday_unpacked = [c for c in weeknday]
+    else:
+        raise NotImplementedError("match_weeknday requires Python 2.x or 3.x")
+    month_p, week_of_month_p, day_of_week_p = weeknday_unpacked
+
+    # check the month
+    if month_p == 255:
+        # any month
+        pass
+    elif month_p == 13:
+        # odd months
+        if (month % 2) == 0:
+            return False
+    elif month_p == 14:
+        # even months
+        if (month % 2) == 1:
+            return False
+    elif month != month_p:
+        # specific month
+        return False
+
+    # check the week of the month
+    if week_of_month_p == 255:
+        # any week
+        pass
+    elif week_of_month_p == 1:
+        # days numbered 1-7
+        if (day > 7):
+            return False
+    elif week_of_month_p == 2:
+        # days numbered 8-14
+        if (day < 8) or (day > 14):
+            return False
+    elif week_of_month_p == 3:
+        # days numbered 15-21
+        if (day < 15) or (day > 21):
+            return False
+    elif week_of_month_p == 4:
+        # days numbered 22-28
+        if (day < 22) or (day > 28):
+            return False
+    elif week_of_month_p == 5:
+        # days numbered 29-31
+        if (day < 29) or (day > 31):
+            return False
+    elif week_of_month_p == 6:
+        # last 7 days of this month
+        if (day < last_day - 6):
+            return False
+    elif week_of_month_p == 7:
+        # any of the 7 days prior to the last 7 days of this month
+        if (day < last_day - 13) or (day > last_day - 7):
+            return False
+    elif week_of_month_p == 8:
+        # any of the 7 days prior to the last 14 days of this month
+        if (day < last_day - 20) or (day > last_day - 14):
+            return False
+    elif week_of_month_p == 9:
+        # any of the 7 days prior to the last 21 days of this month
+        if (day < last_day - 27) or (day > last_day - 21):
+            return False
+
+    # check the day
+    if day_of_week_p == 255:
+        # any day
+        pass
+    elif day_of_week != day_of_week_p:
+        # specific day
+        return False
+
+    # all tests pass
+    return True
+
+#
+#   date_in_calendar_entry
+#
+
+@bacpypes_debugging
+def date_in_calendar_entry(date, calendar_entry):
+    if _debug: date_in_calendar_entry._debug("date_in_calendar_entry %r %r", date, calendar_entry)
+
+    match = False
+    if calendar_entry.date:
+        match = match_date(date, calendar_entry.date)
+    elif calendar_entry.dateRange:
+        match = match_date_range(date, calendar_entry.dateRange)
+    elif calendar_entry.weekNDay:
+        match = match_weeknday(date, calendar_entry.weekNDay)
+    else:
+        raise RuntimeError("")
+    if _debug: date_in_calendar_entry._debug("    - match: %r", match)
+
+    return match
+
+#
+#   datetime_to_time
+#
+
+def datetime_to_time(date, time):
+    """Take the date and time 4-tuples and return the time in seconds since
+    the epoch as a floating point number."""
+    if (255 in date) or (255 in time):
+        raise RuntimeError("specific date and time required")
+
+    time_tuple = (
+        date[0]+1900, date[1], date[2],
+        time[0], time[1], time[2],
+        0, 0, -1,
+        )
+    return _mktime(time_tuple)
+
+#
+#   LocalScheduleObject
+#
+
+@bacpypes_debugging
+@register_object_type(vendor_id=999)
+class LocalScheduleObject(CurrentPropertyListMixIn, ScheduleObject):
+
+    properties = [
+        WritableProperty('presentValue', AnyAtomic),
+        ]
+
+    def __init__(self, **kwargs):
+        if _debug: LocalScheduleObject._debug("__init__ %r", kwargs)
+        ScheduleObject.__init__(self, **kwargs)
+
+        # attach an interpreter task
+        self._task = LocalScheduleInterpreter(self)
+
+        # add some monitors
+        for prop in ('weeklySchedule', 'exceptionSchedule', 'scheduleDefault'):
+            self._property_monitors[prop].append(self._check_reliability)
+
+        # check it now
+        self._check_reliability()
+
+    def _check_reliability(self, old_value=None, new_value=None):
+        """This function is called when the object is created and after
+        one of its configuration properties has changed.  The new and old value
+        parameters are ignored, this is called after the property has been
+        changed and this is only concerned with the current value."""
+        if _debug: LocalScheduleObject._debug("_check_reliability %r %r", old_value, new_value)
+
+        try:
+            schedule_default = self.scheduleDefault
+
+            if schedule_default is None:
+                raise ValueError("scheduleDefault expected")
+            if not isinstance(schedule_default, Atomic):
+                raise TypeError("scheduleDefault must be an instance of an atomic type")
+
+            if (self.weeklySchedule is None) and (self.exceptionSchedule is None):
+                raise ValueError("schedule required")
+
+            schedule_datatype = schedule_default.__class__
+            if _debug: LocalScheduleObject._debug("    - schedule_datatype: %r", schedule_datatype)
+
+            # check the weekly schedule values
+            if self.weeklySchedule:
+                for daily_schedule in self.weeklySchedule:
+                    for time_value in daily_schedule.daySchedule:
+                        if _debug: LocalScheduleObject._debug("    - daily time_value: %r", time_value)
+                        if time_value is None:
+                            pass
+                        elif not isinstance(time_value.value, (Null, schedule_datatype)):
+                            if _debug: LocalScheduleObject._debug("    - wrong type: expected %r, got %r",
+                                schedule_datatype,
+                                time_value.__class__,
+                                )
+                            raise TypeError("wrong type")
+                        elif 255 in time_value.time:
+                            if _debug: LocalScheduleObject._debug("    - wildcard in time")
+                            raise ValueError("must be a specific time")
+
+            # check the exception schedule values
+            if self.exceptionSchedule:
+                for special_event in self.exceptionSchedule:
+                    for time_value in special_event.listOfTimeValues:
+                        if _debug: LocalScheduleObject._debug("    - special event time_value: %r", time_value)
+                        if time_value is None:
+                            pass
+                        elif not isinstance(time_value.value, (Null, schedule_datatype)):
+                            if _debug: LocalScheduleObject._debug("    - wrong type: expected %r, got %r",
+                                schedule_datatype,
+                                time_value.__class__,
+                                )
+                            raise TypeError("wrong type")
+
+            # check list of object property references
+            obj_prop_refs = self.listOfObjectPropertyReferences
+            if obj_prop_refs:
+                for obj_prop_ref in obj_prop_refs:
+                    obj_type = obj_prop_ref.objectIdentifier[0]
+
+                    # get the datatype of the property to be written
+                    datatype = get_datatype(obj_type, obj_prop_ref.propertyIdentifier)
+                    if _debug: LocalScheduleObject._debug("    - datatype: %r", datatype)
+
+                    if issubclass(datatype, Array) and (obj_prop_ref.propertyArrayIndex is not None):
+                        if obj_prop_ref.propertyArrayIndex == 0:
+                            datatype = Unsigned
+                        else:
+                            datatype = datatype.subtype
+                        if _debug: LocalScheduleObject._debug("    - datatype: %r", datatype)
+
+                    if datatype is not schedule_datatype:
+                        if _debug: LocalScheduleObject._debug("    - wrong type: expected %r, got %r",
+                            datatype,
+                            schedule_datatype,
+                            )
+                        raise TypeError("wrong type")
+
+            # all good
+            self.reliability = 'noFaultDetected'
+            if _debug: LocalScheduleObject._debug("    - no fault detected")
+
+        except Exception as err:
+            if _debug: LocalScheduleObject._debug("    - exception: %r", err)
+            self.reliability = 'configurationError'
+
+#
+#   LocalScheduleInterpreter
+#
+
+@bacpypes_debugging
+class LocalScheduleInterpreter(OneShotTask):
+
+    def __init__(self, sched_obj):
+        if _debug: LocalScheduleInterpreter._debug("__init__ %r", sched_obj)
+        OneShotTask.__init__(self)
+
+        # reference the schedule object to update
+        self.sched_obj = sched_obj
+
+        # add a monitor for the present value
+        sched_obj._property_monitors['presentValue'].append(self.present_value_changed)
+
+        # call to interpret the schedule
+        deferred(self.process_task)
+
+    def present_value_changed(self, old_value, new_value):
+        """This function is called when the presentValue of the local schedule
+        object has changed, both internally by this interpreter, or externally
+        by some client using WriteProperty."""
+        if _debug: LocalScheduleInterpreter._debug("present_value_changed %s %s", old_value, new_value)
+
+        # if this hasn't been added to an application, there's nothing to do
+        if not self.sched_obj._app:
+            if _debug: LocalScheduleInterpreter._debug("    - no application")
+            return
+
+        # process the list of [device] object property [array index] references
+        obj_prop_refs = self.listOfObjectPropertyReferences
+        if obj_prop_refs:
+            for obj_prop_ref in obj_prop_refs:
+                if obj_prop_ref.deviceIdentifier:
+                    if _debug: LocalScheduleInterpreter._debug("    - no externals")
+                    continue
+
+                # get the object from the application
+                obj = self.sched_obj._app.get_object_id(obj_prop_ref.objectIdentifier)
+                if not obj:
+                    if _debug: LocalScheduleInterpreter._debug("    - no object")
+                    continue
+
+                # try to change the value
+                try:
+                    obj.WriteProperty(
+                        obj_prop_ref.propertyIdentifier,
+                        new_value,
+                        obj_prop_ref.propertyArrayIndex,
+                        )
+                    if _debug: LocalScheduleInterpreter._debug("    - success")
+                except Exception as err:
+                    if _debug: LocalScheduleInterpreter._debug("    - error: %r", err)
+
+    def process_task(self):
+        if _debug: LocalScheduleInterpreter._debug("process_task(%s)", self.sched_obj.objectName)
+
+        # check for a valid configuration
+        if self.sched_obj.reliability != 'noFaultDetected':
+            if _debug: LocalScheduleInterpreter._debug("    - fault detected")
+            return
+
+        # get the date and time from the device object in case it provides
+        # some custom functionality
+        if self.sched_obj._app and self.sched_obj._app.localDevice:
+            current_date = self.sched_obj._app.localDevice.localDate
+            if _debug: LocalScheduleInterpreter._debug("    - current_date: %r", current_date)
+
+            current_time = self.sched_obj._app.localDevice.localTime
+            if _debug: LocalScheduleInterpreter._debug("    - current_time: %r", current_time)
+        else:
+            # get the current date and time, as provided by the task manager
+            current_date = Date().now().value
+            if _debug: LocalScheduleInterpreter._debug("    - current_date: %r", current_date)
+
+            current_time = Time().now().value
+            if _debug: LocalScheduleInterpreter._debug("    - current_time: %r", current_time)
+
+        # evaluate the time
+        current_value, next_transition = self.eval(current_date, current_time)
+        if _debug: LocalScheduleInterpreter._debug("    - current_value, next_transition: %r, %r", current_value, next_transition)
+
+        # set the present value
+        self.sched_obj.presentValue = current_value
+
+        # compute the time of the next transition
+        transition_time = datetime_to_time(current_date, next_transition)
+
+        # install this to run again
+        self.install_task(transition_time)
+
+    def eval(self, edate, etime):
+        """Evaluate the schedule according to the provided date and time and
+        return the appropriate present value, or None if not in the effective
+        period."""
+        if _debug: LocalScheduleInterpreter._debug("eval %r %r", edate, etime)
+
+        # reference the schedule object
+        sched_obj = self.sched_obj
+        if _debug: LocalScheduleInterpreter._debug("    sched_obj: %r", sched_obj)
+
+        # verify the date falls in the effective period
+        if not match_date_range(edate, sched_obj.effectivePeriod):
+            return None
+
+        # the event priority is a list of values that are in effect for
+        # exception schedules with the special event priority, see 135.1-2013
+        # clause 7.3.2.23.10.3.8, Revision 4 Event Priority Test
+        event_priority = [None] * 16
+
+        next_day = (24, 0, 0, 0)
+        next_transition_time = [None] * 16
+
+        # check the exception schedule values
+        if sched_obj.exceptionSchedule:
+            for special_event in sched_obj.exceptionSchedule:
+                if _debug: LocalScheduleInterpreter._debug("    - special_event: %r", special_event)
+
+                # check the special event period
+                special_event_period = special_event.period
+                if special_event_period is None:
+                    raise RuntimeError("special event period required")
+
+                match = False
+                calendar_entry = special_event_period.calendarEntry
+                if calendar_entry:
+                    if _debug: LocalScheduleInterpreter._debug("    - calendar_entry: %r", calendar_entry)
+                    match = date_in_calendar_entry(edate, calendar_entry)
+                else:
+                    # get the calendar object from the application
+                    calendar_object = sched_obj._app.get_object_id(special_event_period.calendarReference)
+                    if not calendar_object:
+                        raise RuntimeError("invalid calendar object reference")
+                    if _debug: LocalScheduleInterpreter._debug("    - calendar_object: %r", calendar_object)
+
+                    for calendar_entry in calendar_object.dateList:
+                        if _debug: LocalScheduleInterpreter._debug("    - calendar_entry: %r", calendar_entry)
+                        match = date_in_calendar_entry(edate, calendar_entry)
+                        if match:
+                            break
+
+                # didn't match the period, try the next special event
+                if not match:
+                    if _debug: LocalScheduleInterpreter._debug("    - no matching calendar entry")
+                    continue
+
+                # event priority array index
+                priority = special_event.eventPriority - 1
+                if _debug: LocalScheduleInterpreter._debug("    - priority: %r", priority)
+
+                # look for all of the possible times
+                for time_value in special_event.listOfTimeValues:
+                    tval = time_value.time
+                    if tval <= etime:
+                        if isinstance(time_value.value, Null):
+                            if _debug: LocalScheduleInterpreter._debug("    - relinquish exception @ %r", tval)
+                            event_priority[priority] = None
+                            next_transition_time[priority] = None
+                        else:
+                            if _debug: LocalScheduleInterpreter._debug("    - consider exception @ %r", tval)
+                            event_priority[priority] = time_value.value
+                            next_transition_time[priority] = next_day
+                    else:
+                        next_transition_time[priority] = tval
+                        break
+
+        # assume the next transition will be at the start of the next day
+        earliest_transition = next_day
+
+        # check if any of the special events came up with something
+        for priority_value, next_transition in zip(event_priority, next_transition_time):
+            if next_transition is not None:
+                earliest_transition = min(earliest_transition, next_transition)
+            if priority_value is not None:
+                if _debug: LocalScheduleInterpreter._debug("    - priority_value: %r", priority_value)
+                return priority_value, earliest_transition
+
+        # start out with the default
+        daily_value = sched_obj.scheduleDefault
+
+        # check the daily schedule
+        if sched_obj.weeklySchedule:
+            daily_schedule = sched_obj.weeklySchedule[edate[3]]
+            if _debug: LocalScheduleInterpreter._debug("    - daily_schedule: %r", daily_schedule)
+
+            # look for all of the possible times
+            for time_value in daily_schedule.daySchedule:
+                if _debug: LocalScheduleInterpreter._debug("    - time_value: %r", time_value)
+
+                tval = time_value.time
+                if tval <= etime:
+                    if isinstance(time_value.value, Null):
+                        if _debug: LocalScheduleInterpreter._debug("    - back to normal @ %r", tval)
+                        daily_value = sched_obj.scheduleDefault
+                    else:
+                        if _debug: LocalScheduleInterpreter._debug("    - new value @ %r", tval)
+                        daily_value = time_value.value
+                else:
+                    earliest_transition = min(earliest_transition, tval)
+                    break
+
+        # return what was matched, if anything
+        return daily_value, earliest_transition
+
+#
+#   TestConsoleCmd
+#
+
+@bacpypes_debugging
+class TestConsoleCmd(ConsoleCmd):
+
+    def do_test(self, args):
+        """test <date> <time>"""
+        args = args.split()
+        if _debug: TestConsoleCmd._debug("do_test %r", args)
+
+        date_string, time_string = args
+        test_date = Date(date_string).value
+        test_time = Time(time_string).value
+
+        for so in schedule_objects:
+            v, t = so._task.eval(test_date, test_time)
+            print(so.objectName + ", " + repr(v and v.value) + " until " + str(t))
+
+    def do_now(self, args):
+        """now"""
+        args = args.split()
+        if _debug: TestConsoleCmd._debug("do_now %r", args)
+
+        y = _localtime()
+        print("y: {}".format(y))
+
+#
+#   __main__
+#
+
+def main():
+    global args, schedule_objects
+
+    # parse the command line arguments
+    parser = ConfigArgumentParser(description=__doc__)
+
+    # parse the command line arguments
+    args = parser.parse_args()
+
+    if _debug: _log.debug("initialization")
+    if _debug: _log.debug("    - args: %r", args)
+
+    # set up testing
+    setup_module()
+
+    # reset the time machine
+    reset_time_machine(start_time="1970-01-01")
+
+    #
+    #   Simple daily schedule (actually a weekly schedule with every day
+    #   being identical.
+    #
+    so = LocalScheduleObject(
+        objectIdentifier=('schedule', 1),
+        objectName='Schedule 1',
+        presentValue=Integer(5),
+        effectivePeriod=DateRange(
+            startDate=(0, 1, 1, 1),
+            endDate=(254, 12, 31, 2),
+            ),
+        weeklySchedule=ArrayOf(DailySchedule)([
+            DailySchedule(
+                daySchedule=[
+                    TimeValue(time=(8,0,0,0), value=Integer(8)),
+                    TimeValue(time=(14,0,0,0), value=Null()),
+                    TimeValue(time=(17,0,0,0), value=Integer(42)),
+#                   TimeValue(time=(0,0,0,0), value=Null()),
+                    ]
+                ),
+            ] * 7),
+        scheduleDefault=Integer(0),
+        )
+    _log.debug("    - so: %r", so)
+    schedule_objects.append(so)
+
+    print("{} @ {}".format(so.presentValue.value, Time().now()))
+
+    for i in range(1, 25):
+        hr = "{}:00:01".format(i)
+
+        # let it run until just after midnight
+        run_time_machine(stop_time=hr)
+
+        print("{} @ {}".format(so.presentValue.value, Time().now()))
+
+    # done testing
+    teardown_module()
+
+if __name__ == "__main__":
+    main()
+
diff --git a/sandbox/local_schedule_object_t2.py b/sandbox/local_schedule_object_t2.py
new file mode 100644
index 00000000..beaa83f8
--- /dev/null
+++ b/sandbox/local_schedule_object_t2.py
@@ -0,0 +1,733 @@
+#!/usr/bin/env python
+
+"""
+Local Schedule Object Test
+"""
+
+import sys
+import calendar
+from time import mktime as _mktime, localtime as _localtime
+
+from bacpypes.debugging import bacpypes_debugging, ModuleLogger, xtob
+from bacpypes.consolelogging import ConfigArgumentParser
+from bacpypes.consolecmd import ConsoleCmd
+
+from bacpypes.core import run, deferred
+from bacpypes.task import OneShotTask, TaskManager
+
+from bacpypes.primitivedata import Atomic, Null, Integer, Unsigned, Real, Date, Time, CharacterString
+from bacpypes.constructeddata import Array, ArrayOf, SequenceOf, AnyAtomic
+from bacpypes.basetypes import CalendarEntry, DailySchedule, DateRange, \
+    DeviceObjectPropertyReference, SpecialEvent, SpecialEventPeriod, TimeValue
+from bacpypes.object import register_object_type, get_datatype, \
+    WritableProperty, ScheduleObject, AnalogValueObject
+
+from bacpypes.app import Application
+from bacpypes.service.object import CurrentPropertyListMixIn
+from bacpypes.service.device import LocalDeviceObject
+
+### testing
+import time
+
+sys.path[:0] = ['.']
+from tests.time_machine import TimeMachine, reset_time_machine, run_time_machine, xdatetime
+global timemachine
+###
+
+# some debugging
+_debug = 0
+_log = ModuleLogger(globals())
+
+### testing
+@bacpypes_debugging
+def setup_module(module=None):
+    if _debug: setup_module._debug("setup_module %r", module)
+    global time_machine
+
+    # this is a singleton
+    time_machine = TimeMachine()
+
+    # make sure this is the same one referenced by the functions
+    assert time_machine is reset_time_machine.__globals__['time_machine']
+    assert time_machine is run_time_machine.__globals__['time_machine']
+
+
+@bacpypes_debugging
+def teardown_module():
+    if _debug: teardown_module._debug("teardown_module")
+    global time_machine
+
+    # all done
+    time_machine = None
+###
+
+#
+#   match_date
+#
+
+def match_date(date, date_pattern):
+    """
+    Match a specific date, a four-tuple with no special values, with a date
+    pattern, four-tuple possibly having special values.
+    """
+    # unpack the date and pattern
+    year, month, day, day_of_week = date
+    year_p, month_p, day_p, day_of_week_p = date_pattern
+
+    # check the year
+    if year_p == 255:
+        # any year
+        pass
+    elif year != year_p:
+        # specific year
+        return False
+
+    # check the month
+    if month_p == 255:
+        # any month
+        pass
+    elif month_p == 13:
+        # odd months
+        if (month % 2) == 0:
+            return False
+    elif month_p == 14:
+        # even months
+        if (month % 2) == 1:
+            return False
+    elif month != month_p:
+        # specific month
+        return False
+
+    # check the day
+    if day_p == 255:
+        # any day
+        pass
+    elif day_p == 32:
+        # last day of the month
+        last_day = calendar.monthrange(year + 1900, month)[1]
+        if day != last_day:
+            return False
+    elif day_p == 33:
+        # odd days of the month
+        if (day % 2) == 0:
+            return False
+    elif day_p == 34:
+        # even days of the month
+        if (day % 2) == 1:
+            return False
+    elif day != day_p:
+        # specific day
+        return False
+
+    # check the day of week
+    if day_of_week_p == 255:
+        # any day of the week
+        pass
+    elif day_of_week != day_of_week_p:
+        # specific day of the week
+        return False
+
+    # all tests pass
+    return True
+
+#
+#   match_date_range
+#
+
+def match_date_range(date, date_range):
+    """
+    Match a specific date, a four-tuple with no special values, with a DateRange
+    object which as a start date and end date.
+    """
+    return (date[:3] >= date_range.startDate[:3]) \
+        and (date[:3] <= date_range.endDate[:3])
+
+#
+#   match_weeknday
+#
+
+def match_weeknday(date, weeknday):
+    """
+    Match a specific date, a four-tuple with no special values, with a
+    BACnetWeekNDay, an octet string with three (unsigned) octets.
+    """
+    # unpack the date
+    year, month, day, day_of_week = date
+    last_day = calendar.monthrange(year + 1900, month)[1]
+
+    # unpack the date pattern octet string
+    if sys.version_info[0] == 2:
+        weeknday_unpacked = [ord(c) for c in weeknday]
+    elif sys.version_info[0] == 3:
+        weeknday_unpacked = [c for c in weeknday]
+    else:
+        raise NotImplementedError("match_weeknday requires Python 2.x or 3.x")
+    month_p, week_of_month_p, day_of_week_p = weeknday_unpacked
+
+    # check the month
+    if month_p == 255:
+        # any month
+        pass
+    elif month_p == 13:
+        # odd months
+        if (month % 2) == 0:
+            return False
+    elif month_p == 14:
+        # even months
+        if (month % 2) == 1:
+            return False
+    elif month != month_p:
+        # specific month
+        return False
+
+    # check the week of the month
+    if week_of_month_p == 255:
+        # any week
+        pass
+    elif week_of_month_p == 1:
+        # days numbered 1-7
+        if (day > 7):
+            return False
+    elif week_of_month_p == 2:
+        # days numbered 8-14
+        if (day < 8) or (day > 14):
+            return False
+    elif week_of_month_p == 3:
+        # days numbered 15-21
+        if (day < 15) or (day > 21):
+            return False
+    elif week_of_month_p == 4:
+        # days numbered 22-28
+        if (day < 22) or (day > 28):
+            return False
+    elif week_of_month_p == 5:
+        # days numbered 29-31
+        if (day < 29) or (day > 31):
+            return False
+    elif week_of_month_p == 6:
+        # last 7 days of this month
+        if (day < last_day - 6):
+            return False
+    elif week_of_month_p == 7:
+        # any of the 7 days prior to the last 7 days of this month
+        if (day < last_day - 13) or (day > last_day - 7):
+            return False
+    elif week_of_month_p == 8:
+        # any of the 7 days prior to the last 14 days of this month
+        if (day < last_day - 20) or (day > last_day - 14):
+            return False
+    elif week_of_month_p == 9:
+        # any of the 7 days prior to the last 21 days of this month
+        if (day < last_day - 27) or (day > last_day - 21):
+            return False
+
+    # check the day
+    if day_of_week_p == 255:
+        # any day
+        pass
+    elif day_of_week != day_of_week_p:
+        # specific day
+        return False
+
+    # all tests pass
+    return True
+
+#
+#   date_in_calendar_entry
+#
+
+@bacpypes_debugging
+def date_in_calendar_entry(date, calendar_entry):
+    if _debug: date_in_calendar_entry._debug("date_in_calendar_entry %r %r", date, calendar_entry)
+
+    match = False
+    if calendar_entry.date:
+        match = match_date(date, calendar_entry.date)
+    elif calendar_entry.dateRange:
+        match = match_date_range(date, calendar_entry.dateRange)
+    elif calendar_entry.weekNDay:
+        match = match_weeknday(date, calendar_entry.weekNDay)
+    else:
+        raise RuntimeError("")
+    if _debug: date_in_calendar_entry._debug("    - match: %r", match)
+
+    return match
+
+#
+#   datetime_to_time
+#
+
+def datetime_to_time(date, time):
+    """Take the date and time 4-tuples and return the time in seconds since
+    the epoch as a floating point number."""
+    if (255 in date) or (255 in time):
+        raise RuntimeError("specific date and time required")
+
+    time_tuple = (
+        date[0]+1900, date[1], date[2],
+        time[0], time[1], time[2],
+        0, 0, -1,
+        )
+    return _mktime(time_tuple)
+
+#
+#   LocalScheduleObject
+#
+
+@bacpypes_debugging
+@register_object_type(vendor_id=999)
+class LocalScheduleObject(CurrentPropertyListMixIn, ScheduleObject):
+
+    properties = [
+        WritableProperty('presentValue', AnyAtomic),
+        ]
+
+    def __init__(self, **kwargs):
+        if _debug: LocalScheduleObject._debug("__init__ %r", kwargs)
+        ScheduleObject.__init__(self, **kwargs)
+
+        # attach an interpreter task
+        self._task = LocalScheduleInterpreter(self)
+
+        # add some monitors
+        for prop in ('weeklySchedule', 'exceptionSchedule', 'scheduleDefault'):
+            self._property_monitors[prop].append(self._check_reliability)
+
+        # check it now
+        self._check_reliability()
+
+    def _check_reliability(self, old_value=None, new_value=None):
+        """This function is called when the object is created and after
+        one of its configuration properties has changed.  The new and old value
+        parameters are ignored, this is called after the property has been
+        changed and this is only concerned with the current value."""
+        if _debug: LocalScheduleObject._debug("_check_reliability %r %r", old_value, new_value)
+
+        try:
+            schedule_default = self.scheduleDefault
+
+            if schedule_default is None:
+                raise ValueError("scheduleDefault expected")
+            if not isinstance(schedule_default, Atomic):
+                raise TypeError("scheduleDefault must be an instance of an atomic type")
+
+            if (self.weeklySchedule is None) and (self.exceptionSchedule is None):
+                raise ValueError("schedule required")
+
+            schedule_datatype = schedule_default.__class__
+            if _debug: LocalScheduleObject._debug("    - schedule_datatype: %r", schedule_datatype)
+
+            # check the weekly schedule values
+            if self.weeklySchedule:
+                for daily_schedule in self.weeklySchedule:
+                    for time_value in daily_schedule.daySchedule:
+                        if _debug: LocalScheduleObject._debug("    - daily time_value: %r", time_value)
+                        if time_value is None:
+                            pass
+                        elif not isinstance(time_value.value, (Null, schedule_datatype)):
+                            if _debug: LocalScheduleObject._debug("    - wrong type: expected %r, got %r",
+                                schedule_datatype,
+                                time_value.__class__,
+                                )
+                            raise TypeError("wrong type")
+                        elif 255 in time_value.time:
+                            if _debug: LocalScheduleObject._debug("    - wildcard in time")
+                            raise ValueError("must be a specific time")
+
+            # check the exception schedule values
+            if self.exceptionSchedule:
+                for special_event in self.exceptionSchedule:
+                    for time_value in special_event.listOfTimeValues:
+                        if _debug: LocalScheduleObject._debug("    - special event time_value: %r", time_value)
+                        if time_value is None:
+                            pass
+                        elif not isinstance(time_value.value, (Null, schedule_datatype)):
+                            if _debug: LocalScheduleObject._debug("    - wrong type: expected %r, got %r",
+                                schedule_datatype,
+                                time_value.__class__,
+                                )
+                            raise TypeError("wrong type")
+
+            # check list of object property references
+            obj_prop_refs = self.listOfObjectPropertyReferences
+            if obj_prop_refs:
+                for obj_prop_ref in obj_prop_refs:
+                    if obj_prop_ref.deviceIdentifier:
+                        raise RuntimeError("no external references")
+
+                    # get the datatype of the property to be written
+                    obj_type = obj_prop_ref.objectIdentifier[0]
+                    datatype = get_datatype(obj_type, obj_prop_ref.propertyIdentifier)
+                    if _debug: LocalScheduleObject._debug("    - datatype: %r", datatype)
+
+                    if issubclass(datatype, Array) and (obj_prop_ref.propertyArrayIndex is not None):
+                        if obj_prop_ref.propertyArrayIndex == 0:
+                            datatype = Unsigned
+                        else:
+                            datatype = datatype.subtype
+                        if _debug: LocalScheduleObject._debug("    - datatype: %r", datatype)
+
+                    if datatype is not schedule_datatype:
+                        if _debug: LocalScheduleObject._debug("    - wrong type: expected %r, got %r",
+                            datatype,
+                            schedule_datatype,
+                            )
+                        raise TypeError("wrong type")
+
+            # all good
+            self.reliability = 'noFaultDetected'
+            if _debug: LocalScheduleObject._debug("    - no fault detected")
+
+        except Exception as err:
+            if _debug: LocalScheduleObject._debug("    - exception: %r", err)
+            self.reliability = 'configurationError'
+
+#
+#   LocalScheduleInterpreter
+#
+
+@bacpypes_debugging
+class LocalScheduleInterpreter(OneShotTask):
+
+    def __init__(self, sched_obj):
+        if _debug: LocalScheduleInterpreter._debug("__init__ %r", sched_obj)
+        OneShotTask.__init__(self)
+
+        # reference the schedule object to update
+        self.sched_obj = sched_obj
+
+        # add a monitor for the present value
+        sched_obj._property_monitors['presentValue'].append(self.present_value_changed)
+
+        # call to interpret the schedule
+        deferred(self.process_task)
+
+    def present_value_changed(self, old_value, new_value):
+        """This function is called when the presentValue of the local schedule
+        object has changed, both internally by this interpreter, or externally
+        by some client using WriteProperty."""
+        if _debug: LocalScheduleInterpreter._debug("present_value_changed %s %s", old_value, new_value)
+
+        # if this hasn't been added to an application, there's nothing to do
+        if not self.sched_obj._app:
+            if _debug: LocalScheduleInterpreter._debug("    - no application")
+            return
+
+        # process the list of [device] object property [array index] references
+        obj_prop_refs = self.sched_obj.listOfObjectPropertyReferences
+        if not obj_prop_refs:
+            if _debug: LocalScheduleInterpreter._debug("    - no writes defined")
+            return
+
+        # primitive values just set the value part
+        new_value = new_value.value
+
+        # loop through the writes
+        for obj_prop_ref in obj_prop_refs:
+            if obj_prop_ref.deviceIdentifier:
+                if _debug: LocalScheduleInterpreter._debug("    - no externals")
+                continue
+
+            # get the object from the application
+            obj = self.sched_obj._app.get_object_id(obj_prop_ref.objectIdentifier)
+            if not obj:
+                if _debug: LocalScheduleInterpreter._debug("    - no object")
+                continue
+
+            # try to change the value
+            try:
+                obj.WriteProperty(
+                    obj_prop_ref.propertyIdentifier,
+                    new_value,
+                    obj_prop_ref.propertyArrayIndex,
+                    )
+                if _debug: LocalScheduleInterpreter._debug("    - success")
+            except Exception as err:
+                if _debug: LocalScheduleInterpreter._debug("    - error: %r", err)
+
+    def process_task(self):
+        if _debug: LocalScheduleInterpreter._debug("process_task(%s)", self.sched_obj.objectName)
+
+        # check for a valid configuration
+        if self.sched_obj.reliability != 'noFaultDetected':
+            if _debug: LocalScheduleInterpreter._debug("    - fault detected")
+            return
+
+        # get the date and time from the device object in case it provides
+        # some custom functionality
+        if self.sched_obj._app and self.sched_obj._app.localDevice:
+            current_date = self.sched_obj._app.localDevice.localDate
+            if _debug: LocalScheduleInterpreter._debug("    - current_date: %r", current_date)
+
+            current_time = self.sched_obj._app.localDevice.localTime
+            if _debug: LocalScheduleInterpreter._debug("    - current_time: %r", current_time)
+        else:
+            # get the current date and time, as provided by the task manager
+            current_date = Date().now().value
+            if _debug: LocalScheduleInterpreter._debug("    - current_date: %r", current_date)
+
+            current_time = Time().now().value
+            if _debug: LocalScheduleInterpreter._debug("    - current_time: %r", current_time)
+
+        # evaluate the time
+        current_value, next_transition = self.eval(current_date, current_time)
+        if _debug: LocalScheduleInterpreter._debug("    - current_value, next_transition: %r, %r", current_value, next_transition)
+
+        # set the present value
+        self.sched_obj.presentValue = current_value
+
+        # compute the time of the next transition
+        transition_time = datetime_to_time(current_date, next_transition)
+
+        # install this to run again
+        self.install_task(transition_time)
+
+    def eval(self, edate, etime):
+        """Evaluate the schedule according to the provided date and time and
+        return the appropriate present value, or None if not in the effective
+        period."""
+        if _debug: LocalScheduleInterpreter._debug("eval %r %r", edate, etime)
+
+        # reference the schedule object
+        sched_obj = self.sched_obj
+        if _debug: LocalScheduleInterpreter._debug("    sched_obj: %r", sched_obj)
+
+        # verify the date falls in the effective period
+        if not match_date_range(edate, sched_obj.effectivePeriod):
+            return None
+
+        # the event priority is a list of values that are in effect for
+        # exception schedules with the special event priority, see 135.1-2013
+        # clause 7.3.2.23.10.3.8, Revision 4 Event Priority Test
+        event_priority = [None] * 16
+
+        next_day = (24, 0, 0, 0)
+        next_transition_time = [None] * 16
+
+        # check the exception schedule values
+        if sched_obj.exceptionSchedule:
+            for special_event in sched_obj.exceptionSchedule:
+                if _debug: LocalScheduleInterpreter._debug("    - special_event: %r", special_event)
+
+                # check the special event period
+                special_event_period = special_event.period
+                if special_event_period is None:
+                    raise RuntimeError("special event period required")
+
+                match = False
+                calendar_entry = special_event_period.calendarEntry
+                if calendar_entry:
+                    if _debug: LocalScheduleInterpreter._debug("    - calendar_entry: %r", calendar_entry)
+                    match = date_in_calendar_entry(edate, calendar_entry)
+                else:
+                    # get the calendar object from the application
+                    calendar_object = sched_obj._app.get_object_id(special_event_period.calendarReference)
+                    if not calendar_object:
+                        raise RuntimeError("invalid calendar object reference")
+                    if _debug: LocalScheduleInterpreter._debug("    - calendar_object: %r", calendar_object)
+
+                    for calendar_entry in calendar_object.dateList:
+                        if _debug: LocalScheduleInterpreter._debug("    - calendar_entry: %r", calendar_entry)
+                        match = date_in_calendar_entry(edate, calendar_entry)
+                        if match:
+                            break
+
+                # didn't match the period, try the next special event
+                if not match:
+                    if _debug: LocalScheduleInterpreter._debug("    - no matching calendar entry")
+                    continue
+
+                # event priority array index
+                priority = special_event.eventPriority - 1
+                if _debug: LocalScheduleInterpreter._debug("    - priority: %r", priority)
+
+                # look for all of the possible times
+                for time_value in special_event.listOfTimeValues:
+                    tval = time_value.time
+                    if tval <= etime:
+                        if isinstance(time_value.value, Null):
+                            if _debug: LocalScheduleInterpreter._debug("    - relinquish exception @ %r", tval)
+                            event_priority[priority] = None
+                            next_transition_time[priority] = None
+                        else:
+                            if _debug: LocalScheduleInterpreter._debug("    - consider exception @ %r", tval)
+                            event_priority[priority] = time_value.value
+                            next_transition_time[priority] = next_day
+                    else:
+                        next_transition_time[priority] = tval
+                        break
+
+        # assume the next transition will be at the start of the next day
+        earliest_transition = next_day
+
+        # check if any of the special events came up with something
+        for priority_value, next_transition in zip(event_priority, next_transition_time):
+            if next_transition is not None:
+                earliest_transition = min(earliest_transition, next_transition)
+            if priority_value is not None:
+                if _debug: LocalScheduleInterpreter._debug("    - priority_value: %r", priority_value)
+                return priority_value, earliest_transition
+
+        # start out with the default
+        daily_value = sched_obj.scheduleDefault
+
+        # check the daily schedule
+        if sched_obj.weeklySchedule:
+            daily_schedule = sched_obj.weeklySchedule[edate[3]]
+            if _debug: LocalScheduleInterpreter._debug("    - daily_schedule: %r", daily_schedule)
+
+            # look for all of the possible times
+            for time_value in daily_schedule.daySchedule:
+                if _debug: LocalScheduleInterpreter._debug("    - time_value: %r", time_value)
+
+                tval = time_value.time
+                if tval <= etime:
+                    if isinstance(time_value.value, Null):
+                        if _debug: LocalScheduleInterpreter._debug("    - back to normal @ %r", tval)
+                        daily_value = sched_obj.scheduleDefault
+                    else:
+                        if _debug: LocalScheduleInterpreter._debug("    - new value @ %r", tval)
+                        daily_value = time_value.value
+                else:
+                    earliest_transition = min(earliest_transition, tval)
+                    break
+
+        # return what was matched, if anything
+        return daily_value, earliest_transition
+
+#
+#   WritableAnalogValueObject
+#
+
+@register_object_type(vendor_id=999)
+class WritableAnalogValueObject(CurrentPropertyListMixIn, AnalogValueObject):
+
+    properties = [
+        WritableProperty('presentValue', Real),
+        ]
+
+#
+#   TestConsoleCmd
+#
+
+@bacpypes_debugging
+class TestConsoleCmd(ConsoleCmd):
+
+    def do_test(self, args):
+        """test <date> <time>"""
+        args = args.split()
+        if _debug: TestConsoleCmd._debug("do_test %r", args)
+
+        date_string, time_string = args
+        test_date = Date(date_string).value
+        test_time = Time(time_string).value
+
+        for so in schedule_objects:
+            v, t = so._task.eval(test_date, test_time)
+            print(so.objectName + ", " + repr(v and v.value) + " until " + str(t))
+
+#
+#   __main__
+#
+
+def main():
+    global args, schedule_objects
+
+    # parse the command line arguments
+    parser = ConfigArgumentParser(description=__doc__)
+
+    # parse the command line arguments
+    args = parser.parse_args()
+
+    if _debug: _log.debug("initialization")
+    if _debug: _log.debug("    - args: %r", args)
+
+    # set up testing
+    setup_module()
+
+    # reset the time machine
+    reset_time_machine(start_time="1970-01-01")
+
+    # make a device object
+    this_device = LocalDeviceObject(
+        objectName=args.ini.objectname,
+        objectIdentifier=('device', int(args.ini.objectidentifier)),
+        maxApduLengthAccepted=int(args.ini.maxapdulengthaccepted),
+        segmentationSupported=args.ini.segmentationsupported,
+        vendorIdentifier=int(args.ini.vendoridentifier),
+        )
+
+    # make a floating application, no network interface
+    this_application = Application(this_device)
+
+    # get the services supported
+    services_supported = this_application.get_services_supported()
+    if _debug: _log.debug("    - services_supported: %r", services_supported)
+
+    # let the device object know
+    this_device.protocolServicesSupported = services_supported.value
+
+    #
+    #   Simple daily schedule (actually a weekly schedule with every day
+    #   being identical.
+    #
+    so = LocalScheduleObject(
+        objectIdentifier=('schedule', 1),
+        objectName='Schedule 1',
+        presentValue=Real(-1.0),
+        effectivePeriod=DateRange(
+            startDate=(0, 1, 1, 1),
+            endDate=(254, 12, 31, 2),
+            ),
+        weeklySchedule=ArrayOf(DailySchedule)([
+            DailySchedule(
+                daySchedule=[
+                    TimeValue(time=(8,0,0,0), value=Real(8)),
+                    TimeValue(time=(14,0,0,0), value=Null()),
+                    TimeValue(time=(17,0,0,0), value=Real(42)),
+#                   TimeValue(time=(0,0,0,0), value=Null()),
+                    ]
+                ),
+            ] * 7),
+        listOfObjectPropertyReferences=[
+            DeviceObjectPropertyReference(
+                objectIdentifier=('analogValue', 1),
+                propertyIdentifier='presentValue',
+#               propertyArrayIndex=5,
+#               deviceIdentifier=('device', 999),
+                ),
+            ],
+        scheduleDefault=Real(0.0),
+        )
+    _log.debug("    - so: %r", so)
+    this_application.add_object(so)
+
+    # add an analog value object
+    avo = WritableAnalogValueObject(
+        objectIdentifier=('analogValue', 1),
+        objectName='analog value 1',
+        presentValue=0.0,
+        )
+    _log.debug("    - avo: %r", avo)
+    this_application.add_object(avo)
+
+    print("{} @ {}".format(so.presentValue.value, Time().now()))
+
+    for i in range(1, 25):
+        hr = "{}:00:01".format(i)
+
+        # let it run until just after midnight
+        run_time_machine(stop_time=hr)
+
+        print("{}, {} @ {}".format(
+            so.presentValue.value,
+            avo.presentValue,
+            Time().now(),
+            ))
+
+    # done testing
+    teardown_module()
+
+if __name__ == "__main__":
+    main()
+

From 86d0f1c2cf5318125c34340828ec00518b68fb72 Mon Sep 17 00:00:00 2001
From: Joel Bender <joel@carrickbender.com>
Date: Thu, 18 Jan 2018 23:22:36 -0500
Subject: [PATCH 13/21] pass the priority parameter

---
 sandbox/local_schedule_object_t2.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/sandbox/local_schedule_object_t2.py b/sandbox/local_schedule_object_t2.py
index beaa83f8..6c5bc29f 100644
--- a/sandbox/local_schedule_object_t2.py
+++ b/sandbox/local_schedule_object_t2.py
@@ -439,7 +439,8 @@ def present_value_changed(self, old_value, new_value):
                 obj.WriteProperty(
                     obj_prop_ref.propertyIdentifier,
                     new_value,
-                    obj_prop_ref.propertyArrayIndex,
+                    arrayIndex=obj_prop_ref.propertyArrayIndex,
+                    priority=self.sched_obj.priorityForWriting,
                     )
                 if _debug: LocalScheduleInterpreter._debug("    - success")
             except Exception as err:
@@ -697,6 +698,7 @@ def main():
 #               deviceIdentifier=('device', 999),
                 ),
             ],
+        priorityForWriting=7,
         scheduleDefault=Real(0.0),
         )
     _log.debug("    - so: %r", so)

From e07ab588828a1c40eb1b6a93b1af2fe8aa427d9d Mon Sep 17 00:00:00 2001
From: Joel Bender <joel@carrickbender.com>
Date: Fri, 16 Feb 2018 23:16:47 -0500
Subject: [PATCH 14/21] bring up-to-date with the 0.16.7 release

---
 py25/bacpypes/app.py            |  13 +-
 py25/bacpypes/basetypes.py      |  41 ++-
 py25/bacpypes/bvllservice.py    | 120 ++++++++-
 py25/bacpypes/service/device.py |  10 +-
 py25/bacpypes/service/object.py |   6 +-
 py27/bacpypes/app.py            |  13 +-
 py27/bacpypes/basetypes.py      |  41 ++-
 py27/bacpypes/bvllservice.py    | 121 ++++++++-
 py27/bacpypes/service/device.py |  10 +-
 py34/bacpypes/app.py            |  13 +-
 py34/bacpypes/basetypes.py      |  41 ++-
 py34/bacpypes/bvllservice.py    | 120 ++++++++-
 py34/bacpypes/service/device.py |  10 +-
 samples/CommandableMixin.py     | 465 ++++++++++++++++++++++++--------
 samples/WhoIsIAm.py             | 230 ++++++++++++++++
 15 files changed, 1033 insertions(+), 221 deletions(-)
 mode change 100755 => 100644 samples/CommandableMixin.py
 create mode 100755 samples/WhoIsIAm.py

diff --git a/py25/bacpypes/app.py b/py25/bacpypes/app.py
index 059da41e..fa5f9ca5 100755
--- a/py25/bacpypes/app.py
+++ b/py25/bacpypes/app.py
@@ -473,7 +473,7 @@ class BIPSimpleApplication(ApplicationIOController, WhoIsIAmServices, ReadWriteP
 
     def __init__(self, localDevice, localAddress, deviceInfoCache=None, aseID=None):
         if _debug: BIPSimpleApplication._debug("__init__ %r %r deviceInfoCache=%r aseID=%r", localDevice, localAddress, deviceInfoCache, aseID)
-        ApplicationIOController.__init__(self, localDevice, deviceInfoCache, aseID=aseID)
+        ApplicationIOController.__init__(self, localDevice, localAddress, deviceInfoCache, aseID=aseID)
 
         # local address might be useful for subclasses
         if isinstance(localAddress, Address):
@@ -528,9 +528,14 @@ def close_socket(self):
 
 class BIPForeignApplication(ApplicationIOController, WhoIsIAmServices, ReadWritePropertyServices):
 
-    def __init__(self, localDevice, localAddress, bbmdAddress, bbmdTTL, aseID=None):
-        if _debug: BIPForeignApplication._debug("__init__ %r %r %r %r aseID=%r", localDevice, localAddress, bbmdAddress, bbmdTTL, aseID)
-        ApplicationIOController.__init__(self, localDevice, aseID=aseID)
+    def __init__(self, localDevice, localAddress, bbmdAddress, bbmdTTL, deviceInfoCache=None, aseID=None):
+        if _debug:
+            BIPForeignApplication._debug(
+                "__init__ %r %r %r %r deviceInfoCache=%r aseID=%r",
+                localDevice, localAddress, bbmdAddress, bbmdTTL,
+                deviceInfoCache, aseID,
+                )
+        ApplicationIOController.__init__(self, localDevice, localAddress, deviceInfoCache, aseID=aseID)
 
         # local address might be useful for subclasses
         if isinstance(localAddress, Address):
diff --git a/py25/bacpypes/basetypes.py b/py25/bacpypes/basetypes.py
index b5485f9d..9d385249 100755
--- a/py25/bacpypes/basetypes.py
+++ b/py25/bacpypes/basetypes.py
@@ -1604,6 +1604,16 @@ class ErrorType(Sequence):
         , Element('errorCode', ErrorCode)
         ]
 
+class LightingCommand(Sequence):
+    sequenceElements = \
+        [ Element('operation', LightingOperation, 0)
+        , Element('targetLevel', Real, 1, True)
+        , Element('rampRate', Real, 2, True)
+        , Element('stepIncrement', Real, 3, True)
+        , Element('fadeTime', Unsigned, 4, True)
+        , Element('priority', Unsigned, 5, True)
+        ]
+
 class ObjectPropertyReference(Sequence):
     sequenceElements = \
         [ Element('objectIdentifier', ObjectIdentifier, 0)
@@ -1792,8 +1802,21 @@ class CalendarEntry(Choice):
         ]
 
 class ChannelValue(Choice):
-    choiceElements = [
-        ### needs help
+    choiceElements = \
+        [ Element('null', Null)
+        , Element('real', Real)
+        , Element('enumerated', Enumerated)
+        , Element('unsigned', Unsigned)
+        , Element('boolean', Boolean)
+        , Element('integer', Integer)
+        , Element('double', Double)
+        , Element('time', Time)
+        , Element('characterString', CharacterString)
+        , Element('octetString', OctetString)
+        , Element('bitString', BitString)
+        , Element('date', Date)
+        , Element('objectidentifier', ObjectIdentifier)
+        , Element('lightingCommand', LightingCommand, 0)
         ]
 
 class ClientCOV(Choice):
@@ -2068,16 +2091,6 @@ class KeyIdentifier(Sequence):
         , Element('keyId', Unsigned, 1)
         ]
 
-class LightingCommand(Sequence):
-    sequenceElements = \
-        [ Element('operation', LightingOperation, 0)
-        , Element('targetLevel', Real, 1) ### optional
-        , Element('rampRate', Real, 2)   ### optional
-        , Element('stepIncrement', Real, 3) ### optional
-        , Element('fadeTime', Unsigned, 4) ### optional
-        , Element('priority', Unsigned, 5) ### optional
-        ]
-
 class LogDataLogData(Choice):
     choiceElements = \
         [ Element('booleanValue', Boolean, 0)
@@ -2336,14 +2349,14 @@ class PriorityValue(Choice):
         , Element('enumerated', Enumerated)
         , Element('unsigned', Unsigned)
         , Element('boolean', Boolean)
-        , Element('signed', Integer)
+        , Element('integer', Integer)
         , Element('double', Double)
         , Element('time', Time)
         , Element('characterString', CharacterString)
         , Element('octetString', OctetString)
         , Element('bitString', BitString)
         , Element('date', Date)
-        , Element('objectid', ObjectIdentifier)
+        , Element('objectidentifier', ObjectIdentifier)
         , Element('constructedValue', Any, 0)
         , Element('datetime', DateTime, 1)
         ]
diff --git a/py25/bacpypes/bvllservice.py b/py25/bacpypes/bvllservice.py
index e195d39a..65ae6143 100755
--- a/py25/bacpypes/bvllservice.py
+++ b/py25/bacpypes/bvllservice.py
@@ -407,6 +407,54 @@ def confirmation(self, pdu):
             # send it upstream
             self.response(xpdu)
 
+        elif isinstance(pdu, WriteBroadcastDistributionTable):
+            # build a response
+            xpdu = Result(code=0x0010, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
+        elif isinstance(pdu, ReadBroadcastDistributionTable):
+            # build a response
+            xpdu = Result(code=0x0020, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
+        elif isinstance(pdu, RegisterForeignDevice):
+            # build a response
+            xpdu = Result(code=0x0030, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
+        elif isinstance(pdu, ReadForeignDeviceTable):
+            # build a response
+            xpdu = Result(code=0x0040, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
+        elif isinstance(pdu, DeleteForeignDeviceTableEntry):
+            # build a response
+            xpdu = Result(code=0x0050, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
+        elif isinstance(pdu, DistributeBroadcastToNetwork):
+            # build a response
+            xpdu = Result(code=0x0060, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
         else:
             BIPSimple._warning("invalid pdu type: %s", type(pdu))
 
@@ -446,11 +494,6 @@ def __init__(self, addr=None, ttl=None, sapID=None, cid=None, sid=None):
     def indication(self, pdu):
         if _debug: BIPForeign._debug("indication %r", pdu)
 
-        # check the BBMD registration status, we may not be registered
-        if self.registrationStatus != 0:
-            if _debug: BIPForeign._debug("    - packet dropped, unregistered")
-            return
-
         # check for local stations
         if pdu.pduDestination.addrType == Address.localStationAddr:
             # make an original unicast PDU
@@ -462,6 +505,11 @@ def indication(self, pdu):
 
         # check for broadcasts
         elif pdu.pduDestination.addrType == Address.localBroadcastAddr:
+            # check the BBMD registration status, we may not be registered
+            if self.registrationStatus != 0:
+                if _debug: BIPForeign._debug("    - packet dropped, unregistered")
+                return
+
             # make an original broadcast PDU
             xpdu = DistributeBroadcastToNetwork(pdu, user_data=pdu.pduUserData)
             xpdu.pduDestination = self.bbmdAddress
@@ -498,6 +546,13 @@ def confirmation(self, pdu):
 
             return
 
+        elif isinstance(pdu, OriginalUnicastNPDU):
+            # build a vanilla PDU
+            xpdu = PDU(pdu.pduData, source=pdu.pduSource, destination=pdu.pduDestination, user_data=pdu.pduUserData)
+
+            # send it upstream
+            self.response(xpdu)
+
         # check the BBMD registration status, we may not be registered
         if self.registrationStatus != 0:
             if _debug: BIPForeign._debug("    - packet dropped, unregistered")
@@ -511,13 +566,6 @@ def confirmation(self, pdu):
             # send this to the service access point
             self.sap_response(pdu)
 
-        elif isinstance(pdu, OriginalUnicastNPDU):
-            # build a vanilla PDU
-            xpdu = PDU(pdu.pduData, source=pdu.pduSource, destination=pdu.pduDestination, user_data=pdu.pduUserData)
-
-            # send it upstream
-            self.response(xpdu)
-
         elif isinstance(pdu, ForwardedNPDU):
             # build a PDU with the source from the real source
             xpdu = PDU(pdu.pduData, source=pdu.bvlciAddress, destination=LocalBroadcast(), user_data=pdu.pduUserData)
@@ -525,6 +573,54 @@ def confirmation(self, pdu):
             # send it upstream
             self.response(xpdu)
 
+        elif isinstance(pdu, WriteBroadcastDistributionTable):
+            # build a response
+            xpdu = Result(code=0x0010, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
+        elif isinstance(pdu, ReadBroadcastDistributionTable):
+            # build a response
+            xpdu = Result(code=0x0020, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
+        elif isinstance(pdu, RegisterForeignDevice):
+            # build a response
+            xpdu = Result(code=0x0030, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
+        elif isinstance(pdu, ReadForeignDeviceTable):
+            # build a response
+            xpdu = Result(code=0x0040, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
+        elif isinstance(pdu, DeleteForeignDeviceTableEntry):
+            # build a response
+            xpdu = Result(code=0x0050, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
+        elif isinstance(pdu, DistributeBroadcastToNetwork):
+            # build a response
+            xpdu = Result(code=0x0060, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
         else:
             BIPForeign._warning("invalid pdu type: %s", type(pdu))
 
diff --git a/py25/bacpypes/service/device.py b/py25/bacpypes/service/device.py
index 94958bf5..1d8e11d6 100644
--- a/py25/bacpypes/service/device.py
+++ b/py25/bacpypes/service/device.py
@@ -113,13 +113,15 @@ def __init__(self, **kwargs):
         if 'objectIdentifier' not in kwargs:
             raise RuntimeError("objectIdentifier is required")
 
+        # coerce the object identifier
+        object_identifier = kwargs['objectIdentifier']
+        if isinstance(object_identifier, (int, long)):
+            object_identifier = ('device', object_identifier)
+
         # the object list is provided
         if 'objectList' in kwargs:
             raise RuntimeError("objectList is provided by LocalDeviceObject and cannot be overridden")
-        else:
-            kwargs['objectList'] = ArrayOf(ObjectIdentifier)([
-                kwargs['objectIdentifier'],
-                ])
+        kwargs['objectList'] = ArrayOf(ObjectIdentifier)([object_identifier])
 
         # check for a minimum value
         if kwargs['maxApduLengthAccepted'] < 50:
diff --git a/py25/bacpypes/service/object.py b/py25/bacpypes/service/object.py
index ae8e7dad..0ce857a7 100755
--- a/py25/bacpypes/service/object.py
+++ b/py25/bacpypes/service/object.py
@@ -24,7 +24,6 @@
 #   CurrentPropertyList
 #
 
-@bacpypes_debugging
 class CurrentPropertyList(Property):
 
     def __init__(self):
@@ -60,17 +59,20 @@ def ReadProperty(self, obj, arrayIndex=None):
     def WriteProperty(self, obj, value, arrayIndex=None, priority=None, direct=False):
         raise ExecutionError(errorClass='property', errorCode='writeAccessDenied')
 
+bacpypes_debugging(CurrentPropertyList)
+
 #
 #   CurrentPropertyListMixIn
 #
 
-@bacpypes_debugging
 class CurrentPropertyListMixIn(Object):
 
     properties = [
         CurrentPropertyList(),
         ]
 
+bacpypes_debugging(CurrentPropertyListMixIn)
+
 #
 #   ReadProperty and WriteProperty Services
 #
diff --git a/py27/bacpypes/app.py b/py27/bacpypes/app.py
index 3aa33ec6..a1081497 100755
--- a/py27/bacpypes/app.py
+++ b/py27/bacpypes/app.py
@@ -470,7 +470,7 @@ class BIPSimpleApplication(ApplicationIOController, WhoIsIAmServices, ReadWriteP
 
     def __init__(self, localDevice, localAddress, deviceInfoCache=None, aseID=None):
         if _debug: BIPSimpleApplication._debug("__init__ %r %r deviceInfoCache=%r aseID=%r", localDevice, localAddress, deviceInfoCache, aseID)
-        ApplicationIOController.__init__(self, localDevice, deviceInfoCache, aseID=aseID)
+        ApplicationIOController.__init__(self, localDevice, localAddress, deviceInfoCache, aseID=aseID)
 
         # local address might be useful for subclasses
         if isinstance(localAddress, Address):
@@ -524,9 +524,14 @@ def close_socket(self):
 @bacpypes_debugging
 class BIPForeignApplication(ApplicationIOController, WhoIsIAmServices, ReadWritePropertyServices):
 
-    def __init__(self, localDevice, localAddress, bbmdAddress, bbmdTTL, aseID=None):
-        if _debug: BIPForeignApplication._debug("__init__ %r %r %r %r aseID=%r", localDevice, localAddress, bbmdAddress, bbmdTTL, aseID)
-        ApplicationIOController.__init__(self, localDevice, aseID=aseID)
+    def __init__(self, localDevice, localAddress, bbmdAddress, bbmdTTL, deviceInfoCache=None, aseID=None):
+        if _debug:
+            BIPForeignApplication._debug(
+                "__init__ %r %r %r %r deviceInfoCache=%r aseID=%r",
+                localDevice, localAddress, bbmdAddress, bbmdTTL,
+                deviceInfoCache, aseID,
+                )
+        ApplicationIOController.__init__(self, localDevice, localAddress, deviceInfoCache, aseID=aseID)
 
         # local address might be useful for subclasses
         if isinstance(localAddress, Address):
diff --git a/py27/bacpypes/basetypes.py b/py27/bacpypes/basetypes.py
index b5485f9d..9d385249 100755
--- a/py27/bacpypes/basetypes.py
+++ b/py27/bacpypes/basetypes.py
@@ -1604,6 +1604,16 @@ class ErrorType(Sequence):
         , Element('errorCode', ErrorCode)
         ]
 
+class LightingCommand(Sequence):
+    sequenceElements = \
+        [ Element('operation', LightingOperation, 0)
+        , Element('targetLevel', Real, 1, True)
+        , Element('rampRate', Real, 2, True)
+        , Element('stepIncrement', Real, 3, True)
+        , Element('fadeTime', Unsigned, 4, True)
+        , Element('priority', Unsigned, 5, True)
+        ]
+
 class ObjectPropertyReference(Sequence):
     sequenceElements = \
         [ Element('objectIdentifier', ObjectIdentifier, 0)
@@ -1792,8 +1802,21 @@ class CalendarEntry(Choice):
         ]
 
 class ChannelValue(Choice):
-    choiceElements = [
-        ### needs help
+    choiceElements = \
+        [ Element('null', Null)
+        , Element('real', Real)
+        , Element('enumerated', Enumerated)
+        , Element('unsigned', Unsigned)
+        , Element('boolean', Boolean)
+        , Element('integer', Integer)
+        , Element('double', Double)
+        , Element('time', Time)
+        , Element('characterString', CharacterString)
+        , Element('octetString', OctetString)
+        , Element('bitString', BitString)
+        , Element('date', Date)
+        , Element('objectidentifier', ObjectIdentifier)
+        , Element('lightingCommand', LightingCommand, 0)
         ]
 
 class ClientCOV(Choice):
@@ -2068,16 +2091,6 @@ class KeyIdentifier(Sequence):
         , Element('keyId', Unsigned, 1)
         ]
 
-class LightingCommand(Sequence):
-    sequenceElements = \
-        [ Element('operation', LightingOperation, 0)
-        , Element('targetLevel', Real, 1) ### optional
-        , Element('rampRate', Real, 2)   ### optional
-        , Element('stepIncrement', Real, 3) ### optional
-        , Element('fadeTime', Unsigned, 4) ### optional
-        , Element('priority', Unsigned, 5) ### optional
-        ]
-
 class LogDataLogData(Choice):
     choiceElements = \
         [ Element('booleanValue', Boolean, 0)
@@ -2336,14 +2349,14 @@ class PriorityValue(Choice):
         , Element('enumerated', Enumerated)
         , Element('unsigned', Unsigned)
         , Element('boolean', Boolean)
-        , Element('signed', Integer)
+        , Element('integer', Integer)
         , Element('double', Double)
         , Element('time', Time)
         , Element('characterString', CharacterString)
         , Element('octetString', OctetString)
         , Element('bitString', BitString)
         , Element('date', Date)
-        , Element('objectid', ObjectIdentifier)
+        , Element('objectidentifier', ObjectIdentifier)
         , Element('constructedValue', Any, 0)
         , Element('datetime', DateTime, 1)
         ]
diff --git a/py27/bacpypes/bvllservice.py b/py27/bacpypes/bvllservice.py
index 8c01f05e..4c2cc182 100755
--- a/py27/bacpypes/bvllservice.py
+++ b/py27/bacpypes/bvllservice.py
@@ -404,6 +404,54 @@ def confirmation(self, pdu):
             # send it upstream
             self.response(xpdu)
 
+        elif isinstance(pdu, WriteBroadcastDistributionTable):
+            # build a response
+            xpdu = Result(code=0x0010, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
+        elif isinstance(pdu, ReadBroadcastDistributionTable):
+            # build a response
+            xpdu = Result(code=0x0020, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
+        elif isinstance(pdu, RegisterForeignDevice):
+            # build a response
+            xpdu = Result(code=0x0030, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
+        elif isinstance(pdu, ReadForeignDeviceTable):
+            # build a response
+            xpdu = Result(code=0x0040, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
+        elif isinstance(pdu, DeleteForeignDeviceTableEntry):
+            # build a response
+            xpdu = Result(code=0x0050, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
+        elif isinstance(pdu, DistributeBroadcastToNetwork):
+            # build a response
+            xpdu = Result(code=0x0060, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
         else:
             BIPSimple._warning("invalid pdu type: %s", type(pdu))
 
@@ -442,11 +490,6 @@ def __init__(self, addr=None, ttl=None, sapID=None, cid=None, sid=None):
     def indication(self, pdu):
         if _debug: BIPForeign._debug("indication %r", pdu)
 
-        # check the BBMD registration status, we may not be registered
-        if self.registrationStatus != 0:
-            if _debug: BIPForeign._debug("    - packet dropped, unregistered")
-            return
-
         # check for local stations
         if pdu.pduDestination.addrType == Address.localStationAddr:
             # make an original unicast PDU
@@ -458,6 +501,11 @@ def indication(self, pdu):
 
         # check for broadcasts
         elif pdu.pduDestination.addrType == Address.localBroadcastAddr:
+            # check the BBMD registration status, we may not be registered
+            if self.registrationStatus != 0:
+                if _debug: BIPForeign._debug("    - packet dropped, unregistered")
+                return
+
             # make an original broadcast PDU
             xpdu = DistributeBroadcastToNetwork(pdu, user_data=pdu.pduUserData)
             xpdu.pduDestination = self.bbmdAddress
@@ -494,6 +542,14 @@ def confirmation(self, pdu):
 
             return
 
+        elif isinstance(pdu, OriginalUnicastNPDU):
+            # build a vanilla PDU
+            xpdu = PDU(pdu.pduData, source=pdu.pduSource, destination=pdu.pduDestination, user_data=pdu.pduUserData)
+
+            # send it upstream
+            self.response(xpdu)
+            return
+
         # check the BBMD registration status, we may not be registered
         if self.registrationStatus != 0:
             if _debug: BIPForeign._debug("    - packet dropped, unregistered")
@@ -507,13 +563,6 @@ def confirmation(self, pdu):
             # send this to the service access point
             self.sap_response(pdu)
 
-        elif isinstance(pdu, OriginalUnicastNPDU):
-            # build a vanilla PDU
-            xpdu = PDU(pdu.pduData, source=pdu.pduSource, destination=pdu.pduDestination, user_data=pdu.pduUserData)
-
-            # send it upstream
-            self.response(xpdu)
-
         elif isinstance(pdu, ForwardedNPDU):
             # build a PDU with the source from the real source
             xpdu = PDU(pdu.pduData, source=pdu.bvlciAddress, destination=LocalBroadcast(), user_data=pdu.pduUserData)
@@ -521,6 +570,54 @@ def confirmation(self, pdu):
             # send it upstream
             self.response(xpdu)
 
+        elif isinstance(pdu, WriteBroadcastDistributionTable):
+            # build a response
+            xpdu = Result(code=0x0010, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
+        elif isinstance(pdu, ReadBroadcastDistributionTable):
+            # build a response
+            xpdu = Result(code=0x0020, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
+        elif isinstance(pdu, RegisterForeignDevice):
+            # build a response
+            xpdu = Result(code=0x0030, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
+        elif isinstance(pdu, ReadForeignDeviceTable):
+            # build a response
+            xpdu = Result(code=0x0040, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
+        elif isinstance(pdu, DeleteForeignDeviceTableEntry):
+            # build a response
+            xpdu = Result(code=0x0050, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
+        elif isinstance(pdu, DistributeBroadcastToNetwork):
+            # build a response
+            xpdu = Result(code=0x0060, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
         else:
             BIPForeign._warning("invalid pdu type: %s", type(pdu))
 
diff --git a/py27/bacpypes/service/device.py b/py27/bacpypes/service/device.py
index 647714bd..25283a4d 100644
--- a/py27/bacpypes/service/device.py
+++ b/py27/bacpypes/service/device.py
@@ -114,13 +114,15 @@ def __init__(self, **kwargs):
         if 'objectIdentifier' not in kwargs:
             raise RuntimeError("objectIdentifier is required")
 
+        # coerce the object identifier
+        object_identifier = kwargs['objectIdentifier']
+        if isinstance(object_identifier, (int, long)):
+            object_identifier = ('device', object_identifier)
+
         # the object list is provided
         if 'objectList' in kwargs:
             raise RuntimeError("objectList is provided by LocalDeviceObject and cannot be overridden")
-        else:
-            kwargs['objectList'] = ArrayOf(ObjectIdentifier)([
-                kwargs['objectIdentifier'],
-                ])
+        kwargs['objectList'] = ArrayOf(ObjectIdentifier)([object_identifier])
 
         # check for a minimum value
         if kwargs['maxApduLengthAccepted'] < 50:
diff --git a/py34/bacpypes/app.py b/py34/bacpypes/app.py
index 3aa33ec6..a1081497 100755
--- a/py34/bacpypes/app.py
+++ b/py34/bacpypes/app.py
@@ -470,7 +470,7 @@ class BIPSimpleApplication(ApplicationIOController, WhoIsIAmServices, ReadWriteP
 
     def __init__(self, localDevice, localAddress, deviceInfoCache=None, aseID=None):
         if _debug: BIPSimpleApplication._debug("__init__ %r %r deviceInfoCache=%r aseID=%r", localDevice, localAddress, deviceInfoCache, aseID)
-        ApplicationIOController.__init__(self, localDevice, deviceInfoCache, aseID=aseID)
+        ApplicationIOController.__init__(self, localDevice, localAddress, deviceInfoCache, aseID=aseID)
 
         # local address might be useful for subclasses
         if isinstance(localAddress, Address):
@@ -524,9 +524,14 @@ def close_socket(self):
 @bacpypes_debugging
 class BIPForeignApplication(ApplicationIOController, WhoIsIAmServices, ReadWritePropertyServices):
 
-    def __init__(self, localDevice, localAddress, bbmdAddress, bbmdTTL, aseID=None):
-        if _debug: BIPForeignApplication._debug("__init__ %r %r %r %r aseID=%r", localDevice, localAddress, bbmdAddress, bbmdTTL, aseID)
-        ApplicationIOController.__init__(self, localDevice, aseID=aseID)
+    def __init__(self, localDevice, localAddress, bbmdAddress, bbmdTTL, deviceInfoCache=None, aseID=None):
+        if _debug:
+            BIPForeignApplication._debug(
+                "__init__ %r %r %r %r deviceInfoCache=%r aseID=%r",
+                localDevice, localAddress, bbmdAddress, bbmdTTL,
+                deviceInfoCache, aseID,
+                )
+        ApplicationIOController.__init__(self, localDevice, localAddress, deviceInfoCache, aseID=aseID)
 
         # local address might be useful for subclasses
         if isinstance(localAddress, Address):
diff --git a/py34/bacpypes/basetypes.py b/py34/bacpypes/basetypes.py
index b5485f9d..9d385249 100755
--- a/py34/bacpypes/basetypes.py
+++ b/py34/bacpypes/basetypes.py
@@ -1604,6 +1604,16 @@ class ErrorType(Sequence):
         , Element('errorCode', ErrorCode)
         ]
 
+class LightingCommand(Sequence):
+    sequenceElements = \
+        [ Element('operation', LightingOperation, 0)
+        , Element('targetLevel', Real, 1, True)
+        , Element('rampRate', Real, 2, True)
+        , Element('stepIncrement', Real, 3, True)
+        , Element('fadeTime', Unsigned, 4, True)
+        , Element('priority', Unsigned, 5, True)
+        ]
+
 class ObjectPropertyReference(Sequence):
     sequenceElements = \
         [ Element('objectIdentifier', ObjectIdentifier, 0)
@@ -1792,8 +1802,21 @@ class CalendarEntry(Choice):
         ]
 
 class ChannelValue(Choice):
-    choiceElements = [
-        ### needs help
+    choiceElements = \
+        [ Element('null', Null)
+        , Element('real', Real)
+        , Element('enumerated', Enumerated)
+        , Element('unsigned', Unsigned)
+        , Element('boolean', Boolean)
+        , Element('integer', Integer)
+        , Element('double', Double)
+        , Element('time', Time)
+        , Element('characterString', CharacterString)
+        , Element('octetString', OctetString)
+        , Element('bitString', BitString)
+        , Element('date', Date)
+        , Element('objectidentifier', ObjectIdentifier)
+        , Element('lightingCommand', LightingCommand, 0)
         ]
 
 class ClientCOV(Choice):
@@ -2068,16 +2091,6 @@ class KeyIdentifier(Sequence):
         , Element('keyId', Unsigned, 1)
         ]
 
-class LightingCommand(Sequence):
-    sequenceElements = \
-        [ Element('operation', LightingOperation, 0)
-        , Element('targetLevel', Real, 1) ### optional
-        , Element('rampRate', Real, 2)   ### optional
-        , Element('stepIncrement', Real, 3) ### optional
-        , Element('fadeTime', Unsigned, 4) ### optional
-        , Element('priority', Unsigned, 5) ### optional
-        ]
-
 class LogDataLogData(Choice):
     choiceElements = \
         [ Element('booleanValue', Boolean, 0)
@@ -2336,14 +2349,14 @@ class PriorityValue(Choice):
         , Element('enumerated', Enumerated)
         , Element('unsigned', Unsigned)
         , Element('boolean', Boolean)
-        , Element('signed', Integer)
+        , Element('integer', Integer)
         , Element('double', Double)
         , Element('time', Time)
         , Element('characterString', CharacterString)
         , Element('octetString', OctetString)
         , Element('bitString', BitString)
         , Element('date', Date)
-        , Element('objectid', ObjectIdentifier)
+        , Element('objectidentifier', ObjectIdentifier)
         , Element('constructedValue', Any, 0)
         , Element('datetime', DateTime, 1)
         ]
diff --git a/py34/bacpypes/bvllservice.py b/py34/bacpypes/bvllservice.py
index 2a6285c5..dddb2d01 100755
--- a/py34/bacpypes/bvllservice.py
+++ b/py34/bacpypes/bvllservice.py
@@ -403,6 +403,54 @@ def confirmation(self, pdu):
             # send it upstream
             self.response(xpdu)
 
+        elif isinstance(pdu, WriteBroadcastDistributionTable):
+            # build a response
+            xpdu = Result(code=0x0010, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
+        elif isinstance(pdu, ReadBroadcastDistributionTable):
+            # build a response
+            xpdu = Result(code=0x0020, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
+        elif isinstance(pdu, RegisterForeignDevice):
+            # build a response
+            xpdu = Result(code=0x0030, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
+        elif isinstance(pdu, ReadForeignDeviceTable):
+            # build a response
+            xpdu = Result(code=0x0040, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
+        elif isinstance(pdu, DeleteForeignDeviceTableEntry):
+            # build a response
+            xpdu = Result(code=0x0050, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
+        elif isinstance(pdu, DistributeBroadcastToNetwork):
+            # build a response
+            xpdu = Result(code=0x0060, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
         else:
             BIPSimple._warning("invalid pdu type: %s", type(pdu))
 
@@ -441,11 +489,6 @@ def __init__(self, addr=None, ttl=None, sapID=None, cid=None, sid=None):
     def indication(self, pdu):
         if _debug: BIPForeign._debug("indication %r", pdu)
 
-        # check the BBMD registration status, we may not be registered
-        if self.registrationStatus != 0:
-            if _debug: BIPForeign._debug("    - packet dropped, unregistered")
-            return
-
         # check for local stations
         if pdu.pduDestination.addrType == Address.localStationAddr:
             # make an original unicast PDU
@@ -457,6 +500,11 @@ def indication(self, pdu):
 
         # check for broadcasts
         elif pdu.pduDestination.addrType == Address.localBroadcastAddr:
+            # check the BBMD registration status, we may not be registered
+            if self.registrationStatus != 0:
+                if _debug: BIPForeign._debug("    - packet dropped, unregistered")
+                return
+
             # make an original broadcast PDU
             xpdu = DistributeBroadcastToNetwork(pdu, user_data=pdu.pduUserData)
             xpdu.pduDestination = self.bbmdAddress
@@ -493,6 +541,13 @@ def confirmation(self, pdu):
 
             return
 
+        elif isinstance(pdu, OriginalUnicastNPDU):
+            # build a vanilla PDU
+            xpdu = PDU(pdu.pduData, source=pdu.pduSource, destination=pdu.pduDestination, user_data=pdu.pduUserData)
+
+            # send it upstream
+            self.response(xpdu)
+
         # check the BBMD registration status, we may not be registered
         if self.registrationStatus != 0:
             if _debug: BIPForeign._debug("    - packet dropped, unregistered")
@@ -506,13 +561,6 @@ def confirmation(self, pdu):
             # send this to the service access point
             self.sap_response(pdu)
 
-        elif isinstance(pdu, OriginalUnicastNPDU):
-            # build a vanilla PDU
-            xpdu = PDU(pdu.pduData, source=pdu.pduSource, destination=pdu.pduDestination, user_data=pdu.pduUserData)
-
-            # send it upstream
-            self.response(xpdu)
-
         elif isinstance(pdu, ForwardedNPDU):
             # build a PDU with the source from the real source
             xpdu = PDU(pdu.pduData, source=pdu.bvlciAddress, destination=LocalBroadcast(), user_data=pdu.pduUserData)
@@ -520,6 +568,54 @@ def confirmation(self, pdu):
             # send it upstream
             self.response(xpdu)
 
+        elif isinstance(pdu, WriteBroadcastDistributionTable):
+            # build a response
+            xpdu = Result(code=0x0010, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
+        elif isinstance(pdu, ReadBroadcastDistributionTable):
+            # build a response
+            xpdu = Result(code=0x0020, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
+        elif isinstance(pdu, RegisterForeignDevice):
+            # build a response
+            xpdu = Result(code=0x0030, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
+        elif isinstance(pdu, ReadForeignDeviceTable):
+            # build a response
+            xpdu = Result(code=0x0040, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
+        elif isinstance(pdu, DeleteForeignDeviceTableEntry):
+            # build a response
+            xpdu = Result(code=0x0050, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
+        elif isinstance(pdu, DistributeBroadcastToNetwork):
+            # build a response
+            xpdu = Result(code=0x0060, user_data=pdu.pduUserData)
+            xpdu.pduDestination = pdu.pduSource
+
+            # send it downstream
+            self.request(xpdu)
+
         else:
             BIPForeign._warning("invalid pdu type: %s", type(pdu))
 
diff --git a/py34/bacpypes/service/device.py b/py34/bacpypes/service/device.py
index 647714bd..b367a1ed 100644
--- a/py34/bacpypes/service/device.py
+++ b/py34/bacpypes/service/device.py
@@ -114,13 +114,15 @@ def __init__(self, **kwargs):
         if 'objectIdentifier' not in kwargs:
             raise RuntimeError("objectIdentifier is required")
 
+        # coerce the object identifier
+        object_identifier = kwargs['objectIdentifier']
+        if isinstance(object_identifier, int):
+            object_identifier = ('device', object_identifier)
+
         # the object list is provided
         if 'objectList' in kwargs:
             raise RuntimeError("objectList is provided by LocalDeviceObject and cannot be overridden")
-        else:
-            kwargs['objectList'] = ArrayOf(ObjectIdentifier)([
-                kwargs['objectIdentifier'],
-                ])
+        kwargs['objectList'] = ArrayOf(ObjectIdentifier)([object_identifier])
 
         # check for a minimum value
         if kwargs['maxApduLengthAccepted'] < 50:
diff --git a/samples/CommandableMixin.py b/samples/CommandableMixin.py
old mode 100755
new mode 100644
index 2bce0862..16b13401
--- a/samples/CommandableMixin.py
+++ b/samples/CommandableMixin.py
@@ -1,154 +1,371 @@
 #!/usr/bin/env python
 
 """
-This sample application demonstrates a mix-in class for commandable properties
-(not useful for Binary Out or Binary Value objects that have a minimum on and off
-time, or for Channel objects).
+Rebuilt Commandable
 """
 
 from bacpypes.debugging import bacpypes_debugging, ModuleLogger
 from bacpypes.consolelogging import ConfigArgumentParser
 
 from bacpypes.core import run
+from bacpypes.task import OneShotTask
 from bacpypes.errors import ExecutionError
 
-from bacpypes.object import AnalogValueObject, DateValueObject
-from bacpypes.primitivedata import Null, Date
-from bacpypes.basetypes import PriorityValue, PriorityArray
+from bacpypes.primitivedata import BitString, CharacterString, Date, Integer, \
+    Double, Enumerated, OctetString, Real, Time, Unsigned
+from bacpypes.basetypes import BinaryPV, ChannelValue, DateTime, DoorValue, PriorityValue, \
+    PriorityArray
+from bacpypes.object import Property, ReadableProperty, WritableProperty, \
+    register_object_type, \
+    AccessDoorObject, AnalogOutputObject, AnalogValueObject, \
+    BinaryOutputObject, BinaryValueObject, BitStringValueObject, CharacterStringValueObject, \
+    DateValueObject, DatePatternValueObject, DateTimePatternValueObject, \
+    DateTimeValueObject, IntegerValueObject, \
+    LargeAnalogValueObject, LightingOutputObject, MultiStateOutputObject, \
+    MultiStateValueObject, OctetStringValueObject, PositiveIntegerValueObject, \
+    TimeValueObject, TimePatternValueObject, ChannelObject
 
 from bacpypes.app import BIPSimpleApplication
+from bacpypes.service.object import CurrentPropertyListMixIn
 from bacpypes.service.device import LocalDeviceObject
 
 # some debugging
 _debug = 0
 _log = ModuleLogger(globals())
 
+
 #
-#   CommandableMixin
+#   Commandable
 #
 
 @bacpypes_debugging
-class CommandableMixin(object):
-
-    def __init__(self, init_value, **kwargs):
-        if _debug: CommandableMixin._debug("__init__ %r, %r", init_value, kwargs)
-        super(CommandableMixin, self).__init__(**kwargs)
-
-        # if no present value given, give it the default value
-        if ('presentValue' not in kwargs):
-            if _debug: CommandableMixin._debug("    - initialize present value")
-            self.presentValue = init_value
-
-        # if no priority array given, give it an empty one
-        if ('priorityArray' not in kwargs):
-            if _debug: CommandableMixin._debug("    - initialize priority array")
-            self.priorityArray = PriorityArray()
-            for i in range(16):
-                self.priorityArray.append(PriorityValue(null=Null()))
-
-        # if no relinquish default value given, give it the default value
-        if ('relinquishDefault' not in kwargs):
-            if _debug: CommandableMixin._debug("    - initialize relinquish default")
-            self.relinquishDefault = init_value
-
-        # capture the present value property
-        self._pv = self._properties['presentValue']
-        if _debug: CommandableMixin._debug("    - _pv: %r", self._pv)
-
-        # capture the datatype
-        self._pv_datatype = self._pv.datatype
-        if _debug: CommandableMixin._debug("    - _pv_datatype: %r", self._pv_datatype)
-
-        # look up a matching priority value choice
-        for element in PriorityValue.choiceElements:
-            if element.klass is self._pv_datatype:
-                self._pv_choice = element.name
-                break
-        else:
-            self._pv_choice = 'constructedValue'
-        if _debug: CommandableMixin._debug("    - _pv_choice: %r", self._pv_choice)
-
-    def WriteProperty(self, property, value, arrayIndex=None, priority=None, direct=False):
-        if _debug: CommandableMixin._debug("WriteProperty %r %r arrayIndex=%r priority=%r direct=%r", property, value, arrayIndex, priority, direct)
-
-        # when writing to the presentValue with a priority
-        if (property == 'presentValue'):
-            # default (lowest) priority
-            if priority is None:
-                priority = 16
-            if _debug: CommandableMixin._debug("    - translate to array index %d", priority)
-
-            # translate to updating the priority array
-            property = 'priorityArray'
-            arrayIndex = priority
-            priority = None
-
-        # update the priority array entry
-        if (property == 'priorityArray') and (arrayIndex is not None):
-            # check the bounds
-            if arrayIndex == 0:
-                raise ExecutionError(errorClass='property', errorCode='writeAccessDenied')
-            if (arrayIndex < 1) or (arrayIndex > 16):
-                raise ExecutionError(errorClass='property', errorCode='invalidArrayIndex')
-
-            # update the specific priorty value element
-            priority_value = self.priorityArray[arrayIndex]
-            if _debug: CommandableMixin._debug("    - priority_value: %r", priority_value)
-
-            # the null or the choice has to be set, the other clear
-            if value is ():
-                if _debug: CommandableMixin._debug("    - write a null")
-                priority_value.null = value
-                setattr(priority_value, self._pv_choice, None)
-            else:
-                if _debug: CommandableMixin._debug("    - write a value")
-                priority_value.null = None
-                setattr(priority_value, self._pv_choice, value)
+def Commandable(datatype, presentValue='presentValue', priorityArray='priorityArray', relinquishDefault='relinquishDefault'):
+    if _debug: Commandable._debug("Commandable %r ...", datatype)
+
+    class _Commando(object):
+
+        properties = [
+            WritableProperty(presentValue, datatype),
+            ReadableProperty(priorityArray, PriorityArray),
+            ReadableProperty(relinquishDefault, datatype),
+            ]
+
+        _pv_choice = None
+
+        def __init__(self, **kwargs):
+            super(_Commando, self).__init__(**kwargs)
+
+            # build a default value in case one is needed
+            default_value = datatype().value
+            if issubclass(datatype, Enumerated):
+                default_value = datatype._xlate_table[default_value]
+            if _debug: Commandable._debug("    - default_value: %r", default_value)
+
+            # see if a present value was provided
+            if (presentValue not in kwargs):
+                setattr(self, presentValue, default_value)
 
-            # look for the highest priority value
+            # see if a priority array was provided
+            if (priorityArray not in kwargs):
+                new_priority_array = PriorityArray()
+                for i in range(16):
+                    new_priority_array.append(PriorityValue(null=()))
+                setattr(self, priorityArray, new_priority_array)
+
+            # see if a present value was provided
+            if (relinquishDefault not in kwargs):
+                setattr(self, relinquishDefault, default_value)
+
+        def _highest_priority_value(self):
+            if _debug: Commandable._debug("_highest_priority_value")
+
+            priority_array = getattr(self, priorityArray)
             for i in range(1, 17):
-                priority_value = self.priorityArray[i]
+                priority_value = priority_array[i]
                 if priority_value.null is None:
-                    if (i < arrayIndex):
-                        if _debug: CommandableMixin._debug("    - existing higher priority value")
-                        return
-                    value = getattr(priority_value, self._pv_choice)
+                    if _debug: Commandable._debug("    - found at index: %r", i)
+
+                    value = getattr(priority_value, _Commando._pv_choice)
+                    value_source = "###"
+
+                    if issubclass(datatype, Enumerated):
+                        value = datatype._xlate_table[value]
+                        if _debug: Commandable._debug("    - remapped enumeration: %r", value)
+
                     break
             else:
-                value = self.relinquishDefault
-            if _debug: CommandableMixin._debug("    - new present value: %r", value)
+                value = getattr(self, relinquishDefault)
+                value_source = None
+
+            if _debug: Commandable._debug("    - value, value_source: %r, %r", value, value_source)
+
+            # return what you found
+            return value, value_source
+
+        def WriteProperty(self, property, value, arrayIndex=None, priority=None, direct=False):
+            if _debug: Commandable._debug("WriteProperty %r %r arrayIndex=%r priority=%r direct=%r", property, value, arrayIndex, priority, direct)
+
+            # when writing to the presentValue with a priority
+            if (property == presentValue):
+                if _debug: Commandable._debug("    - writing to %s, priority %r", presentValue, priority)
+
+                # default (lowest) priority
+                if priority is None:
+                    priority = 16
+                if _debug: Commandable._debug("    - translate to priority array, index %d", priority)
+
+                # translate to updating the priority array
+                property = priorityArray
+                arrayIndex = priority
+                priority = None
+
+            # update the priority array entry
+            if (property == priorityArray):
+                if (arrayIndex is None):
+                    if _debug: Commandable._debug("    - writing entire %s", priorityArray)
+
+                    # pass along the request
+                    super(_Commando, self).WriteProperty(
+                        property, value,
+                        arrayIndex=arrayIndex, priority=priority, direct=direct,
+                        )
+                else:
+                    if _debug: Commandable._debug("    - writing to %s, array index %d", priorityArray, arrayIndex)
+
+                    # check the bounds
+                    if arrayIndex == 0:
+                        raise ExecutionError(errorClass='property', errorCode='writeAccessDenied')
+                    if (arrayIndex < 1) or (arrayIndex > 16):
+                        raise ExecutionError(errorClass='property', errorCode='invalidArrayIndex')
+
+                    # update the specific priorty value element
+                    priority_value = getattr(self, priorityArray)[arrayIndex]
+                    if _debug: Commandable._debug("    - priority_value: %r", priority_value)
+
+                    # the null or the choice has to be set, the other clear
+                    if value is ():
+                        if _debug: Commandable._debug("    - write a null")
+                        priority_value.null = value
+                        setattr(priority_value, _Commando._pv_choice, None)
+                    else:
+                        if _debug: Commandable._debug("    - write a value")
+
+                        if issubclass(datatype, Enumerated):
+                            value = datatype._xlate_table[value]
+                            if _debug: Commandable._debug("    - remapped enumeration: %r", value)
+
+                        priority_value.null = None
+                        setattr(priority_value, _Commando._pv_choice, value)
+
+                # look for the highest priority value
+                value, value_source = self._highest_priority_value()
+
+                # compare with the current value
+                current_value = getattr(self, presentValue)
+                if value == current_value:
+                    if _debug: Commandable._debug("    - no present value change")
+                    return
+
+                # turn this into a present value change
+                property = presentValue
+                arrayIndex = priority = None
+
+            # allow the request to pass through
+            if _debug: Commandable._debug("    - super: %r %r arrayIndex=%r priority=%r", property, value, arrayIndex, priority)
+
+            super(_Commando, self).WriteProperty(
+                property, value,
+                arrayIndex=arrayIndex, priority=priority, direct=direct,
+                )
+
+    # look up a matching priority value choice
+    for element in PriorityValue.choiceElements:
+        if issubclass(datatype, element.klass):
+            _Commando._pv_choice = element.name
+            break
+    else:
+        _Commando._pv_choice = 'constructedValue'
+    if _debug: Commandable._debug("    - _pv_choice: %r", _Commando._pv_choice)
+
+    # return the class
+    return _Commando
 
-            property = 'presentValue'
-            arrayIndex = priority = None
+#
+#   MinOnOffTask
+#
 
-        # allow the request to pass through
-        if _debug: CommandableMixin._debug("    - super: %r %r arrayIndex=%r priority=%r", property, value, arrayIndex, priority)
-        super(CommandableMixin, self).WriteProperty(
-            property, value,
-            arrayIndex=arrayIndex, priority=priority, direct=direct,
-            )
+@bacpypes_debugging
+class MinOnOffTask(OneShotTask):
+
+    def __init__(self, binary_obj):
+        if _debug: MinOnOffTask._debug("__init__ %s", repr(binary_obj))
+        OneShotTask.__init__(self)
+
+        # save a reference to the object
+        self.binary_obj = binary_obj
+
+        # listen for changes to the present value
+        self.binary_obj._property_monitors['presentValue'].append(self.present_value_change)
+
+    def present_value_change(self, old_value, new_value):
+        if _debug: MinOnOffTask._debug("present_value_change %r %r", old_value, new_value)
+
+        # if there's no value change, skip all this
+        if old_value == new_value:
+            if _debug: MinOnOffTask._debug("    - no state change")
+            return
+
+        # get the minimum on/off time
+        if new_value == 'inactive':
+            task_delay = getattr(self.binary_obj, 'minimumOnTime') or 0
+            if _debug: MinOnOffTask._debug("    - minimum on: %r", task_delay)
+        elif new_value == 'active':
+            task_delay = getattr(self.binary_obj, 'minimumOffTime') or 0
+            if _debug: MinOnOffTask._debug("    - minimum off: %r", task_delay)
+        else:
+            raise ValueError("unrecognized present value for %r: %r" % (self.binary_obj.objectIdentifier, new_value))
+
+        # if there's no delay, don't bother
+        if not task_delay:
+            if _debug: MinOnOffTask._debug("    - no delay")
+            return
+
+        # set the value at priority 6
+        self.binary_obj.WriteProperty('presentValue', new_value, priority=6)
+
+        # install this to run, if there is a delay
+        self.install_task(delta=task_delay)
+
+    def process_task(self):
+        if _debug: MinOnOffTask._debug("process_task(%s)", self.binary_obj.objectName)
+
+        # clear the value at priority 6
+        self.binary_obj.WriteProperty('presentValue', (), priority=6)
 
 #
-#   CommandableAnalogValueObject
+#   MinOnOff
 #
 
 @bacpypes_debugging
-class CommandableAnalogValueObject(CommandableMixin, AnalogValueObject):
+class MinOnOff(object):
 
     def __init__(self, **kwargs):
-        if _debug: CommandableAnalogValueObject._debug("__init__ %r", kwargs)
-        CommandableMixin.__init__(self, 0.0, **kwargs)
+        if _debug: MinOnOff._debug("__init__ ...")
+        super(MinOnOff, self).__init__(**kwargs)
+
+        # create the timer task
+        self._min_on_off_task = MinOnOffTask(self)
 
 #
-#   CommandableDateValueObject
+#   Commandable Standard Objects
 #
 
-@bacpypes_debugging
-class CommandableDateValueObject(CommandableMixin, DateValueObject):
+class AccessDoorObjectCmd(Commandable(DoorValue), AccessDoorObject):
+    pass
 
-    def __init__(self, **kwargs):
-        if _debug: CommandableDateValueObject._debug("__init__ %r", kwargs)
-        CommandableMixin.__init__(self, None, **kwargs)
+class AnalogOutputObjectCmd(Commandable(Real), AnalogOutputObject):
+    pass
+
+class AnalogValueObjectCmd(Commandable(Real), AnalogValueObject):
+    pass
+
+### class BinaryLightingOutputObjectCmd(Commandable(Real), BinaryLightingOutputObject):
+###     pass
+
+class BinaryOutputObjectCmd(Commandable(BinaryPV), MinOnOff, BinaryOutputObject):
+    pass
+
+class BinaryValueObjectCmd(Commandable(BinaryPV), MinOnOff, BinaryValueObject):
+    pass
+
+class BitStringValueObjectCmd(Commandable(BitString), BitStringValueObject):
+    pass
+
+class CharacterStringValueObjectCmd(Commandable(CharacterString), CharacterStringValueObject):
+    pass
+
+class DateValueObjectCmd(Commandable(Date), DateValueObject):
+    pass
+
+class DatePatternValueObjectCmd(Commandable(Date), DatePatternValueObject):
+    pass
+
+class DateTimeValueObjectCmd(Commandable(DateTime), DateTimeValueObject):
+    pass
+
+class DateTimePatternValueObjectCmd(Commandable(DateTime), DateTimePatternValueObject):
+    pass
+
+class IntegerValueObjectCmd(Commandable(Integer), IntegerValueObject):
+    pass
+
+class LargeAnalogValueObjectCmd(Commandable(Double), LargeAnalogValueObject):
+    pass
+
+class LightingOutputObjectCmd(Commandable(Real), LightingOutputObject):
+    pass
+
+class MultiStateOutputObjectCmd(Commandable(Unsigned), MultiStateOutputObject):
+    pass
+
+class MultiStateValueObjectCmd(Commandable(Unsigned), MultiStateValueObject):
+    pass
+
+class OctetStringValueObjectCmd(Commandable(OctetString), OctetStringValueObject):
+    pass
+
+class PositiveIntegerValueObjectCmd(Commandable(Unsigned), PositiveIntegerValueObject):
+    pass
+
+class TimeValueObjectCmd(Commandable(Time), TimeValueObject):
+    pass
+
+class TimePatternValueObjectCmd(Commandable(Time), TimePatternValueObject):
+    pass
+
+#
+#   ChannelValueProperty
+#
+
+class ChannelValueProperty(Property):
+
+    def __init__(self):
+        if _debug: ChannelValueProperty._debug("__init__")
+        Property.__init__(self, 'presentValue', ChannelValue, default=None, optional=False, mutable=True)
+
+    def WriteProperty(self, obj, value, arrayIndex=None, priority=None, direct=False):
+        if _debug: ChannelValueProperty._debug("WriteProperty %r %r arrayIndex=%r priority=%r direct=%r", obj, value, arrayIndex, priority, direct)
+
+        ### Clause 12.53.5, page 487
+        raise NotImplementedError()
+
+#
+#   ChannelObjectCmd
+#
+
+class ChannelObjectCmd(ChannelObject):
+
+    properties = [
+        ChannelValueProperty(),
+        ]
+
+##
+##
+##
+##
+##
+
+@register_object_type(vendor_id=999)
+class LocalAnalogValueObjectCmd(CurrentPropertyListMixIn, AnalogValueObjectCmd):
+    pass
+
+@register_object_type(vendor_id=999)
+class LocalBinaryOutputObjectCmd(CurrentPropertyListMixIn, BinaryOutputObjectCmd):
+    pass
+
+@register_object_type(vendor_id=999)
+class LocalDateValueObjectCmd(CurrentPropertyListMixIn, DateValueObjectCmd):
+    pass
 
 #
 #   __main__
@@ -174,22 +391,36 @@ def main():
     this_application = BIPSimpleApplication(this_device, args.ini.address)
 
     # make a commandable analog value object, add to the device
-    cavo1 = CommandableAnalogValueObject(
-        objectIdentifier=('analogValue', 1), objectName='Commandable1',
+    avo1 = LocalAnalogValueObjectCmd(
+        objectIdentifier=('analogValue', 1),
+        objectName='avo1',
+        )
+    if _debug: _log.debug("    - avo1: %r", avo1)
+    this_application.add_object(avo1)
+
+    # make a commandable binary output object, add to the device
+    boo1 = LocalBinaryOutputObjectCmd(
+        objectIdentifier=('binaryOutput', 1),
+        objectName='boo1',
+        presentValue='inactive',
+        relinquishDefault='inactive',
+        minimumOnTime=5,        # let it warm up
+        minimumOffTime=10,      # let it cool off
         )
-    if _debug: _log.debug("    - cavo1: %r", cavo1)
-    this_application.add_object(cavo1)
+    if _debug: _log.debug("    - boo1: %r", boo1)
+    this_application.add_object(boo1)
 
     # get the current date
     today = Date().now()
 
     # make a commandable date value object, add to the device
-    cdvo2 = CommandableDateValueObject(
-        objectIdentifier=('dateValue', 1), objectName='Commandable2',
+    dvo1 = LocalDateValueObjectCmd(
+        objectIdentifier=('dateValue', 1),
+        objectName='dvo1',
         presentValue=today.value,
         )
-    if _debug: _log.debug("    - cdvo2: %r", cdvo2)
-    this_application.add_object(cdvo2)
+    if _debug: _log.debug("    - dvo1: %r", dvo1)
+    this_application.add_object(dvo1)
 
     if _debug: _log.debug("running")
 
diff --git a/samples/WhoIsIAm.py b/samples/WhoIsIAm.py
new file mode 100755
index 00000000..126a4052
--- /dev/null
+++ b/samples/WhoIsIAm.py
@@ -0,0 +1,230 @@
+#!/usr/bin/env python
+
+"""
+This application presents a 'console' prompt to the user asking for Who-Is and I-Am
+commands which create the related APDUs, then lines up the coorresponding I-Am
+for incoming traffic and prints out the contents.
+"""
+
+import sys
+
+from bacpypes.debugging import bacpypes_debugging, ModuleLogger
+from bacpypes.consolelogging import ConfigArgumentParser
+from bacpypes.consolecmd import ConsoleCmd
+
+from bacpypes.core import run, enable_sleeping
+from bacpypes.iocb import IOCB
+
+from bacpypes.pdu import Address, GlobalBroadcast
+from bacpypes.apdu import WhoIsRequest, IAmRequest
+from bacpypes.basetypes import ServicesSupported
+from bacpypes.errors import DecodingError
+
+from bacpypes.app import BIPSimpleApplication
+from bacpypes.service.device import LocalDeviceObject
+
+# some debugging
+_debug = 0
+_log = ModuleLogger(globals())
+
+# globals
+this_device = None
+this_application = None
+
+#
+#   WhoIsIAmApplication
+#
+
+@bacpypes_debugging
+class WhoIsIAmApplication(BIPSimpleApplication):
+
+    def __init__(self, *args):
+        if _debug: WhoIsIAmApplication._debug("__init__ %r", args)
+        BIPSimpleApplication.__init__(self, *args)
+
+        # keep track of requests to line up responses
+        self._request = None
+
+    def request(self, apdu):
+        if _debug: WhoIsIAmApplication._debug("request %r", apdu)
+
+        # save a copy of the request
+        self._request = apdu
+
+        # forward it along
+        BIPSimpleApplication.request(self, apdu)
+
+    def confirmation(self, apdu):
+        if _debug: WhoIsIAmApplication._debug("confirmation %r", apdu)
+
+        # forward it along
+        BIPSimpleApplication.confirmation(self, apdu)
+
+    def indication(self, apdu):
+        if _debug: WhoIsIAmApplication._debug("indication %r", apdu)
+
+        if (isinstance(self._request, WhoIsRequest)) and (isinstance(apdu, IAmRequest)):
+            device_type, device_instance = apdu.iAmDeviceIdentifier
+            if device_type != 'device':
+                raise DecodingError("invalid object type")
+
+            if (self._request.deviceInstanceRangeLowLimit is not None) and \
+                    (device_instance < self._request.deviceInstanceRangeLowLimit):
+                pass
+            elif (self._request.deviceInstanceRangeHighLimit is not None) and \
+                    (device_instance > self._request.deviceInstanceRangeHighLimit):
+                pass
+            else:
+                # print out the contents
+                sys.stdout.write('pduSource = ' + repr(apdu.pduSource) + '\n')
+                sys.stdout.write('iAmDeviceIdentifier = ' + str(apdu.iAmDeviceIdentifier) + '\n')
+                sys.stdout.write('maxAPDULengthAccepted = ' + str(apdu.maxAPDULengthAccepted) + '\n')
+                sys.stdout.write('segmentationSupported = ' + str(apdu.segmentationSupported) + '\n')
+                sys.stdout.write('vendorID = ' + str(apdu.vendorID) + '\n')
+                sys.stdout.flush()
+
+        # forward it along
+        BIPSimpleApplication.indication(self, apdu)
+
+#
+#   WhoIsIAmConsoleCmd
+#
+
+@bacpypes_debugging
+class WhoIsIAmConsoleCmd(ConsoleCmd):
+
+    def do_whois(self, args):
+        """whois [ <addr>] [ <lolimit> <hilimit> ]"""
+        args = args.split()
+        if _debug: WhoIsIAmConsoleCmd._debug("do_whois %r", args)
+
+        try:
+            # build a request
+            request = WhoIsRequest()
+            if (len(args) == 1) or (len(args) == 3):
+                request.pduDestination = Address(args[0])
+                del args[0]
+            else:
+                request.pduDestination = GlobalBroadcast()
+
+            if len(args) == 2:
+                request.deviceInstanceRangeLowLimit = int(args[0])
+                request.deviceInstanceRangeHighLimit = int(args[1])
+            if _debug: WhoIsIAmConsoleCmd._debug("    - request: %r", request)
+
+            # make an IOCB
+            iocb = IOCB(request)
+            if _debug: WhoIsIAmConsoleCmd._debug("    - iocb: %r", iocb)
+
+            # give it to the application
+            this_application.request_io(iocb)
+
+        except Exception as err:
+            WhoIsIAmConsoleCmd._exception("exception: %r", err)
+
+    def do_iam(self, args):
+        """iam"""
+        args = args.split()
+        if _debug: WhoIsIAmConsoleCmd._debug("do_iam %r", args)
+
+        try:
+            # build a request
+            request = IAmRequest()
+            request.pduDestination = GlobalBroadcast()
+
+            # set the parameters from the device object
+            request.iAmDeviceIdentifier = this_device.objectIdentifier
+            request.maxAPDULengthAccepted = this_device.maxApduLengthAccepted
+            request.segmentationSupported = this_device.segmentationSupported
+            request.vendorID = this_device.vendorIdentifier
+            if _debug: WhoIsIAmConsoleCmd._debug("    - request: %r", request)
+
+            # make an IOCB
+            iocb = IOCB(request)
+            if _debug: WhoIsIAmConsoleCmd._debug("    - iocb: %r", iocb)
+
+            # give it to the application
+            this_application.request_io(iocb)
+
+        except Exception as err:
+            WhoIsIAmConsoleCmd._exception("exception: %r", err)
+
+    def do_rtn(self, args):
+        """rtn <addr> <net> ... """
+        args = args.split()
+        if _debug: WhoIsIAmConsoleCmd._debug("do_rtn %r", args)
+
+        # safe to assume only one adapter
+        adapter = this_application.nsap.adapters[0]
+        if _debug: WhoIsIAmConsoleCmd._debug("    - adapter: %r", adapter)
+
+        # provide the address and a list of network numbers
+        router_address = Address(args[0])
+        network_list = [int(arg) for arg in args[1:]]
+
+        # pass along to the service access point
+        this_application.nsap.add_router_references(adapter, router_address, network_list)
+
+
+#
+#   main
+#
+
+def main():
+    global this_device, this_application
+
+    # parse the command line arguments
+    args = ConfigArgumentParser(description=__doc__).parse_args()
+
+    if _debug: _log.debug("initialization")
+    if _debug: _log.debug("    - args: %r", args)
+
+    # make a device object
+    this_device = LocalDeviceObject(
+        objectName=args.ini.objectname,
+        objectIdentifier=int(args.ini.objectidentifier),
+        maxApduLengthAccepted=int(args.ini.maxapdulengthaccepted),
+        segmentationSupported=args.ini.segmentationsupported,
+        vendorIdentifier=int(args.ini.vendoridentifier),
+        )
+    if _debug: _log.debug("    - this_device: %r", this_device)
+
+    # build a bit string that knows about the bit names
+    pss = ServicesSupported()
+    pss['whoIs'] = 1
+    pss['iAm'] = 1
+    pss['readProperty'] = 1
+    pss['writeProperty'] = 1
+
+    # set the property value to be just the bits
+    this_device.protocolServicesSupported = pss.value
+
+    # make a simple application
+    this_application = WhoIsIAmApplication(
+        this_device, args.ini.address,
+        )
+    if _debug: _log.debug("    - this_application: %r", this_application)
+
+    # get the services supported
+    services_supported = this_application.get_services_supported()
+    if _debug: _log.debug("    - services_supported: %r", services_supported)
+
+    # let the device object know
+    this_device.protocolServicesSupported = services_supported.value
+
+    # make a console
+    this_console = WhoIsIAmConsoleCmd()
+    if _debug: _log.debug("    - this_console: %r", this_console)
+
+    # enable sleeping will help with threads
+    enable_sleeping()
+
+    _log.debug("running")
+
+    run()
+
+    _log.debug("fini")
+
+
+if __name__ == "__main__":
+    main()

From b700b09856758dc30bf43838e84d5da2f3f5dc15 Mon Sep 17 00:00:00 2001
From: Joel Bender <joel@carrickbender.com>
Date: Fri, 16 Feb 2018 23:19:59 -0500
Subject: [PATCH 15/21] get ready for the next release

---
 py25/bacpypes/__init__.py | 2 +-
 py27/bacpypes/__init__.py | 2 +-
 py34/bacpypes/__init__.py | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/py25/bacpypes/__init__.py b/py25/bacpypes/__init__.py
index 477e6836..90604514 100755
--- a/py25/bacpypes/__init__.py
+++ b/py25/bacpypes/__init__.py
@@ -18,7 +18,7 @@
 #   Project Metadata
 #
 
-__version__ = '0.16.7'
+__version__ = '0.17.0'
 __author__ = 'Joel Bender'
 __email__ = 'joel@carrickbender.com'
 
diff --git a/py27/bacpypes/__init__.py b/py27/bacpypes/__init__.py
index 477e6836..90604514 100755
--- a/py27/bacpypes/__init__.py
+++ b/py27/bacpypes/__init__.py
@@ -18,7 +18,7 @@
 #   Project Metadata
 #
 
-__version__ = '0.16.7'
+__version__ = '0.17.0'
 __author__ = 'Joel Bender'
 __email__ = 'joel@carrickbender.com'
 
diff --git a/py34/bacpypes/__init__.py b/py34/bacpypes/__init__.py
index bd516040..5ea5be2f 100755
--- a/py34/bacpypes/__init__.py
+++ b/py34/bacpypes/__init__.py
@@ -18,7 +18,7 @@
 #   Project Metadata
 #
 
-__version__ = '0.16.7'
+__version__ = '0.17.0'
 __author__ = 'Joel Bender'
 __email__ = 'joel@carrickbender.com'
 

From c25b0862117f67cf3ac59b8be7a46fe44e9616b2 Mon Sep 17 00:00:00 2001
From: Joel Bender <joel@carrickbender.com>
Date: Sat, 24 Feb 2018 00:37:04 -0500
Subject: [PATCH 16/21] LocalDeviceObject shuffling, automatic
 protocolServicesSupported

---
 py27/bacpypes/__init__.py                     |   2 +
 py27/bacpypes/service/device.py               | 122 +-----------------
 py27/bacpypes/service/object.py               |  55 +-------
 samples/AccumulatorObject.py                  |   9 +-
 samples/BBMD2VLANRouter.py                    |   3 +-
 samples/COVClient.py                          |   9 +-
 samples/COVServer.py                          |   2 +-
 samples/CommandableMixin.py                   |   4 +-
 samples/DeviceCommunicationControl.py         |   9 +-
 samples/DeviceDiscovery.py                    |   9 +-
 samples/DeviceDiscoveryForeign.py             |   9 +-
 samples/HTTPServer.py                         |   9 +-
 .../HandsOnLab/Sample1_SimpleApplication.py   |   9 +-
 .../HandsOnLab/Sample2_WhoIsIAmApplication.py |   9 +-
 .../Sample3_WhoHasIHaveApplication.py         |   9 +-
 .../Sample4_RandomAnalogValueObject.py        |   9 +-
 samples/LocalScheduleObject.py                |  11 +-
 samples/MultiStateValueObject.py              |   9 +-
 samples/MultipleReadProperty.py               |   9 +-
 samples/MultipleReadPropertyHammer.py         |  10 +-
 samples/MultipleReadPropertyThreaded.py       |   9 +-
 samples/RandomAnalogValueSleep.py             |   9 +-
 samples/ReadAllProperties.py                  |   9 +-
 samples/ReadProperty.py                       |   9 +-
 samples/ReadProperty25.py                     |   9 +-
 samples/ReadPropertyAny.py                    |   9 +-
 samples/ReadPropertyMultiple.py               |   9 +-
 samples/ReadPropertyMultiple25.py             |   9 +-
 samples/ReadPropertyMultipleServer.py         |   9 +-
 samples/ReadPropertyMultipleServer25.py       |  11 +-
 samples/ReadRange.py                          |   9 +-
 samples/ReadWriteEventMessageTexts.py         |   9 +-
 samples/ReadWriteFile.py                      |   9 +-
 samples/ReadWriteFileServer.py                |  13 +-
 samples/ReadWriteProperty.py                  |   9 +-
 samples/RecurringMultipleReadProperty.py      |   9 +-
 samples/ThreadedReadProperty.py               |   9 +-
 samples/Tutorial/SampleConsoleCmd-Answer.py   |   9 +-
 samples/Tutorial/SampleConsoleCmd.py          |   9 +-
 samples/Tutorial/WhoIsIAm.py                  |  19 +--
 samples/VendorAVObject.py                     |   9 +-
 samples/VendorReadWriteProperty.py            |   9 +-
 samples/WhoIsIAm.py                           |  19 +--
 samples/WhoIsIAmForeign.py                    |  19 +--
 samples/WriteSomething.py                     |   9 +-
 sandbox/local_schedule_object_t1.py           |   4 +-
 sandbox/local_schedule_object_t2.py           |  11 +-
 setup.py                                      |   1 +
 tests/test_service/helpers.py                 |   2 +-
 tests/test_service/test_object.py             |   2 +-
 50 files changed, 61 insertions(+), 537 deletions(-)

diff --git a/py27/bacpypes/__init__.py b/py27/bacpypes/__init__.py
index 90604514..70e98038 100755
--- a/py27/bacpypes/__init__.py
+++ b/py27/bacpypes/__init__.py
@@ -69,6 +69,8 @@
 
 from . import app
 from . import appservice
+
+from . import local
 from . import service
 
 #
diff --git a/py27/bacpypes/service/device.py b/py27/bacpypes/service/device.py
index 25283a4d..11be52b0 100644
--- a/py27/bacpypes/service/device.py
+++ b/py27/bacpypes/service/device.py
@@ -4,136 +4,16 @@
 from ..capability import Capability
 
 from ..pdu import GlobalBroadcast
-from ..primitivedata import Date, Time, ObjectIdentifier
-from ..constructeddata import ArrayOf
 
-from ..apdu import WhoIsRequest, IAmRequest, IHaveRequest, SimpleAckPDU, Error
+from ..apdu import WhoIsRequest, IAmRequest, IHaveRequest, SimpleAckPDU
 from ..errors import ExecutionError, InconsistentParameters, \
     MissingRequiredParameter, ParameterOutOfRange
-from ..object import register_object_type, registered_object_types, \
-    Property, DeviceObject
 from ..task import FunctionTask
 
-from .object import CurrentPropertyListMixIn
-
 # some debugging
 _debug = 0
 _log = ModuleLogger(globals())
 
-#
-#   CurrentDateProperty
-#
-
-class CurrentDateProperty(Property):
-
-    def __init__(self, identifier):
-        Property.__init__(self, identifier, Date, default=(), optional=True, mutable=False)
-
-    def ReadProperty(self, obj, arrayIndex=None):
-        # access an array
-        if arrayIndex is not None:
-            raise TypeError("{0} is unsubscriptable".format(self.identifier))
-
-        # get the value
-        now = Date()
-        now.now()
-        return now.value
-
-    def WriteProperty(self, obj, value, arrayIndex=None, priority=None, direct=False):
-        raise ExecutionError(errorClass='property', errorCode='writeAccessDenied')
-
-#
-#   CurrentTimeProperty
-#
-
-class CurrentTimeProperty(Property):
-
-    def __init__(self, identifier):
-        Property.__init__(self, identifier, Time, default=(), optional=True, mutable=False)
-
-    def ReadProperty(self, obj, arrayIndex=None):
-        # access an array
-        if arrayIndex is not None:
-            raise TypeError("{0} is unsubscriptable".format(self.identifier))
-
-        # get the value
-        now = Time()
-        now.now()
-        return now.value
-
-    def WriteProperty(self, obj, value, arrayIndex=None, priority=None, direct=False):
-        raise ExecutionError(errorClass='property', errorCode='writeAccessDenied')
-
-#
-#   LocalDeviceObject
-#
-
-@bacpypes_debugging
-class LocalDeviceObject(CurrentPropertyListMixIn, DeviceObject):
-
-    properties = \
-        [ CurrentTimeProperty('localTime')
-        , CurrentDateProperty('localDate')
-        ]
-
-    defaultProperties = \
-        { 'maxApduLengthAccepted': 1024
-        , 'segmentationSupported': 'segmentedBoth'
-        , 'maxSegmentsAccepted': 16
-        , 'apduSegmentTimeout': 5000
-        , 'apduTimeout': 3000
-        , 'numberOfApduRetries': 3
-        }
-
-    def __init__(self, **kwargs):
-        if _debug: LocalDeviceObject._debug("__init__ %r", kwargs)
-
-        # fill in default property values not in kwargs
-        for attr, value in LocalDeviceObject.defaultProperties.items():
-            if attr not in kwargs:
-                kwargs[attr] = value
-
-        for key, value in kwargs.items():
-            if key.startswith("_"):
-                setattr(self, key, value)
-                del kwargs[key]
-
-        # check for registration
-        if self.__class__ not in registered_object_types.values():
-            if 'vendorIdentifier' not in kwargs:
-                raise RuntimeError("vendorIdentifier required to auto-register the LocalDeviceObject class")
-            register_object_type(self.__class__, vendor_id=kwargs['vendorIdentifier'])
-
-        # check for properties this class implements
-        if 'localDate' in kwargs:
-            raise RuntimeError("localDate is provided by LocalDeviceObject and cannot be overridden")
-        if 'localTime' in kwargs:
-            raise RuntimeError("localTime is provided by LocalDeviceObject and cannot be overridden")
-
-        # the object identifier is required for the object list
-        if 'objectIdentifier' not in kwargs:
-            raise RuntimeError("objectIdentifier is required")
-
-        # coerce the object identifier
-        object_identifier = kwargs['objectIdentifier']
-        if isinstance(object_identifier, (int, long)):
-            object_identifier = ('device', object_identifier)
-
-        # the object list is provided
-        if 'objectList' in kwargs:
-            raise RuntimeError("objectList is provided by LocalDeviceObject and cannot be overridden")
-        kwargs['objectList'] = ArrayOf(ObjectIdentifier)([object_identifier])
-
-        # check for a minimum value
-        if kwargs['maxApduLengthAccepted'] < 50:
-            raise ValueError("invalid max APDU length accepted")
-
-        # dump the updated attributes
-        if _debug: LocalDeviceObject._debug("    - updated kwargs: %r", kwargs)
-
-        # proceed as usual
-        super(LocalDeviceObject, self).__init__(**kwargs)
-
 #
 #   Who-Is I-Am Services
 #
diff --git a/py27/bacpypes/service/object.py b/py27/bacpypes/service/object.py
index ca8d3fe9..5c4c993f 100644
--- a/py27/bacpypes/service/object.py
+++ b/py27/bacpypes/service/object.py
@@ -7,11 +7,11 @@
 from ..primitivedata import Atomic, Null, Unsigned
 from ..constructeddata import Any, Array, ArrayOf
 
-from ..apdu import Error, \
+from ..apdu import \
     SimpleAckPDU, ReadPropertyACK, ReadPropertyMultipleACK, \
     ReadAccessResult, ReadAccessResultElement, ReadAccessResultElementChoice
 from ..errors import ExecutionError
-from ..object import Property, Object, PropertyError
+from ..object import PropertyError
 
 # some debugging
 _debug = 0
@@ -20,57 +20,6 @@
 # handy reference
 ArrayOfPropertyIdentifier = ArrayOf(PropertyIdentifier)
 
-#
-#   CurrentPropertyList
-#
-
-@bacpypes_debugging
-class CurrentPropertyList(Property):
-
-    def __init__(self):
-        if _debug: CurrentPropertyList._debug("__init__")
-        Property.__init__(self, 'propertyList', ArrayOfPropertyIdentifier, default=None, optional=True, mutable=False)
-
-    def ReadProperty(self, obj, arrayIndex=None):
-        if _debug: CurrentPropertyList._debug("ReadProperty %r %r", obj, arrayIndex)
-
-        # make a list of the properties that have values
-        property_list = [k for k, v in obj._values.items()
-            if v is not None
-                and k not in ('objectName', 'objectType', 'objectIdentifier', 'propertyList')
-            ]
-        if _debug: CurrentPropertyList._debug("    - property_list: %r", property_list)
-
-        # sort the list so it's stable
-        property_list.sort()
-
-        # asking for the whole thing
-        if arrayIndex is None:
-            return ArrayOfPropertyIdentifier(property_list)
-
-        # asking for the length
-        if arrayIndex == 0:
-            return len(property_list)
-
-        # asking for an index
-        if arrayIndex > len(property_list):
-            raise ExecutionError(errorClass='property', errorCode='invalidArrayIndex')
-        return property_list[arrayIndex - 1]
-
-    def WriteProperty(self, obj, value, arrayIndex=None, priority=None, direct=False):
-        raise ExecutionError(errorClass='property', errorCode='writeAccessDenied')
-
-#
-#   CurrentPropertyListMixIn
-#
-
-@bacpypes_debugging
-class CurrentPropertyListMixIn(Object):
-
-    properties = [
-        CurrentPropertyList(),
-        ]
-
 #
 #   ReadProperty and WriteProperty Services
 #
diff --git a/samples/AccumulatorObject.py b/samples/AccumulatorObject.py
index a03026ea..01130394 100755
--- a/samples/AccumulatorObject.py
+++ b/samples/AccumulatorObject.py
@@ -15,7 +15,7 @@
 from bacpypes.object import AccumulatorObject
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 from bacpypes.service.object import ReadWritePropertyMultipleServices
 
 # some debugging
@@ -84,13 +84,6 @@ def main():
     # add the additional service
     this_application.add_capability(ReadWritePropertyMultipleServices)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     # make a random input object
     accumulator = AccumulatorObject(
         objectIdentifier=('accumulator', 1),
diff --git a/samples/BBMD2VLANRouter.py b/samples/BBMD2VLANRouter.py
index e416cb00..b2e18d3f 100755
--- a/samples/BBMD2VLANRouter.py
+++ b/samples/BBMD2VLANRouter.py
@@ -24,7 +24,8 @@
 
 from bacpypes.app import Application
 from bacpypes.appservice import StateMachineAccessPoint, ApplicationServiceAccessPoint
-from bacpypes.service.device import LocalDeviceObject, WhoIsIAmServices
+from bacpypes.local.device import LocalDeviceObject
+from bacpypes.service.device import WhoIsIAmServices
 from bacpypes.service.object import ReadWritePropertyServices
 
 from bacpypes.primitivedata import Real
diff --git a/samples/COVClient.py b/samples/COVClient.py
index 29281fa4..e79ba964 100755
--- a/samples/COVClient.py
+++ b/samples/COVClient.py
@@ -20,7 +20,7 @@
     SimpleAckPDU, RejectPDU, AbortPDU
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 0
@@ -228,13 +228,6 @@ def main():
     # make a simple application
     this_application = SubscribeCOVApplication(this_device, args.ini.address)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     # make a console
     this_console = SubscribeCOVConsoleCmd()
     if _debug: _log.debug("    - this_console: %r", this_console)
diff --git a/samples/COVServer.py b/samples/COVServer.py
index c1c2de8e..ad2558a4 100755
--- a/samples/COVServer.py
+++ b/samples/COVServer.py
@@ -18,7 +18,7 @@
 
 from bacpypes.app import BIPSimpleApplication
 from bacpypes.object import AnalogValueObject, BinaryValueObject
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 from bacpypes.service.cov import ChangeOfValueServices
 
 # some debugging
diff --git a/samples/CommandableMixin.py b/samples/CommandableMixin.py
index 16b13401..41b8998c 100644
--- a/samples/CommandableMixin.py
+++ b/samples/CommandableMixin.py
@@ -26,8 +26,8 @@
     TimeValueObject, TimePatternValueObject, ChannelObject
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.object import CurrentPropertyListMixIn
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.object import CurrentPropertyListMixIn
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 0
diff --git a/samples/DeviceCommunicationControl.py b/samples/DeviceCommunicationControl.py
index a5247559..e4ce6d63 100755
--- a/samples/DeviceCommunicationControl.py
+++ b/samples/DeviceCommunicationControl.py
@@ -18,7 +18,7 @@
 from bacpypes.apdu import DeviceCommunicationControlRequest
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 0
@@ -134,13 +134,6 @@ def main():
     # make a simple application
     this_application = BIPSimpleApplication(this_device, args.ini.address)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     # make a console
     this_console = DCCConsoleCmd()
     if _debug: _log.debug("    - this_console: %r", this_console)
diff --git a/samples/DeviceDiscovery.py b/samples/DeviceDiscovery.py
index 7c6b1c82..e0f7276b 100755
--- a/samples/DeviceDiscovery.py
+++ b/samples/DeviceDiscovery.py
@@ -22,7 +22,7 @@
 from bacpypes.errors import DecodingError
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 1
@@ -211,13 +211,6 @@ def main():
     # make a simple application
     this_application = DiscoveryApplication(this_device, args.ini.address)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     # make a console
     this_console = DiscoveryConsoleCmd()
     if _debug: _log.debug("    - this_console: %r", this_console)
diff --git a/samples/DeviceDiscoveryForeign.py b/samples/DeviceDiscoveryForeign.py
index fa315b9b..1e7b977e 100755
--- a/samples/DeviceDiscoveryForeign.py
+++ b/samples/DeviceDiscoveryForeign.py
@@ -22,7 +22,7 @@
 from bacpypes.errors import DecodingError
 
 from bacpypes.app import BIPForeignApplication
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 1
@@ -215,13 +215,6 @@ def main():
         int(args.ini.foreignttl),
         )
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     # make a console
     this_console = DiscoveryConsoleCmd()
     if _debug: _log.debug("    - this_console: %r", this_console)
diff --git a/samples/HTTPServer.py b/samples/HTTPServer.py
index 9d99cb4b..61d1c21e 100755
--- a/samples/HTTPServer.py
+++ b/samples/HTTPServer.py
@@ -22,7 +22,7 @@
 
 from bacpypes.app import BIPSimpleApplication
 from bacpypes.object import get_object_class, get_datatype
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 0
@@ -190,13 +190,6 @@ class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
     # make a simple application
     this_application = BIPSimpleApplication(this_device, args.ini.address)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     # local host, special port
     HOST, PORT = "", int(args.port)
     server = ThreadedTCPServer((HOST, PORT), ThreadedHTTPRequestHandler)
diff --git a/samples/HandsOnLab/Sample1_SimpleApplication.py b/samples/HandsOnLab/Sample1_SimpleApplication.py
index b96478b7..dd02bd3c 100644
--- a/samples/HandsOnLab/Sample1_SimpleApplication.py
+++ b/samples/HandsOnLab/Sample1_SimpleApplication.py
@@ -13,7 +13,7 @@
 from bacpypes.core import run
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 1
@@ -72,13 +72,6 @@ def main():
     this_application = SampleApplication(this_device, args.ini.address)
     if _debug: _log.debug("    - this_application: %r", this_application)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     _log.debug("running")
 
     run()
diff --git a/samples/HandsOnLab/Sample2_WhoIsIAmApplication.py b/samples/HandsOnLab/Sample2_WhoIsIAmApplication.py
index 27d00499..2a185f96 100644
--- a/samples/HandsOnLab/Sample2_WhoIsIAmApplication.py
+++ b/samples/HandsOnLab/Sample2_WhoIsIAmApplication.py
@@ -15,7 +15,7 @@
 from bacpypes.core import run
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 0
@@ -90,13 +90,6 @@ def main():
     # make a sample application
     this_application = WhoIsIAmApplication(this_device, args.ini.address)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     _log.debug("running")
 
     run()
diff --git a/samples/HandsOnLab/Sample3_WhoHasIHaveApplication.py b/samples/HandsOnLab/Sample3_WhoHasIHaveApplication.py
index 9c06c0b2..c44e8dd0 100644
--- a/samples/HandsOnLab/Sample3_WhoHasIHaveApplication.py
+++ b/samples/HandsOnLab/Sample3_WhoHasIHaveApplication.py
@@ -16,7 +16,7 @@
 from bacpypes.core import run
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 0
@@ -92,13 +92,6 @@ def main():
     # make a sample application
     this_application = WhoHasIHaveApplication(this_device, args.ini.address)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     _log.debug("running")
 
     # run until stopped, ^C works
diff --git a/samples/HandsOnLab/Sample4_RandomAnalogValueObject.py b/samples/HandsOnLab/Sample4_RandomAnalogValueObject.py
index 8aeb5a44..c5de7083 100644
--- a/samples/HandsOnLab/Sample4_RandomAnalogValueObject.py
+++ b/samples/HandsOnLab/Sample4_RandomAnalogValueObject.py
@@ -21,7 +21,7 @@
 from bacpypes.errors import ExecutionError
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 0
@@ -99,13 +99,6 @@ def main():
     # make a sample application
     this_application = BIPSimpleApplication(this_device, args.ini.address)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     # make some random input objects
     for i in range(1, RANDOM_OBJECT_COUNT+1):
         ravo = RandomAnalogValueObject(
diff --git a/samples/LocalScheduleObject.py b/samples/LocalScheduleObject.py
index 7706e9c0..788285c7 100644
--- a/samples/LocalScheduleObject.py
+++ b/samples/LocalScheduleObject.py
@@ -22,8 +22,8 @@
 from bacpypes.object import register_object_type, get_datatype, WritableProperty, ScheduleObject
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.object import CurrentPropertyListMixIn
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.object import CurrentPropertyListMixIn
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 0
@@ -573,13 +573,6 @@ def main():
     # make a sample application
     this_application = BIPSimpleApplication(this_device, args.ini.address)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     #
     #   Simple daily schedule (actually a weekly schedule with every day
     #   being identical.
diff --git a/samples/MultiStateValueObject.py b/samples/MultiStateValueObject.py
index 6465728c..b3c9b903 100755
--- a/samples/MultiStateValueObject.py
+++ b/samples/MultiStateValueObject.py
@@ -15,7 +15,7 @@
 from bacpypes.object import MultiStateValueObject
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 0
@@ -44,13 +44,6 @@ def main():
     # make a sample application
     this_application = BIPSimpleApplication(this_device, args.ini.address)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     # make a multistate value object
     msvo = MultiStateValueObject(
         objectIdentifier=('multiStateValue', 1),
diff --git a/samples/MultipleReadProperty.py b/samples/MultipleReadProperty.py
index e7bce7f8..4bf2dde5 100755
--- a/samples/MultipleReadProperty.py
+++ b/samples/MultipleReadProperty.py
@@ -23,7 +23,7 @@
 from bacpypes.constructeddata import Array
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 0
@@ -142,13 +142,6 @@ def main():
     # make a simple application
     this_application = ReadPointListApplication(point_list, this_device, args.ini.address)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     # fire off a request when the core has a chance
     deferred(this_application.next_request)
 
diff --git a/samples/MultipleReadPropertyHammer.py b/samples/MultipleReadPropertyHammer.py
index 7bfa4e8b..fbac9694 100755
--- a/samples/MultipleReadPropertyHammer.py
+++ b/samples/MultipleReadPropertyHammer.py
@@ -31,7 +31,8 @@
 
 from bacpypes.apdu import ReadPropertyRequest
 
-from bacpypes.service.device import LocalDeviceObject, WhoIsIAmServices
+from bacpypes.local.device import LocalDeviceObject
+from bacpypes.service.device import WhoIsIAmServices
 from bacpypes.service.object import ReadWritePropertyServices
 
 
@@ -211,13 +212,6 @@ def main():
     # make a simple application
     this_application = ReadPointListApplication(this_device, args.ini.address)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     _log.debug("running")
 
     run()
diff --git a/samples/MultipleReadPropertyThreaded.py b/samples/MultipleReadPropertyThreaded.py
index 9620b8ed..652057ae 100755
--- a/samples/MultipleReadPropertyThreaded.py
+++ b/samples/MultipleReadPropertyThreaded.py
@@ -24,7 +24,7 @@
 from bacpypes.constructeddata import Array
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 0
@@ -134,13 +134,6 @@ def main():
     # make a simple application
     this_application = BIPSimpleApplication(this_device, args.ini.address)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     # create a thread and
     read_thread = ReadPointListThread(point_list)
     if _debug: _log.debug("    - read_thread: %r", read_thread)
diff --git a/samples/RandomAnalogValueSleep.py b/samples/RandomAnalogValueSleep.py
index ea71cdbc..ef944b25 100644
--- a/samples/RandomAnalogValueSleep.py
+++ b/samples/RandomAnalogValueSleep.py
@@ -22,7 +22,7 @@
 from bacpypes.errors import ExecutionError
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 0
@@ -119,13 +119,6 @@ def main():
     # make a sample application
     this_application = BIPSimpleApplication(this_device, args.ini.address)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     # make some random input objects
     for i in range(1, RANDOM_OBJECT_COUNT+1):
         ravo = RandomAnalogValueObject(
diff --git a/samples/ReadAllProperties.py b/samples/ReadAllProperties.py
index b52d8721..8cd81627 100755
--- a/samples/ReadAllProperties.py
+++ b/samples/ReadAllProperties.py
@@ -23,7 +23,7 @@
 
 from bacpypes.app import BIPSimpleApplication
 from bacpypes.object import get_object_class, get_datatype
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 0
@@ -168,13 +168,6 @@ def main():
     # make a simple application
     this_application = ReadPropertyApplication(this_device, args.ini.address)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     # fire off a request when the core has a chance
     deferred(this_application.next_request)
 
diff --git a/samples/ReadProperty.py b/samples/ReadProperty.py
index da42e7ee..f0f7dfe2 100755
--- a/samples/ReadProperty.py
+++ b/samples/ReadProperty.py
@@ -22,7 +22,7 @@
 
 from bacpypes.app import BIPSimpleApplication
 from bacpypes.object import get_object_class, get_datatype
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 0
@@ -162,13 +162,6 @@ def main():
     # make a simple application
     this_application = BIPSimpleApplication(this_device, args.ini.address)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     # make a console
     this_console = ReadPropertyConsoleCmd()
     if _debug: _log.debug("    - this_console: %r", this_console)
diff --git a/samples/ReadProperty25.py b/samples/ReadProperty25.py
index 7924adff..abfa136c 100755
--- a/samples/ReadProperty25.py
+++ b/samples/ReadProperty25.py
@@ -22,7 +22,7 @@
 
 from bacpypes.app import BIPSimpleApplication
 from bacpypes.object import get_object_class, get_datatype
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 0
@@ -164,13 +164,6 @@ def main():
     # make a simple application
     this_application = BIPSimpleApplication(this_device, args.ini.address)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     # make a console
     this_console = ReadPropertyConsoleCmd()
     if _debug: _log.debug("    - this_console: %r", this_console)
diff --git a/samples/ReadPropertyAny.py b/samples/ReadPropertyAny.py
index 44cac18b..6b9be041 100755
--- a/samples/ReadPropertyAny.py
+++ b/samples/ReadPropertyAny.py
@@ -23,7 +23,7 @@
 from bacpypes.primitivedata import Tag
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 
 # some debugging
@@ -136,13 +136,6 @@ def main():
     this_application = BIPSimpleApplication(this_device, args.ini.address)
     if _debug: _log.debug("    - this_application: %r", this_application)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     # make a console
     this_console = ReadPropertyAnyConsoleCmd()
     if _debug: _log.debug("    - this_console: %r", this_console)
diff --git a/samples/ReadPropertyMultiple.py b/samples/ReadPropertyMultiple.py
index f355f8d8..ca1df025 100755
--- a/samples/ReadPropertyMultiple.py
+++ b/samples/ReadPropertyMultiple.py
@@ -25,7 +25,7 @@
 from bacpypes.basetypes import PropertyIdentifier
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 0
@@ -214,13 +214,6 @@ def main():
     # make a simple application
     this_application = BIPSimpleApplication(this_device, args.ini.address)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     # make a console
     this_console = ReadPropertyMultipleConsoleCmd()
     if _debug: _log.debug("    - this_console: %r", this_console)
diff --git a/samples/ReadPropertyMultiple25.py b/samples/ReadPropertyMultiple25.py
index cd53c5db..41a857b7 100755
--- a/samples/ReadPropertyMultiple25.py
+++ b/samples/ReadPropertyMultiple25.py
@@ -25,7 +25,7 @@
 from bacpypes.basetypes import PropertyIdentifier
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 0
@@ -220,13 +220,6 @@ def main():
     # make a simple application
     this_application = BIPSimpleApplication(this_device, args.ini.address)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     # make a console
     this_console = ReadPropertyMultipleConsoleCmd()
     if _debug: _log.debug("    - this_console: %r", this_console)
diff --git a/samples/ReadPropertyMultipleServer.py b/samples/ReadPropertyMultipleServer.py
index 961bd633..c186599b 100755
--- a/samples/ReadPropertyMultipleServer.py
+++ b/samples/ReadPropertyMultipleServer.py
@@ -18,7 +18,7 @@
 from bacpypes.errors import ExecutionError
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import LocalDeviceObject, DeviceCommunicationControlServices
+from bacpypes.service.device import DeviceCommunicationControlServices
 from bacpypes.service.object import ReadWritePropertyMultipleServices
 
 # some debugging
@@ -124,13 +124,6 @@ def main():
     this_application.add_object(ravo2)
     _log.debug("    - object list: %r", this_device.objectList)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     _log.debug("running")
 
     run()
diff --git a/samples/ReadPropertyMultipleServer25.py b/samples/ReadPropertyMultipleServer25.py
index 4c97e13f..b483e2fc 100755
--- a/samples/ReadPropertyMultipleServer25.py
+++ b/samples/ReadPropertyMultipleServer25.py
@@ -18,8 +18,8 @@
 from bacpypes.errors import ExecutionError
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import ReadWritePropertyMultipleServices, \
-    LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
+from bacpypes.service.device import ReadWritePropertyMultipleServices
 
 # some debugging
 _debug = 0
@@ -122,13 +122,6 @@ def main():
     this_application.add_object(ravo2)
     _log.debug("    - object list: %r", this_device.objectList)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     _log.debug("running")
 
     run()
diff --git a/samples/ReadRange.py b/samples/ReadRange.py
index b75e43a8..a328dd10 100755
--- a/samples/ReadRange.py
+++ b/samples/ReadRange.py
@@ -20,7 +20,7 @@
 from bacpypes.apdu import ReadRangeRequest, ReadRangeACK
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 0
@@ -132,13 +132,6 @@ def main():
     # make a simple application
     this_application = BIPSimpleApplication(this_device, args.ini.address)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     # make a console
     this_console = ReadRangeConsoleCmd()
     if _debug: _log.debug("    - this_console: %r", this_console)
diff --git a/samples/ReadWriteEventMessageTexts.py b/samples/ReadWriteEventMessageTexts.py
index 124b0db0..67b24e5e 100644
--- a/samples/ReadWriteEventMessageTexts.py
+++ b/samples/ReadWriteEventMessageTexts.py
@@ -23,7 +23,7 @@
 from bacpypes.constructeddata import Array, ArrayOf, Any
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 0
@@ -241,13 +241,6 @@ def main():
     # make a simple application
     this_application = BIPSimpleApplication(this_device, args.ini.address)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     # make a console
     this_console = ReadWritePropertyConsoleCmd()
     if _debug: _log.debug("    - this_console: %r", this_console)
diff --git a/samples/ReadWriteFile.py b/samples/ReadWriteFile.py
index 7cc3a19a..16fd36fa 100755
--- a/samples/ReadWriteFile.py
+++ b/samples/ReadWriteFile.py
@@ -31,7 +31,7 @@
     AtomicWriteFileACK
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 0
@@ -322,13 +322,6 @@ def main():
     # make a simple application
     this_application = BIPSimpleApplication(this_device, args.ini.address)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     # make a console
     this_console = TestConsoleCmd()
     if _debug: _log.debug("    - this_console: %r", this_console)
diff --git a/samples/ReadWriteFileServer.py b/samples/ReadWriteFileServer.py
index 89df3375..407aa093 100755
--- a/samples/ReadWriteFileServer.py
+++ b/samples/ReadWriteFileServer.py
@@ -15,9 +15,9 @@
 from bacpypes.core import run
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import LocalDeviceObject
-from bacpypes.service.file import FileServices, \
-    LocalRecordAccessFileObject, LocalStreamAccessFileObject
+from bacpypes.local.device import LocalDeviceObject
+from bacpypes.local.file import FileServices, LocalRecordAccessFileObject, LocalStreamAccessFileObject
+from bacpypes.service.file import FileServices
 
 # some debugging
 _debug = 0
@@ -188,13 +188,6 @@ def main():
     # add the capability to server file content
     this_application.add_capability(FileServices)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     # make a record access file, add to the device
     f1 = TestRecordFile(
         objectIdentifier=('file', 1),
diff --git a/samples/ReadWriteProperty.py b/samples/ReadWriteProperty.py
index 25e334a7..70e85dea 100755
--- a/samples/ReadWriteProperty.py
+++ b/samples/ReadWriteProperty.py
@@ -27,7 +27,7 @@
 from bacpypes.constructeddata import Array, Any, AnyAtomic
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 0
@@ -282,13 +282,6 @@ def main():
     # make a simple application
     this_application = BIPSimpleApplication(this_device, args.ini.address)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     # make a console
     this_console = ReadWritePropertyConsoleCmd()
     if _debug: _log.debug("    - this_console: %r", this_console)
diff --git a/samples/RecurringMultipleReadProperty.py b/samples/RecurringMultipleReadProperty.py
index 8d4406c2..bb1826ce 100755
--- a/samples/RecurringMultipleReadProperty.py
+++ b/samples/RecurringMultipleReadProperty.py
@@ -24,7 +24,7 @@
 from bacpypes.constructeddata import Array
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 0
@@ -176,13 +176,6 @@ def main():
     this_application = PrairieDog(args.interval, this_device, args.ini.address)
     if _debug: _log.debug("    - this_application: %r", this_application)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     _log.debug("running")
 
     run()
diff --git a/samples/ThreadedReadProperty.py b/samples/ThreadedReadProperty.py
index dfe3d9cd..34f34607 100755
--- a/samples/ThreadedReadProperty.py
+++ b/samples/ThreadedReadProperty.py
@@ -24,7 +24,7 @@
 from bacpypes.constructeddata import Array
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 0
@@ -172,13 +172,6 @@ def main():
     # make a simple application
     this_application = BIPSimpleApplication(this_device, args.ini.address)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     thread_list = []
 
     # loop through the address and point lists
diff --git a/samples/Tutorial/SampleConsoleCmd-Answer.py b/samples/Tutorial/SampleConsoleCmd-Answer.py
index 4198f548..795b3b14 100644
--- a/samples/Tutorial/SampleConsoleCmd-Answer.py
+++ b/samples/Tutorial/SampleConsoleCmd-Answer.py
@@ -15,7 +15,7 @@
 from bacpypes.core import run, enable_sleeping
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 0
@@ -112,13 +112,6 @@ def main():
     # make a sample application
     this_application = SampleApplication(this_device, args.ini.address)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     # make a console
     this_console = SampleConsoleCmd()
 
diff --git a/samples/Tutorial/SampleConsoleCmd.py b/samples/Tutorial/SampleConsoleCmd.py
index 37e34c6f..360fad07 100644
--- a/samples/Tutorial/SampleConsoleCmd.py
+++ b/samples/Tutorial/SampleConsoleCmd.py
@@ -15,7 +15,7 @@
 from bacpypes.core import run, enable_sleeping
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 0
@@ -84,13 +84,6 @@ def main():
     # make a sample application
     this_application = SampleApplication(this_device, args.ini.address)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     # make a console
     this_console = SampleConsoleCmd()
     if _debug: _log.debug("    - this_console: %r", this_console)
diff --git a/samples/Tutorial/WhoIsIAm.py b/samples/Tutorial/WhoIsIAm.py
index b65e9669..67fe1203 100644
--- a/samples/Tutorial/WhoIsIAm.py
+++ b/samples/Tutorial/WhoIsIAm.py
@@ -20,7 +20,7 @@
 from bacpypes.errors import DecodingError
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 1
@@ -167,26 +167,9 @@ def main():
         vendorIdentifier=int(args.ini.vendoridentifier),
         )
 
-    # build a bit string that knows about the bit names
-    pss = ServicesSupported()
-    pss['whoIs'] = 1
-    pss['iAm'] = 1
-    pss['readProperty'] = 1
-    pss['writeProperty'] = 1
-
-    # set the property value to be just the bits
-    this_device.protocolServicesSupported = pss.value
-
     # make a simple application
     this_application = WhoIsIAmApplication(this_device, args.ini.address)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     # make a console
     this_console = WhoIsIAmConsoleCmd()
     if _debug: _log.debug("    - this_console: %r", this_console)
diff --git a/samples/VendorAVObject.py b/samples/VendorAVObject.py
index edef1e76..b2fc5ae6 100755
--- a/samples/VendorAVObject.py
+++ b/samples/VendorAVObject.py
@@ -20,7 +20,7 @@
 from bacpypes.errors import ExecutionError
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 0
@@ -106,13 +106,6 @@ def main():
     # make a sample application
     this_application = BIPSimpleApplication(this_device, args.ini.address)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     # make some objects
     ravo1 = VendorAVObject(
         objectIdentifier=(513, 1), objectName='Random1'
diff --git a/samples/VendorReadWriteProperty.py b/samples/VendorReadWriteProperty.py
index 42916b9d..9687f248 100755
--- a/samples/VendorReadWriteProperty.py
+++ b/samples/VendorReadWriteProperty.py
@@ -26,7 +26,7 @@
 from bacpypes.constructeddata import Array, Any
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 import VendorAVObject
 
@@ -254,13 +254,6 @@ def main():
     # make a simple application
     this_application = BIPSimpleApplication(this_device, args.ini.address)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     # make a console
     this_console = ReadWritePropertyConsoleCmd()
     if _debug: _log.debug("    - this_console: %r", this_console)
diff --git a/samples/WhoIsIAm.py b/samples/WhoIsIAm.py
index 126a4052..1583446e 100755
--- a/samples/WhoIsIAm.py
+++ b/samples/WhoIsIAm.py
@@ -21,7 +21,7 @@
 from bacpypes.errors import DecodingError
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 0
@@ -189,29 +189,12 @@ def main():
         )
     if _debug: _log.debug("    - this_device: %r", this_device)
 
-    # build a bit string that knows about the bit names
-    pss = ServicesSupported()
-    pss['whoIs'] = 1
-    pss['iAm'] = 1
-    pss['readProperty'] = 1
-    pss['writeProperty'] = 1
-
-    # set the property value to be just the bits
-    this_device.protocolServicesSupported = pss.value
-
     # make a simple application
     this_application = WhoIsIAmApplication(
         this_device, args.ini.address,
         )
     if _debug: _log.debug("    - this_application: %r", this_application)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     # make a console
     this_console = WhoIsIAmConsoleCmd()
     if _debug: _log.debug("    - this_console: %r", this_console)
diff --git a/samples/WhoIsIAmForeign.py b/samples/WhoIsIAmForeign.py
index a2eb613d..9dd27eb7 100755
--- a/samples/WhoIsIAmForeign.py
+++ b/samples/WhoIsIAmForeign.py
@@ -31,7 +31,7 @@
 from bacpypes.errors import DecodingError
 
 from bacpypes.app import BIPForeignApplication
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 # some debugging
 _debug = 0
@@ -200,16 +200,6 @@ def main():
         )
     if _debug: _log.debug("    - this_device: %r", this_device)
 
-    # build a bit string that knows about the bit names
-    pss = ServicesSupported()
-    pss['whoIs'] = 1
-    pss['iAm'] = 1
-    pss['readProperty'] = 1
-    pss['writeProperty'] = 1
-
-    # set the property value to be just the bits
-    this_device.protocolServicesSupported = pss.value
-
     # make a simple application
     this_application = WhoIsIAmApplication(
         this_device, args.ini.address,
@@ -218,13 +208,6 @@ def main():
         )
     if _debug: _log.debug("    - this_application: %r", this_application)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     # make a console
     this_console = WhoIsIAmConsoleCmd()
     if _debug: _log.debug("    - this_console: %r", this_console)
diff --git a/samples/WriteSomething.py b/samples/WriteSomething.py
index 9f623aba..5aaa57bb 100755
--- a/samples/WriteSomething.py
+++ b/samples/WriteSomething.py
@@ -19,7 +19,7 @@
 
 from bacpypes.pdu import Address
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 from bacpypes.primitivedata import TagList, OpeningTag, ClosingTag, ContextTag
 from bacpypes.constructeddata import Any
@@ -130,13 +130,6 @@ def main():
     this_application = BIPSimpleApplication(this_device, args.ini.address)
     if _debug: _log.debug("    - this_application: %r", this_application)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     # make a console
     this_console = WriteSomethingConsoleCmd()
     if _debug: _log.debug("    - this_console: %r", this_console)
diff --git a/sandbox/local_schedule_object_t1.py b/sandbox/local_schedule_object_t1.py
index b5f9d2f7..b6d8d048 100644
--- a/sandbox/local_schedule_object_t1.py
+++ b/sandbox/local_schedule_object_t1.py
@@ -22,8 +22,8 @@
 from bacpypes.object import register_object_type, get_datatype, WritableProperty, ScheduleObject
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.service.object import CurrentPropertyListMixIn
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.object import CurrentPropertyListMixIn
+from bacpypes.local.device import LocalDeviceObject
 
 ### testing
 import time
diff --git a/sandbox/local_schedule_object_t2.py b/sandbox/local_schedule_object_t2.py
index 6c5bc29f..0d55aca2 100644
--- a/sandbox/local_schedule_object_t2.py
+++ b/sandbox/local_schedule_object_t2.py
@@ -23,8 +23,8 @@
     WritableProperty, ScheduleObject, AnalogValueObject
 
 from bacpypes.app import Application
-from bacpypes.service.object import CurrentPropertyListMixIn
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.object import CurrentPropertyListMixIn
+from bacpypes.local.device import LocalDeviceObject
 
 ### testing
 import time
@@ -661,13 +661,6 @@ def main():
     # make a floating application, no network interface
     this_application = Application(this_device)
 
-    # get the services supported
-    services_supported = this_application.get_services_supported()
-    if _debug: _log.debug("    - services_supported: %r", services_supported)
-
-    # let the device object know
-    this_device.protocolServicesSupported = services_supported.value
-
     #
     #   Simple daily schedule (actually a weekly schedule with every day
     #   being identical.
diff --git a/setup.py b/setup.py
index 9d732958..cc1a3bae 100644
--- a/setup.py
+++ b/setup.py
@@ -55,6 +55,7 @@
     url="https://github.com/JoelBender/bacpypes",
     packages=[
         'bacpypes',
+        'bacpypes.local',
         'bacpypes.service',
     ],
     package_dir={
diff --git a/tests/test_service/helpers.py b/tests/test_service/helpers.py
index e50cbc76..8ee06b8e 100644
--- a/tests/test_service/helpers.py
+++ b/tests/test_service/helpers.py
@@ -13,7 +13,7 @@
 from bacpypes.app import Application
 from bacpypes.appservice import StateMachineAccessPoint, ApplicationServiceAccessPoint
 from bacpypes.netservice import NetworkServiceAccessPoint, NetworkServiceElement
-from bacpypes.service.device import LocalDeviceObject
+from bacpypes.local.device import LocalDeviceObject
 
 from ..state_machine import StateMachine, StateMachineGroup
 from ..time_machine import reset_time_machine, run_time_machine
diff --git a/tests/test_service/test_object.py b/tests/test_service/test_object.py
index 52040421..a1e2a8b5 100644
--- a/tests/test_service/test_object.py
+++ b/tests/test_service/test_object.py
@@ -16,7 +16,7 @@
 from bacpypes.object import register_object_type, ReadableProperty, \
     WritableProperty, Object
 
-from bacpypes.service.object import CurrentPropertyListMixIn
+from bacpypes.local.object import CurrentPropertyListMixIn
 
 # some debugging
 _debug = 0

From ceb3cf874a2f8963a698e5ba7d2062261e6db47b Mon Sep 17 00:00:00 2001
From: Joel Bender <joel@carrickbender.com>
Date: Tue, 27 Feb 2018 07:56:01 -0500
Subject: [PATCH 17/21] moved classes

---
 py27/bacpypes/local/__init__.py |  10 ++
 py27/bacpypes/local/device.py   | 157 ++++++++++++++++++++++++++++++++
 py27/bacpypes/local/file.py     |  89 ++++++++++++++++++
 py27/bacpypes/local/object.py   |  68 ++++++++++++++
 4 files changed, 324 insertions(+)
 create mode 100644 py27/bacpypes/local/__init__.py
 create mode 100644 py27/bacpypes/local/device.py
 create mode 100644 py27/bacpypes/local/file.py
 create mode 100644 py27/bacpypes/local/object.py

diff --git a/py27/bacpypes/local/__init__.py b/py27/bacpypes/local/__init__.py
new file mode 100644
index 00000000..3b4de283
--- /dev/null
+++ b/py27/bacpypes/local/__init__.py
@@ -0,0 +1,10 @@
+#!/usr/bin/env python
+
+"""
+Local Object Subpackage
+"""
+
+from . import object
+from . import device
+from . import file
+
diff --git a/py27/bacpypes/local/device.py b/py27/bacpypes/local/device.py
new file mode 100644
index 00000000..f1aef729
--- /dev/null
+++ b/py27/bacpypes/local/device.py
@@ -0,0 +1,157 @@
+#!/usr/bin/env python
+
+from ..debugging import bacpypes_debugging, ModuleLogger
+
+from ..primitivedata import Date, Time, ObjectIdentifier
+from ..constructeddata import ArrayOf
+from ..basetypes import ServicesSupported
+
+from ..errors import ExecutionError
+from ..object import register_object_type, registered_object_types, \
+    Property, DeviceObject
+
+from .object import CurrentPropertyListMixIn
+
+# some debugging
+_debug = 0
+_log = ModuleLogger(globals())
+
+#
+#   CurrentLocalDate
+#
+
+class CurrentLocalDate(Property):
+
+    def __init__(self):
+        Property.__init__(self, 'localDate', Date, default=(), optional=True, mutable=False)
+
+    def ReadProperty(self, obj, arrayIndex=None):
+        if arrayIndex is not None:
+            raise ExecutionError(errorClass='property', errorCode='propertyIsNotAnArray')
+
+        # get the value
+        now = Date()
+        now.now()
+        return now.value
+
+    def WriteProperty(self, obj, value, arrayIndex=None, priority=None, direct=False):
+        raise ExecutionError(errorClass='property', errorCode='writeAccessDenied')
+
+#
+#   CurrentLocalTime
+#
+
+class CurrentLocalTime(Property):
+
+    def __init__(self):
+        Property.__init__(self, 'localTime', Time, default=(), optional=True, mutable=False)
+
+    def ReadProperty(self, obj, arrayIndex=None):
+        if arrayIndex is not None:
+            raise ExecutionError(errorClass='property', errorCode='propertyIsNotAnArray')
+
+        # get the value
+        now = Time()
+        now.now()
+        return now.value
+
+    def WriteProperty(self, obj, value, arrayIndex=None, priority=None, direct=False):
+        raise ExecutionError(errorClass='property', errorCode='writeAccessDenied')
+
+#
+#   CurrentProtocolServicesSupported
+#
+
+@bacpypes_debugging
+class CurrentProtocolServicesSupported(Property):
+
+    def __init__(self):
+        if _debug: CurrentProtocolServicesSupported._debug("__init__")
+        Property.__init__(self, 'protocolServicesSupported', ServicesSupported, default=None, optional=True, mutable=False)
+
+    def ReadProperty(self, obj, arrayIndex=None):
+        if _debug: CurrentProtocolServicesSupported._debug("ReadProperty %r %r", obj, arrayIndex)
+
+        # not an array
+        if arrayIndex is not None:
+            raise ExecutionError(errorClass='property', errorCode='propertyIsNotAnArray')
+
+        # return what the application says
+        return obj._app.get_services_supported()
+
+    def WriteProperty(self, obj, value, arrayIndex=None, priority=None, direct=False):
+        raise ExecutionError(errorClass='property', errorCode='writeAccessDenied')
+
+#
+#   LocalDeviceObject
+#
+
+@bacpypes_debugging
+class LocalDeviceObject(CurrentPropertyListMixIn, DeviceObject):
+
+    properties = [
+        CurrentLocalTime(),
+        CurrentLocalDate(),
+        CurrentProtocolServicesSupported(),
+        ]
+
+    defaultProperties = \
+        { 'maxApduLengthAccepted': 1024
+        , 'segmentationSupported': 'segmentedBoth'
+        , 'maxSegmentsAccepted': 16
+        , 'apduSegmentTimeout': 5000
+        , 'apduTimeout': 3000
+        , 'numberOfApduRetries': 3
+        }
+
+    def __init__(self, **kwargs):
+        if _debug: LocalDeviceObject._debug("__init__ %r", kwargs)
+
+        # fill in default property values not in kwargs
+        for attr, value in LocalDeviceObject.defaultProperties.items():
+            if attr not in kwargs:
+                kwargs[attr] = value
+
+        for key, value in kwargs.items():
+            if key.startswith("_"):
+                setattr(self, key, value)
+                del kwargs[key]
+
+        # check for registration
+        if self.__class__ not in registered_object_types.values():
+            if 'vendorIdentifier' not in kwargs:
+                raise RuntimeError("vendorIdentifier required to auto-register the LocalDeviceObject class")
+            register_object_type(self.__class__, vendor_id=kwargs['vendorIdentifier'])
+
+        # check for properties this class implements
+        if 'localDate' in kwargs:
+            raise RuntimeError("localDate is provided by LocalDeviceObject and cannot be overridden")
+        if 'localTime' in kwargs:
+            raise RuntimeError("localTime is provided by LocalDeviceObject and cannot be overridden")
+        if 'protocolServicesSupported' in kwargs:
+            raise RuntimeError("protocolServicesSupported is provided by LocalDeviceObject and cannot be overridden")
+
+        # the object identifier is required for the object list
+        if 'objectIdentifier' not in kwargs:
+            raise RuntimeError("objectIdentifier is required")
+
+        # coerce the object identifier
+        object_identifier = kwargs['objectIdentifier']
+        if isinstance(object_identifier, (int, long)):
+            object_identifier = ('device', object_identifier)
+
+        # the object list is provided
+        if 'objectList' in kwargs:
+            raise RuntimeError("objectList is provided by LocalDeviceObject and cannot be overridden")
+        kwargs['objectList'] = ArrayOf(ObjectIdentifier)([object_identifier])
+
+        # check for a minimum value
+        if kwargs['maxApduLengthAccepted'] < 50:
+            raise ValueError("invalid max APDU length accepted")
+
+        # dump the updated attributes
+        if _debug: LocalDeviceObject._debug("    - updated kwargs: %r", kwargs)
+
+        # proceed as usual
+        super(LocalDeviceObject, self).__init__(**kwargs)
+
diff --git a/py27/bacpypes/local/file.py b/py27/bacpypes/local/file.py
new file mode 100644
index 00000000..8007bef4
--- /dev/null
+++ b/py27/bacpypes/local/file.py
@@ -0,0 +1,89 @@
+#!/usr/bin/env python
+
+from ..debugging import bacpypes_debugging, ModuleLogger
+from ..capability import Capability
+
+from ..object import FileObject
+
+from ..apdu import AtomicReadFileACK, AtomicReadFileACKAccessMethodChoice, \
+    AtomicReadFileACKAccessMethodRecordAccess, \
+    AtomicReadFileACKAccessMethodStreamAccess, \
+    AtomicWriteFileACK
+from ..errors import ExecutionError, MissingRequiredParameter
+
+# some debugging
+_debug = 0
+_log = ModuleLogger(globals())
+
+#
+#   Local Record Access File Object Type
+#
+
+@bacpypes_debugging
+class LocalRecordAccessFileObject(FileObject):
+
+    def __init__(self, **kwargs):
+        """ Initialize a record accessed file object. """
+        if _debug:
+            LocalRecordAccessFileObject._debug("__init__ %r",
+                kwargs,
+                )
+
+        # verify the file access method or provide it
+        if 'fileAccessMethod' in kwargs:
+            if kwargs['fileAccessMethod'] != 'recordAccess':
+                raise ValueError("inconsistent file access method")
+        else:
+            kwargs['fileAccessMethod'] = 'recordAccess'
+
+        # continue with initialization
+        FileObject.__init__(self, **kwargs)
+
+    def __len__(self):
+        """ Return the number of records. """
+        raise NotImplementedError("__len__")
+
+    def read_record(self, start_record, record_count):
+        """ Read a number of records starting at a specific record. """
+        raise NotImplementedError("read_record")
+
+    def write_record(self, start_record, record_count, record_data):
+        """ Write a number of records, starting at a specific record. """
+        raise NotImplementedError("write_record")
+
+#
+#   Local Stream Access File Object Type
+#
+
+@bacpypes_debugging
+class LocalStreamAccessFileObject(FileObject):
+
+    def __init__(self, **kwargs):
+        """ Initialize a stream accessed file object. """
+        if _debug:
+            LocalStreamAccessFileObject._debug("__init__ %r",
+                kwargs,
+                )
+
+        # verify the file access method or provide it
+        if 'fileAccessMethod' in kwargs:
+            if kwargs['fileAccessMethod'] != 'streamAccess':
+                raise ValueError("inconsistent file access method")
+        else:
+            kwargs['fileAccessMethod'] = 'streamAccess'
+
+        # continue with initialization
+        FileObject.__init__(self, **kwargs)
+
+    def __len__(self):
+        """ Return the number of octets in the file. """
+        raise NotImplementedError("write_file")
+
+    def read_stream(self, start_position, octet_count):
+        """ Read a chunk of data out of the file. """
+        raise NotImplementedError("read_stream")
+
+    def write_stream(self, start_position, data):
+        """ Write a number of octets, starting at a specific offset. """
+        raise NotImplementedError("write_stream")
+
diff --git a/py27/bacpypes/local/object.py b/py27/bacpypes/local/object.py
new file mode 100644
index 00000000..3078b9c6
--- /dev/null
+++ b/py27/bacpypes/local/object.py
@@ -0,0 +1,68 @@
+#!/usr/bin/env python
+
+from ..debugging import bacpypes_debugging, ModuleLogger
+
+from ..basetypes import PropertyIdentifier
+from ..constructeddata import ArrayOf
+
+from ..errors import ExecutionError
+from ..object import Property, Object
+
+# some debugging
+_debug = 0
+_log = ModuleLogger(globals())
+
+# handy reference
+ArrayOfPropertyIdentifier = ArrayOf(PropertyIdentifier)
+
+#
+#   CurrentPropertyList
+#
+
+@bacpypes_debugging
+class CurrentPropertyList(Property):
+
+    def __init__(self):
+        if _debug: CurrentPropertyList._debug("__init__")
+        Property.__init__(self, 'propertyList', ArrayOfPropertyIdentifier, default=None, optional=True, mutable=False)
+
+    def ReadProperty(self, obj, arrayIndex=None):
+        if _debug: CurrentPropertyList._debug("ReadProperty %r %r", obj, arrayIndex)
+
+        # make a list of the properties that have values
+        property_list = [k for k, v in obj._values.items()
+            if v is not None
+                and k not in ('objectName', 'objectType', 'objectIdentifier', 'propertyList')
+            ]
+        if _debug: CurrentPropertyList._debug("    - property_list: %r", property_list)
+
+        # sort the list so it's stable
+        property_list.sort()
+
+        # asking for the whole thing
+        if arrayIndex is None:
+            return ArrayOfPropertyIdentifier(property_list)
+
+        # asking for the length
+        if arrayIndex == 0:
+            return len(property_list)
+
+        # asking for an index
+        if arrayIndex > len(property_list):
+            raise ExecutionError(errorClass='property', errorCode='invalidArrayIndex')
+        return property_list[arrayIndex - 1]
+
+    def WriteProperty(self, obj, value, arrayIndex=None, priority=None, direct=False):
+        raise ExecutionError(errorClass='property', errorCode='writeAccessDenied')
+
+#
+#   CurrentPropertyListMixIn
+#
+
+@bacpypes_debugging
+class CurrentPropertyListMixIn(Object):
+
+    properties = [
+        CurrentPropertyList(),
+        ]
+

From 9605bcdc901bbcf5992b72b0f313765571c18484 Mon Sep 17 00:00:00 2001
From: Joel Bender <joel@betelgeuse>
Date: Tue, 27 Feb 2018 16:53:17 -0500
Subject: [PATCH 18/21] copy in schedule object

---
 py27/bacpypes/local/__init__.py |   1 +
 py27/bacpypes/local/schedule.py | 563 ++++++++++++++++++++++++++++++++
 2 files changed, 564 insertions(+)
 create mode 100644 py27/bacpypes/local/schedule.py

diff --git a/py27/bacpypes/local/__init__.py b/py27/bacpypes/local/__init__.py
index 3b4de283..277c3c76 100644
--- a/py27/bacpypes/local/__init__.py
+++ b/py27/bacpypes/local/__init__.py
@@ -7,4 +7,5 @@
 from . import object
 from . import device
 from . import file
+from . import schedule
 
diff --git a/py27/bacpypes/local/schedule.py b/py27/bacpypes/local/schedule.py
new file mode 100644
index 00000000..5f5a53d9
--- /dev/null
+++ b/py27/bacpypes/local/schedule.py
@@ -0,0 +1,563 @@
+#!/usr/bin/env python
+
+"""
+Local Schedule Object
+"""
+
+import sys
+import calendar
+from time import mktime as _mktime
+
+from ..debugging import bacpypes_debugging, ModuleLogger
+
+from ..core import deferred
+from ..task import OneShotTask
+
+from ..primitivedata import Atomic, Null, Unsigned, Date, Time
+from ..constructeddata import Array
+from ..object import get_datatype, ScheduleObject
+
+from .object import CurrentPropertyListMixIn
+
+# some debugging
+_debug = 0
+_log = ModuleLogger(globals())
+
+#
+#   match_date
+#
+
+def match_date(date, date_pattern):
+    """
+    Match a specific date, a four-tuple with no special values, with a date
+    pattern, four-tuple possibly having special values.
+    """
+    # unpack the date and pattern
+    year, month, day, day_of_week = date
+    year_p, month_p, day_p, day_of_week_p = date_pattern
+
+    # check the year
+    if year_p == 255:
+        # any year
+        pass
+    elif year != year_p:
+        # specific year
+        return False
+
+    # check the month
+    if month_p == 255:
+        # any month
+        pass
+    elif month_p == 13:
+        # odd months
+        if (month % 2) == 0:
+            return False
+    elif month_p == 14:
+        # even months
+        if (month % 2) == 1:
+            return False
+    elif month != month_p:
+        # specific month
+        return False
+
+    # check the day
+    if day_p == 255:
+        # any day
+        pass
+    elif day_p == 32:
+        # last day of the month
+        last_day = calendar.monthrange(year + 1900, month)[1]
+        if day != last_day:
+            return False
+    elif day_p == 33:
+        # odd days of the month
+        if (day % 2) == 0:
+            return False
+    elif day_p == 34:
+        # even days of the month
+        if (day % 2) == 1:
+            return False
+    elif day != day_p:
+        # specific day
+        return False
+
+    # check the day of week
+    if day_of_week_p == 255:
+        # any day of the week
+        pass
+    elif day_of_week != day_of_week_p:
+        # specific day of the week
+        return False
+
+    # all tests pass
+    return True
+
+#
+#   match_date_range
+#
+
+def match_date_range(date, date_range):
+    """
+    Match a specific date, a four-tuple with no special values, with a DateRange
+    object which as a start date and end date.
+    """
+    return (date[:3] >= date_range.startDate[:3]) \
+        and (date[:3] <= date_range.endDate[:3])
+
+#
+#   match_weeknday
+#
+
+def match_weeknday(date, weeknday):
+    """
+    Match a specific date, a four-tuple with no special values, with a
+    BACnetWeekNDay, an octet string with three (unsigned) octets.
+    """
+    # unpack the date
+    year, month, day, day_of_week = date
+    last_day = calendar.monthrange(year + 1900, month)[1]
+
+    # unpack the date pattern octet string
+    if sys.version_info[0] == 2:
+        weeknday_unpacked = [ord(c) for c in weeknday]
+    elif sys.version_info[0] == 3:
+        weeknday_unpacked = [c for c in weeknday]
+    else:
+        raise NotImplementedError("match_weeknday requires Python 2.x or 3.x")
+    month_p, week_of_month_p, day_of_week_p = weeknday_unpacked
+
+    # check the month
+    if month_p == 255:
+        # any month
+        pass
+    elif month_p == 13:
+        # odd months
+        if (month % 2) == 0:
+            return False
+    elif month_p == 14:
+        # even months
+        if (month % 2) == 1:
+            return False
+    elif month != month_p:
+        # specific month
+        return False
+
+    # check the week of the month
+    if week_of_month_p == 255:
+        # any week
+        pass
+    elif week_of_month_p == 1:
+        # days numbered 1-7
+        if (day > 7):
+            return False
+    elif week_of_month_p == 2:
+        # days numbered 8-14
+        if (day < 8) or (day > 14):
+            return False
+    elif week_of_month_p == 3:
+        # days numbered 15-21
+        if (day < 15) or (day > 21):
+            return False
+    elif week_of_month_p == 4:
+        # days numbered 22-28
+        if (day < 22) or (day > 28):
+            return False
+    elif week_of_month_p == 5:
+        # days numbered 29-31
+        if (day < 29) or (day > 31):
+            return False
+    elif week_of_month_p == 6:
+        # last 7 days of this month
+        if (day < last_day - 6):
+            return False
+    elif week_of_month_p == 7:
+        # any of the 7 days prior to the last 7 days of this month
+        if (day < last_day - 13) or (day > last_day - 7):
+            return False
+    elif week_of_month_p == 8:
+        # any of the 7 days prior to the last 14 days of this month
+        if (day < last_day - 20) or (day > last_day - 14):
+            return False
+    elif week_of_month_p == 9:
+        # any of the 7 days prior to the last 21 days of this month
+        if (day < last_day - 27) or (day > last_day - 21):
+            return False
+
+    # check the day
+    if day_of_week_p == 255:
+        # any day
+        pass
+    elif day_of_week != day_of_week_p:
+        # specific day
+        return False
+
+    # all tests pass
+    return True
+
+#
+#   date_in_calendar_entry
+#
+
+@bacpypes_debugging
+def date_in_calendar_entry(date, calendar_entry):
+    if _debug: date_in_calendar_entry._debug("date_in_calendar_entry %r %r", date, calendar_entry)
+
+    match = False
+    if calendar_entry.date:
+        match = match_date(date, calendar_entry.date)
+    elif calendar_entry.dateRange:
+        match = match_date_range(date, calendar_entry.dateRange)
+    elif calendar_entry.weekNDay:
+        match = match_weeknday(date, calendar_entry.weekNDay)
+    else:
+        raise RuntimeError("")
+    if _debug: date_in_calendar_entry._debug("    - match: %r", match)
+
+    return match
+
+#
+#   datetime_to_time
+#
+
+def datetime_to_time(date, time):
+    """Take the date and time 4-tuples and return the time in seconds since
+    the epoch as a floating point number."""
+    if (255 in date) or (255 in time):
+        raise RuntimeError("specific date and time required")
+
+    time_tuple = (
+        date[0]+1900, date[1], date[2],
+        time[0], time[1], time[2],
+        0, 0, -1,
+        )
+    return _mktime(time_tuple)
+
+#
+#   LocalScheduleObject
+#
+
+@bacpypes_debugging
+class LocalScheduleObject(CurrentPropertyListMixIn, ScheduleObject):
+
+    def __init__(self, **kwargs):
+        if _debug: LocalScheduleObject._debug("__init__ %r", kwargs)
+
+        # make sure present value was provided
+        if 'presentValue' not in kwargs:
+            raise RuntimeError("presentValue required")
+        if not isinstance(kwargs['presentValue'], Atomic):
+            raise TypeError("presentValue must be an Atomic value")
+
+        # continue initialization
+        ScheduleObject.__init__(self, **kwargs)
+
+        # attach an interpreter task
+        self._task = LocalScheduleInterpreter(self)
+
+        # add some monitors to check the reliability if these change
+        for prop in ('weeklySchedule', 'exceptionSchedule', 'scheduleDefault'):
+            self._property_monitors[prop].append(self._check_reliability)
+
+        # check it now
+        self._check_reliability()
+
+    def _check_reliability(self, old_value=None, new_value=None):
+        """This function is called when the object is created and after
+        one of its configuration properties has changed.  The new and old value
+        parameters are ignored, this is called after the property has been
+        changed and this is only concerned with the current value."""
+        if _debug: LocalScheduleObject._debug("_check_reliability %r %r", old_value, new_value)
+
+        try:
+            schedule_default = self.scheduleDefault
+
+            if schedule_default is None:
+                raise ValueError("scheduleDefault expected")
+            if not isinstance(schedule_default, Atomic):
+                raise TypeError("scheduleDefault must be an instance of an atomic type")
+
+            schedule_datatype = schedule_default.__class__
+            if _debug: LocalScheduleObject._debug("    - schedule_datatype: %r", schedule_datatype)
+
+            if (self.weeklySchedule is None) and (self.exceptionSchedule is None):
+                raise ValueError("schedule required")
+
+            # check the weekly schedule values
+            if self.weeklySchedule:
+                for daily_schedule in self.weeklySchedule:
+                    for time_value in daily_schedule.daySchedule:
+                        if _debug: LocalScheduleObject._debug("    - daily time_value: %r", time_value)
+                        if time_value is None:
+                            pass
+                        elif not isinstance(time_value.value, (Null, schedule_datatype)):
+                            if _debug: LocalScheduleObject._debug("    - wrong type: expected %r, got %r",
+                                schedule_datatype,
+                                time_value.__class__,
+                                )
+                            raise TypeError("wrong type")
+                        elif 255 in time_value.time:
+                            if _debug: LocalScheduleObject._debug("    - wildcard in time")
+                            raise ValueError("must be a specific time")
+
+            # check the exception schedule values
+            if self.exceptionSchedule:
+                for special_event in self.exceptionSchedule:
+                    for time_value in special_event.listOfTimeValues:
+                        if _debug: LocalScheduleObject._debug("    - special event time_value: %r", time_value)
+                        if time_value is None:
+                            pass
+                        elif not isinstance(time_value.value, (Null, schedule_datatype)):
+                            if _debug: LocalScheduleObject._debug("    - wrong type: expected %r, got %r",
+                                schedule_datatype,
+                                time_value.__class__,
+                                )
+                            raise TypeError("wrong type")
+
+            # check list of object property references
+            obj_prop_refs = self.listOfObjectPropertyReferences
+            if obj_prop_refs:
+                for obj_prop_ref in obj_prop_refs:
+                    if obj_prop_ref.deviceIdentifier:
+                        raise RuntimeError("no external references")
+
+                    # get the datatype of the property to be written
+                    obj_type = obj_prop_ref.objectIdentifier[0]
+                    datatype = get_datatype(obj_type, obj_prop_ref.propertyIdentifier)
+                    if _debug: LocalScheduleObject._debug("    - datatype: %r", datatype)
+
+                    if issubclass(datatype, Array) and (obj_prop_ref.propertyArrayIndex is not None):
+                        if obj_prop_ref.propertyArrayIndex == 0:
+                            datatype = Unsigned
+                        else:
+                            datatype = datatype.subtype
+                        if _debug: LocalScheduleObject._debug("    - datatype: %r", datatype)
+
+                    if datatype is not schedule_datatype:
+                        if _debug: LocalScheduleObject._debug("    - wrong type: expected %r, got %r",
+                            datatype,
+                            schedule_datatype,
+                            )
+                        raise TypeError("wrong type")
+
+            # all good
+            self.reliability = 'noFaultDetected'
+            if _debug: LocalScheduleObject._debug("    - no fault detected")
+
+        except Exception as err:
+            if _debug: LocalScheduleObject._debug("    - exception: %r", err)
+            self.reliability = 'configurationError'
+
+#
+#   LocalScheduleInterpreter
+#
+
+@bacpypes_debugging
+class LocalScheduleInterpreter(OneShotTask):
+
+    def __init__(self, sched_obj):
+        if _debug: LocalScheduleInterpreter._debug("__init__ %r", sched_obj)
+        OneShotTask.__init__(self)
+
+        # reference the schedule object to update
+        self.sched_obj = sched_obj
+
+        # add a monitor for the present value
+        sched_obj._property_monitors['presentValue'].append(self.present_value_changed)
+
+        # call to interpret the schedule
+        deferred(self.process_task)
+
+    def present_value_changed(self, old_value, new_value):
+        """This function is called when the presentValue of the local schedule
+        object has changed, both internally by this interpreter, or externally
+        by some client using WriteProperty."""
+        if _debug: LocalScheduleInterpreter._debug("present_value_changed %s %s", old_value, new_value)
+
+        # if this hasn't been added to an application, there's nothing to do
+        if not self.sched_obj._app:
+            if _debug: LocalScheduleInterpreter._debug("    - no application")
+            return
+
+        # process the list of [device] object property [array index] references
+        obj_prop_refs = self.sched_obj.listOfObjectPropertyReferences
+        if not obj_prop_refs:
+            if _debug: LocalScheduleInterpreter._debug("    - no writes defined")
+            return
+
+        # primitive values just set the value part
+        new_value = new_value.value
+
+        # loop through the writes
+        for obj_prop_ref in obj_prop_refs:
+            if obj_prop_ref.deviceIdentifier:
+                if _debug: LocalScheduleInterpreter._debug("    - no externals")
+                continue
+
+            # get the object from the application
+            obj = self.sched_obj._app.get_object_id(obj_prop_ref.objectIdentifier)
+            if not obj:
+                if _debug: LocalScheduleInterpreter._debug("    - no object")
+                continue
+
+            # try to change the value
+            try:
+                obj.WriteProperty(
+                    obj_prop_ref.propertyIdentifier,
+                    new_value,
+                    arrayIndex=obj_prop_ref.propertyArrayIndex,
+                    priority=self.sched_obj.priorityForWriting,
+                    )
+                if _debug: LocalScheduleInterpreter._debug("    - success")
+            except Exception as err:
+                if _debug: LocalScheduleInterpreter._debug("    - error: %r", err)
+
+    def process_task(self):
+        if _debug: LocalScheduleInterpreter._debug("process_task(%s)", self.sched_obj.objectName)
+
+        # check for a valid configuration
+        if self.sched_obj.reliability != 'noFaultDetected':
+            if _debug: LocalScheduleInterpreter._debug("    - fault detected")
+            return
+
+        # get the date and time from the device object in case it provides
+        # some custom functionality
+        if self.sched_obj._app and self.sched_obj._app.localDevice:
+            current_date = self.sched_obj._app.localDevice.localDate
+            if _debug: LocalScheduleInterpreter._debug("    - current_date: %r", current_date)
+
+            current_time = self.sched_obj._app.localDevice.localTime
+            if _debug: LocalScheduleInterpreter._debug("    - current_time: %r", current_time)
+        else:
+            # get the current date and time, as provided by the task manager
+            current_date = Date().now().value
+            if _debug: LocalScheduleInterpreter._debug("    - current_date: %r", current_date)
+
+            current_time = Time().now().value
+            if _debug: LocalScheduleInterpreter._debug("    - current_time: %r", current_time)
+
+        # evaluate the time
+        current_value, next_transition = self.eval(current_date, current_time)
+        if _debug: LocalScheduleInterpreter._debug("    - current_value, next_transition: %r, %r", current_value, next_transition)
+
+        ### set the present value
+        self.sched_obj.presentValue = current_value
+
+        # compute the time of the next transition
+        transition_time = datetime_to_time(current_date, next_transition)
+
+        # install this to run again
+        self.install_task(transition_time)
+
+    def eval(self, edate, etime):
+        """Evaluate the schedule according to the provided date and time and
+        return the appropriate present value, or None if not in the effective
+        period."""
+        if _debug: LocalScheduleInterpreter._debug("eval %r %r", edate, etime)
+
+        # reference the schedule object
+        sched_obj = self.sched_obj
+        if _debug: LocalScheduleInterpreter._debug("    sched_obj: %r", sched_obj)
+
+        # verify the date falls in the effective period
+        if not match_date_range(edate, sched_obj.effectivePeriod):
+            return None
+
+        # the event priority is a list of values that are in effect for
+        # exception schedules with the special event priority, see 135.1-2013
+        # clause 7.3.2.23.10.3.8, Revision 4 Event Priority Test
+        event_priority = [None] * 16
+
+        next_day = (24, 0, 0, 0)
+        next_transition_time = [None] * 16
+
+        # check the exception schedule values
+        if sched_obj.exceptionSchedule:
+            for special_event in sched_obj.exceptionSchedule:
+                if _debug: LocalScheduleInterpreter._debug("    - special_event: %r", special_event)
+
+                # check the special event period
+                special_event_period = special_event.period
+                if special_event_period is None:
+                    raise RuntimeError("special event period required")
+
+                match = False
+                calendar_entry = special_event_period.calendarEntry
+                if calendar_entry:
+                    if _debug: LocalScheduleInterpreter._debug("    - calendar_entry: %r", calendar_entry)
+                    match = date_in_calendar_entry(edate, calendar_entry)
+                else:
+                    # get the calendar object from the application
+                    calendar_object = sched_obj._app.get_object_id(special_event_period.calendarReference)
+                    if not calendar_object:
+                        raise RuntimeError("invalid calendar object reference")
+                    if _debug: LocalScheduleInterpreter._debug("    - calendar_object: %r", calendar_object)
+
+                    for calendar_entry in calendar_object.dateList:
+                        if _debug: LocalScheduleInterpreter._debug("    - calendar_entry: %r", calendar_entry)
+                        match = date_in_calendar_entry(edate, calendar_entry)
+                        if match:
+                            break
+
+                # didn't match the period, try the next special event
+                if not match:
+                    if _debug: LocalScheduleInterpreter._debug("    - no matching calendar entry")
+                    continue
+
+                # event priority array index
+                priority = special_event.eventPriority - 1
+                if _debug: LocalScheduleInterpreter._debug("    - priority: %r", priority)
+
+                # look for all of the possible times
+                for time_value in special_event.listOfTimeValues:
+                    tval = time_value.time
+                    if tval <= etime:
+                        if isinstance(time_value.value, Null):
+                            if _debug: LocalScheduleInterpreter._debug("    - relinquish exception @ %r", tval)
+                            event_priority[priority] = None
+                            next_transition_time[priority] = None
+                        else:
+                            if _debug: LocalScheduleInterpreter._debug("    - consider exception @ %r", tval)
+                            event_priority[priority] = time_value.value
+                            next_transition_time[priority] = next_day
+                    else:
+                        next_transition_time[priority] = tval
+                        break
+
+        # assume the next transition will be at the start of the next day
+        earliest_transition = next_day
+
+        # check if any of the special events came up with something
+        for priority_value, next_transition in zip(event_priority, next_transition_time):
+            if next_transition is not None:
+                earliest_transition = min(earliest_transition, next_transition)
+            if priority_value is not None:
+                if _debug: LocalScheduleInterpreter._debug("    - priority_value: %r", priority_value)
+                return priority_value, earliest_transition
+
+        # start out with the default
+        daily_value = sched_obj.scheduleDefault
+
+        # check the daily schedule
+        if sched_obj.weeklySchedule:
+            daily_schedule = sched_obj.weeklySchedule[edate[3]]
+            if _debug: LocalScheduleInterpreter._debug("    - daily_schedule: %r", daily_schedule)
+
+            # look for all of the possible times
+            for time_value in daily_schedule.daySchedule:
+                if _debug: LocalScheduleInterpreter._debug("    - time_value: %r", time_value)
+
+                tval = time_value.time
+                if tval <= etime:
+                    if isinstance(time_value.value, Null):
+                        if _debug: LocalScheduleInterpreter._debug("    - back to normal @ %r", tval)
+                        daily_value = sched_obj.scheduleDefault
+                    else:
+                        if _debug: LocalScheduleInterpreter._debug("    - new value @ %r", tval)
+                        daily_value = time_value.value
+                else:
+                    earliest_transition = min(earliest_transition, tval)
+                    break
+
+        # return what was matched, if anything
+        return daily_value, earliest_transition
+

From 3c5798d1ea8429517a56405b4f9527d2c9b08498 Mon Sep 17 00:00:00 2001
From: Joel Bender <joel@carrickbender.com>
Date: Tue, 3 Apr 2018 00:53:45 -0400
Subject: [PATCH 19/21] update the sample code to use the library

---
 samples/LocalScheduleObject.py | 511 +--------------------------------
 1 file changed, 9 insertions(+), 502 deletions(-)

diff --git a/samples/LocalScheduleObject.py b/samples/LocalScheduleObject.py
index 788285c7..20e6c48b 100644
--- a/samples/LocalScheduleObject.py
+++ b/samples/LocalScheduleObject.py
@@ -1,29 +1,26 @@
 #!/usr/bin/env python
 
 """
-Local Schedule Object
+This application creates a series of Local Schedule Objects and then prompts
+to test dates and times.
 """
 
-import sys
-import calendar
-from time import mktime as _mktime, localtime as _localtime
+from time import localtime as _localtime
 
 from bacpypes.debugging import bacpypes_debugging, ModuleLogger, xtob
 from bacpypes.consolelogging import ConfigArgumentParser
 from bacpypes.consolecmd import ConsoleCmd
 
-from bacpypes.core import run, deferred
-from bacpypes.task import OneShotTask
+from bacpypes.core import run
 
-from bacpypes.primitivedata import Atomic, Null, Integer, Unsigned, Real, Date, Time, CharacterString
-from bacpypes.constructeddata import Array, ArrayOf, SequenceOf, AnyAtomic
+from bacpypes.primitivedata import Null, Integer, Real, Date, Time, CharacterString
+from bacpypes.constructeddata import ArrayOf, SequenceOf
 from bacpypes.basetypes import CalendarEntry, DailySchedule, DateRange, \
     DeviceObjectPropertyReference, SpecialEvent, SpecialEventPeriod, TimeValue
-from bacpypes.object import register_object_type, get_datatype, WritableProperty, ScheduleObject
 
 from bacpypes.app import BIPSimpleApplication
-from bacpypes.local.object import CurrentPropertyListMixIn
 from bacpypes.local.device import LocalDeviceObject
+from bacpypes.local.schedule import LocalScheduleObject
 
 # some debugging
 _debug = 0
@@ -32,491 +29,6 @@
 # globals
 schedule_objects = []
 
-#
-#   match_date
-#
-
-def match_date(date, date_pattern):
-    """
-    Match a specific date, a four-tuple with no special values, with a date
-    pattern, four-tuple possibly having special values.
-    """
-    # unpack the date and pattern
-    year, month, day, day_of_week = date
-    year_p, month_p, day_p, day_of_week_p = date_pattern
-
-    # check the year
-    if year_p == 255:
-        # any year
-        pass
-    elif year != year_p:
-        # specific year
-        return False
-
-    # check the month
-    if month_p == 255:
-        # any month
-        pass
-    elif month_p == 13:
-        # odd months
-        if (month % 2) == 0:
-            return False
-    elif month_p == 14:
-        # even months
-        if (month % 2) == 1:
-            return False
-    elif month != month_p:
-        # specific month
-        return False
-
-    # check the day
-    if day_p == 255:
-        # any day
-        pass
-    elif day_p == 32:
-        # last day of the month
-        last_day = calendar.monthrange(year + 1900, month)[1]
-        if day != last_day:
-            return False
-    elif day_p == 33:
-        # odd days of the month
-        if (day % 2) == 0:
-            return False
-    elif day_p == 34:
-        # even days of the month
-        if (day % 2) == 1:
-            return False
-    elif day != day_p:
-        # specific day
-        return False
-
-    # check the day of week
-    if day_of_week_p == 255:
-        # any day of the week
-        pass
-    elif day_of_week != day_of_week_p:
-        # specific day of the week
-        return False
-
-    # all tests pass
-    return True
-
-#
-#   match_date_range
-#
-
-def match_date_range(date, date_range):
-    """
-    Match a specific date, a four-tuple with no special values, with a DateRange
-    object which as a start date and end date.
-    """
-    return (date[:3] >= date_range.startDate[:3]) \
-        and (date[:3] <= date_range.endDate[:3])
-
-#
-#   match_weeknday
-#
-
-def match_weeknday(date, weeknday):
-    """
-    Match a specific date, a four-tuple with no special values, with a
-    BACnetWeekNDay, an octet string with three (unsigned) octets.
-    """
-    # unpack the date
-    year, month, day, day_of_week = date
-    last_day = calendar.monthrange(year + 1900, month)[1]
-
-    # unpack the date pattern octet string
-    if sys.version_info[0] == 2:
-        weeknday_unpacked = [ord(c) for c in weeknday]
-    elif sys.version_info[0] == 3:
-        weeknday_unpacked = [c for c in weeknday]
-    else:
-        raise NotImplementedError("match_weeknday requires Python 2.x or 3.x")
-    month_p, week_of_month_p, day_of_week_p = weeknday_unpacked
-
-    # check the month
-    if month_p == 255:
-        # any month
-        pass
-    elif month_p == 13:
-        # odd months
-        if (month % 2) == 0:
-            return False
-    elif month_p == 14:
-        # even months
-        if (month % 2) == 1:
-            return False
-    elif month != month_p:
-        # specific month
-        return False
-
-    # check the week of the month
-    if week_of_month_p == 255:
-        # any week
-        pass
-    elif week_of_month_p == 1:
-        # days numbered 1-7
-        if (day > 7):
-            return False
-    elif week_of_month_p == 2:
-        # days numbered 8-14
-        if (day < 8) or (day > 14):
-            return False
-    elif week_of_month_p == 3:
-        # days numbered 15-21
-        if (day < 15) or (day > 21):
-            return False
-    elif week_of_month_p == 4:
-        # days numbered 22-28
-        if (day < 22) or (day > 28):
-            return False
-    elif week_of_month_p == 5:
-        # days numbered 29-31
-        if (day < 29) or (day > 31):
-            return False
-    elif week_of_month_p == 6:
-        # last 7 days of this month
-        if (day < last_day - 6):
-            return False
-    elif week_of_month_p == 7:
-        # any of the 7 days prior to the last 7 days of this month
-        if (day < last_day - 13) or (day > last_day - 7):
-            return False
-    elif week_of_month_p == 8:
-        # any of the 7 days prior to the last 14 days of this month
-        if (day < last_day - 20) or (day > last_day - 14):
-            return False
-    elif week_of_month_p == 9:
-        # any of the 7 days prior to the last 21 days of this month
-        if (day < last_day - 27) or (day > last_day - 21):
-            return False
-
-    # check the day
-    if day_of_week_p == 255:
-        # any day
-        pass
-    elif day_of_week != day_of_week_p:
-        # specific day
-        return False
-
-    # all tests pass
-    return True
-
-#
-#   date_in_calendar_entry
-#
-
-@bacpypes_debugging
-def date_in_calendar_entry(date, calendar_entry):
-    if _debug: date_in_calendar_entry._debug("date_in_calendar_entry %r %r", date, calendar_entry)
-
-    match = False
-    if calendar_entry.date:
-        match = match_date(date, calendar_entry.date)
-    elif calendar_entry.dateRange:
-        match = match_date_range(date, calendar_entry.dateRange)
-    elif calendar_entry.weekNDay:
-        match = match_weeknday(date, calendar_entry.weekNDay)
-    else:
-        raise RuntimeError("")
-    if _debug: date_in_calendar_entry._debug("    - match: %r", match)
-
-    return match
-
-#
-#   datetime_to_time
-#
-
-def datetime_to_time(date, time):
-    """Take the date and time 4-tuples and return the time in seconds since
-    the epoch as a floating point number."""
-    if (255 in date) or (255 in time):
-        raise RuntimeError("specific date and time required")
-
-    time_tuple = (
-        date[0]+1900, date[1], date[2],
-        time[0], time[1], time[2],
-        0, 0, -1,
-        )
-    return _mktime(time_tuple)
-
-#
-#   LocalScheduleObject
-#
-
-@bacpypes_debugging
-@register_object_type(vendor_id=999)
-class LocalScheduleObject(CurrentPropertyListMixIn, ScheduleObject):
-
-    properties = [
-        WritableProperty('presentValue', AnyAtomic),
-        ]
-
-    def __init__(self, **kwargs):
-        if _debug: LocalScheduleObject._debug("__init__ %r", kwargs)
-        ScheduleObject.__init__(self, **kwargs)
-
-        # attach an interpreter task
-        self._task = LocalScheduleInterpreter(self)
-
-        # add some monitors
-        for prop in ('weeklySchedule', 'exceptionSchedule', 'scheduleDefault'):
-            self._property_monitors[prop].append(self._check_reliability)
-
-        # check it now
-        self._check_reliability()
-
-    def _check_reliability(self, old_value=None, new_value=None):
-        """This function is called when the object is created and after
-        one of its configuration properties has changed.  The new and old value
-        parameters are ignored, this is called after the property has been
-        changed and this is only concerned with the current value."""
-        if _debug: LocalScheduleObject._debug("_check_reliability %r %r", old_value, new_value)
-
-        try:
-            schedule_default = self.scheduleDefault
-
-            if schedule_default is None:
-                raise ValueError("scheduleDefault expected")
-            if not isinstance(schedule_default, Atomic):
-                raise TypeError("scheduleDefault must be an instance of an atomic type")
-
-            if (self.weeklySchedule is None) and (self.exceptionSchedule is None):
-                raise ValueError("schedule required")
-
-            schedule_datatype = schedule_default.__class__
-            if _debug: LocalScheduleObject._debug("    - schedule_datatype: %r", schedule_datatype)
-
-            # check the weekly schedule values
-            if self.weeklySchedule:
-                for daily_schedule in self.weeklySchedule:
-                    for time_value in daily_schedule.daySchedule:
-                        if _debug: LocalScheduleObject._debug("    - daily time_value: %r", time_value)
-                        if time_value is None:
-                            pass
-                        elif not isinstance(time_value.value, (Null, schedule_datatype)):
-                            if _debug: LocalScheduleObject._debug("    - wrong type: expected %r, got %r",
-                                schedule_datatype,
-                                time_value.__class__,
-                                )
-                            raise TypeError("wrong type")
-                        elif 255 in time_value.time:
-                            if _debug: LocalScheduleObject._debug("    - wildcard in time")
-                            raise ValueError("must be a specific time")
-
-            # check the exception schedule values
-            if self.exceptionSchedule:
-                for special_event in self.exceptionSchedule:
-                    for time_value in special_event.listOfTimeValues:
-                        if _debug: LocalScheduleObject._debug("    - special event time_value: %r", time_value)
-                        if time_value is None:
-                            pass
-                        elif not isinstance(time_value.value, (Null, schedule_datatype)):
-                            if _debug: LocalScheduleObject._debug("    - wrong type: expected %r, got %r",
-                                schedule_datatype,
-                                time_value.__class__,
-                                )
-                            raise TypeError("wrong type")
-
-            # check list of object property references
-            obj_prop_refs = self.listOfObjectPropertyReferences
-            if obj_prop_refs:
-                for obj_prop_ref in obj_prop_refs:
-                    obj_type = obj_prop_ref.objectIdentifier[0]
-
-                    # get the datatype of the property to be written
-                    datatype = get_datatype(obj_type, obj_prop_ref.propertyIdentifier)
-                    if _debug: LocalScheduleObject._debug("    - datatype: %r", datatype)
-
-                    if issubclass(datatype, Array) and (obj_prop_ref.propertyArrayIndex is not None):
-                        if obj_prop_ref.propertyArrayIndex == 0:
-                            datatype = Unsigned
-                        else:
-                            datatype = datatype.subtype
-                        if _debug: LocalScheduleObject._debug("    - datatype: %r", datatype)
-
-                    if datatype is not schedule_datatype:
-                        if _debug: LocalScheduleObject._debug("    - wrong type: expected %r, got %r",
-                            datatype,
-                            schedule_datatype,
-                            )
-                        raise TypeError("wrong type")
-
-            # all good
-            self.reliability = 'noFaultDetected'
-            if _debug: LocalScheduleObject._debug("    - no fault detected")
-
-        except Exception as err:
-            if _debug: LocalScheduleObject._debug("    - exception: %r", err)
-            self.reliability = 'configurationError'
-
-#
-#   LocalScheduleInterpreter
-#
-
-@bacpypes_debugging
-class LocalScheduleInterpreter(OneShotTask):
-
-    def __init__(self, sched_obj):
-        if _debug: LocalScheduleInterpreter._debug("__init__ %r", sched_obj)
-        OneShotTask.__init__(self)
-
-        # reference the schedule object to update
-        self.sched_obj = sched_obj
-
-        # add a monitor for the present value
-        sched_obj._property_monitors['presentValue'].append(self.present_value_changed)
-
-        # call to interpret the schedule
-        deferred(self.process_task)
-
-    def present_value_changed(self, old_value, new_value):
-        """This function is called when the presentValue of the local schedule
-        object has changed, both internally by this interpreter, or externally
-        by some client using WriteProperty."""
-        if _debug: LocalScheduleInterpreter._debug("present_value_changed %r %r", old_value, new_value)
-
-    def process_task(self):
-        if _debug: LocalScheduleInterpreter._debug("process_task(%s)", self.sched_obj.objectName)
-
-        # check for a valid configuration
-        if self.sched_obj.reliability != 'noFaultDetected':
-            return
-
-        # get the date and time from the device object
-        current_date = self.sched_obj._app.localDevice.localDate
-        if _debug: LocalScheduleInterpreter._debug("    - current_date: %r", current_date)
-
-        current_time = self.sched_obj._app.localDevice.localTime
-        if _debug: LocalScheduleInterpreter._debug("    - current_time: %r", current_time)
-
-        # evaluate the time
-        current_value, next_transition = self.eval(current_date, current_time)
-        if _debug: LocalScheduleInterpreter._debug("    - current_value, next_transition: %r, %r", current_value, next_transition)
-
-        # set the present value
-        self.sched_obj.presentValue = current_value
-
-        # compute the time of the next transition
-        transition_time = datetime_to_time(current_date, next_transition)
-
-        # install this to run again
-        self.install_task(transition_time)
-
-    def eval(self, edate, etime):
-        """Evaluate the schedule according to the provided date and time and
-        return the appropriate present value, or None if not in the effective
-        period."""
-        if _debug: LocalScheduleInterpreter._debug("eval %r %r", edate, etime)
-
-        # reference the schedule object
-        sched_obj = self.sched_obj
-        if _debug: LocalScheduleInterpreter._debug("    sched_obj: %r", sched_obj)
-
-        # verify the date falls in the effective period
-        if not match_date_range(edate, sched_obj.effectivePeriod):
-            return None
-
-        # the event priority is a list of values that are in effect for
-        # exception schedules with the special event priority, see 135.1-2013
-        # clause 7.3.2.23.10.3.8, Revision 4 Event Priority Test
-        event_priority = [None] * 16
-
-        next_day = (24, 0, 0, 0)
-        next_transition_time = [None] * 16
-
-        # check the exception schedule values
-        if sched_obj.exceptionSchedule:
-            for special_event in sched_obj.exceptionSchedule:
-                if _debug: LocalScheduleInterpreter._debug("    - special_event: %r", special_event)
-
-                # check the special event period
-                special_event_period = special_event.period
-                if special_event_period is None:
-                    raise RuntimeError("special event period required")
-
-                match = False
-                calendar_entry = special_event_period.calendarEntry
-                if calendar_entry:
-                    if _debug: LocalScheduleInterpreter._debug("    - calendar_entry: %r", calendar_entry)
-                    match = date_in_calendar_entry(edate, calendar_entry)
-                else:
-                    # get the calendar object from the application
-                    calendar_object = sched_obj._app.get_object_id(special_event_period.calendarReference)
-                    if not calendar_object:
-                        raise RuntimeError("invalid calendar object reference")
-                    if _debug: LocalScheduleInterpreter._debug("    - calendar_object: %r", calendar_object)
-
-                    for calendar_entry in calendar_object.dateList:
-                        if _debug: LocalScheduleInterpreter._debug("    - calendar_entry: %r", calendar_entry)
-                        match = date_in_calendar_entry(edate, calendar_entry)
-                        if match:
-                            break
-
-                # didn't match the period, try the next special event
-                if not match:
-                    if _debug: LocalScheduleInterpreter._debug("    - no matching calendar entry")
-                    continue
-
-                # event priority array index
-                priority = special_event.eventPriority - 1
-                if _debug: LocalScheduleInterpreter._debug("    - priority: %r", priority)
-
-                # look for all of the possible times
-                for time_value in special_event.listOfTimeValues:
-                    tval = time_value.time
-                    if tval <= etime:
-                        if isinstance(time_value.value, Null):
-                            if _debug: LocalScheduleInterpreter._debug("    - relinquish exception @ %r", tval)
-                            event_priority[priority] = None
-                            next_transition_time[priority] = None
-                        else:
-                            if _debug: LocalScheduleInterpreter._debug("    - consider exception @ %r", tval)
-                            event_priority[priority] = time_value.value
-                            next_transition_time[priority] = next_day
-                    else:
-                        next_transition_time[priority] = tval
-                        break
-
-        # assume the next transition will be at the start of the next day
-        earliest_transition = next_day
-
-        # check if any of the special events came up with something
-        for priority_value, next_transition in zip(event_priority, next_transition_time):
-            if next_transition is not None:
-                earliest_transition = min(earliest_transition, next_transition)
-            if priority_value is not None:
-                if _debug: LocalScheduleInterpreter._debug("    - priority_value: %r", priority_value)
-                return priority_value, earliest_transition
-
-        # start out with the default
-        daily_value = sched_obj.scheduleDefault
-
-        # check the daily schedule
-        if sched_obj.weeklySchedule:
-            daily_schedule = sched_obj.weeklySchedule[edate[3]]
-            if _debug: LocalScheduleInterpreter._debug("    - daily_schedule: %r", daily_schedule)
-
-            # look for all of the possible times
-            for time_value in daily_schedule.daySchedule:
-                if _debug: LocalScheduleInterpreter._debug("    - time_value: %r", time_value)
-
-                tval = time_value.time
-                if tval <= etime:
-                    if isinstance(time_value.value, Null):
-                        if _debug: LocalScheduleInterpreter._debug("    - back to normal @ %r", tval)
-                        daily_value = sched_obj.scheduleDefault
-                    else:
-                        if _debug: LocalScheduleInterpreter._debug("    - new value @ %r", tval)
-                        daily_value = time_value.value
-                else:
-                    earliest_transition = min(earliest_transition, tval)
-                    break
-
-        # return what was matched, if anything
-        return daily_value, earliest_transition
-
 #
 #   TestConsoleCmd
 #
@@ -634,8 +146,7 @@ def main():
     schedule_objects.append(so)
 
     #
-    #   A special schedule when the Year 2000 problem was supposed to collapse
-    #   systems, the panic clears ten minutes later when it didn't.
+    #   A special schedule to celebrate Friday.
     #
     so = LocalScheduleObject(
         objectIdentifier=('schedule', 3),
@@ -774,15 +285,12 @@ def main():
     this_application.add_object(so)
     schedule_objects.append(so)
 
-
+    # list of time values for every five minutes
     ltv = []
     for hr in range(24):
         for mn in range(0, 60, 5):
             ltv.append(TimeValue(time=(hr,mn,0,0), value=Integer(hr * 100 + mn)))
 
-    #
-    #   Every five minutes
-    #
     so = LocalScheduleObject(
         objectIdentifier=('schedule', 6),
         objectName='Schedule 6',
@@ -808,7 +316,6 @@ def main():
     this_application.add_object(so)
     schedule_objects.append(so)
 
-
     # make sure they are all there
     _log.debug("    - object list: %r", this_device.objectList)
 

From 46278c905b21af2bb99ee0706372c7a5c093d5c5 Mon Sep 17 00:00:00 2001
From: Joel Bender <joel@carrickbender.com>
Date: Tue, 3 Apr 2018 00:54:07 -0400
Subject: [PATCH 20/21] add some schedule object tests

---
 tests/__init__.py                         |   1 +
 tests/test_local/__init__.py              |   9 ++
 tests/test_local/test_local_schedule_1.py |  27 ++++++
 tests/test_local/test_local_schedule_2.py | 110 ++++++++++++++++++++++
 4 files changed, 147 insertions(+)
 create mode 100644 tests/test_local/__init__.py
 create mode 100644 tests/test_local/test_local_schedule_1.py
 create mode 100644 tests/test_local/test_local_schedule_2.py

diff --git a/tests/__init__.py b/tests/__init__.py
index ac78389f..89ed8435 100644
--- a/tests/__init__.py
+++ b/tests/__init__.py
@@ -24,4 +24,5 @@
 from . import test_bvll
 
 from . import test_service
+from . import test_local
 
diff --git a/tests/test_local/__init__.py b/tests/test_local/__init__.py
new file mode 100644
index 00000000..2af3de4e
--- /dev/null
+++ b/tests/test_local/__init__.py
@@ -0,0 +1,9 @@
+#!/usr/bin/python
+
+"""
+Test Local Schedule
+"""
+
+from . import test_local_schedule_1
+from . import test_local_schedule_2
+
diff --git a/tests/test_local/test_local_schedule_1.py b/tests/test_local/test_local_schedule_1.py
new file mode 100644
index 00000000..71f3dd90
--- /dev/null
+++ b/tests/test_local/test_local_schedule_1.py
@@ -0,0 +1,27 @@
+#!/usr/bin/python
+
+"""
+Test Local Schedule
+
+    so = LocalScheduleObject(
+        objectIdentifier=('schedule', 1),
+        objectName='Schedule 1',
+        presentValue=Integer(5),
+        effectivePeriod=DateRange(
+            startDate=(0, 1, 1, 1),
+            endDate=(254, 12, 31, 2),
+            ),
+        weeklySchedule=ArrayOf(DailySchedule)([
+            DailySchedule(
+                daySchedule=[
+                    TimeValue(time=(8,0,0,0), value=Integer(8)),
+                    TimeValue(time=(14,0,0,0), value=Null()),
+                    TimeValue(time=(17,0,0,0), value=Integer(42)),
+#                   TimeValue(time=(0,0,0,0), value=Null()),
+                    ]
+                ),
+            ] * 7),
+        scheduleDefault=Integer(0),
+        )
+"""
+
diff --git a/tests/test_local/test_local_schedule_2.py b/tests/test_local/test_local_schedule_2.py
new file mode 100644
index 00000000..c2177dfc
--- /dev/null
+++ b/tests/test_local/test_local_schedule_2.py
@@ -0,0 +1,110 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Test Local Schedule
+"""
+
+import unittest
+
+from bacpypes.debugging import bacpypes_debugging, ModuleLogger
+
+from bacpypes.primitivedata import Null, Real
+from bacpypes.constructeddata import ArrayOf
+from bacpypes.basetypes import DailySchedule, DateRange, \
+    DeviceObjectPropertyReference, TimeValue
+from bacpypes.object import register_object_type, \
+    WritableProperty, AnalogValueObject
+
+from bacpypes.app import Application
+from bacpypes.local.object import CurrentPropertyListMixIn
+from bacpypes.local.device import LocalDeviceObject
+from bacpypes.local.schedule import LocalScheduleObject
+
+from ..time_machine import reset_time_machine, run_time_machine
+
+# some debugging
+_debug = 0
+_log = ModuleLogger(globals())
+
+
+@register_object_type(vendor_id=999)
+class WritableAnalogValueObject(CurrentPropertyListMixIn, AnalogValueObject):
+
+    properties = [
+        WritableProperty('presentValue', Real),
+        ]
+
+
+@bacpypes_debugging
+class TestLocalSchedule(unittest.TestCase):
+
+    def test_local_schedule(self):
+        if _debug: TestLocalSchedule._debug("test_local_schedule")
+
+        # reset the time machine
+        reset_time_machine(start_time="1970-01-01")
+
+        # make a device object
+        this_device = LocalDeviceObject(
+            objectName="device 1",
+            objectIdentifier=('device', 1),
+            maxApduLengthAccepted=1024,
+            segmentationSupported='segmentedBoth',
+            vendorIdentifier=999,
+            )
+
+        # make a floating application, no network interface
+        this_application = Application(this_device)
+
+        # create a writeable analog value object
+        avo = WritableAnalogValueObject(
+            objectIdentifier=('analogValue', 1),
+            objectName='analog value 1',
+            presentValue=0.0,
+            )
+        _log.debug("    - avo: %r", avo)
+        this_application.add_object(avo)
+
+        # create a simple daily schedule, actually a weekly schedule with
+        # every day identical
+        so = LocalScheduleObject(
+            objectIdentifier=('schedule', 1),
+            objectName='Schedule 1',
+            presentValue=Real(-1.0),
+            effectivePeriod=DateRange(
+                startDate=(0, 1, 1, 1),
+                endDate=(254, 12, 31, 2),
+                ),
+            weeklySchedule=ArrayOf(DailySchedule)([
+                DailySchedule(
+                    daySchedule=[
+                        TimeValue(time=(8,0,0,0), value=Real(8)),
+                        TimeValue(time=(14,0,0,0), value=Null()),
+                        TimeValue(time=(17,0,0,0), value=Real(42)),
+                        ]
+                    ),
+                ] * 7),
+            listOfObjectPropertyReferences=[
+                DeviceObjectPropertyReference(
+                    objectIdentifier=('analogValue', 1),
+                    propertyIdentifier='presentValue',
+                    ),
+                ],
+            priorityForWriting=7,
+            scheduleDefault=Real(0.0),
+            )
+        _log.debug("    - so: %r", so)
+        this_application.add_object(so)
+
+        # run from midnight to just after midnight the next day
+        for hr, val in zip(range(0, 26), [0]*8 + [8]*6 + [0]*3 + [42]*7 + [0]):
+            # let it run
+            run_time_machine(stop_time="{}:00:01".format(hr))
+            if _debug: TestLocalSchedule._debug("    - hr, val, pv: %s, %s, %s",
+                hr, val, so.presentValue.value,
+                )
+
+            assert so.presentValue.value == val
+            assert avo.presentValue == val
+

From 80f3fa5a8ebe18fef149ff4512ee3d3a66244b6b Mon Sep 17 00:00:00 2001
From: Joel Bender <joel@carrickbender.com>
Date: Tue, 3 Apr 2018 01:20:50 -0400
Subject: [PATCH 21/21] sync the Python versions

---
 py25/bacpypes/__init__.py       |   2 +
 py25/bacpypes/local/__init__.py |  11 +
 py25/bacpypes/local/device.py   | 159 +++++++++
 py25/bacpypes/local/file.py     |  91 ++++++
 py25/bacpypes/local/object.py   |  69 ++++
 py25/bacpypes/local/schedule.py | 561 ++++++++++++++++++++++++++++++++
 py27/bacpypes/local/schedule.py |   7 +-
 py34/bacpypes/__init__.py       |   2 +
 py34/bacpypes/local/__init__.py |  11 +
 py34/bacpypes/local/device.py   | 157 +++++++++
 py34/bacpypes/local/file.py     |  89 +++++
 py34/bacpypes/local/object.py   |  68 ++++
 py34/bacpypes/local/schedule.py | 558 +++++++++++++++++++++++++++++++
 13 files changed, 1779 insertions(+), 6 deletions(-)
 create mode 100644 py25/bacpypes/local/__init__.py
 create mode 100644 py25/bacpypes/local/device.py
 create mode 100644 py25/bacpypes/local/file.py
 create mode 100644 py25/bacpypes/local/object.py
 create mode 100644 py25/bacpypes/local/schedule.py
 create mode 100644 py34/bacpypes/local/__init__.py
 create mode 100644 py34/bacpypes/local/device.py
 create mode 100644 py34/bacpypes/local/file.py
 create mode 100644 py34/bacpypes/local/object.py
 create mode 100644 py34/bacpypes/local/schedule.py

diff --git a/py25/bacpypes/__init__.py b/py25/bacpypes/__init__.py
index 90604514..70e98038 100755
--- a/py25/bacpypes/__init__.py
+++ b/py25/bacpypes/__init__.py
@@ -69,6 +69,8 @@
 
 from . import app
 from . import appservice
+
+from . import local
 from . import service
 
 #
diff --git a/py25/bacpypes/local/__init__.py b/py25/bacpypes/local/__init__.py
new file mode 100644
index 00000000..277c3c76
--- /dev/null
+++ b/py25/bacpypes/local/__init__.py
@@ -0,0 +1,11 @@
+#!/usr/bin/env python
+
+"""
+Local Object Subpackage
+"""
+
+from . import object
+from . import device
+from . import file
+from . import schedule
+
diff --git a/py25/bacpypes/local/device.py b/py25/bacpypes/local/device.py
new file mode 100644
index 00000000..7af52a7d
--- /dev/null
+++ b/py25/bacpypes/local/device.py
@@ -0,0 +1,159 @@
+#!/usr/bin/env python
+
+from ..debugging import bacpypes_debugging, ModuleLogger
+
+from ..primitivedata import Date, Time, ObjectIdentifier
+from ..constructeddata import ArrayOf
+from ..basetypes import ServicesSupported
+
+from ..errors import ExecutionError
+from ..object import register_object_type, registered_object_types, \
+    Property, DeviceObject
+
+from .object import CurrentPropertyListMixIn
+
+# some debugging
+_debug = 0
+_log = ModuleLogger(globals())
+
+#
+#   CurrentLocalDate
+#
+
+class CurrentLocalDate(Property):
+
+    def __init__(self):
+        Property.__init__(self, 'localDate', Date, default=(), optional=True, mutable=False)
+
+    def ReadProperty(self, obj, arrayIndex=None):
+        if arrayIndex is not None:
+            raise ExecutionError(errorClass='property', errorCode='propertyIsNotAnArray')
+
+        # get the value
+        now = Date()
+        now.now()
+        return now.value
+
+    def WriteProperty(self, obj, value, arrayIndex=None, priority=None, direct=False):
+        raise ExecutionError(errorClass='property', errorCode='writeAccessDenied')
+
+#
+#   CurrentLocalTime
+#
+
+class CurrentLocalTime(Property):
+
+    def __init__(self):
+        Property.__init__(self, 'localTime', Time, default=(), optional=True, mutable=False)
+
+    def ReadProperty(self, obj, arrayIndex=None):
+        if arrayIndex is not None:
+            raise ExecutionError(errorClass='property', errorCode='propertyIsNotAnArray')
+
+        # get the value
+        now = Time()
+        now.now()
+        return now.value
+
+    def WriteProperty(self, obj, value, arrayIndex=None, priority=None, direct=False):
+        raise ExecutionError(errorClass='property', errorCode='writeAccessDenied')
+
+#
+#   CurrentProtocolServicesSupported
+#
+
+class CurrentProtocolServicesSupported(Property):
+
+    def __init__(self):
+        if _debug: CurrentProtocolServicesSupported._debug("__init__")
+        Property.__init__(self, 'protocolServicesSupported', ServicesSupported, default=None, optional=True, mutable=False)
+
+    def ReadProperty(self, obj, arrayIndex=None):
+        if _debug: CurrentProtocolServicesSupported._debug("ReadProperty %r %r", obj, arrayIndex)
+
+        # not an array
+        if arrayIndex is not None:
+            raise ExecutionError(errorClass='property', errorCode='propertyIsNotAnArray')
+
+        # return what the application says
+        return obj._app.get_services_supported()
+
+    def WriteProperty(self, obj, value, arrayIndex=None, priority=None, direct=False):
+        raise ExecutionError(errorClass='property', errorCode='writeAccessDenied')
+
+bacpypes_debugging(CurrentProtocolServicesSupported)
+
+#
+#   LocalDeviceObject
+#
+
+class LocalDeviceObject(CurrentPropertyListMixIn, DeviceObject):
+
+    properties = [
+        CurrentLocalTime(),
+        CurrentLocalDate(),
+        CurrentProtocolServicesSupported(),
+        ]
+
+    defaultProperties = \
+        { 'maxApduLengthAccepted': 1024
+        , 'segmentationSupported': 'segmentedBoth'
+        , 'maxSegmentsAccepted': 16
+        , 'apduSegmentTimeout': 5000
+        , 'apduTimeout': 3000
+        , 'numberOfApduRetries': 3
+        }
+
+    def __init__(self, **kwargs):
+        if _debug: LocalDeviceObject._debug("__init__ %r", kwargs)
+
+        # fill in default property values not in kwargs
+        for attr, value in LocalDeviceObject.defaultProperties.items():
+            if attr not in kwargs:
+                kwargs[attr] = value
+
+        for key, value in kwargs.items():
+            if key.startswith("_"):
+                setattr(self, key, value)
+                del kwargs[key]
+
+        # check for registration
+        if self.__class__ not in registered_object_types.values():
+            if 'vendorIdentifier' not in kwargs:
+                raise RuntimeError("vendorIdentifier required to auto-register the LocalDeviceObject class")
+            register_object_type(self.__class__, vendor_id=kwargs['vendorIdentifier'])
+
+        # check for properties this class implements
+        if 'localDate' in kwargs:
+            raise RuntimeError("localDate is provided by LocalDeviceObject and cannot be overridden")
+        if 'localTime' in kwargs:
+            raise RuntimeError("localTime is provided by LocalDeviceObject and cannot be overridden")
+        if 'protocolServicesSupported' in kwargs:
+            raise RuntimeError("protocolServicesSupported is provided by LocalDeviceObject and cannot be overridden")
+
+        # the object identifier is required for the object list
+        if 'objectIdentifier' not in kwargs:
+            raise RuntimeError("objectIdentifier is required")
+
+        # coerce the object identifier
+        object_identifier = kwargs['objectIdentifier']
+        if isinstance(object_identifier, (int, long)):
+            object_identifier = ('device', object_identifier)
+
+        # the object list is provided
+        if 'objectList' in kwargs:
+            raise RuntimeError("objectList is provided by LocalDeviceObject and cannot be overridden")
+        kwargs['objectList'] = ArrayOf(ObjectIdentifier)([object_identifier])
+
+        # check for a minimum value
+        if kwargs['maxApduLengthAccepted'] < 50:
+            raise ValueError("invalid max APDU length accepted")
+
+        # dump the updated attributes
+        if _debug: LocalDeviceObject._debug("    - updated kwargs: %r", kwargs)
+
+        # proceed as usual
+        super(LocalDeviceObject, self).__init__(**kwargs)
+
+bacpypes_debugging(LocalDeviceObject)
+
diff --git a/py25/bacpypes/local/file.py b/py25/bacpypes/local/file.py
new file mode 100644
index 00000000..3792526a
--- /dev/null
+++ b/py25/bacpypes/local/file.py
@@ -0,0 +1,91 @@
+#!/usr/bin/env python
+
+from ..debugging import bacpypes_debugging, ModuleLogger
+from ..capability import Capability
+
+from ..object import FileObject
+
+from ..apdu import AtomicReadFileACK, AtomicReadFileACKAccessMethodChoice, \
+    AtomicReadFileACKAccessMethodRecordAccess, \
+    AtomicReadFileACKAccessMethodStreamAccess, \
+    AtomicWriteFileACK
+from ..errors import ExecutionError, MissingRequiredParameter
+
+# some debugging
+_debug = 0
+_log = ModuleLogger(globals())
+
+#
+#   Local Record Access File Object Type
+#
+
+class LocalRecordAccessFileObject(FileObject):
+
+    def __init__(self, **kwargs):
+        """ Initialize a record accessed file object. """
+        if _debug:
+            LocalRecordAccessFileObject._debug("__init__ %r",
+                kwargs,
+                )
+
+        # verify the file access method or provide it
+        if 'fileAccessMethod' in kwargs:
+            if kwargs['fileAccessMethod'] != 'recordAccess':
+                raise ValueError("inconsistent file access method")
+        else:
+            kwargs['fileAccessMethod'] = 'recordAccess'
+
+        # continue with initialization
+        FileObject.__init__(self, **kwargs)
+
+    def __len__(self):
+        """ Return the number of records. """
+        raise NotImplementedError("__len__")
+
+    def read_record(self, start_record, record_count):
+        """ Read a number of records starting at a specific record. """
+        raise NotImplementedError("read_record")
+
+    def write_record(self, start_record, record_count, record_data):
+        """ Write a number of records, starting at a specific record. """
+        raise NotImplementedError("write_record")
+
+bacpypes_debugging(LocalRecordAccessFileObject)
+
+#
+#   Local Stream Access File Object Type
+#
+
+class LocalStreamAccessFileObject(FileObject):
+
+    def __init__(self, **kwargs):
+        """ Initialize a stream accessed file object. """
+        if _debug:
+            LocalStreamAccessFileObject._debug("__init__ %r",
+                kwargs,
+                )
+
+        # verify the file access method or provide it
+        if 'fileAccessMethod' in kwargs:
+            if kwargs['fileAccessMethod'] != 'streamAccess':
+                raise ValueError("inconsistent file access method")
+        else:
+            kwargs['fileAccessMethod'] = 'streamAccess'
+
+        # continue with initialization
+        FileObject.__init__(self, **kwargs)
+
+    def __len__(self):
+        """ Return the number of octets in the file. """
+        raise NotImplementedError("write_file")
+
+    def read_stream(self, start_position, octet_count):
+        """ Read a chunk of data out of the file. """
+        raise NotImplementedError("read_stream")
+
+    def write_stream(self, start_position, data):
+        """ Write a number of octets, starting at a specific offset. """
+        raise NotImplementedError("write_stream")
+
+bacpypes_debugging(LocalStreamAccessFileObject)
+
diff --git a/py25/bacpypes/local/object.py b/py25/bacpypes/local/object.py
new file mode 100644
index 00000000..5b5be5d3
--- /dev/null
+++ b/py25/bacpypes/local/object.py
@@ -0,0 +1,69 @@
+#!/usr/bin/env python
+
+from ..debugging import bacpypes_debugging, ModuleLogger
+
+from ..basetypes import PropertyIdentifier
+from ..constructeddata import ArrayOf
+
+from ..errors import ExecutionError
+from ..object import Property, Object
+
+# some debugging
+_debug = 0
+_log = ModuleLogger(globals())
+
+# handy reference
+ArrayOfPropertyIdentifier = ArrayOf(PropertyIdentifier)
+
+#
+#   CurrentPropertyList
+#
+
+class CurrentPropertyList(Property):
+
+    def __init__(self):
+        if _debug: CurrentPropertyList._debug("__init__")
+        Property.__init__(self, 'propertyList', ArrayOfPropertyIdentifier, default=None, optional=True, mutable=False)
+
+    def ReadProperty(self, obj, arrayIndex=None):
+        if _debug: CurrentPropertyList._debug("ReadProperty %r %r", obj, arrayIndex)
+
+        # make a list of the properties that have values
+        property_list = [k for k, v in obj._values.items()
+            if v is not None
+                and k not in ('objectName', 'objectType', 'objectIdentifier', 'propertyList')
+            ]
+        if _debug: CurrentPropertyList._debug("    - property_list: %r", property_list)
+
+        # sort the list so it's stable
+        property_list.sort()
+
+        # asking for the whole thing
+        if arrayIndex is None:
+            return ArrayOfPropertyIdentifier(property_list)
+
+        # asking for the length
+        if arrayIndex == 0:
+            return len(property_list)
+
+        # asking for an index
+        if arrayIndex > len(property_list):
+            raise ExecutionError(errorClass='property', errorCode='invalidArrayIndex')
+        return property_list[arrayIndex - 1]
+
+    def WriteProperty(self, obj, value, arrayIndex=None, priority=None, direct=False):
+        raise ExecutionError(errorClass='property', errorCode='writeAccessDenied')
+
+bacpypes_debugging(CurrentPropertyList)
+
+#
+#   CurrentPropertyListMixIn
+#
+
+@bacpypes_debugging
+class CurrentPropertyListMixIn(Object):
+
+    properties = [
+        CurrentPropertyList(),
+        ]
+
diff --git a/py25/bacpypes/local/schedule.py b/py25/bacpypes/local/schedule.py
new file mode 100644
index 00000000..a6f368be
--- /dev/null
+++ b/py25/bacpypes/local/schedule.py
@@ -0,0 +1,561 @@
+#!/usr/bin/env python
+
+"""
+Local Schedule Object
+"""
+
+import sys
+import calendar
+from time import mktime as _mktime
+
+from ..debugging import bacpypes_debugging, ModuleLogger
+
+from ..core import deferred
+from ..task import OneShotTask
+
+from ..primitivedata import Atomic, Null, Unsigned, Date, Time
+from ..constructeddata import Array
+from ..object import get_datatype, ScheduleObject
+
+from .object import CurrentPropertyListMixIn
+
+# some debugging
+_debug = 0
+_log = ModuleLogger(globals())
+
+#
+#   match_date
+#
+
+def match_date(date, date_pattern):
+    """
+    Match a specific date, a four-tuple with no special values, with a date
+    pattern, four-tuple possibly having special values.
+    """
+    # unpack the date and pattern
+    year, month, day, day_of_week = date
+    year_p, month_p, day_p, day_of_week_p = date_pattern
+
+    # check the year
+    if year_p == 255:
+        # any year
+        pass
+    elif year != year_p:
+        # specific year
+        return False
+
+    # check the month
+    if month_p == 255:
+        # any month
+        pass
+    elif month_p == 13:
+        # odd months
+        if (month % 2) == 0:
+            return False
+    elif month_p == 14:
+        # even months
+        if (month % 2) == 1:
+            return False
+    elif month != month_p:
+        # specific month
+        return False
+
+    # check the day
+    if day_p == 255:
+        # any day
+        pass
+    elif day_p == 32:
+        # last day of the month
+        last_day = calendar.monthrange(year + 1900, month)[1]
+        if day != last_day:
+            return False
+    elif day_p == 33:
+        # odd days of the month
+        if (day % 2) == 0:
+            return False
+    elif day_p == 34:
+        # even days of the month
+        if (day % 2) == 1:
+            return False
+    elif day != day_p:
+        # specific day
+        return False
+
+    # check the day of week
+    if day_of_week_p == 255:
+        # any day of the week
+        pass
+    elif day_of_week != day_of_week_p:
+        # specific day of the week
+        return False
+
+    # all tests pass
+    return True
+
+#
+#   match_date_range
+#
+
+def match_date_range(date, date_range):
+    """
+    Match a specific date, a four-tuple with no special values, with a DateRange
+    object which as a start date and end date.
+    """
+    return (date[:3] >= date_range.startDate[:3]) \
+        and (date[:3] <= date_range.endDate[:3])
+
+#
+#   match_weeknday
+#
+
+def match_weeknday(date, weeknday):
+    """
+    Match a specific date, a four-tuple with no special values, with a
+    BACnetWeekNDay, an octet string with three (unsigned) octets.
+    """
+    # unpack the date
+    year, month, day, day_of_week = date
+    last_day = calendar.monthrange(year + 1900, month)[1]
+
+    # unpack the date pattern octet string
+    weeknday_unpacked = [ord(c) for c in weeknday]
+    month_p, week_of_month_p, day_of_week_p = weeknday_unpacked
+
+    # check the month
+    if month_p == 255:
+        # any month
+        pass
+    elif month_p == 13:
+        # odd months
+        if (month % 2) == 0:
+            return False
+    elif month_p == 14:
+        # even months
+        if (month % 2) == 1:
+            return False
+    elif month != month_p:
+        # specific month
+        return False
+
+    # check the week of the month
+    if week_of_month_p == 255:
+        # any week
+        pass
+    elif week_of_month_p == 1:
+        # days numbered 1-7
+        if (day > 7):
+            return False
+    elif week_of_month_p == 2:
+        # days numbered 8-14
+        if (day < 8) or (day > 14):
+            return False
+    elif week_of_month_p == 3:
+        # days numbered 15-21
+        if (day < 15) or (day > 21):
+            return False
+    elif week_of_month_p == 4:
+        # days numbered 22-28
+        if (day < 22) or (day > 28):
+            return False
+    elif week_of_month_p == 5:
+        # days numbered 29-31
+        if (day < 29) or (day > 31):
+            return False
+    elif week_of_month_p == 6:
+        # last 7 days of this month
+        if (day < last_day - 6):
+            return False
+    elif week_of_month_p == 7:
+        # any of the 7 days prior to the last 7 days of this month
+        if (day < last_day - 13) or (day > last_day - 7):
+            return False
+    elif week_of_month_p == 8:
+        # any of the 7 days prior to the last 14 days of this month
+        if (day < last_day - 20) or (day > last_day - 14):
+            return False
+    elif week_of_month_p == 9:
+        # any of the 7 days prior to the last 21 days of this month
+        if (day < last_day - 27) or (day > last_day - 21):
+            return False
+
+    # check the day
+    if day_of_week_p == 255:
+        # any day
+        pass
+    elif day_of_week != day_of_week_p:
+        # specific day
+        return False
+
+    # all tests pass
+    return True
+
+#
+#   date_in_calendar_entry
+#
+
+def date_in_calendar_entry(date, calendar_entry):
+    if _debug: date_in_calendar_entry._debug("date_in_calendar_entry %r %r", date, calendar_entry)
+
+    match = False
+    if calendar_entry.date:
+        match = match_date(date, calendar_entry.date)
+    elif calendar_entry.dateRange:
+        match = match_date_range(date, calendar_entry.dateRange)
+    elif calendar_entry.weekNDay:
+        match = match_weeknday(date, calendar_entry.weekNDay)
+    else:
+        raise RuntimeError("")
+    if _debug: date_in_calendar_entry._debug("    - match: %r", match)
+
+    return match
+
+bacpypes_debugging(date_in_calendar_entry)
+
+#
+#   datetime_to_time
+#
+
+def datetime_to_time(date, time):
+    """Take the date and time 4-tuples and return the time in seconds since
+    the epoch as a floating point number."""
+    if (255 in date) or (255 in time):
+        raise RuntimeError("specific date and time required")
+
+    time_tuple = (
+        date[0]+1900, date[1], date[2],
+        time[0], time[1], time[2],
+        0, 0, -1,
+        )
+    return _mktime(time_tuple)
+
+#
+#   LocalScheduleObject
+#
+
+class LocalScheduleObject(CurrentPropertyListMixIn, ScheduleObject):
+
+    def __init__(self, **kwargs):
+        if _debug: LocalScheduleObject._debug("__init__ %r", kwargs)
+
+        # make sure present value was provided
+        if 'presentValue' not in kwargs:
+            raise RuntimeError("presentValue required")
+        if not isinstance(kwargs['presentValue'], Atomic):
+            raise TypeError("presentValue must be an Atomic value")
+
+        # continue initialization
+        ScheduleObject.__init__(self, **kwargs)
+
+        # attach an interpreter task
+        self._task = LocalScheduleInterpreter(self)
+
+        # add some monitors to check the reliability if these change
+        for prop in ('weeklySchedule', 'exceptionSchedule', 'scheduleDefault'):
+            self._property_monitors[prop].append(self._check_reliability)
+
+        # check it now
+        self._check_reliability()
+
+    def _check_reliability(self, old_value=None, new_value=None):
+        """This function is called when the object is created and after
+        one of its configuration properties has changed.  The new and old value
+        parameters are ignored, this is called after the property has been
+        changed and this is only concerned with the current value."""
+        if _debug: LocalScheduleObject._debug("_check_reliability %r %r", old_value, new_value)
+
+        try:
+            schedule_default = self.scheduleDefault
+
+            if schedule_default is None:
+                raise ValueError("scheduleDefault expected")
+            if not isinstance(schedule_default, Atomic):
+                raise TypeError("scheduleDefault must be an instance of an atomic type")
+
+            schedule_datatype = schedule_default.__class__
+            if _debug: LocalScheduleObject._debug("    - schedule_datatype: %r", schedule_datatype)
+
+            if (self.weeklySchedule is None) and (self.exceptionSchedule is None):
+                raise ValueError("schedule required")
+
+            # check the weekly schedule values
+            if self.weeklySchedule:
+                for daily_schedule in self.weeklySchedule:
+                    for time_value in daily_schedule.daySchedule:
+                        if _debug: LocalScheduleObject._debug("    - daily time_value: %r", time_value)
+                        if time_value is None:
+                            pass
+                        elif not isinstance(time_value.value, (Null, schedule_datatype)):
+                            if _debug: LocalScheduleObject._debug("    - wrong type: expected %r, got %r",
+                                schedule_datatype,
+                                time_value.__class__,
+                                )
+                            raise TypeError("wrong type")
+                        elif 255 in time_value.time:
+                            if _debug: LocalScheduleObject._debug("    - wildcard in time")
+                            raise ValueError("must be a specific time")
+
+            # check the exception schedule values
+            if self.exceptionSchedule:
+                for special_event in self.exceptionSchedule:
+                    for time_value in special_event.listOfTimeValues:
+                        if _debug: LocalScheduleObject._debug("    - special event time_value: %r", time_value)
+                        if time_value is None:
+                            pass
+                        elif not isinstance(time_value.value, (Null, schedule_datatype)):
+                            if _debug: LocalScheduleObject._debug("    - wrong type: expected %r, got %r",
+                                schedule_datatype,
+                                time_value.__class__,
+                                )
+                            raise TypeError("wrong type")
+
+            # check list of object property references
+            obj_prop_refs = self.listOfObjectPropertyReferences
+            if obj_prop_refs:
+                for obj_prop_ref in obj_prop_refs:
+                    if obj_prop_ref.deviceIdentifier:
+                        raise RuntimeError("no external references")
+
+                    # get the datatype of the property to be written
+                    obj_type = obj_prop_ref.objectIdentifier[0]
+                    datatype = get_datatype(obj_type, obj_prop_ref.propertyIdentifier)
+                    if _debug: LocalScheduleObject._debug("    - datatype: %r", datatype)
+
+                    if issubclass(datatype, Array) and (obj_prop_ref.propertyArrayIndex is not None):
+                        if obj_prop_ref.propertyArrayIndex == 0:
+                            datatype = Unsigned
+                        else:
+                            datatype = datatype.subtype
+                        if _debug: LocalScheduleObject._debug("    - datatype: %r", datatype)
+
+                    if datatype is not schedule_datatype:
+                        if _debug: LocalScheduleObject._debug("    - wrong type: expected %r, got %r",
+                            datatype,
+                            schedule_datatype,
+                            )
+                        raise TypeError("wrong type")
+
+            # all good
+            self.reliability = 'noFaultDetected'
+            if _debug: LocalScheduleObject._debug("    - no fault detected")
+
+        except Exception as err:
+            if _debug: LocalScheduleObject._debug("    - exception: %r", err)
+            self.reliability = 'configurationError'
+
+bacpypes_debugging(LocalScheduleObject)
+
+#
+#   LocalScheduleInterpreter
+#
+
+class LocalScheduleInterpreter(OneShotTask):
+
+    def __init__(self, sched_obj):
+        if _debug: LocalScheduleInterpreter._debug("__init__ %r", sched_obj)
+        OneShotTask.__init__(self)
+
+        # reference the schedule object to update
+        self.sched_obj = sched_obj
+
+        # add a monitor for the present value
+        sched_obj._property_monitors['presentValue'].append(self.present_value_changed)
+
+        # call to interpret the schedule
+        deferred(self.process_task)
+
+    def present_value_changed(self, old_value, new_value):
+        """This function is called when the presentValue of the local schedule
+        object has changed, both internally by this interpreter, or externally
+        by some client using WriteProperty."""
+        if _debug: LocalScheduleInterpreter._debug("present_value_changed %s %s", old_value, new_value)
+
+        # if this hasn't been added to an application, there's nothing to do
+        if not self.sched_obj._app:
+            if _debug: LocalScheduleInterpreter._debug("    - no application")
+            return
+
+        # process the list of [device] object property [array index] references
+        obj_prop_refs = self.sched_obj.listOfObjectPropertyReferences
+        if not obj_prop_refs:
+            if _debug: LocalScheduleInterpreter._debug("    - no writes defined")
+            return
+
+        # primitive values just set the value part
+        new_value = new_value.value
+
+        # loop through the writes
+        for obj_prop_ref in obj_prop_refs:
+            if obj_prop_ref.deviceIdentifier:
+                if _debug: LocalScheduleInterpreter._debug("    - no externals")
+                continue
+
+            # get the object from the application
+            obj = self.sched_obj._app.get_object_id(obj_prop_ref.objectIdentifier)
+            if not obj:
+                if _debug: LocalScheduleInterpreter._debug("    - no object")
+                continue
+
+            # try to change the value
+            try:
+                obj.WriteProperty(
+                    obj_prop_ref.propertyIdentifier,
+                    new_value,
+                    arrayIndex=obj_prop_ref.propertyArrayIndex,
+                    priority=self.sched_obj.priorityForWriting,
+                    )
+                if _debug: LocalScheduleInterpreter._debug("    - success")
+            except Exception as err:
+                if _debug: LocalScheduleInterpreter._debug("    - error: %r", err)
+
+    def process_task(self):
+        if _debug: LocalScheduleInterpreter._debug("process_task(%s)", self.sched_obj.objectName)
+
+        # check for a valid configuration
+        if self.sched_obj.reliability != 'noFaultDetected':
+            if _debug: LocalScheduleInterpreter._debug("    - fault detected")
+            return
+
+        # get the date and time from the device object in case it provides
+        # some custom functionality
+        if self.sched_obj._app and self.sched_obj._app.localDevice:
+            current_date = self.sched_obj._app.localDevice.localDate
+            if _debug: LocalScheduleInterpreter._debug("    - current_date: %r", current_date)
+
+            current_time = self.sched_obj._app.localDevice.localTime
+            if _debug: LocalScheduleInterpreter._debug("    - current_time: %r", current_time)
+        else:
+            # get the current date and time, as provided by the task manager
+            current_date = Date().now().value
+            if _debug: LocalScheduleInterpreter._debug("    - current_date: %r", current_date)
+
+            current_time = Time().now().value
+            if _debug: LocalScheduleInterpreter._debug("    - current_time: %r", current_time)
+
+        # evaluate the time
+        current_value, next_transition = self.eval(current_date, current_time)
+        if _debug: LocalScheduleInterpreter._debug("    - current_value, next_transition: %r, %r", current_value, next_transition)
+
+        ### set the present value
+        self.sched_obj.presentValue = current_value
+
+        # compute the time of the next transition
+        transition_time = datetime_to_time(current_date, next_transition)
+
+        # install this to run again
+        self.install_task(transition_time)
+
+    def eval(self, edate, etime):
+        """Evaluate the schedule according to the provided date and time and
+        return the appropriate present value, or None if not in the effective
+        period."""
+        if _debug: LocalScheduleInterpreter._debug("eval %r %r", edate, etime)
+
+        # reference the schedule object
+        sched_obj = self.sched_obj
+        if _debug: LocalScheduleInterpreter._debug("    sched_obj: %r", sched_obj)
+
+        # verify the date falls in the effective period
+        if not match_date_range(edate, sched_obj.effectivePeriod):
+            return None
+
+        # the event priority is a list of values that are in effect for
+        # exception schedules with the special event priority, see 135.1-2013
+        # clause 7.3.2.23.10.3.8, Revision 4 Event Priority Test
+        event_priority = [None] * 16
+
+        next_day = (24, 0, 0, 0)
+        next_transition_time = [None] * 16
+
+        # check the exception schedule values
+        if sched_obj.exceptionSchedule:
+            for special_event in sched_obj.exceptionSchedule:
+                if _debug: LocalScheduleInterpreter._debug("    - special_event: %r", special_event)
+
+                # check the special event period
+                special_event_period = special_event.period
+                if special_event_period is None:
+                    raise RuntimeError("special event period required")
+
+                match = False
+                calendar_entry = special_event_period.calendarEntry
+                if calendar_entry:
+                    if _debug: LocalScheduleInterpreter._debug("    - calendar_entry: %r", calendar_entry)
+                    match = date_in_calendar_entry(edate, calendar_entry)
+                else:
+                    # get the calendar object from the application
+                    calendar_object = sched_obj._app.get_object_id(special_event_period.calendarReference)
+                    if not calendar_object:
+                        raise RuntimeError("invalid calendar object reference")
+                    if _debug: LocalScheduleInterpreter._debug("    - calendar_object: %r", calendar_object)
+
+                    for calendar_entry in calendar_object.dateList:
+                        if _debug: LocalScheduleInterpreter._debug("    - calendar_entry: %r", calendar_entry)
+                        match = date_in_calendar_entry(edate, calendar_entry)
+                        if match:
+                            break
+
+                # didn't match the period, try the next special event
+                if not match:
+                    if _debug: LocalScheduleInterpreter._debug("    - no matching calendar entry")
+                    continue
+
+                # event priority array index
+                priority = special_event.eventPriority - 1
+                if _debug: LocalScheduleInterpreter._debug("    - priority: %r", priority)
+
+                # look for all of the possible times
+                for time_value in special_event.listOfTimeValues:
+                    tval = time_value.time
+                    if tval <= etime:
+                        if isinstance(time_value.value, Null):
+                            if _debug: LocalScheduleInterpreter._debug("    - relinquish exception @ %r", tval)
+                            event_priority[priority] = None
+                            next_transition_time[priority] = None
+                        else:
+                            if _debug: LocalScheduleInterpreter._debug("    - consider exception @ %r", tval)
+                            event_priority[priority] = time_value.value
+                            next_transition_time[priority] = next_day
+                    else:
+                        next_transition_time[priority] = tval
+                        break
+
+        # assume the next transition will be at the start of the next day
+        earliest_transition = next_day
+
+        # check if any of the special events came up with something
+        for priority_value, next_transition in zip(event_priority, next_transition_time):
+            if next_transition is not None:
+                earliest_transition = min(earliest_transition, next_transition)
+            if priority_value is not None:
+                if _debug: LocalScheduleInterpreter._debug("    - priority_value: %r", priority_value)
+                return priority_value, earliest_transition
+
+        # start out with the default
+        daily_value = sched_obj.scheduleDefault
+
+        # check the daily schedule
+        if sched_obj.weeklySchedule:
+            daily_schedule = sched_obj.weeklySchedule[edate[3]]
+            if _debug: LocalScheduleInterpreter._debug("    - daily_schedule: %r", daily_schedule)
+
+            # look for all of the possible times
+            for time_value in daily_schedule.daySchedule:
+                if _debug: LocalScheduleInterpreter._debug("    - time_value: %r", time_value)
+
+                tval = time_value.time
+                if tval <= etime:
+                    if isinstance(time_value.value, Null):
+                        if _debug: LocalScheduleInterpreter._debug("    - back to normal @ %r", tval)
+                        daily_value = sched_obj.scheduleDefault
+                    else:
+                        if _debug: LocalScheduleInterpreter._debug("    - new value @ %r", tval)
+                        daily_value = time_value.value
+                else:
+                    earliest_transition = min(earliest_transition, tval)
+                    break
+
+        # return what was matched, if anything
+        return daily_value, earliest_transition
+
+bacpypes_debugging(LocalScheduleInterpreter)
+
diff --git a/py27/bacpypes/local/schedule.py b/py27/bacpypes/local/schedule.py
index 5f5a53d9..91cbee62 100644
--- a/py27/bacpypes/local/schedule.py
+++ b/py27/bacpypes/local/schedule.py
@@ -118,12 +118,7 @@ def match_weeknday(date, weeknday):
     last_day = calendar.monthrange(year + 1900, month)[1]
 
     # unpack the date pattern octet string
-    if sys.version_info[0] == 2:
-        weeknday_unpacked = [ord(c) for c in weeknday]
-    elif sys.version_info[0] == 3:
-        weeknday_unpacked = [c for c in weeknday]
-    else:
-        raise NotImplementedError("match_weeknday requires Python 2.x or 3.x")
+    weeknday_unpacked = [ord(c) for c in weeknday]
     month_p, week_of_month_p, day_of_week_p = weeknday_unpacked
 
     # check the month
diff --git a/py34/bacpypes/__init__.py b/py34/bacpypes/__init__.py
index 5ea5be2f..a77e8be9 100755
--- a/py34/bacpypes/__init__.py
+++ b/py34/bacpypes/__init__.py
@@ -69,6 +69,8 @@
 
 from . import app
 from . import appservice
+
+from . import local
 from . import service
 
 #
diff --git a/py34/bacpypes/local/__init__.py b/py34/bacpypes/local/__init__.py
new file mode 100644
index 00000000..277c3c76
--- /dev/null
+++ b/py34/bacpypes/local/__init__.py
@@ -0,0 +1,11 @@
+#!/usr/bin/env python
+
+"""
+Local Object Subpackage
+"""
+
+from . import object
+from . import device
+from . import file
+from . import schedule
+
diff --git a/py34/bacpypes/local/device.py b/py34/bacpypes/local/device.py
new file mode 100644
index 00000000..c823b897
--- /dev/null
+++ b/py34/bacpypes/local/device.py
@@ -0,0 +1,157 @@
+#!/usr/bin/env python
+
+from ..debugging import bacpypes_debugging, ModuleLogger
+
+from ..primitivedata import Date, Time, ObjectIdentifier
+from ..constructeddata import ArrayOf
+from ..basetypes import ServicesSupported
+
+from ..errors import ExecutionError
+from ..object import register_object_type, registered_object_types, \
+    Property, DeviceObject
+
+from .object import CurrentPropertyListMixIn
+
+# some debugging
+_debug = 0
+_log = ModuleLogger(globals())
+
+#
+#   CurrentLocalDate
+#
+
+class CurrentLocalDate(Property):
+
+    def __init__(self):
+        Property.__init__(self, 'localDate', Date, default=(), optional=True, mutable=False)
+
+    def ReadProperty(self, obj, arrayIndex=None):
+        if arrayIndex is not None:
+            raise ExecutionError(errorClass='property', errorCode='propertyIsNotAnArray')
+
+        # get the value
+        now = Date()
+        now.now()
+        return now.value
+
+    def WriteProperty(self, obj, value, arrayIndex=None, priority=None, direct=False):
+        raise ExecutionError(errorClass='property', errorCode='writeAccessDenied')
+
+#
+#   CurrentLocalTime
+#
+
+class CurrentLocalTime(Property):
+
+    def __init__(self):
+        Property.__init__(self, 'localTime', Time, default=(), optional=True, mutable=False)
+
+    def ReadProperty(self, obj, arrayIndex=None):
+        if arrayIndex is not None:
+            raise ExecutionError(errorClass='property', errorCode='propertyIsNotAnArray')
+
+        # get the value
+        now = Time()
+        now.now()
+        return now.value
+
+    def WriteProperty(self, obj, value, arrayIndex=None, priority=None, direct=False):
+        raise ExecutionError(errorClass='property', errorCode='writeAccessDenied')
+
+#
+#   CurrentProtocolServicesSupported
+#
+
+@bacpypes_debugging
+class CurrentProtocolServicesSupported(Property):
+
+    def __init__(self):
+        if _debug: CurrentProtocolServicesSupported._debug("__init__")
+        Property.__init__(self, 'protocolServicesSupported', ServicesSupported, default=None, optional=True, mutable=False)
+
+    def ReadProperty(self, obj, arrayIndex=None):
+        if _debug: CurrentProtocolServicesSupported._debug("ReadProperty %r %r", obj, arrayIndex)
+
+        # not an array
+        if arrayIndex is not None:
+            raise ExecutionError(errorClass='property', errorCode='propertyIsNotAnArray')
+
+        # return what the application says
+        return obj._app.get_services_supported()
+
+    def WriteProperty(self, obj, value, arrayIndex=None, priority=None, direct=False):
+        raise ExecutionError(errorClass='property', errorCode='writeAccessDenied')
+
+#
+#   LocalDeviceObject
+#
+
+@bacpypes_debugging
+class LocalDeviceObject(CurrentPropertyListMixIn, DeviceObject):
+
+    properties = [
+        CurrentLocalTime(),
+        CurrentLocalDate(),
+        CurrentProtocolServicesSupported(),
+        ]
+
+    defaultProperties = \
+        { 'maxApduLengthAccepted': 1024
+        , 'segmentationSupported': 'segmentedBoth'
+        , 'maxSegmentsAccepted': 16
+        , 'apduSegmentTimeout': 5000
+        , 'apduTimeout': 3000
+        , 'numberOfApduRetries': 3
+        }
+
+    def __init__(self, **kwargs):
+        if _debug: LocalDeviceObject._debug("__init__ %r", kwargs)
+
+        # fill in default property values not in kwargs
+        for attr, value in LocalDeviceObject.defaultProperties.items():
+            if attr not in kwargs:
+                kwargs[attr] = value
+
+        for key, value in kwargs.items():
+            if key.startswith("_"):
+                setattr(self, key, value)
+                del kwargs[key]
+
+        # check for registration
+        if self.__class__ not in registered_object_types.values():
+            if 'vendorIdentifier' not in kwargs:
+                raise RuntimeError("vendorIdentifier required to auto-register the LocalDeviceObject class")
+            register_object_type(self.__class__, vendor_id=kwargs['vendorIdentifier'])
+
+        # check for properties this class implements
+        if 'localDate' in kwargs:
+            raise RuntimeError("localDate is provided by LocalDeviceObject and cannot be overridden")
+        if 'localTime' in kwargs:
+            raise RuntimeError("localTime is provided by LocalDeviceObject and cannot be overridden")
+        if 'protocolServicesSupported' in kwargs:
+            raise RuntimeError("protocolServicesSupported is provided by LocalDeviceObject and cannot be overridden")
+
+        # the object identifier is required for the object list
+        if 'objectIdentifier' not in kwargs:
+            raise RuntimeError("objectIdentifier is required")
+
+        # coerce the object identifier
+        object_identifier = kwargs['objectIdentifier']
+        if isinstance(object_identifier, int):
+            object_identifier = ('device', object_identifier)
+
+        # the object list is provided
+        if 'objectList' in kwargs:
+            raise RuntimeError("objectList is provided by LocalDeviceObject and cannot be overridden")
+        kwargs['objectList'] = ArrayOf(ObjectIdentifier)([object_identifier])
+
+        # check for a minimum value
+        if kwargs['maxApduLengthAccepted'] < 50:
+            raise ValueError("invalid max APDU length accepted")
+
+        # dump the updated attributes
+        if _debug: LocalDeviceObject._debug("    - updated kwargs: %r", kwargs)
+
+        # proceed as usual
+        super(LocalDeviceObject, self).__init__(**kwargs)
+
diff --git a/py34/bacpypes/local/file.py b/py34/bacpypes/local/file.py
new file mode 100644
index 00000000..8007bef4
--- /dev/null
+++ b/py34/bacpypes/local/file.py
@@ -0,0 +1,89 @@
+#!/usr/bin/env python
+
+from ..debugging import bacpypes_debugging, ModuleLogger
+from ..capability import Capability
+
+from ..object import FileObject
+
+from ..apdu import AtomicReadFileACK, AtomicReadFileACKAccessMethodChoice, \
+    AtomicReadFileACKAccessMethodRecordAccess, \
+    AtomicReadFileACKAccessMethodStreamAccess, \
+    AtomicWriteFileACK
+from ..errors import ExecutionError, MissingRequiredParameter
+
+# some debugging
+_debug = 0
+_log = ModuleLogger(globals())
+
+#
+#   Local Record Access File Object Type
+#
+
+@bacpypes_debugging
+class LocalRecordAccessFileObject(FileObject):
+
+    def __init__(self, **kwargs):
+        """ Initialize a record accessed file object. """
+        if _debug:
+            LocalRecordAccessFileObject._debug("__init__ %r",
+                kwargs,
+                )
+
+        # verify the file access method or provide it
+        if 'fileAccessMethod' in kwargs:
+            if kwargs['fileAccessMethod'] != 'recordAccess':
+                raise ValueError("inconsistent file access method")
+        else:
+            kwargs['fileAccessMethod'] = 'recordAccess'
+
+        # continue with initialization
+        FileObject.__init__(self, **kwargs)
+
+    def __len__(self):
+        """ Return the number of records. """
+        raise NotImplementedError("__len__")
+
+    def read_record(self, start_record, record_count):
+        """ Read a number of records starting at a specific record. """
+        raise NotImplementedError("read_record")
+
+    def write_record(self, start_record, record_count, record_data):
+        """ Write a number of records, starting at a specific record. """
+        raise NotImplementedError("write_record")
+
+#
+#   Local Stream Access File Object Type
+#
+
+@bacpypes_debugging
+class LocalStreamAccessFileObject(FileObject):
+
+    def __init__(self, **kwargs):
+        """ Initialize a stream accessed file object. """
+        if _debug:
+            LocalStreamAccessFileObject._debug("__init__ %r",
+                kwargs,
+                )
+
+        # verify the file access method or provide it
+        if 'fileAccessMethod' in kwargs:
+            if kwargs['fileAccessMethod'] != 'streamAccess':
+                raise ValueError("inconsistent file access method")
+        else:
+            kwargs['fileAccessMethod'] = 'streamAccess'
+
+        # continue with initialization
+        FileObject.__init__(self, **kwargs)
+
+    def __len__(self):
+        """ Return the number of octets in the file. """
+        raise NotImplementedError("write_file")
+
+    def read_stream(self, start_position, octet_count):
+        """ Read a chunk of data out of the file. """
+        raise NotImplementedError("read_stream")
+
+    def write_stream(self, start_position, data):
+        """ Write a number of octets, starting at a specific offset. """
+        raise NotImplementedError("write_stream")
+
diff --git a/py34/bacpypes/local/object.py b/py34/bacpypes/local/object.py
new file mode 100644
index 00000000..3078b9c6
--- /dev/null
+++ b/py34/bacpypes/local/object.py
@@ -0,0 +1,68 @@
+#!/usr/bin/env python
+
+from ..debugging import bacpypes_debugging, ModuleLogger
+
+from ..basetypes import PropertyIdentifier
+from ..constructeddata import ArrayOf
+
+from ..errors import ExecutionError
+from ..object import Property, Object
+
+# some debugging
+_debug = 0
+_log = ModuleLogger(globals())
+
+# handy reference
+ArrayOfPropertyIdentifier = ArrayOf(PropertyIdentifier)
+
+#
+#   CurrentPropertyList
+#
+
+@bacpypes_debugging
+class CurrentPropertyList(Property):
+
+    def __init__(self):
+        if _debug: CurrentPropertyList._debug("__init__")
+        Property.__init__(self, 'propertyList', ArrayOfPropertyIdentifier, default=None, optional=True, mutable=False)
+
+    def ReadProperty(self, obj, arrayIndex=None):
+        if _debug: CurrentPropertyList._debug("ReadProperty %r %r", obj, arrayIndex)
+
+        # make a list of the properties that have values
+        property_list = [k for k, v in obj._values.items()
+            if v is not None
+                and k not in ('objectName', 'objectType', 'objectIdentifier', 'propertyList')
+            ]
+        if _debug: CurrentPropertyList._debug("    - property_list: %r", property_list)
+
+        # sort the list so it's stable
+        property_list.sort()
+
+        # asking for the whole thing
+        if arrayIndex is None:
+            return ArrayOfPropertyIdentifier(property_list)
+
+        # asking for the length
+        if arrayIndex == 0:
+            return len(property_list)
+
+        # asking for an index
+        if arrayIndex > len(property_list):
+            raise ExecutionError(errorClass='property', errorCode='invalidArrayIndex')
+        return property_list[arrayIndex - 1]
+
+    def WriteProperty(self, obj, value, arrayIndex=None, priority=None, direct=False):
+        raise ExecutionError(errorClass='property', errorCode='writeAccessDenied')
+
+#
+#   CurrentPropertyListMixIn
+#
+
+@bacpypes_debugging
+class CurrentPropertyListMixIn(Object):
+
+    properties = [
+        CurrentPropertyList(),
+        ]
+
diff --git a/py34/bacpypes/local/schedule.py b/py34/bacpypes/local/schedule.py
new file mode 100644
index 00000000..d22911a3
--- /dev/null
+++ b/py34/bacpypes/local/schedule.py
@@ -0,0 +1,558 @@
+#!/usr/bin/env python
+
+"""
+Local Schedule Object
+"""
+
+import sys
+import calendar
+from time import mktime as _mktime
+
+from ..debugging import bacpypes_debugging, ModuleLogger
+
+from ..core import deferred
+from ..task import OneShotTask
+
+from ..primitivedata import Atomic, Null, Unsigned, Date, Time
+from ..constructeddata import Array
+from ..object import get_datatype, ScheduleObject
+
+from .object import CurrentPropertyListMixIn
+
+# some debugging
+_debug = 0
+_log = ModuleLogger(globals())
+
+#
+#   match_date
+#
+
+def match_date(date, date_pattern):
+    """
+    Match a specific date, a four-tuple with no special values, with a date
+    pattern, four-tuple possibly having special values.
+    """
+    # unpack the date and pattern
+    year, month, day, day_of_week = date
+    year_p, month_p, day_p, day_of_week_p = date_pattern
+
+    # check the year
+    if year_p == 255:
+        # any year
+        pass
+    elif year != year_p:
+        # specific year
+        return False
+
+    # check the month
+    if month_p == 255:
+        # any month
+        pass
+    elif month_p == 13:
+        # odd months
+        if (month % 2) == 0:
+            return False
+    elif month_p == 14:
+        # even months
+        if (month % 2) == 1:
+            return False
+    elif month != month_p:
+        # specific month
+        return False
+
+    # check the day
+    if day_p == 255:
+        # any day
+        pass
+    elif day_p == 32:
+        # last day of the month
+        last_day = calendar.monthrange(year + 1900, month)[1]
+        if day != last_day:
+            return False
+    elif day_p == 33:
+        # odd days of the month
+        if (day % 2) == 0:
+            return False
+    elif day_p == 34:
+        # even days of the month
+        if (day % 2) == 1:
+            return False
+    elif day != day_p:
+        # specific day
+        return False
+
+    # check the day of week
+    if day_of_week_p == 255:
+        # any day of the week
+        pass
+    elif day_of_week != day_of_week_p:
+        # specific day of the week
+        return False
+
+    # all tests pass
+    return True
+
+#
+#   match_date_range
+#
+
+def match_date_range(date, date_range):
+    """
+    Match a specific date, a four-tuple with no special values, with a DateRange
+    object which as a start date and end date.
+    """
+    return (date[:3] >= date_range.startDate[:3]) \
+        and (date[:3] <= date_range.endDate[:3])
+
+#
+#   match_weeknday
+#
+
+def match_weeknday(date, weeknday):
+    """
+    Match a specific date, a four-tuple with no special values, with a
+    BACnetWeekNDay, an octet string with three (unsigned) octets.
+    """
+    # unpack the date
+    year, month, day, day_of_week = date
+    last_day = calendar.monthrange(year + 1900, month)[1]
+
+    # unpack the date pattern octet string
+    weeknday_unpacked = [c for c in weeknday]
+    month_p, week_of_month_p, day_of_week_p = weeknday_unpacked
+
+    # check the month
+    if month_p == 255:
+        # any month
+        pass
+    elif month_p == 13:
+        # odd months
+        if (month % 2) == 0:
+            return False
+    elif month_p == 14:
+        # even months
+        if (month % 2) == 1:
+            return False
+    elif month != month_p:
+        # specific month
+        return False
+
+    # check the week of the month
+    if week_of_month_p == 255:
+        # any week
+        pass
+    elif week_of_month_p == 1:
+        # days numbered 1-7
+        if (day > 7):
+            return False
+    elif week_of_month_p == 2:
+        # days numbered 8-14
+        if (day < 8) or (day > 14):
+            return False
+    elif week_of_month_p == 3:
+        # days numbered 15-21
+        if (day < 15) or (day > 21):
+            return False
+    elif week_of_month_p == 4:
+        # days numbered 22-28
+        if (day < 22) or (day > 28):
+            return False
+    elif week_of_month_p == 5:
+        # days numbered 29-31
+        if (day < 29) or (day > 31):
+            return False
+    elif week_of_month_p == 6:
+        # last 7 days of this month
+        if (day < last_day - 6):
+            return False
+    elif week_of_month_p == 7:
+        # any of the 7 days prior to the last 7 days of this month
+        if (day < last_day - 13) or (day > last_day - 7):
+            return False
+    elif week_of_month_p == 8:
+        # any of the 7 days prior to the last 14 days of this month
+        if (day < last_day - 20) or (day > last_day - 14):
+            return False
+    elif week_of_month_p == 9:
+        # any of the 7 days prior to the last 21 days of this month
+        if (day < last_day - 27) or (day > last_day - 21):
+            return False
+
+    # check the day
+    if day_of_week_p == 255:
+        # any day
+        pass
+    elif day_of_week != day_of_week_p:
+        # specific day
+        return False
+
+    # all tests pass
+    return True
+
+#
+#   date_in_calendar_entry
+#
+
+@bacpypes_debugging
+def date_in_calendar_entry(date, calendar_entry):
+    if _debug: date_in_calendar_entry._debug("date_in_calendar_entry %r %r", date, calendar_entry)
+
+    match = False
+    if calendar_entry.date:
+        match = match_date(date, calendar_entry.date)
+    elif calendar_entry.dateRange:
+        match = match_date_range(date, calendar_entry.dateRange)
+    elif calendar_entry.weekNDay:
+        match = match_weeknday(date, calendar_entry.weekNDay)
+    else:
+        raise RuntimeError("")
+    if _debug: date_in_calendar_entry._debug("    - match: %r", match)
+
+    return match
+
+#
+#   datetime_to_time
+#
+
+def datetime_to_time(date, time):
+    """Take the date and time 4-tuples and return the time in seconds since
+    the epoch as a floating point number."""
+    if (255 in date) or (255 in time):
+        raise RuntimeError("specific date and time required")
+
+    time_tuple = (
+        date[0]+1900, date[1], date[2],
+        time[0], time[1], time[2],
+        0, 0, -1,
+        )
+    return _mktime(time_tuple)
+
+#
+#   LocalScheduleObject
+#
+
+@bacpypes_debugging
+class LocalScheduleObject(CurrentPropertyListMixIn, ScheduleObject):
+
+    def __init__(self, **kwargs):
+        if _debug: LocalScheduleObject._debug("__init__ %r", kwargs)
+
+        # make sure present value was provided
+        if 'presentValue' not in kwargs:
+            raise RuntimeError("presentValue required")
+        if not isinstance(kwargs['presentValue'], Atomic):
+            raise TypeError("presentValue must be an Atomic value")
+
+        # continue initialization
+        ScheduleObject.__init__(self, **kwargs)
+
+        # attach an interpreter task
+        self._task = LocalScheduleInterpreter(self)
+
+        # add some monitors to check the reliability if these change
+        for prop in ('weeklySchedule', 'exceptionSchedule', 'scheduleDefault'):
+            self._property_monitors[prop].append(self._check_reliability)
+
+        # check it now
+        self._check_reliability()
+
+    def _check_reliability(self, old_value=None, new_value=None):
+        """This function is called when the object is created and after
+        one of its configuration properties has changed.  The new and old value
+        parameters are ignored, this is called after the property has been
+        changed and this is only concerned with the current value."""
+        if _debug: LocalScheduleObject._debug("_check_reliability %r %r", old_value, new_value)
+
+        try:
+            schedule_default = self.scheduleDefault
+
+            if schedule_default is None:
+                raise ValueError("scheduleDefault expected")
+            if not isinstance(schedule_default, Atomic):
+                raise TypeError("scheduleDefault must be an instance of an atomic type")
+
+            schedule_datatype = schedule_default.__class__
+            if _debug: LocalScheduleObject._debug("    - schedule_datatype: %r", schedule_datatype)
+
+            if (self.weeklySchedule is None) and (self.exceptionSchedule is None):
+                raise ValueError("schedule required")
+
+            # check the weekly schedule values
+            if self.weeklySchedule:
+                for daily_schedule in self.weeklySchedule:
+                    for time_value in daily_schedule.daySchedule:
+                        if _debug: LocalScheduleObject._debug("    - daily time_value: %r", time_value)
+                        if time_value is None:
+                            pass
+                        elif not isinstance(time_value.value, (Null, schedule_datatype)):
+                            if _debug: LocalScheduleObject._debug("    - wrong type: expected %r, got %r",
+                                schedule_datatype,
+                                time_value.__class__,
+                                )
+                            raise TypeError("wrong type")
+                        elif 255 in time_value.time:
+                            if _debug: LocalScheduleObject._debug("    - wildcard in time")
+                            raise ValueError("must be a specific time")
+
+            # check the exception schedule values
+            if self.exceptionSchedule:
+                for special_event in self.exceptionSchedule:
+                    for time_value in special_event.listOfTimeValues:
+                        if _debug: LocalScheduleObject._debug("    - special event time_value: %r", time_value)
+                        if time_value is None:
+                            pass
+                        elif not isinstance(time_value.value, (Null, schedule_datatype)):
+                            if _debug: LocalScheduleObject._debug("    - wrong type: expected %r, got %r",
+                                schedule_datatype,
+                                time_value.__class__,
+                                )
+                            raise TypeError("wrong type")
+
+            # check list of object property references
+            obj_prop_refs = self.listOfObjectPropertyReferences
+            if obj_prop_refs:
+                for obj_prop_ref in obj_prop_refs:
+                    if obj_prop_ref.deviceIdentifier:
+                        raise RuntimeError("no external references")
+
+                    # get the datatype of the property to be written
+                    obj_type = obj_prop_ref.objectIdentifier[0]
+                    datatype = get_datatype(obj_type, obj_prop_ref.propertyIdentifier)
+                    if _debug: LocalScheduleObject._debug("    - datatype: %r", datatype)
+
+                    if issubclass(datatype, Array) and (obj_prop_ref.propertyArrayIndex is not None):
+                        if obj_prop_ref.propertyArrayIndex == 0:
+                            datatype = Unsigned
+                        else:
+                            datatype = datatype.subtype
+                        if _debug: LocalScheduleObject._debug("    - datatype: %r", datatype)
+
+                    if datatype is not schedule_datatype:
+                        if _debug: LocalScheduleObject._debug("    - wrong type: expected %r, got %r",
+                            datatype,
+                            schedule_datatype,
+                            )
+                        raise TypeError("wrong type")
+
+            # all good
+            self.reliability = 'noFaultDetected'
+            if _debug: LocalScheduleObject._debug("    - no fault detected")
+
+        except Exception as err:
+            if _debug: LocalScheduleObject._debug("    - exception: %r", err)
+            self.reliability = 'configurationError'
+
+#
+#   LocalScheduleInterpreter
+#
+
+@bacpypes_debugging
+class LocalScheduleInterpreter(OneShotTask):
+
+    def __init__(self, sched_obj):
+        if _debug: LocalScheduleInterpreter._debug("__init__ %r", sched_obj)
+        OneShotTask.__init__(self)
+
+        # reference the schedule object to update
+        self.sched_obj = sched_obj
+
+        # add a monitor for the present value
+        sched_obj._property_monitors['presentValue'].append(self.present_value_changed)
+
+        # call to interpret the schedule
+        deferred(self.process_task)
+
+    def present_value_changed(self, old_value, new_value):
+        """This function is called when the presentValue of the local schedule
+        object has changed, both internally by this interpreter, or externally
+        by some client using WriteProperty."""
+        if _debug: LocalScheduleInterpreter._debug("present_value_changed %s %s", old_value, new_value)
+
+        # if this hasn't been added to an application, there's nothing to do
+        if not self.sched_obj._app:
+            if _debug: LocalScheduleInterpreter._debug("    - no application")
+            return
+
+        # process the list of [device] object property [array index] references
+        obj_prop_refs = self.sched_obj.listOfObjectPropertyReferences
+        if not obj_prop_refs:
+            if _debug: LocalScheduleInterpreter._debug("    - no writes defined")
+            return
+
+        # primitive values just set the value part
+        new_value = new_value.value
+
+        # loop through the writes
+        for obj_prop_ref in obj_prop_refs:
+            if obj_prop_ref.deviceIdentifier:
+                if _debug: LocalScheduleInterpreter._debug("    - no externals")
+                continue
+
+            # get the object from the application
+            obj = self.sched_obj._app.get_object_id(obj_prop_ref.objectIdentifier)
+            if not obj:
+                if _debug: LocalScheduleInterpreter._debug("    - no object")
+                continue
+
+            # try to change the value
+            try:
+                obj.WriteProperty(
+                    obj_prop_ref.propertyIdentifier,
+                    new_value,
+                    arrayIndex=obj_prop_ref.propertyArrayIndex,
+                    priority=self.sched_obj.priorityForWriting,
+                    )
+                if _debug: LocalScheduleInterpreter._debug("    - success")
+            except Exception as err:
+                if _debug: LocalScheduleInterpreter._debug("    - error: %r", err)
+
+    def process_task(self):
+        if _debug: LocalScheduleInterpreter._debug("process_task(%s)", self.sched_obj.objectName)
+
+        # check for a valid configuration
+        if self.sched_obj.reliability != 'noFaultDetected':
+            if _debug: LocalScheduleInterpreter._debug("    - fault detected")
+            return
+
+        # get the date and time from the device object in case it provides
+        # some custom functionality
+        if self.sched_obj._app and self.sched_obj._app.localDevice:
+            current_date = self.sched_obj._app.localDevice.localDate
+            if _debug: LocalScheduleInterpreter._debug("    - current_date: %r", current_date)
+
+            current_time = self.sched_obj._app.localDevice.localTime
+            if _debug: LocalScheduleInterpreter._debug("    - current_time: %r", current_time)
+        else:
+            # get the current date and time, as provided by the task manager
+            current_date = Date().now().value
+            if _debug: LocalScheduleInterpreter._debug("    - current_date: %r", current_date)
+
+            current_time = Time().now().value
+            if _debug: LocalScheduleInterpreter._debug("    - current_time: %r", current_time)
+
+        # evaluate the time
+        current_value, next_transition = self.eval(current_date, current_time)
+        if _debug: LocalScheduleInterpreter._debug("    - current_value, next_transition: %r, %r", current_value, next_transition)
+
+        ### set the present value
+        self.sched_obj.presentValue = current_value
+
+        # compute the time of the next transition
+        transition_time = datetime_to_time(current_date, next_transition)
+
+        # install this to run again
+        self.install_task(transition_time)
+
+    def eval(self, edate, etime):
+        """Evaluate the schedule according to the provided date and time and
+        return the appropriate present value, or None if not in the effective
+        period."""
+        if _debug: LocalScheduleInterpreter._debug("eval %r %r", edate, etime)
+
+        # reference the schedule object
+        sched_obj = self.sched_obj
+        if _debug: LocalScheduleInterpreter._debug("    sched_obj: %r", sched_obj)
+
+        # verify the date falls in the effective period
+        if not match_date_range(edate, sched_obj.effectivePeriod):
+            return None
+
+        # the event priority is a list of values that are in effect for
+        # exception schedules with the special event priority, see 135.1-2013
+        # clause 7.3.2.23.10.3.8, Revision 4 Event Priority Test
+        event_priority = [None] * 16
+
+        next_day = (24, 0, 0, 0)
+        next_transition_time = [None] * 16
+
+        # check the exception schedule values
+        if sched_obj.exceptionSchedule:
+            for special_event in sched_obj.exceptionSchedule:
+                if _debug: LocalScheduleInterpreter._debug("    - special_event: %r", special_event)
+
+                # check the special event period
+                special_event_period = special_event.period
+                if special_event_period is None:
+                    raise RuntimeError("special event period required")
+
+                match = False
+                calendar_entry = special_event_period.calendarEntry
+                if calendar_entry:
+                    if _debug: LocalScheduleInterpreter._debug("    - calendar_entry: %r", calendar_entry)
+                    match = date_in_calendar_entry(edate, calendar_entry)
+                else:
+                    # get the calendar object from the application
+                    calendar_object = sched_obj._app.get_object_id(special_event_period.calendarReference)
+                    if not calendar_object:
+                        raise RuntimeError("invalid calendar object reference")
+                    if _debug: LocalScheduleInterpreter._debug("    - calendar_object: %r", calendar_object)
+
+                    for calendar_entry in calendar_object.dateList:
+                        if _debug: LocalScheduleInterpreter._debug("    - calendar_entry: %r", calendar_entry)
+                        match = date_in_calendar_entry(edate, calendar_entry)
+                        if match:
+                            break
+
+                # didn't match the period, try the next special event
+                if not match:
+                    if _debug: LocalScheduleInterpreter._debug("    - no matching calendar entry")
+                    continue
+
+                # event priority array index
+                priority = special_event.eventPriority - 1
+                if _debug: LocalScheduleInterpreter._debug("    - priority: %r", priority)
+
+                # look for all of the possible times
+                for time_value in special_event.listOfTimeValues:
+                    tval = time_value.time
+                    if tval <= etime:
+                        if isinstance(time_value.value, Null):
+                            if _debug: LocalScheduleInterpreter._debug("    - relinquish exception @ %r", tval)
+                            event_priority[priority] = None
+                            next_transition_time[priority] = None
+                        else:
+                            if _debug: LocalScheduleInterpreter._debug("    - consider exception @ %r", tval)
+                            event_priority[priority] = time_value.value
+                            next_transition_time[priority] = next_day
+                    else:
+                        next_transition_time[priority] = tval
+                        break
+
+        # assume the next transition will be at the start of the next day
+        earliest_transition = next_day
+
+        # check if any of the special events came up with something
+        for priority_value, next_transition in zip(event_priority, next_transition_time):
+            if next_transition is not None:
+                earliest_transition = min(earliest_transition, next_transition)
+            if priority_value is not None:
+                if _debug: LocalScheduleInterpreter._debug("    - priority_value: %r", priority_value)
+                return priority_value, earliest_transition
+
+        # start out with the default
+        daily_value = sched_obj.scheduleDefault
+
+        # check the daily schedule
+        if sched_obj.weeklySchedule:
+            daily_schedule = sched_obj.weeklySchedule[edate[3]]
+            if _debug: LocalScheduleInterpreter._debug("    - daily_schedule: %r", daily_schedule)
+
+            # look for all of the possible times
+            for time_value in daily_schedule.daySchedule:
+                if _debug: LocalScheduleInterpreter._debug("    - time_value: %r", time_value)
+
+                tval = time_value.time
+                if tval <= etime:
+                    if isinstance(time_value.value, Null):
+                        if _debug: LocalScheduleInterpreter._debug("    - back to normal @ %r", tval)
+                        daily_value = sched_obj.scheduleDefault
+                    else:
+                        if _debug: LocalScheduleInterpreter._debug("    - new value @ %r", tval)
+                        daily_value = time_value.value
+                else:
+                    earliest_transition = min(earliest_transition, tval)
+                    break
+
+        # return what was matched, if anything
+        return daily_value, earliest_transition
+