}
static void setup_receive_handle(DiagnosticRequestHandle* handle) {
- handle->isotp_receive_handle = isotp_receive(&handle->isotp_shims,
- handle->request.arbitration_id + ARBITRATION_ID_OFFSET,
- NULL);
+ if(handle->request.arbitration_id == OBD2_FUNCTIONAL_BROADCAST_ID) {
+ for(uint16_t response_id = 0;
+ response_id < OBD2_FUNCTIONAL_RESPONSE_COUNT; ++response_id) {
+ handle->isotp_receive_handles[response_id] = isotp_receive(
+ &handle->isotp_shims, OBD2_FUNCTIONAL_RESPONSE_START + response_id,
+ NULL);
+ }
+ handle->isotp_receive_handle_count = OBD2_FUNCTIONAL_RESPONSE_COUNT;
+ } else {
+ handle->isotp_receive_handle_count = 1;
+ handle->isotp_receive_handles[0] = isotp_receive(&handle->isotp_shims,
+ handle->request.arbitration_id + ARBITRATION_ID_OFFSET,
+ NULL);
+ }
}
if(!handle->isotp_send_handle.completed) {
isotp_continue_send(&handle->isotp_shims,
&handle->isotp_send_handle, arbitration_id, data, size);
- } else if(!handle->isotp_receive_handle.completed) {
- IsoTpMessage message = isotp_continue_receive(&handle->isotp_shims,
- &handle->isotp_receive_handle, arbitration_id, data, size);
-
- if(message.completed) {
- if(message.size > 0) {
- response.mode = message.payload[0];
- if(handle_negative_response(&message, &response, shims)) {
- shims->log("Received a negative response to mode %d on arb ID 0x%x",
- response.mode, response.arbitration_id);
- handle->success = true;
- handle->completed = true;
- } else if(handle_positive_response(handle, &message, &response,
- shims)) {
- shims->log("Received a positive mode %d response on arb ID 0x%x",
- response.mode, response.arbitration_id);
- handle->success = true;
- handle->completed = true;
+ } else {
+ for(uint8_t i = 0; i < handle->isotp_receive_handle_count; ++i) {
+ IsoTpMessage message = isotp_continue_receive(&handle->isotp_shims,
+ &handle->isotp_receive_handles[i], arbitration_id, data, size);
+
+ // TODO as of now we're completing the handle as soon as one
+ // broadcast response is received....need to hang on for 100ms
+ if(message.completed) {
+ if(message.size > 0) {
+ response.mode = message.payload[0];
+ if(handle_negative_response(&message, &response, shims)) {
+ shims->log("Received a negative response to mode %d on arb ID 0x%x",
+ response.mode, response.arbitration_id);
+ handle->success = true;
+ handle->completed = true;
+ } else if(handle_positive_response(handle, &message, &response,
+ shims)) {
+ shims->log("Received a positive mode %d response on arb ID 0x%x",
+ response.mode, response.arbitration_id);
+ handle->success = true;
+ handle->completed = true;
+ } else {
+ shims->log("Response was for a mode 0x%x request (pid 0x%x), not our mode 0x%x request (pid 0x%x)",
+ MAX(0, response.mode - MODE_RESPONSE_OFFSET),
+ response.pid, handle->request.mode,
+ handle->request.pid);
+ // TODO just leave handles open until the user decides
+ // to be done with it - keep a count of valid responses
+ // received.
+ }
} else {
- shims->log("Response was for a mode 0x%x request (pid 0x%x), not our mode 0x%x request (pid 0x%x)",
- MAX(0, response.mode - MODE_RESPONSE_OFFSET),
- response.pid, handle->request.mode,
- handle->request.pid);
- setup_receive_handle(handle);
+ shims->log("Received an empty response on arb ID 0x%x",
+ response.arbitration_id);
}
- } else {
- shims->log("Received an empty response on arb ID 0x%x",
- response.arbitration_id);
- }
- if(handle->completed && handle->callback != NULL) {
- handle->callback(&response);
+ if(handle->completed && handle->callback != NULL) {
+ handle->callback(&response);
+ }
}
}
- } else {
- shims->log("Mode %d request to arb ID 0x%x is already completed",
- handle->request.mode, handle->request.arbitration_id);
}
return response;
}
START_TEST (test_receive_wrong_arb_id)
{
DiagnosticRequest request = {
- arbitration_id: OBD2_FUNCTIONAL_BROADCAST_ID,
+ arbitration_id: 0x100,
mode: OBD2_MODE_POWERTRAIN_DIAGNOSTIC_REQUEST
};
DiagnosticRequestHandle handle = diagnostic_request(&SHIMS, &request,
START_TEST (test_send_diag_request_with_payload)
{
DiagnosticRequest request = {
- arbitration_id: OBD2_FUNCTIONAL_BROADCAST_ID,
+ arbitration_id: 0x100,
mode: OBD2_MODE_POWERTRAIN_DIAGNOSTIC_REQUEST,
payload: {0x12, 0x34},
payload_length: 2
}
END_TEST
-START_TEST (test_send_diag_request)
+START_TEST (test_send_functional_request)
{
DiagnosticRequest request = {
arbitration_id: OBD2_FUNCTIONAL_BROADCAST_ID,
ck_assert_int_eq(last_can_payload_sent[1], request.mode);
ck_assert_int_eq(last_can_payload_size, 2);
+ fail_if(last_response_was_received);
+ const uint8_t can_data[] = {0x2, request.mode + 0x40, 0x23};
+ for(uint16_t filter = OBD2_FUNCTIONAL_RESPONSE_START; filter <
+ OBD2_FUNCTIONAL_RESPONSE_START + OBD2_FUNCTIONAL_RESPONSE_COUNT;
+ filter++) {
+ DiagnosticResponse response = diagnostic_receive_can_frame(&SHIMS, &handle,
+ filter, can_data, sizeof(can_data));
+ fail_unless(response.success);
+ fail_unless(response.completed);
+ fail_unless(handle.completed);
+ ck_assert(last_response_received.success);
+ ck_assert_int_eq(last_response_received.arbitration_id,
+ filter);
+ ck_assert_int_eq(last_response_received.mode, request.mode);
+ ck_assert_int_eq(last_response_received.pid, 0);
+ ck_assert_int_eq(last_response_received.payload_length, 1);
+ ck_assert_int_eq(last_response_received.payload[0], can_data[2]);
+ }
+}
+END_TEST
+
+START_TEST (test_send_diag_request)
+{
+ DiagnosticRequest request = {
+ arbitration_id: 0x100,
+ mode: OBD2_MODE_EMISSIONS_DTC_REQUEST
+ };
+ DiagnosticRequestHandle handle = diagnostic_request(&SHIMS, &request,
+ response_received_handler);
+
+ fail_if(handle.completed);
+ ck_assert_int_eq(last_can_frame_sent_arb_id, request.arbitration_id);
+ ck_assert_int_eq(last_can_payload_sent[1], request.mode);
+ ck_assert_int_eq(last_can_payload_size, 2);
+
fail_if(last_response_was_received);
const uint8_t can_data[] = {0x2, request.mode + 0x40, 0x23};
DiagnosticResponse response = diagnostic_receive_can_frame(&SHIMS, &handle,
START_TEST (test_request_pid_enhanced)
{
- uint16_t arb_id = OBD2_FUNCTIONAL_BROADCAST_ID;
+ uint16_t arb_id = 0x100;
DiagnosticRequestHandle handle = diagnostic_request_pid(&SHIMS,
DIAGNOSTIC_ENHANCED_PID, arb_id, 0x2, response_received_handler);
START_TEST (test_wrong_mode_response)
{
- uint16_t arb_id = OBD2_FUNCTIONAL_BROADCAST_ID;
+ uint16_t arb_id = 0x100;
DiagnosticRequestHandle handle = diagnostic_request_pid(&SHIMS,
DIAGNOSTIC_ENHANCED_PID, arb_id, 0x2, response_received_handler);
START_TEST (test_missing_pid)
{
- uint16_t arb_id = OBD2_FUNCTIONAL_BROADCAST_ID;
+ uint16_t arb_id = 0x100;
DiagnosticRequestHandle handle = diagnostic_request_pid(&SHIMS,
DIAGNOSTIC_ENHANCED_PID, arb_id, 0x2, response_received_handler);
START_TEST (test_wrong_pid_response)
{
- uint16_t arb_id = OBD2_FUNCTIONAL_BROADCAST_ID;
+ uint16_t arb_id = 0x100;
DiagnosticRequestHandle handle = diagnostic_request_pid(&SHIMS,
DIAGNOSTIC_ENHANCED_PID, arb_id, 0x2, response_received_handler);
START_TEST (test_wrong_pid_then_right_completes)
{
- uint16_t arb_id = OBD2_FUNCTIONAL_BROADCAST_ID;
+ uint16_t arb_id = 0x100;
DiagnosticRequestHandle handle = diagnostic_request_pid(&SHIMS,
DIAGNOSTIC_ENHANCED_PID, arb_id, 0x2, response_received_handler);
}
END_TEST
-START_TEST (test_handle_completed)
-{
- DiagnosticRequest request = {
- arbitration_id: OBD2_FUNCTIONAL_BROADCAST_ID,
- mode: OBD2_MODE_POWERTRAIN_DIAGNOSTIC_REQUEST
- };
- DiagnosticRequestHandle handle = diagnostic_request(&SHIMS, &request,
- response_received_handler);
-
- fail_if(handle.completed);
-
- const uint8_t can_data[] = {0x2, request.mode + 0x40, 0x23};
- DiagnosticResponse response = diagnostic_receive_can_frame(&SHIMS, &handle,
- request.arbitration_id + 0x8, can_data, sizeof(can_data));
- fail_unless(response.success);
- fail_unless(response.completed);
- fail_unless(handle.completed);
-
- response = diagnostic_receive_can_frame(&SHIMS, &handle,
- request.arbitration_id + 0x8, can_data, sizeof(can_data));
- fail_if(response.success);
- fail_if(response.completed);
- fail_unless(handle.completed);
-
- ck_assert(last_response_received.success);
- ck_assert_int_eq(last_response_received.arbitration_id,
- request.arbitration_id + 0x8);
- ck_assert_int_eq(last_response_received.mode, request.mode);
- ck_assert_int_eq(last_response_received.pid, 0);
- ck_assert_int_eq(last_response_received.payload_length, 1);
- ck_assert_int_eq(last_response_received.payload[0], can_data[2]);
-}
-END_TEST
-
START_TEST (test_negative_response)
{
DiagnosticRequest request = {
- arbitration_id: OBD2_FUNCTIONAL_BROADCAST_ID,
+ arbitration_id: 0x100,
mode: OBD2_MODE_POWERTRAIN_DIAGNOSTIC_REQUEST
};
DiagnosticRequestHandle handle = diagnostic_request(&SHIMS, &request,
TCase *tc_core = tcase_create("core");
tcase_add_checked_fixture(tc_core, setup, NULL);
tcase_add_test(tc_core, test_send_diag_request);
+ tcase_add_test(tc_core, test_send_functional_request);
tcase_add_test(tc_core, test_send_diag_request_with_payload);
tcase_add_test(tc_core, test_receive_wrong_arb_id);
tcase_add_test(tc_core, test_request_pid_standard);
tcase_add_test(tc_core, test_wrong_pid_response);
tcase_add_test(tc_core, test_missing_pid);
tcase_add_test(tc_core, test_wrong_pid_then_right_completes);
- tcase_add_test(tc_core, test_handle_completed);
tcase_add_test(tc_core, test_negative_response);
// TODO these are future work: