2

所以我正在开发一个 BACnet 自动控制系统，我对它比较陌生，因为这是我第一次使用 BACnet。我将 ASN.1 协议与 asn1c 编译器一起使用，该编译器将我的代码转换为 C 格式。由于多种原因，我很难找到一个关于如何实现代码的清晰示例。1，我不完全确定 ASN.1 的实际工作原理，以及 2，现在代码已经转换为 C，它看起来大不相同，物理语法让我很困惑。我想知道是否有人可以解释 ASN.1 传输数据的实际过程。我已经读过使用 ASN.1 可以让手机与超级计算机进行通信，我想确切地知道如何，而且，如果有人有明确的“白痴证明” 如何实际解码和编码可以从 BACnet 消息读取和写入的消息的示例。下面我发布了 BACnetObjectIdentifier

           #include "BACnetObjectIdentifier.h"
           main()
           {
           int
           BACnetObjectIdentifier_constraint(asn_TYPE_descriptor_t *td, const void                         
                    asn_app_constraint_failed_f *ctfailcb, void *app_key) {
        const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
        size_t size;

          if(!sptr) {
                    _ASN_CTFAIL(app_key, td, sptr,
                    "%s: value not given (%s:%d)",
                    td->name, __FILE__, __LINE__);
                    return -1;
                     }

    size = st->size;

    if((size == 4)) {
            /* Constraint check succeeded */
            return 0;
    } else {
            _ASN_CTFAIL(app_key, td, sptr,
                    "%s: constraint failed (%s:%d)",
                    td->name, __FILE__, __LINE__);
            return -1;
            }
     }
           static void
       BACnetObjectIdentifier_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
           td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
           td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
           td->check_constraints = asn_DEF_OCTET_STRING.check_constraints;
           td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
           td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
           td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
           td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
           td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
           td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
           if(!td->per_constraints){
               td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
               td->elements       = asn_DEF_OCTET_STRING.elements;
               td->elements_count = asn_DEF_OCTET_STRING.elements_count;
               td->specifics      = asn_DEF_OCTET_STRING.specifics;
               }

            void
             BACnetObjectIdentifier_free(asn_TYPE_descriptor_t *td,
               void *struct_ptr, int contents_only) {
               BACnetObjectIdentifier_1_inherit_TYPE_descriptor(td);
               td->free_struct(td, struct_ptr, contents_only);
               }

                int
        BACnetObjectIdentifier_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
            int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
            BACnetObjectIdentifier_1_inherit_TYPE_descriptor(td);
            return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
             }

            asn_dec_rval_t
 BACnetObjectIdentifier_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
               void **structure, const void *bufptr, size_t size, int tag_mode) {
                BACnetObjectIdentifier_1_inherit_TYPE_descriptor(td);
          return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
                 }

            asn_enc_rval_t
            BACnetObjectIdentifier_encode_der(asn_TYPE_descriptor_t *td,
                    void *structure, int tag_mode, ber_tlv_tag_t tag,
                    asn_app_consume_bytes_f *cb, void *app_key) {
                    BACnetObjectIdentifier_1_inherit_TYPE_descriptor(td);
                    return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
                    }

                 asn_dec_rval_t
             BACnetObjectIdentifier_decode_xer(asn_codec_ctx_t *opt_codec_ctx,   asn_TYPE_descriptor_t *td,

                             void **structure, const void *bufptr, size_t size, int   tag_mode) {
             BACnetObjectIdentifier_1_inherit_TYPE_descriptor(td);
           return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
            }

          asn_enc_rval_t
          BACnetObjectIdentifier_encode_der(asn_TYPE_descriptor_t *td,
             void *structure, int tag_mode, ber_tlv_tag_t tag,
             asn_app_consume_bytes_f *cb, void *app_key) {
            BACnetObjectIdentifier_1_inherit_TYPE_descriptor(td);
             return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
            }

        asn_dec_rval_t
        BACnetObjectIdentifier_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
            void **structure, const char *opt_mname, const void *bufptr, size_t size) {
            BACnetObjectIdentifier_1_inherit_TYPE_descriptor(td);
           return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr,  size);
             }

             asn_enc_rval_t
              BACnetObjectIdentifier_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
               int ilevel, enum xer_encoder_flags_e flags,
               asn_app_consume_bytes_f *cb, void *app_key) {
               BACnetObjectIdentifier_1_inherit_TYPE_descriptor(td);
               return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
               }

              asn_dec_rval_t
              BACnetObjectIdentifier_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
               asn_per_constraints_t *constraints, void **structure, asn_per_data_t                 *per_data) {
             BACnetObjectIdentifier_1_inherit_TYPE_descriptor(td);
             return td->uper_decoder(opt_codec_ctx, td, constraints, structure,  per_data);
              }

            asn_enc_rval_t
            BACnetObjectIdentifier_encode_uper(asn_TYPE_descriptor_t *td,
                  asn_per_constraints_t *constraints,
                  void *structure, asn_per_outp_t *per_out) {
                  BACnetObjectIdentifier_1_inherit_TYPE_descriptor(td);
                  return td->uper_encoder(td, constraints, structure, per_out);
                }

                static asn_per_constraints_t            asn_PER_type_BACnetObjectIdentifier_constr_1 GCC_NOTUSED = {
          { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
                   { APC_CONSTRAINED,       0,  0,  4,  4 }        /* (SIZE(4..4)) */,
       0, 0    /* No PER value map */
         };
       static ber_tlv_tag_t asn_DEF_BACnetObjectIdentifier_tags_1[] = {
            (ASN_TAG_CLASS_APPLICATION | (12 << 2)),
         (ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
             };
           asn_TYPE_descriptor_t asn_DEF_BACnetObjectIdentifier = {
          "BACnetObjectIdentifier",
          "BACnetObjectIdentifier",
           BACnetObjectIdentifier_free,
           BACnetObjectIdentifier_print,
           BACnetObjectIdentifier_constraint,
           BACnetObjectIdentifier_decode_ber,
           BACnetObjectIdentifier_encode_der,
           BACnetObjectIdentifier_decode_xer,
           BACnetObjectIdentifier_encode_xer,
           BACnetObjectIdentifier_decode_uper,
           BACnetObjectIdentifier_encode_uper,
           0,      /* Use generic outmost tag fetcher */
           asn_DEF_BACnetObjectIdentifier_tags_1,
               sizeof(asn_DEF_BACnetObjectIdentifier_tags_1)
               /sizeof(asn_DEF_BACnetObjectIdentifier_tags_1[0]) - 1, /* 1 */
                asn_DEF_BACnetObjectIdentifier_tags_1,  /* Same as above */
               sizeof(asn_DEF_BACnetObjectIdentifier_tags_1)
                 /sizeof(asn_DEF_BACnetObjectIdentifier_tags_1[0]), /* 2 */
                   &asn_PER_type_BACnetObjectIdentifier_constr_1,
                   0, 0,   /* No members */
                 0       /* No specifics */
                     };
                 }

上面的代码是 asn1c 编译器生成的。任何帮助是极大的赞赏。

4

3 回答 3

1

您需要的是对 ASN.1 的介绍以及您正在使用的工具的介绍。对于前者，您可以从这里开始：http ://www.obj-sys.com/resources/links_asn1_info.php 。后者我帮不了你。

为了帮助您定位，一个非常简短的总结：ASN.1 是抽象语法表示法。它是一种用于在摘要中描述消息语法的符号。“抽象地”意味着，例如，使用符号您将指定一个整数在序列中跟随另一个整数，但您没有指定这些整数在传输中如何实际表示（例如，将使用多少位？） . 当您将抽象符号与一组编码规则（例如 BER、PER；编码规则是标准化的——您不必编写它们）结合起来时，它就会变得具体。编码规则与抽象语法相结合，完全指定了传输的内容。

代码生成工具的作用在概念上很简单。他们阅读 ASN.1 描述并以您最喜欢的编程语言生成数据结构，这些数据结构对来自 ASN.1 的消息进行建模，以及可以采用这些数据结构并根据您选择的一组编码规则对相应消息进行编码/解码的函数。作为程序员，您填充数据结构，调用 encode 方法，并接收根据您选择的规则（例如 BER）编码的 ASN.1 消息。

于 2014-07-26T12:47:19.853 回答
0

您真正需要的是一份 Ashrae 135-2012（或更高版本）标准的副本。（不幸的是非免费的——尽管勘误表和附录是免费的）。

ASN1只是描述了一些编码规则，但这并不是因为我的邮件是用base64编码的，你读base64就可以读邮件。您还需要了解其他标头、上下文、规则和语义。

编码、类型、枚举和服务代码在 Ashrae 135 标准中非常详细。而这种信息对于理解和“读取”BACnet 数据包确实是必需的。

使用 Wireshark 查看和打开一些捕获的数据包，也确实很有帮助，以便了解信息是如何列出和发送的，具体取决于各种消息上下文。

您还可以选择 BACnet 通信协议的免费或非免费 C 或 Java 或 C#（或其他）实现并使用它。

于 2016-12-16T17:07:05.033 回答
0

如果您想深入研究 BACnet 的（世界），那么我担心您可能会从错误的角度/直接进入深端（或至少是它的特定方面/深度），因此在给自己机会涉足之前咀嚼复杂性，首先了解/测试水（以更一般/跨领域的方式）。

例如，以空手道为例，如果学习 BACnet 正在获得黑带，那么学习 ASN 可能是进一步提升到 1 段或 2 段。

我建议尝试像 YABE 这样的工具，然后（而不是 Wireshark）VTS（Visual Test Shell），然后有一天 - 如果您编写自己的 BACnet（模拟）设备的一部分，那么您将获得更多理解。

（YABE 是用 C# 编写的，但 VTS 是用 C++ 编写的，BACnetStack 是用 C 编写的。）

于 2021-08-24T20:56:20.003 回答