Esempio n. 1
0
    def readProperty(self, request, address, invoke_key, device):
        # Read Property
        # TODO: add support for PropertyArrayIndex handling;
        for obj in device.objectList.value[2:]:
            if (
                int(request.objectIdentifier[1]) == obj[1]
                and request.objectIdentifier[0] == obj[0]
            ):
                objName = self.objectIdentifier[obj].objectName
                for prop in self.objectIdentifier[obj].properties:
                    if request.propertyIdentifier == prop.identifier:
                        propName = prop.identifier
                        propValue = prop.ReadProperty(self.objectIdentifier[obj])
                        propType = prop.datatype()
                        self._response_service = "ComplexAckPDU"
                        self._response = ReadPropertyACK()
                        self._response.pduDestination = address
                        self._response.apduInvokeID = invoke_key
                        self._response.objectIdentifier = obj[1]
                        self._response.objectName = objName
                        self._response.propertyIdentifier = propName

                        # get the property type
                        for p in dir(sys.modules[propType.__module__]):
                            _obj = getattr(sys.modules[propType.__module__], p)
                            try:
                                if type(propType) == _obj:
                                    break
                            except TypeError:
                                pass
                        value = ast.literal_eval(propValue)
                        self._response.propertyValue = Any(_obj(value))
                        # self._response.propertyValue.cast_in(objPropVal)
                        # self._response.debug_contents()
                        break
                else:
                    logger.info(
                        "Bacnet ReadProperty: object has no property %s",
                        request.propertyIdentifier,
                    )
                    self._response = ErrorPDU()
                    self._response.pduDestination = address
                    self._response.apduInvokeID = invoke_key
                    self._response.apduService = 0x0C
Esempio n. 2
0
    def indication(self, apdu, address, device):
        """logging the received PDU type and Service request"""
        request = None
        apdu_type = apdu_types.get(apdu.apduType)
        invoke_key = apdu.apduInvokeID
        logger.info('Bacnet PDU received from %s:%d. (%s)', address[0],
                    address[1], apdu_type.__name__)
        if apdu_type.pduType == 0x0:
            # Confirmed request handling
            apdu_service = confirmed_request_types.get(apdu.apduService)
            logger.info('Bacnet indication from %s:%d. (%s)', address[0],
                        address[1], apdu_service.__name__)
            try:
                request = apdu_service()
                request.decode(apdu)
            except (AttributeError, RuntimeError,
                    InvalidParameterDatatype) as e:
                logger.warning(
                    'Bacnet indication: Invalid service. Error: %s' % e)
                return
            except bacpypes.errors.DecodingError:
                pass

            for key, value in list(
                    ConfirmedServiceChoice.enumerations.items()):
                if apdu_service.serviceChoice == value:
                    try:
                        getattr(self, key)(request, address, invoke_key,
                                           device)
                        break
                    except AttributeError:
                        logger.error('Not implemented Bacnet command')
                        self._response = None
                        return
            else:
                logger.info(
                    'Bacnet indication: Invalid confirmed service choice (%s)',
                    apdu_service.__name__)
                self._response = None
                return

        # Unconfirmed request handling
        elif apdu_type.pduType == 0x1:
            apdu_service = unconfirmed_request_types.get(apdu.apduService)
            logger.info('Bacnet indication from %s:%d. (%s)', address[0],
                        address[1], apdu_service.__name__)
            try:
                request = apdu_service()
                request.decode(apdu)
            except (AttributeError, RuntimeError):
                logger.exception('Bacnet indication: Invalid service.')
                self._response = None
                return
            except bacpypes.errors.DecodingError:
                pass

            for key, value in list(
                    UnconfirmedServiceChoice.enumerations.items()):
                if apdu_service.serviceChoice == value:
                    try:
                        getattr(self, key)(request, address, invoke_key,
                                           device)
                        break
                    except AttributeError:
                        logger.error('Not implemented Bacnet command')
                        self._response = None
                        return
            else:
                # Unrecognized services
                logger.info(
                    'Bacnet indication: Invalid unconfirmed service choice (%s)',
                    apdu_service)
                self._response_service = 'ErrorPDU'
                self._response = ErrorPDU()
                self._response.pduDestination = address
                return
        # ignore the following
        elif apdu_type.pduType == 0x2:
            # simple ack pdu
            self._response = None
            return
        elif apdu_type.pduType == 0x3:
            # complex ack pdu
            self._response = None
            return
        elif apdu_type.pduType == 0x4:
            # segment ack
            self._response = None
            return
        elif apdu_type.pduType == 0x5:
            # error pdu
            self._response = None
            return
        elif apdu_type.pduType == 0x6:
            # reject pdu
            self._response = None
            return
        elif apdu_type.pduType == 0x7:
            # abort pdu
            self._response = None
            return
        elif 0x8 <= apdu_type.pduType <= 0xf:
            # reserved
            self._response = None
            return
        else:
            # non-BACnet PDU types
            logger.info('Bacnet Unrecognized service')
            self._response = None
            return
 def readProperty(self, request, address, invoke_key, device):
     # Read Property
     # TODO: add support for PropertyArrayIndex handling;
     logger.info('requestPropertyId: ' + str(request.propertyIdentifier))
     for obj in device.objectList.value[2:]:
         if int(request.objectIdentifier[1]) == obj[1] and \
                         request.objectIdentifier[0] == obj[0]:
             objName = self.objectIdentifier[obj].objectName
             for prop in self.objectIdentifier[obj].properties:
                 #logger.info('propIdentifier: ' + str(prop.identifier))
                 if request.propertyIdentifier == prop.identifier:
                     propName = prop.identifier
                     propValue = prop.ReadProperty(
                         self.objectIdentifier[obj])
                     propType = prop.datatype()
                     self._response_service = 'ComplexAckPDU'
                     self._response = ReadPropertyACK()
                     self._response.pduDestination = address
                     self._response.apduInvokeID = invoke_key
                     self._response.objectIdentifier = obj[1]
                     self._response.objectName = objName
                     self._response.propertyIdentifier = propName
                     """
                     # get the property type
                     for p in dir(sys.modules[propType.__module__]):
                         _obj = getattr(sys.modules[propType.__module__], p)
                         #try:
                         #    if type(propType) == _obj:
                         if (isinstance(_obj,dict)):
                             if _obj.get(ObjectIdentifier) is not None:
                                 _obj_type = _obj.get(ObjectIdentifier)
                                 break
                         else:
                             try:
                                 if type(propType) == _obj:
                                     _obj_type = _obj
                                     break
                             except TypeError:
                                 pass
                     """
                     logger.info('propValue is : ' + str(propValue))
                     if propValue is not None:
                         value = ast.literal_eval(propValue)
                         self._response.propertyValue = Any(
                             type(propType)(value))
                     else:
                         logger.info(
                             'Bacnet ReadProperty: object has no property %s',
                             request.propertyIdentifier)
                         self._response = ErrorPDU()
                         self._response.pduDestination = address
                         self._response.apduInvokeID = invoke_key
                         self._response.apduService = 0x0c
                     #self._response.propertyValue = Any(_obj(value))
                     # self._response.propertyValue.cast_in(objPropVal)
                     # self._response.debug_contents()
                     break
             else:
                 logger.info(
                     'Bacnet ReadProperty: object has no property %s',
                     request.propertyIdentifier)
                 self._response = ErrorPDU()
                 self._response.pduDestination = address
                 self._response.apduInvokeID = invoke_key
                 self._response.apduService = 0x0c