Esempi in C++ (Cpp) per alarm_ack_decode_service_request

Esempio n. 1

File: alarm_ack.c Progetto: stargieg/bacnet-stack

void testAlarmAck(
    Test * pTest)
{
    BACNET_ALARM_ACK_DATA testAlarmAckIn;
    BACNET_ALARM_ACK_DATA testAlarmAckOut;

    uint8_t buffer[MAX_APDU];
    int inLen;
    int outLen;

    testAlarmAckIn.ackProcessIdentifier = 0x1234;
    characterstring_init_ansi(&testAlarmAckIn.ackSource, "This is a test");
    testAlarmAckIn.ackTimeStamp.tag = TIME_STAMP_SEQUENCE;
    testAlarmAckIn.ackTimeStamp.value.sequenceNum = 0x4331;
    testAlarmAckIn.eventObjectIdentifier.instance = 567;
    testAlarmAckIn.eventObjectIdentifier.type = OBJECT_DEVICE;
    testAlarmAckIn.eventTimeStamp.tag = TIME_STAMP_TIME;
    testAlarmAckIn.eventTimeStamp.value.time.hour = 10;
    testAlarmAckIn.eventTimeStamp.value.time.min = 11;
    testAlarmAckIn.eventTimeStamp.value.time.sec = 12;
    testAlarmAckIn.eventTimeStamp.value.time.hundredths = 14;
    testAlarmAckIn.eventStateAcked = EVENT_STATE_OFFNORMAL;

    memset(&testAlarmAckOut, 0, sizeof(testAlarmAckOut));


    inLen = alarm_ack_encode_service_request(buffer, &testAlarmAckIn);
    outLen = alarm_ack_decode_service_request(buffer, inLen, &testAlarmAckOut);

    ct_test(pTest, inLen == outLen);

    ct_test(pTest,
            testAlarmAckIn.ackProcessIdentifier ==
            testAlarmAckOut.ackProcessIdentifier);

    ct_test(pTest,
            testAlarmAckIn.ackTimeStamp.tag == testAlarmAckOut.ackTimeStamp.tag);
    ct_test(pTest,
            testAlarmAckIn.ackTimeStamp.value.sequenceNum ==
            testAlarmAckOut.ackTimeStamp.value.sequenceNum);

    ct_test(pTest,
            testAlarmAckIn.ackProcessIdentifier ==
            testAlarmAckOut.ackProcessIdentifier);

    ct_test(pTest,
            testAlarmAckIn.eventObjectIdentifier.instance ==
            testAlarmAckOut.eventObjectIdentifier.instance);
    ct_test(pTest,
            testAlarmAckIn.eventObjectIdentifier.type ==
            testAlarmAckOut.eventObjectIdentifier.type);

    ct_test(pTest,
            testAlarmAckIn.eventTimeStamp.tag ==
            testAlarmAckOut.eventTimeStamp.tag);
    ct_test(pTest,
            testAlarmAckIn.eventTimeStamp.value.time.hour ==
            testAlarmAckOut.eventTimeStamp.value.time.hour);
    ct_test(pTest,
            testAlarmAckIn.eventTimeStamp.value.time.min ==
            testAlarmAckOut.eventTimeStamp.value.time.min);
    ct_test(pTest,
            testAlarmAckIn.eventTimeStamp.value.time.sec ==
            testAlarmAckOut.eventTimeStamp.value.time.sec);
    ct_test(pTest,
            testAlarmAckIn.eventTimeStamp.value.time.hundredths ==
            testAlarmAckOut.eventTimeStamp.value.time.hundredths);

    ct_test(pTest,
            testAlarmAckIn.eventStateAcked == testAlarmAckOut.eventStateAcked);

}

Esempio n. 2

File: h_alarm_ack.c Progetto: beh9540/bacnetwx2

void handler_alarm_ack(
    uint8_t * service_request,
    uint16_t service_len,
    BACNET_ADDRESS * src,
    BACNET_CONFIRMED_SERVICE_DATA * service_data)
{
    BACNET_ALARM_ACK_DATA data;
    int len = 0;
    int pdu_len = 0;
    BACNET_NPDU_DATA npdu_data;
    int bytes_sent = 0;
    BACNET_ADDRESS my_address;

    /* encode the NPDU portion of the packet */
    datalink_get_my_address(&my_address);
    npdu_encode_npdu_data(&npdu_data, false, MESSAGE_PRIORITY_NORMAL);
    pdu_len =
        npdu_encode_pdu(&Handler_Transmit_Buffer[0], src, &my_address,
        &npdu_data);
    if (service_data->segmented_message) {
        /* we don't support segmentation - send an abort */
        len =
            abort_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
            service_data->invoke_id, ABORT_REASON_SEGMENTATION_NOT_SUPPORTED,
            true);
#if PRINT_ENABLED
        fprintf(stderr, "Alarm Ack: Segmented message.  Sending Abort!\n");
#endif
        goto AA_ABORT;
    }

    len =
        alarm_ack_decode_service_request(service_request, service_len, &data);
#if PRINT_ENABLED
    if (len <= 0)
        fprintf(stderr, "Alarm Ack: Unable to decode Request!\n");
#endif
    if (len < 0) {
        /* bad decoding - send an abort */
        len =
            abort_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
            service_data->invoke_id, ABORT_REASON_OTHER, true);
#if PRINT_ENABLED
        fprintf(stderr, "Alarm Ack: Bad Encoding.  Sending Abort!\n");
#endif
        goto AA_ABORT;
    }

    /*
     ** Process Life Safety Operation Here
     */
#if PRINT_ENABLED
    fprintf(stderr,
        "Alarm Ack Operation: Received acknowledge for object id %d from %s for process id %d for object %id\n",
        data.eventObjectIdentifier.instance, data.ackSource.value,
        data.ackProcessIdentifier, data.eventObjectIdentifier.instance);
#endif

    len =
        encode_simple_ack(&Handler_Transmit_Buffer[pdu_len],
        service_data->invoke_id, SERVICE_CONFIRMED_ACKNOWLEDGE_ALARM);
#if PRINT_ENABLED
    fprintf(stderr, "Alarm Acknowledge: " "Sending Simple Ack!\n");
#endif

  AA_ABORT:
    pdu_len += len;
    bytes_sent =
        datalink_send_pdu(src, &npdu_data, &Handler_Transmit_Buffer[0],
        pdu_len);
#if PRINT_ENABLED
    if (bytes_sent <= 0)
        fprintf(stderr, "Alarm Acknowledge: " "Failed to send PDU (%s)!\n",
            strerror(errno));
#endif

    return;
}