Draft reworking of API.

[apps/low-level-can-service.git] / src / isotp / isotp.h

diff --git a/src/isotp/isotp.h b/src/isotp/isotp.h
index 923d592..1035238 100644 (file)
--- a/src/isotp/isotp.h
+++ b/src/isotp/isotp.h
@@ -1,59 +1,116 @@
 #ifndef __ISOTP_H__
 #define __ISOTP_H__
 
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdio.h>
+
+#define CAN_MESSAGE_BYTE_SIZE 8
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-struct {
-    uint16_t arb_id;
-    void* message_received_callback;
-    void* message_sent_callback;
-    void* can_frame_sent_callback;
+const uint16_t MAX_ISO_TP_MESSAGE_SIZE;
+const uint16_t MAX_CAN_FRAME_SIZE;
+const uint8_t ISO_TP_DEFAULT_RESPONSE_TIMEOUT;
+const bool ISO_TP_DEFAULT_FRAME_PADDING_STATUS;
+
+typedef struct {
+    const uint16_t arbitration_id;
+    const uint8_t* payload;
+    const uint16_t size;
+} IsoTpMessage;
+
+typedef void (*LogShim)(const char* message, ...);
+typedef bool (*SendCanMessageShim)(const uint16_t arbitration_id,
+        const uint8_t* data, const uint8_t size);
+typedef bool (*SetTimerShim)(uint16_t time_ms, void (*callback));
+
+typedef void (*IsoTpMessageReceivedHandler)(const IsoTpMessage* message);
+typedef void (*IsoTpMessageSentHandler)(const IsoTpMessage* message,
+        const bool success);
+typedef void (*IsoTpCanFrameSentHandler)(const IsoTpMessage* message);
+
+typedef struct {
+    LogShim log;
+    SendCanMessageShim send_can_message;
+    SetTimerShim set_timer;
+} IsoTpShims;
+
+typedef struct {
+    uint16_t arbitration_id;
+    IsoTpMessageReceivedHandler message_received_callback;
 
     // Private
     uint16_t timeout_ms;
-    bool framePadding;
+    // timeout_ms: ISO_TP_DEFAULT_RESPONSE_TIMEOUT,
+    bool frame_padding;
+    // frame_padding: ISO_TP_DEFAULT_FRAME_PADDING_STATUS,
     uint8_t* receive_buffer;
     uint16_t received_buffer_size;
     uint16_t incoming_message_size;
-    bool sending;
-    // TODO timer
-} IsoTpHandler;
-
-enum {
-    PCI_SINGLE,
-    PCI_FIRST_FRAME,
-    PCI_CONSECUTIVE_FRAME,
-    PCI_FLOW_CONTROL_FRAME
+    // TODO timer callback
+} IsoTpReceiveHandle;
+
+typedef struct {
+    uint16_t sending_arbitration_id;
+    uint16_t receiving_arbitration_id;
+    IsoTpMessageSentHandler message_sent_callback;
+    IsoTpCanFrameSentHandler can_frame_sent_callback;
+
+    // TODO going to need some state here for multi frame messages
+} IsoTpSendHandle;
+
+typedef enum {
+    ISOTP_HANDLE_SENDING,
+    ISOTP_HANDLE_RECEIVING
+} IsoTpHandleType;
+
+typedef struct {
+    bool success;
+    bool completed;
+    IsoTpHandleType type;
+    IsoTpReceiveHandle receive_handle;
+    IsoTpSendHandle send_handle;
+} IsoTpHandle;
+
+
+typedef enum {
+    PCI_SINGLE = 0x0,
+    PCI_FIRST_FRAME = 0x1,
+    PCI_CONSECUTIVE_FRAME = 0x2,
+    PCI_FLOW_CONTROL_FRAME = 0x3
 } IsoTpProtocolControlInformation;
 
-enum {
-    PCI_FLOW_STATUS_CONTINUE,
-    PCI_FLOW_STATUS_WAIT,
-    PCI_FLOW_STATUS_OVERFLOW
+typedef enum {
+    PCI_FLOW_STATUS_CONTINUE = 0x0,
+    PCI_FLOW_STATUS_WAIT = 0x1,
+    PCI_FLOW_STATUS_OVERFLOW = 0x2
 } IsoTpFlowStatus;
 
-const uint16_t MAX_ISO_TP_MESSAGE_SIZE = 4096;
-const uint16_t MAX_CAN_FRAME_SIZE = 8;
-const uint8_t ISO_TP_DEFAULT_RESPONSE_TIMEOUT = 100;
-const bool ISO_TP_DEFAULT_FRAME_PADDING_STATUS = true;
+IsoTpShims isotp_init_shims(LogShim log,
+        SendCanMessageShim send_can_message,
+        SetTimerShim set_timer);
 
-IsoTpHandler isotp_init(uint16_t arbitration_id,
-        IsoTpMessageReceivedHandler* message_received_callback,
-        IsoTpMessageSentHandler* message_sent_callback,
-        IsoTpCanFrameSentHandler* can_frame_sent_callback);
+void isotp_receive_can_frame(IsoTpShims* shims, IsoTpHandle* handle,
+        const uint16_t arbitration_id, const uint8_t data[],
+        const uint8_t size);
 
-void isotp_set_timeout(uint16_t timeout);
+/* Public: Change the timeout for waiting on an ISO-TP response frame.
+ *
+ * If this function is not used, the conventional 100ms is used by default.
+ *
+ * handler - the ISO-TP handler to modify.
+ * timeout - the new timeout in milliseconds.
+ */
+// void isotp_set_timeout(IsoTpHandler* handler, uint16_t timeout_ms);
 
-// TODO we have to make sure to copy the payload internall if it's more than 1
-// frame, the soure could go out of scope
-bool isotp_send(const uint8_t* payload, uint16_t payload_size);
+// void isotp_destroy(IsoTpHandler* handler);
 
-void isotp_receive_can_frame(const uint16_t arbitration_id, const uint8_t* data,
-        const uint8_t length);
+void isotp_message_to_string(const IsoTpMessage* message, char* destination,
+        size_t destination_length);
 
-void isotp_destroy(IsoTpHandler* handler);
 
 #ifdef __cplusplus
 }