C++ (Cpp) Analog_Value_Encode_Property_APDU Examples

Example #1

File: av.c Project: TemcoEvan/T3-Modules

void testAnalog_Value(
    Test * pTest)
{
    uint8_t far apdu[MAX_APDU] = { 0 };
    int len = 0;
    uint32_t len_value = 0;
    uint8_t tag_number = 0;
    BACNET_OBJECT_TYPE decoded_type = OBJECT_ANALOG_VALUE;
    uint32_t decoded_instance = 0;
    uint32_t instance = 123;
    BACNET_ERROR_CLASS error_class;
    BACNET_ERROR_CODE error_code;

    len =
        Analog_Value_Encode_Property_APDU(&apdu[0], instance,
        PROP_OBJECT_IDENTIFIER, BACNET_ARRAY_ALL, &error_class, &error_code);
    ct_test(pTest, len != 0);
    len = decode_tag_number_and_value(&apdu[0], &tag_number, &len_value);
    ct_test(pTest, tag_number == BACNET_APPLICATION_TAG_OBJECT_ID);
    len =
        decode_object_id(&apdu[len], (int *) &decoded_type, &decoded_instance);
    ct_test(pTest, decoded_type == OBJECT_ANALOG_VALUE);
    ct_test(pTest, decoded_instance == instance);

    return;
}

Example #2

File: h_rp.c Project: Jongil-Park/Lin_PRJ

/* Encodes the property APDU and returns the length,
   or sets the error, and returns -1 */
int Encode_Property_APDU(
    uint8_t * apdu,
    BACNET_OBJECT_TYPE object_type,
    uint32_t object_instance,
    BACNET_PROPERTY_ID property,
    int32_t array_index,
    BACNET_ERROR_CLASS * error_class,
    BACNET_ERROR_CODE * error_code)
{
    int apdu_len = -1;

    /* initialize the default return values */
    *error_class = ERROR_CLASS_OBJECT;
    *error_code = ERROR_CODE_UNKNOWN_OBJECT;
    /* handle each object type */
    switch (object_type) {
        case OBJECT_DEVICE:
            if (Device_Valid_Object_Instance_Number(object_instance)) {
                apdu_len =
                    Device_Encode_Property_APDU(&apdu[0], object_instance,
                    property, array_index, error_class, error_code);
            }
            break;
        case OBJECT_ANALOG_INPUT:
            if (Analog_Input_Valid_Instance(object_instance)) {
                apdu_len =
                    Analog_Input_Encode_Property_APDU(&apdu[0],
                    object_instance, property, array_index, error_class,
                    error_code);
            }
            break;
        case OBJECT_ANALOG_VALUE:
            if (Analog_Value_Valid_Instance(object_instance)) {
                apdu_len =
                    Analog_Value_Encode_Property_APDU(&apdu[0],
                    object_instance, property, array_index, error_class,
                    error_code);
            }
            break;
        case OBJECT_BINARY_INPUT:
            if (Binary_Input_Valid_Instance(object_instance)) {
                apdu_len =
                    Binary_Input_Encode_Property_APDU(&apdu[0],
                    object_instance, property, array_index, error_class,
                    error_code);
            }
            break;
        case OBJECT_BINARY_OUTPUT:
            if (Binary_Output_Valid_Instance(object_instance)) {
                apdu_len =
                    Binary_Output_Encode_Property_APDU(&apdu[0],
                    object_instance, property, array_index, error_class,
                    error_code);
            }
            break;
        default:
            *error_class = ERROR_CLASS_OBJECT;
            *error_code = ERROR_CODE_UNSUPPORTED_OBJECT_TYPE;
            break;
    }

    return apdu_len;
}