def _register_vav_objs(self, vav_id, zone_id): for idx, obj_template in enumerate(vav_point_templates): idx += 1 obj_point_type = None for point_type_rule, point_type in point_type_rules.items(): if point_type_rule in obj_template : obj_point_type = point_type assert obj_point_type obj_value_type = None for value_type_rule, value_type in value_type_rules.items(): if value_type_rule in obj_template : obj_value_type = value_type assert obj_value_type obj_typestr = obj_value_type + obj_point_type obj_cls = eval('Random{0}Object'.format(obj_typestr)) name_values = [NameValue(name=name_template, value=CharacterString(value_template)) for (name_template, value_template) in obj_template] name_values.append(NameValue(name='brick:isPointOf', value=CharacterString(vav_id))) name_values.append(NameValue(name='brick:isPointOf', value=CharacterString(zone_id))) tags = ArrayOf(NameValue)(name_values) obj = obj_cls( objectIdentifier=idx + 10, objectName='Random{0}-{1}'.format(obj_cls.__name__, idx), tags=tags, ) self.add_object(obj)
def __init__(self, localIPAddr=None, localObjName='BAC0', Boid=None, maxAPDULengthAccepted='1024', segmentationSupported='segmentedBoth'): """ Initialization requires information about the local device Default values are localObjName = 'name', Boid = '2015',maxAPDULengthAccepted = '1024',segmentationSupported = 'segmentedBoth', vendorId = '842' ) Local IP address must be given in a string. Normally, the address must be in the same subnet than the bacnet network (if no BBMD or Foreign device is used) Script doesn't support BBMD actually """ log_debug("Configurating app") self.response = None self._initialized = False self._started = False self._stopped = False if localIPAddr: self.localIPAddr = localIPAddr else: self.localIPAddr = '127.0.0.1' self.segmentationSupported = segmentationSupported self.localObjName = localObjName if Boid: self.Boid = int(Boid) else: self.Boid = int('3056177') + int(random.uniform(0, 1000)) self.maxAPDULengthAccepted = maxAPDULengthAccepted self.vendorId = '842' self.vendorName = CharacterString('SERVISYS inc.') self.modelName = CharacterString('BAC0 Scripting Tool') self.discoveredDevices = None self.ResponseQueue = Queue() self.systemStatus = DeviceStatus(1) self.startApp()
def __init__(self, localIPAddr='127.0.0.1', localObjName='BAC0', DeviceId=None, maxAPDULengthAccepted='1024', maxSegmentsAccepted='1024', segmentationSupported='segmentedBoth', bbmdAddress=None, bbmdTTL=0): self._log.debug("Configurating app") self.response = None self._initialized = False self._started = False self._stopped = False self.localIPAddr = localIPAddr self.Boid = int(DeviceId) if DeviceId else ( 3056177 + int(random.uniform(0, 1000))) self.segmentationSupported = segmentationSupported self.maxSegmentsAccepted = maxSegmentsAccepted self.localObjName = localObjName self.maxAPDULengthAccepted = maxAPDULengthAccepted self.vendorId = 842 self.vendorName = CharacterString('SERVISYS inc.') self.modelName = CharacterString('BAC0 Scripting Tool') self.discoveredDevices = None self.systemStatus = DeviceStatus(1) self.bbmdAddress = bbmdAddress self.bbmdTTL = bbmdTTL self.startApp()
def __init__(self, local_ip, local_object_name='PyScada', device_id=None, max_APDU_length_accepted='1024', max_segments_accepted='1024', segmentation_supported='segmentedBoth', bbmd_address=None, bbmd_TTL=0, *args): if _debug: logger.debug("__init__ %r", args) self.this_device = None self.this_application = None self.local_ip = local_ip self.local_object_name = local_object_name self.boid = int(device_id) if device_id else ( 3056177 + int(random.uniform(0, 1000))) self.vendor_id = 0 self.vendor_name = CharacterString('PyScada') self.model_name = CharacterString('BACnet DAQ Service') self.system_status = DeviceStatus(1) self.max_APDU_length_accepted = max_APDU_length_accepted self.max_segments_accepted = max_segments_accepted self.segmentation_supported = segmentation_supported self.bbmd_address = bbmd_address self.bbmd_TTL = bbmd_TTL self.t = None
def test_character_string(self): if _debug: TestCharacterString._debug("test_character_string") obj = CharacterString() assert obj.value == '' with self.assertRaises(TypeError): CharacterString(1) with self.assertRaises(TypeError): CharacterString(1.0)
def __init__( self, localIPAddr="127.0.0.1", localObjName="BAC0", DeviceId=None, maxAPDULengthAccepted="1024", maxSegmentsAccepted="1024", segmentationSupported="segmentedBoth", bbmdAddress=None, bbmdTTL=0, ): self._log.debug("Configurating app") self.response = None self._initialized = False self._started = False self._stopped = False if localIPAddr in Base._used_ips: raise InitializationError( "IP Address provided ({}) already used.".format(localIPAddr)) if validate_ip_address(localIPAddr): self.localIPAddr = localIPAddr else: raise InitializationError( "IP Address provided ({}) invalid.".format(localIPAddr)) self.Boid = (int(DeviceId) if DeviceId else (3056177 + int(random.uniform(0, 1000)))) self.segmentationSupported = segmentationSupported self.maxSegmentsAccepted = maxSegmentsAccepted self.localObjName = localObjName self.maxAPDULengthAccepted = maxAPDULengthAccepted self.vendorId = 842 self.vendorName = CharacterString("SERVISYS inc.") self.modelName = CharacterString("BAC0 Scripting Tool") self.discoveredDevices = None self.systemStatus = DeviceStatus(1) self.bbmdAddress = bbmdAddress self.bbmdTTL = bbmdTTL try: self.startApp() except InitializationError as error: raise InitializationError("Gros probleme : {}".format(error))
def character_string_decode(tag): """Decode an character_string application tag into an character_string.""" if _debug: character_string_decode._debug("character_string_decode %r", tag) obj = CharacterString(tag) if _debug: character_string_decode._debug(" - obj: %r", obj) return obj
def create(object_type, instance, objectName, presentValue, description): new_object = object_type( objectIdentifier=(object_type.objectType, instance), objectName="{}".format(objectName), presentValue=presentValue, description=CharacterString("{}".format(presentValue)), ) return new_object
def test_character_string_endec(self): if _debug: TestCharacterString._debug("test_character_string_endec") with self.assertRaises(InvalidTag): obj = CharacterString(character_string_tag('')) character_string_endec("", '00') character_string_endec("abc", '00616263')
def test_character_string_tag(self): if _debug: TestCharacterString._debug("test_character_string_tag") tag = Tag(Tag.applicationTagClass, Tag.characterStringAppTag, 1, xtob('00')) obj = CharacterString(tag) assert obj.value == '' tag = Tag(Tag.applicationTagClass, Tag.booleanAppTag, 0, xtob('')) with self.assertRaises(InvalidTag): CharacterString(tag) tag = Tag(Tag.contextTagClass, 0, 1, xtob('ff')) with self.assertRaises(InvalidTag): CharacterString(tag) tag = Tag(Tag.openingTagClass, 0) with self.assertRaises(InvalidTag): CharacterString(tag)
def test_character_string_unicode_with_latin(self): if _debug: TestCharacterString._debug( "test_character_string_unicode_with_latin") # some controllers encoding character string mixing latin-1 and utf-8 # try to cover those cases without failing b = xtob('0030b043') # zero degress celsius tag = Tag(Tag.applicationTagClass, Tag.characterStringAppTag, len(b), b) obj = CharacterString() obj.decode(tag) assert str(obj) == "CharacterString(0,X'30b043')" if sys.version_info[0] == 2: assert obj.value == "0C" # degree symbol dropped, see unicodedata.normalize() elif sys.version_info[0] == 3: assert obj.value == "0°C" else: raise RuntimeError("unsupported version")
def character_string_statement(value): if _debug: character_string_statement._debug("character_string_statement %r", value) # chop off the encoding encoding = None if value and value[0].isdigit(): encoding, value = value.split(' ', 1) value = value.strip() if _debug: ExtendedTagList._debug(" - encoding: %r", encoding) # chop off the quotes if value: value = value[1:-1] element = CharacterString(value) if encoding: element.strEncoding = int(encoding) return element
def whohas( self, object_id=None, object_name=None, instance_range_low_limit=0, instance_range_high_limit=4194303, destination=None, global_broadcast=False, ): """ Object ID : analogInput:1 Object Name : string Instance Range Low Limit : 0 Instance Range High Limit : 4194303 destination (optional) : If empty, local broadcast will be used. global_broadcast : False """ obj_id = ObjectIdentifier(object_id) if object_name and not object_id: obj_name = CharacterString(object_name) obj = WhoHasObject(objectName=obj_name) elif object_id and not object_name: obj = WhoHasObject(objectIdentifier=obj_id) else: obj = WhoHasObject(objectIdentifier=obj_id, objectName=obj_name) limits = WhoHasLimits( deviceInstanceRangeLowLimit=instance_range_low_limit, deviceInstanceRangeHighLimit=instance_range_high_limit, ) request = WhoHasRequest(object=obj, limits=limits) if destination: request.pduDestination = Address(destination) else: if global_broadcast: request.pduDestination = GlobalBroadcast() else: request.pduDestination = LocalBroadcast() iocb = IOCB(request) # make an IOCB iocb.set_timeout(2) deferred(self.this_application.request_io, iocb) iocb.wait() iocb = IOCB(request) # make an IOCB self.this_application._last_i_have_received = [] if iocb.ioResponse: # successful response apdu = iocb.ioResponse if iocb.ioError: # unsuccessful: error/reject/abort pass time.sleep(3) # self.discoveredObjects = self.this_application.i_am_counter return self.this_application._last_i_have_received
def create_CharStrValue(oid=1, pv="null", name="String", pv_writable=False): charval = CharacterStringValueObject( objectIdentifier=("characterstringValue", oid), objectName=name, priorityArray=PriorityArray(), statusFlags=StatusFlags(), ) charval = _make_mutable(charval, mutable=pv_writable) charval.presentValue = CharacterString(pv) deprecate_msg() return charval
def dcc(self, address=None, duration=None, password=None, state=None): """ Will send DeviceCommunicationControl request """ if not self._started: raise ApplicationNotStarted( "BACnet stack not running - use startApp()") if not address: raise ValueError("Provide address for request") if not state: raise ValueError( "Provide state ('enable', 'disable', 'disableInitiation'") # build a request request = DeviceCommunicationControlRequest() request.enableDisable = DeviceCommunicationControlRequestEnableDisable.enumerations[ state] request.pduDestination = Address(address) if duration: request.duration = Unsigned16(duration) request.password = CharacterString(password) self._log.debug("{:>12} {}".format("- request:", request)) iocb = IOCB(request) # make an IOCB # pass to the BACnet stack deferred(self.this_application.request_io, iocb) # Unconfirmed request...so wait until complete iocb.wait() # Wait for BACnet response if iocb.ioResponse: # successful response apdu = iocb.ioResponse if not isinstance(apdu, SimpleAckPDU): # expect an ACK self._log.warning("Not an ack, see debug for more infos.") self._log.debug("Not an ack. | APDU : {} / {}".format( (apdu, type(apdu)))) return if iocb.ioError: # unsuccessful: error/reject/abort apdu = iocb.ioError reason = find_reason(apdu) raise NoResponseFromController( "APDU Abort Reason : {}".format(reason)) self._log.info( "DeviceCommunicationControl request sent to device : {}".format( address))
def _add_points(qty, device): # Add a lot of points for tests (segmentation required) mvs = [] avs = [] bvs = [] ais = [] bis = [] aos = [] bos = [] charstr = [] for i in range(qty): mvs.append( create_MV(oid=i, name="mv{}".format(i), pv=1, pv_writable=True)) new_av = create_AV(oid=i, name="av{}".format(i), pv=99.9, pv_writable=True) new_av.units = EngineeringUnits.enumerations["degreesCelsius"] new_av.description = "Fake Description {}".format(i) avs.append(new_av) bvs.append( create_BV(oid=i, name="bv{}".format(i), pv=1, pv_writable=True)) ais.append(create_AI(oid=i, name="ai{}".format(i), pv=99.9)) aos.append(create_AO(oid=i, name="ao{}".format(i), pv=99.9)) bis.append(create_BI(oid=i, name="bi{}".format(i), pv=1)) bos.append(create_BO(oid=i, name="bo{}".format(i), pv=1)) charstr.append( create_CharStrValue( oid=i, name="string{}".format(i), pv=CharacterString("test"), pv_writable=True, )) for mv in mvs: device.this_application.add_object(mv) for av in avs: device.this_application.add_object(av) for bv in bvs: device.this_application.add_object(bv) for ai in ais: device.this_application.add_object(ai) for ao in aos: device.this_application.add_object(ao) for bi in bis: device.this_application.add_object(bi) for bo in bos: device.this_application.add_object(bo) for cs in charstr: device.this_application.add_object(cs)
def connect(self, bacnet_server): address = self._ip_address(bacnet_server) version = get_version() description = "nube-io bacnet server" self.ldo = LocalDeviceObject( objectName=bacnet_server.local_obj_name, objectIdentifier=int(bacnet_server.device_id), maxApduLengthAccepted=1024, segmentationSupported="segmentedBoth", vendorIdentifier=bacnet_server.vendor_id, firmwareRevision=CharacterString(version), modelName=CharacterString(bacnet_server.model_name), vendorName=CharacterString(bacnet_server.vendor_name), description=CharacterString(description), systemStatus=DeviceStatus(1), applicationSoftwareVersion=CharacterString(version), databaseRevision=0) self.__bacnet = BIPSimpleApplication(self.ldo, address) self.__bacnet.add_capability(ReadWritePropertyMultipleServices) self.sync_stack() FlaskThread(target=bacnet_run).start() # start bacpypes thread
def character_string_endec(v, x): """Pass the value to CharacterString, construct a tag from the hex string, and compare results of encode and decoding each other.""" if _debug: character_string_endec._debug("character_string_endec %r %r", v, x) tag = character_string_tag(x) if _debug: character_string_endec._debug(" - tag: %r, %r", tag, tag.tagData) obj = CharacterString(v) if _debug: character_string_endec._debug(" - obj: %r, %r", obj, obj.value) assert character_string_encode(obj) == tag assert character_string_decode(tag) == obj
def build_binary(self, input_device, input_dev_point): self.input_device = input_device self.input_dev_point = input_dev_point register_object_type(BinaryValueCmdObject, vendor_id=842) bv_object = BinaryValueCmdObject( objectIdentifier=("binaryValue", BAC0_Converter.binary_value_num), objectName=self.input_dev_point, presentValue='inactive', description=CharacterString( f"imported from {self.input_device}: {self.input_dev_point} ")) BAC0_Converter.binary_value_num += 1 BAC0_Converter.binary_value_list.append(bv_object) self.device.this_application.add_object(bv_object) return bv_object
def build_analog(self, input_device, input_dev_point): global objects self.input_device = input_device self.input_dev_point = input_dev_point register_object_type(AnalogValueCmdObject, vendor_id=842) av_object = AnalogValueCmdObject( objectIdentifier=("analogValue", BAC0_Converter.analog_value_num), objectName=self.input_dev_point, presentValue=666, description=CharacterString( f"imported from {self.input_device}: {self.input_dev_point} ")) BAC0_Converter.analog_value_num += 1 BAC0_Converter.analog_value_list.append(av_object) self.device.this_application.add_object(av_object) return av_object
def build_text_write_request(self, addr, obj_type, obj_inst, value, prop_id="description"): request = WritePropertyRequest(objectIdentifier=(obj_type, obj_inst), propertyIdentifier=prop_id) request.pduDestination = Address(addr) _value = Any() _value.cast_in(CharacterString(value)) request.propertyValue = _value return request
def create_object(object_class, oid, objectName, description, presentValue=None, commandable=False): new_object = object_class( objectIdentifier=(object_class.objectType, oid), objectName="{}".format(objectName), presentValue=presentValue, description=CharacterString("{}".format(description)), statusFlags=StatusFlags(), ) deprecate_msg() return _make_mutable(new_object, mutable=commandable)
def wrapper(*args, **kwargs): if callable(func): obj = func(*args, **kwargs) else: obj = func base_cls = obj.__class__ base_cls_name = obj.__class__.__name__ + cls.__name__ new_type = type(base_cls_name, (cls, base_cls), {}) register_object_type(new_type, vendor_id=842) instance, objectName, presentValue, description = args new_object = new_type( objectIdentifier=(base_cls.objectType, instance), objectName="{}".format(objectName), presentValue=presentValue, description=CharacterString("{}".format(description)), ) return new_object
def create_object_list(objects_dict): """ d = {name: (name, description, presentValue, units, commandable)} """ obj_list = [] for obj_id, v in objects_dict.items(): object_class, name, oid, description, presentValue, commandable = v description = CharacterString(description) new_obj = create_object(object_class, name, oid, description, commandable=commandable) if presentValue: new_obj.presentValue = presentValue obj_list.append(new_obj) return obj_list
def wrapper(*args, **kwargs): if callable(func): obj = func(*args, **kwargs) else: obj = func allowed_prop = _allowed_prop(obj) _type = allowed_prop["presentValue"] _commando = Commandable(_type) base_cls = obj.__class__ base_cls_name = obj.__class__.__name__ + "Cmd" new_type = type(base_cls_name, (_commando, base_cls), {}) new_type.__name__ = base_cls_name register_object_type(new_type, vendor_id=842) objectType, instance, objectName, presentValue, description = args new_object = new_type( objectIdentifier=(base_cls.objectType, instance), objectName="{}".format(objectName), presentValue=presentValue, description=CharacterString("{}".format(description)), ) return new_object
def __init__( self, localIPAddr="127.0.0.1", localObjName="BAC0", deviceId=None, firmwareRevision="".join(sys.version.split("|")[:2]), maxAPDULengthAccepted="1024", maxSegmentsAccepted="1024", segmentationSupported="segmentedBoth", bbmdAddress=None, bbmdTTL=0, bdtable=None, modelName=CharacterString("BAC0 Scripting Tool"), vendorId=842, vendorName=CharacterString("SERVISYS inc."), description=CharacterString( "http://christiantremblay.github.io/BAC0/"), ): self._log.debug("Configurating app") if not _COMPLETE: self._log.debug( "To be able to run the web server, you must install pandas, bokeh, flask and flask_bootstrap" ) self._log.debug( "Those are not all installed so BAC0 will work in Lite mode only." ) self.response = None self._initialized = False self._started = False self._stopped = False if localIPAddr in Base._used_ips: raise InitializationError( "IP Address provided ({}) already used by BAC0. Check if another software is using port 47808 on this network interface. If so, you can define multiple IP per interface. Or specify another IP using BAC0.lite(ip='IP/mask')" .format(localIPAddr)) if validate_ip_address(localIPAddr): self.localIPAddr = localIPAddr else: raise InitializationError( "IP Address provided ({}) invalid. Check if another software is using port 47808 on this network interface. If so, you can define multiple IP per interface. Or specify another IP using BAC0.lite(ip='IP/mask')" .format(localIPAddr)) self.Boid = (int(deviceId) if deviceId else (3056177 + int(random.uniform(0, 1000)))) self.segmentationSupported = segmentationSupported self.maxSegmentsAccepted = maxSegmentsAccepted self.localObjName = localObjName self.local_objects = LocalObjects(device=self) self.maxAPDULengthAccepted = maxAPDULengthAccepted self.vendorId = vendorId self.vendorName = vendorName self.modelName = modelName self.description = description self.discoveredDevices = None self.systemStatus = DeviceStatus(1) self.bbmdAddress = bbmdAddress self.bbmdTTL = bbmdTTL self.bdtable = bdtable self.firmwareRevision = firmwareRevision self._ric = {} self.subscription_contexts = {} try: self.startApp() except InitializationError as error: raise InitializationError( "Gros probleme : {}. Address requested : {}".format( error, localIPAddr))
def do_write(self, args): """ write <indx> <value> write 0 <len> write [ <value> ]... """ args = args.split() ReadWritePropertyConsoleCmd._debug("do_write %r", args) try: addr, obj_type, obj_inst = context prop_id = 'eventMessageTexts' indx = None if args and args[0].isdigit(): indx = int(args[0]) if indx == 0: value = Unsigned(int(args[1])) else: value = CharacterString(args[1]) else: value = ArrayOf(CharacterString)(args[0:]) # build a request request = WritePropertyRequest(objectIdentifier=(obj_type, obj_inst), propertyIdentifier=prop_id) request.pduDestination = Address(addr) # save the value request.propertyValue = Any() try: request.propertyValue.cast_in(value) except Exception as error: ReadWritePropertyConsoleCmd._exception( "WriteProperty cast error: %r", error) # optional array index if indx is not None: request.propertyArrayIndex = indx if _debug: ReadWritePropertyConsoleCmd._debug(" - request: %r", request) # make an IOCB iocb = IOCB(request) if _debug: ReadWritePropertyConsoleCmd._debug(" - iocb: %r", iocb) # give it to the application this_application.request_io(iocb) # wait for it to complete iocb.wait() # do something for success if iocb.ioResponse: # should be an ack if not isinstance(iocb.ioResponse, SimpleAckPDU): if _debug: ReadWritePropertyConsoleCmd._debug(" - not an ack") return sys.stdout.write("ack\n") # do something for error/reject/abort if iocb.ioError: sys.stdout.write(str(iocb.ioError) + '\n') except Exception as error: ReadWritePropertyConsoleCmd._exception("exception: %r", error)
#!/usr/bin/env python # -*- coding utf-8 -*- """ Test Bacnet communication with another device """ from bacpypes.primitivedata import CharacterString NEWCSVALUE = CharacterString("New_Test") def test_WriteAV(network_and_devices): # Write to an object and validate new value is correct test_device = network_and_devices.test_device old_value = test_device["av0"].value test_device["av0"] = 11.2 new_value = test_device["av0"].value assert (new_value - 11.2) < 0.01 def test_RelinquishDefault(network_and_devices): # Write to an object and validate new value is correct test_device = network_and_devices.test_device old_value = test_device["av0"].value test_device["av0"].default(90) new_value = test_device["av0"].value assert (new_value - 90) < 0.01 def test_WriteCharStr(network_and_devices):
def start_device(): print("Starting BACnet device") new_device = BAC0.lite() new_device._log.info('Device ID : {}'.format(new_device.Boid)) time.sleep(10) default_pv = CharacterString("empty") current_humidity = create_AV(oid=0, name="Current_Humidity", pv=0, pv_writable=False) current_humidity.units = EngineeringUnits("percent") current_humidity.description = CharacterString( "Current Humidity in percent relative humidity") current_temp = create_AV(oid=1, name="Current_Temp", pv=0, pv_writable=False) current_temp.units = EngineeringUnits("degreesFahrenheit") current_temp.description = CharacterString("Current Temperature in degF") current_windspd = create_AV(oid=2, name="Current_Wind_Speed", pv=0, pv_writable=False) current_windspd.units = EngineeringUnits("milesPerHour") current_windspd.description = CharacterString("Current Wind Speed") current_winddir = create_CharStrValue(oid=3, name="Current_Wind_Dir", pv=default_pv, pv_writable=False) current_winddir.description = CharacterString("Wind Direction String") current_pressure = create_AV(oid=4, name="Current_Pressure", pv=0, pv_writable=False) current_pressure.units = EngineeringUnits("hectopascals") current_pressure.description = CharacterString( "Current Barometric Pressure") current_cloudcov = create_AV(oid=5, name="Current_Cloud_Cover", pv=0, pv_writable=False) current_cloudcov.units = EngineeringUnits("percent") current_cloudcov.description = CharacterString( "Current Cloud Cover in Percent") last_update = create_DateTimeValue(oid=1, name="Last_Update") last_update.description = CharacterString("Last update timestamp") current_location = create_CharStrValue(oid=8, name="Weather_Station_City", pv=default_pv) current_location.description = CharacterString( "Location of Weather Station") current_description = create_CharStrValue( oid=9, name="Current_Weather_Description", pv=default_pv) current_description.description = CharacterString( "Weather Station Description String") current_dewpoint = create_AV(oid=10, name="Current_Dewpoint", pv=0, pv_writable=False) current_dewpoint.units = EngineeringUnits("degreesFahrenheit") current_dewpoint.description = CharacterString("Current Outdoor Dewpoint") new_device.this_application.add_object(current_humidity) new_device.this_application.add_object(current_temp) new_device.this_application.add_object(current_windspd) new_device.this_application.add_object(current_winddir) new_device.this_application.add_object(current_pressure) new_device.this_application.add_object(current_cloudcov) new_device.this_application.add_object(last_update) new_device.this_application.add_object(current_location) new_device.this_application.add_object(current_description) new_device.this_application.add_object(current_dewpoint) return new_device
def test_boolean_application_to_object(self): if _debug: TestApplicationTag._debug("test_boolean_application_to_object") # null obj_endec(Null(), '00') # boolean obj_endec(Boolean(True), '11') obj_endec(Boolean(False), '10') # unsigned obj_endec(Unsigned(0), '2100') obj_endec(Unsigned(1), '2101') obj_endec(Unsigned(127), '217F') obj_endec(Unsigned(128), '2180') # integer obj_endec(Integer(0), '3100') obj_endec(Integer(1), '3101') obj_endec(Integer(-1), '31FF') obj_endec(Integer(128), '320080') obj_endec(Integer(-128), '3180') # real obj_endec(Real(0), '4400000000') obj_endec(Real(1), '443F800000') obj_endec(Real(-1), '44BF800000') obj_endec(Real(73.5), '4442930000') # double obj_endec(Double(0), '55080000000000000000') obj_endec(Double(1), '55083FF0000000000000') obj_endec(Double(-1), '5508BFF0000000000000') obj_endec(Double(73.5), '55084052600000000000') # octet string obj_endec(OctetString(xtob('')), '60') obj_endec(OctetString(xtob('01')), '6101') obj_endec(OctetString(xtob('0102')), '620102') obj_endec(OctetString(xtob('010203040506')), '6506010203040506') # character string obj_endec(CharacterString(''), '7100') obj_endec(CharacterString('a'), '720061') obj_endec(CharacterString('abcde'), '7506006162636465') # bit string obj_endec(BitString([]), '8100') obj_endec(BitString([0]), '820700') obj_endec(BitString([1]), '820780') obj_endec(BitString([1, 1, 1, 1, 1]), '8203F8') obj_endec(BitString([1] * 10), '8306FFC0') # enumerated obj_endec(Enumerated(0), '9100') obj_endec(Enumerated(1), '9101') obj_endec(Enumerated(127), '917F') obj_endec(Enumerated(128), '9180') # date obj_endec(Date((1, 2, 3, 4)), 'A401020304') obj_endec(Date((255, 2, 3, 4)), 'A4FF020304') obj_endec(Date((1, 255, 3, 4)), 'A401FF0304') obj_endec(Date((1, 2, 255, 4)), 'A40102FF04') obj_endec(Date((1, 2, 3, 255)), 'A4010203FF') # time obj_endec(Time((1, 2, 3, 4)), 'B401020304') obj_endec(Time((255, 2, 3, 4)), 'B4FF020304') obj_endec(Time((1, 255, 3, 4)), 'B401FF0304') obj_endec(Time((1, 2, 255, 4)), 'B40102FF04') obj_endec(Time((1, 2, 3, 255)), 'B4010203FF') # object identifier obj_endec(ObjectIdentifier(0, 0), 'C400000000') obj_endec(ObjectIdentifier(1, 0), 'C400400000') obj_endec(ObjectIdentifier(0, 2), 'C400000002') obj_endec(ObjectIdentifier(3, 4), 'C400C00004')