Scs (#3)

* Add send scs

* Create scs dict

* Fix compilation errors

* Fix compile error

* Change default include

* Add Timer SCS manager

* Remove unused files

* Fix bugs

* Add documentation

* Add SCS manager

bozza

* Refactor

* Use same naming convention

* Add tick provider

* Update header

* Fix header bit translation

* Test HandleNext OK

* Remove linting

* Remove indents

* Add documentation

* Improve docs

* Remove pointer

* Remove mailbox

* Remove useless comment

* Add newline

* Fix compile errors

* Separate scs entries from manager

* Refactor

* Fix include guards

Co-authored-by: nicolagutierrez <nicolagutierrez.ng@gmail.com>

Src/mmr_can.c

@@ -2,12 +2,19 @@
 #include "mmr_can_util.h"
 
 
-/**
- * @brief
- * Initializes the filter using the values
- * from MMR_CAN_GetDefaultFilterSettings, and then
- * starts the CAN
- */
+MmrCanTickProvider __mmr_can_tickProvider;
+
+
+void MMR_CAN_SetTickProvider(MmrCanTickProvider tickProvider) {
+  __mmr_can_tickProvider = tickProvider;
+}
+
+
+uint32_t MMR_CAN_GetCurrentTick() {
+  return __mmr_can_tickProvider();
+}
+
+
 HalStatus MMR_CAN_BasicSetupAndStart(CanHandle *hcan) {
   return
     MMR_CAN_FilterConfigDefault(hcan) |

Src/mmr_can_events.c

@@ -10,13 +10,7 @@ static void __invokeAll(const MmrCanEventList *events, const MmrCanMessage *even
 static void __maybeInvoke(const MmrCanEventHandler handler, const MmrCanMessage *event);
 
 
-/**
- * @brief
- * Activates the CAN rx interrupts
- *
- * When one is fired, the callbacks provided inside the
- * MmrCanEventList will be invoked
- */
+
 HalStatus MMR_CAN_InitRxHandlers(CanHandle *hcan, const MmrCanEventList *rxEvents) {
   _rxEvents = rxEvents;
   return HAL_CAN_ActivateNotification(hcan, MMR_CAN_RX_INTERRUPT);

Src/mmr_can_header.c

@@ -2,19 +2,34 @@
 #include "mmr_can_util.h"
 #include "mmr_can_optimize.h"
 
-uint32_t *MMR_CAN_HeaderToBits(MmrCanHeader *header) {
-  return (uint32_t*)header;
+uint32_t MMR_CAN_HeaderToBits(MmrCanHeader header) {
+  return 0
+  | ((uint32_t)header.priority << 26)
+  | ((uint32_t)header.messageId << 23)
+  | ((uint32_t)header.senderId << 13)
+  | ((uint32_t)header.seqNumber << 3)
+  | ((uint32_t)header.messageType);
 }
 
-MmrCanHeader *MMR_CAN_HeaderFromBits(uint32_t *bits) {
-  return (MmrCanHeader*)bits;
+MmrCanHeader MMR_CAN_HeaderFromBits(uint32_t bits) {
+  return (MmrCanHeader) {
+    .priority = bits >> 26,
+    .messageId = bits >> 23,
+    .senderId = bits >> 13,
+    .seqNumber = bits >> 3,
+    .messageType = bits,
+  };
 }
 
 
-bool MMR_CAN_IsMultiFrame(MmrCanHeader *header) {
-  return header->messageType == MMR_CAN_MESSAGE_TYPE_MULTI_FRAME;
+bool MMR_CAN_IsHeaderScs(MmrCanHeader header) {
+  return header.messageType == MMR_CAN_MESSAGE_TYPE_SCS;
 }
 
-bool MMR_CAN_IsMultiFrameEnd(MmrCanHeader *header) {
-  return header->messageType == MMR_CAN_MESSAGE_TYPE_MULTI_FRAME_END;
+bool MMR_CAN_IsMultiFrame(MmrCanHeader header) {
+  return header.messageType == MMR_CAN_MESSAGE_TYPE_MULTI_FRAME;
+}
+
+bool MMR_CAN_IsMultiFrameEnd(MmrCanHeader header) {
+  return header.messageType == MMR_CAN_MESSAGE_TYPE_MULTI_FRAME_END;
 }

Src/mmr_can_message_id.c

@@ -1,11 +1,7 @@
+#include <stdint.h>
 #include "mmr_can_message_id.h"
 
 
-bool MMR_CAN_IsMessageIdSCS(MmrCanMessageId msgId) {
-  return MMR_CAN_IsMessageIdOfType(msgId, MMR_CAN_MESSAGE_ID_TYPE_SCS);
-}
-
-
 bool MMR_CAN_IsMessageIdOfType(
   MmrCanMessageId msgId,
   MmrCanMessageIdType type

Src/mmr_can_receive.c

@@ -17,7 +17,7 @@ typedef struct {
 
 static HalStatus receiveOne(ReceptionParams *rp);
 static HalStatus receiveAll(ReceptionParams *rp);
-static bool headerIsMultiFrame(MmrCanHeader *header, CanId targetId);
+static bool headerIsMultiFrame(MmrCanHeader header, CanId targetId);
 
 
 /**
@@ -41,7 +41,7 @@ HalStatus MMR_CAN_Receive(CanHandle *hcan, MmrCanMessage *result) {
   }
 
   result->header = rp.headers.mmr;
-  if (MMR_CAN_IsMultiFrame(&rp.headers.mmr)) {
+  if (MMR_CAN_IsMultiFrame(rp.headers.mmr)) {
     status |= receiveAll(&rp);
   }
 
@@ -55,8 +55,9 @@ static HalStatus receiveAll(ReceptionParams *rp) {
   do {
     rp->result += MMR_CAN_MAX_DATA_LENGTH;
     status |= receiveOne(rp);
-  } while (
-    headerIsMultiFrame(&rp->headers.mmr, targetId) && status == HAL_OK
+  }
+  while (
+    headerIsMultiFrame(rp->headers.mmr, targetId) && status == HAL_OK
   );
 
   return status;
@@ -64,17 +65,21 @@ static HalStatus receiveAll(ReceptionParams *rp) {
 
 
 static HalStatus receiveOne(ReceptionParams *rp) {
-  HalStatus status =
-    HAL_CAN_GetRxMessage(rp->handle, rp->fifo, &(rp->headers.rx), rp->result);
+  HalStatus status = HAL_CAN_GetRxMessage(
+    rp->handle,
+    rp->fifo,
+    &rp->headers.rx,
+    rp->result
+  );
 
-  rp->headers.mmr = convertTo(MmrCanHeader, rp->headers.rx.ExtId);
+  rp->headers.mmr = MMR_CAN_HeaderFromBits(rp->headers.rx.ExtId);
   return status;
 }
 
 
-static always_inline bool headerIsMultiFrame(MmrCanHeader *header, CanId targetId) {
+static bool headerIsMultiFrame(MmrCanHeader header, CanId targetId) {
   return
     MMR_CAN_IsMultiFrame(header) &&
     !MMR_CAN_IsMultiFrameEnd(header) &&
-    header->senderId == targetId;
+    header.senderId == targetId;
 }

Src/mmr_can_scs_entries.c

@@ -0,0 +1,60 @@
+#include "mmr_can_scs.h"
+
+#define EMPTY_HEADER ((MmrCanHeader){})
+#define EMPTY_ENTRY ((MmrCanScsEntry){})
+
+static MmrCanScsEntry __scsEntries[MMR_CAN_SCS_ENTRIES_COUNT];
+
+
+MmrCanScsEntry* MMR_CAN_GetNextScsEntry() {
+  static int counter = 0;
+
+  MmrCanScsEntry *entry = __scsEntries + counter;
+  counter++;
+  counter %= MMR_CAN_SCS_ENTRIES_COUNT;
+
+  return entry;
+}
+
+
+MmrCanScsEntry* MMR_CAN_PutScsEntry(MmrCanHeader header) {
+  MmrCanScsEntry *entry = MMR_CAN_FindScsEntry(EMPTY_HEADER);
+  if (entry == NULL) {
+    return NULL;
+  }
+
+  *entry = (MmrCanScsEntry){
+    .header = header,
+    .counter = MMR_CAN_GetCurrentTick(),
+  };
+
+  return entry;
+}
+
+
+MmrCanScsEntry* MMR_CAN_ClearScsEntry(MmrCanHeader header) {
+  MmrCanScsEntry *entry = MMR_CAN_FindScsEntry(header);
+  if (entry == NULL) {
+    return NULL;
+  }
+
+  *entry = EMPTY_ENTRY;
+  return entry;
+}
+
+
+MmrCanScsEntry* MMR_CAN_FindScsEntry(MmrCanHeader header) {
+  uint32_t target = MMR_CAN_HeaderToBits(header);
+  uint32_t i = 0;
+
+  for (; i < MMR_CAN_SCS_ENTRIES_COUNT; i++) {
+    MmrCanScsEntry *entry = __scsEntries + i;
+    uint32_t curr = MMR_CAN_HeaderToBits(entry->header);
+
+    if (curr == target) {
+      return entry;
+    }
+  }
+
+  return NULL;
+}

Src/mmr_can_scs_manager.c

@@ -0,0 +1,96 @@
+#include "mmr_can_scs.h"
+
+static void maybeIncrementRtr(MmrCanScsEntry *entry);
+static HalStatus sendScs(CanHandle *hcan, MmrCanHeader header);
+static MmrCanScsCheckResult checkScs(MmrCanScsEntry *entry);
+
+
+bool MMR_CAN_MaybeHandleAck(MmrCanHeader header) {
+  if (header.messageType != MMR_CAN_MESSAGE_TYPE_ACK) {
+    return false;
+  }
+
+  header.messageType = MMR_CAN_MESSAGE_TYPE_SCS;
+  MmrCanScsEntry *entry = MMR_CAN_FindScsEntry(header);
+  if (entry == NULL) {
+    return false;
+  }
+
+  MMR_CAN_ClearScsEntry(header);
+  return true;
+}
+
+
+HalStatus MMR_CAN_SendAck(
+  CanHandle *hcan,
+  MmrCanHeader originalHeader
+) {
+  originalHeader.messageType = MMR_CAN_MESSAGE_TYPE_ACK;
+  return sendScs(hcan, originalHeader);
+}
+
+
+HalStatus MMR_CAN_SendScs(
+  CanHandle *hcan,
+  MmrCanMessageId scsId,
+  CanId senderId
+) {
+  MmrCanHeader header = {
+    .senderId = senderId,
+    .messageId = scsId,
+    .priority = MMR_CAN_MESSAGE_PRIORITY_HIGH,
+    .messageType = MMR_CAN_MESSAGE_TYPE_SCS,
+  };
+
+  if (MMR_CAN_PutScsEntry(header) == NULL) {
+    return HAL_ERROR;
+  }
+
+  return sendScs(hcan, header);
+}
+
+
+HalStatus MMR_CAN_HandleNextScs(CanHandle *hcan) {
+  MmrCanScsEntry *entry = MMR_CAN_GetNextScsEntry();
+
+  if (MMR_CAN_HeaderToBits(entry->header) == 0) {
+    return HAL_OK;
+  }
+
+  switch (checkScs(entry)) {
+    case MMR_CAN_SCS_CHECK_ERROR: return HAL_ERROR;
+    case MMR_CAN_SCS_CHECK_OK: return HAL_OK;
+    default: break;
+  }
+
+  entry->counter = MMR_CAN_GetCurrentTick();
+  return sendScs(hcan, entry->header);
+}
+
+
+static HalStatus sendScs(CanHandle *hcan, MmrCanHeader header) {
+  MmrCanPacket packet = {
+    .header = header,
+    .length = 0,
+  };
+
+  return MMR_CAN_SendNoTamper(hcan, packet);
+}
+
+
+static MmrCanScsCheckResult checkScs(MmrCanScsEntry *entry) {
+  maybeIncrementRtr(entry);
+  return
+    entry->rtr == 1 ? MMR_CAN_SCS_CHECK_RTR :
+    entry->rtr > 1 ? MMR_CAN_SCS_CHECK_ERROR :
+    MMR_CAN_SCS_CHECK_OK;
+}
+
+static void maybeIncrementRtr(MmrCanScsEntry *entry) {
+  TimerRange now = MMR_CAN_GetCurrentTick();
+  TimerRange delay = now - entry->counter;
+
+  if (delay >= MMR_CAN_MAX_TIMEOUT) {
+    entry->rtr++;
+  }
+}

Src/mmr_can_send.c

@@ -14,6 +14,7 @@ typedef struct {
 } TransmissionParams;
 
 
+static TransmissionParams buildParams(CanHandle *hcan, MmrCanPacket packet);
 static HalStatus send(TransmissionParams *tp);
 static HalStatus sendNormal(TransmissionParams *tp);
 static HalStatus sendMulti(TransmissionParams *tp);
@@ -24,10 +25,33 @@ static void setMessageType(TransmissionParams *header, MmrCanMessageType type);
 static void syncHeaders(TransmissionParams *tp);
 
 
+static CanMailbox __mailbox;
+
+
 HalStatus MMR_CAN_Send(CanHandle *hcan, MmrCanPacket packet) {
-  TransmissionParams tp = {
+  TransmissionParams tp =
+    buildParams(hcan, packet);
+
+  syncHeaders(&tp);
+  return packet.length <= MMR_CAN_MAX_DATA_LENGTH
+    ? sendNormal(&tp)
+    : sendMulti(&tp);
+}
+
+
+HalStatus MMR_CAN_SendNoTamper(CanHandle *hcan, MmrCanPacket packet) {
+  TransmissionParams tp =
+    buildParams(hcan, packet);
+
+  return send(&tp);
+}
+
+
+static TransmissionParams buildParams(CanHandle *hcan, MmrCanPacket packet) {
+  return (TransmissionParams) {
     .handle = hcan,
     .packet = &packet,
+    .headers.mmr = packet.header,
     .headers.tx = {
       .IDE = CAN_ID_EXT,
       .RTR = CAN_RTR_DATA,
@@ -35,11 +59,6 @@ HalStatus MMR_CAN_Send(CanHandle *hcan, MmrCanPacket packet) {
       .TransmitGlobalTime = DISABLE,
     },
   };
-  syncHeaders(&tp);
-
-  return packet.length <= MMR_CAN_MAX_DATA_LENGTH
-    ? sendNormal(&tp)
-    : sendMulti(&tp);
 }
 
 
@@ -72,11 +91,13 @@ static HalStatus sendSingleMultiFrame(TransmissionParams *tp) {
   uint8_t length =
     computeNextMessageLength(tp->packet);
 
-  tp->packet->length -= length;
-  tp->packet->data += length;
   tp->headers.tx.DLC = length;
+  tp->packet->length -= length;
 
-  return send(tp);
+  HalStatus result = send(tp);
+
+  tp->packet->data += length;
+  return result;
 }
 
 
@@ -87,13 +108,13 @@ static HalStatus send(TransmissionParams *tp) {
     tp->handle,
     &tp->headers.tx,
     tp->packet->data,
-    tp->packet->mailbox
+    &__mailbox
   );
 }
 
 
 static void syncHeaders(TransmissionParams *tp) {
-  tp->headers.tx.ExtId = *MMR_CAN_HeaderToBits(&tp->headers.mmr);
+  tp->headers.tx.ExtId = MMR_CAN_HeaderToBits(tp->headers.mmr);
 }