Timestamped Frames

generator/bus.py

@@ -20,7 +20,7 @@ def write(can, computers, output_path=bus_path):
         raw_buses = set()
         for computer in computers:
             if not ('can' in computer.participation['name'].keys()):
-                # This computer neither sends nor recieves can messages
+                # This computer neither sends nor receives can messages
                 continue
 
             raw_buses |= set(computer.participation['name']['can'].mapping.values())

generator/computers_c.py

@@ -6,12 +6,14 @@
     frame_handler, is_multplxd
 from math import ceil
 
+raw_bus_to_handle = {"CAN_1": "hcan1", "CAN_2": "hcan2", "CAN_3": "hcan3"}
+raw_bus_to_instance = {"CAN_1": "CAN1", "CAN_2": "CAN2", "CAN_3": "CAN3"}
 
 def single_handler(frame, name_prepends, num_tabs, fw):
     tot_name = coord(name_prepends, frame.name, prefix=False)
     fw(
         '\t' * num_tabs + 'case CANlib_{}_key:'.format(tot_name) + '\n' +
-        '\t' * (num_tabs + 1) + 'CANlib_Handle_{}(frame);\n'.format(tot_name) +
+        '\t' * (num_tabs + 1) + 'CANlib_Handle_{}(ts_frame);\n'.format(tot_name) +
         '\t' * (num_tabs + 1) + 'break;\n'
     )
 
@@ -63,9 +65,16 @@ def write(can, computers, output_path=computer_c_dir_path):
 
         with open(f_path, 'w') as f:
             fw = f.write
+            fw('#include <time.h>\n')
+            fw('#include <stdbool.h>\n')
+            fw('#include <stm32f4xx_hal.h>\n')
             fw('#include "pack_unpack.h"\n')
             fw('#include "canlib_{}.h"\n\n'.format(computer.name))
 
+            fw('extern CAN_HandleTypeDef hcan1;\n')
+            fw('extern CAN_HandleTypeDef hcan2;\n')
+            fw('extern CAN_HandleTypeDef hcan3;\n\n')
+
             fw(
               'CAN_Raw_Bus_T CANlib_GetRawBus(CANlib_Bus_T bus) {\n'
               '\tswitch (bus) {\n'
@@ -91,10 +100,11 @@ def write(can, computers, output_path=computer_c_dir_path):
             fw('\t}\n}\n\n')
 
             for busnm, bus in computer.participation['name']['can'].subscribe.items():
-                fw('static void CANlib_HandleFrame_{}(Frame* frame)'.format(busnm) + '{\n')
+
+                fw('static void CANlib_HandleFrame_{}(TimestampedFrame* ts_frame)'.format(busnm) + '{\n')
                 if any(is_multplxd(msg) for msg in bus):
                     fw('\tuint64_t bitstring;\n')
-                fw('\tswitch(frame->id) {\n')
+                fw('\tswitch(ts_frame->frame.id) {\n')
 
                 for msg in bus:
                     msg_handler(msg, busnm, fw)
@@ -108,27 +118,42 @@ def write(can, computers, output_path=computer_c_dir_path):
 
             for busnm, bus in computer.participation['name']['can'].subscribe.items():
                 fw(
-                    'static void CANlib_update_can_{}(void)'.format(busnm) + '{\n' +
-                    '\tFrame frame;\n'
+                    'static void CANlib_Update_can_{}(void)'.format(busnm) + ' {\n' +
+                    '\tTimestampedFrame ts_frame;\n'
                 )
+
+                raw_bus = computer.participation['name']['can'].mapping[busnm]
+                instance = raw_bus_to_handle[raw_bus]
+
                 fw(
-                    '\tCANlib_ReadFrame(&frame, {});\n'.format(busnm) +
-                    '\tCANlib_HandleFrame_{}(&frame);\n'.format(busnm) +
+                    '\tif (HAL_CANlib_ReadFrame(&{}, &(ts_frame.frame))) {{\n'.format(instance) +
+                    '\t\tts_frame.stamp = HAL_GetTick();\n' +
+                    '\t\tCANlib_HandleFrame_{}(&ts_frame);\n'.format(busnm) +
+                    '\t}\n' +
                     '}\n\n'
                 )
 
             fw('void CANlib_update_can() {\n')
             for busnm in computer.participation['name']['can'].subscribe.keys():
-                fw('\tCANlib_update_can_{}();\n'.format(busnm))
+                fw('\tCANlib_Update_can_{}();\n'.format(busnm))
             fw('}\n\n')
 
-            fw('void CANlib_HandleFrame(CAN_Raw_Bus_T raw_bus, Frame* frame) {\n')
-            fw('\tswitch(raw_bus) {\n')
-            for bus in computer.participation['name']['can'].subscribe.keys():
-                fw(
-                    '\t\tcase {}:\n'.format(computer.participation['name']['can'].mapping[bus]) +
-                    '\t\t\tCANlib_HandleFrame_{}(frame);\n'.format(bus) +
-                    '\t\t\tbreak;\n'
-                )
-            fw('\t\tdefault:\n\t\t\tUNUSED(frame);\n\t\tbreak;\n')
-            fw('\t}\n}\n')
+            fw('void CANlib_HandleFrame(TimestampedFrame *ts_frame, time_t stamp, CAN_TypeDef* instance) {\n')
+            if len(computer.participation['name']['can'].subscribe.keys()) > 0: # check if computer receives messages
+                fw('\tts_frame->stamp = stamp;\n')
+                fw('\tswitch ((intptr_t)instance) {\n')
+                for bus in computer.participation['name']['can'].subscribe.keys():
+                    fw(
+                        '\t\tcase (intptr_t){}:\n'.format(raw_bus_to_instance[computer.participation['name']['can'].mapping[
+                            bus]]) +
+                        '\t\t\tCANlib_HandleFrame_{}(ts_frame);\n'.format(bus) +
+                        '\t\t\tbreak;\n'
+                    )
+                fw('\t\tdefault:\n')
+                fw('\t\t\tbreak;\n')
+                fw('\t}\n')
+            else: # prevent unused warning
+                fw('\tUNUSED(ts_frame);\n')
+                fw('\tUNUSED(stamp);\n')
+                fw('\tUNUSED(instance);\n')
+            fw('}\n')

generator/computers_h.py

@@ -13,8 +13,8 @@ def declare_pub_frame(frame, name_prepends, fw):
 def declare_sub_frame(frame, name_prepends, fw):
     tot_name = coord(name_prepends, frame.name, prefix=False)
     fw(
-        'extern CANlib_{}_T CANlib_{}_Input;\n'.format(tot_name, tot_name) +
-        'void CANlib_Handle_{}(Frame *frame);\n'.format(tot_name, tot_name)
+        'extern CANlib_{}_Timestamped_T CANlib_{}_Input;\n'.format(tot_name, tot_name) +
+        'void CANlib_Handle_{}(TimestampedFrame *frame);\n'.format(tot_name, tot_name)
     )
 
 
@@ -26,7 +26,7 @@ def write(can, computers, output_path=computer_h_dir_path):
         f_path = os.path.join(output_path, 'canlib_{}.h'.format(computer.name))
 
         if not ('can' in computer.participation['name'].keys()):
-            # This computer neither sends nor recieves can messagess
+            # This computer neither sends nor receives can messages
             continue
 
         with open(f_path, 'w') as f:
@@ -54,7 +54,7 @@ def write(can, computers, output_path=computer_h_dir_path):
                     for frame in bus:
                         frame_handler(frame, bus_name, declare_pub_frame, fw)
             except KeyError:
-                pass # No CAN messages sent by this board
+                pass  # No CAN messages sent by this board
 
             fw('\n')
 
@@ -64,12 +64,13 @@ def write(can, computers, output_path=computer_h_dir_path):
                     for frame in bus:
                         frame_handler(frame, bus_name, declare_sub_frame, fw)
                         fw('\n')
-                fw('void CANlib_update_can(void);\n')
-                fw('void CANlib_HandleFrame(CAN_Raw_Bus_T raw_bus, Frame* frame);\n')
+                fw('void CANlib_update_can(void); // for those who still lack CAN interrupts\n')
+                fw('void CANlib_HandleFrame(TimestampedFrame *ts_frame, time_t stamp, CAN_TypeDef* instance);\n')
+                fw('bool HAL_CANlib_ReadFrame(CAN_HandleTypeDef *hcan, Frame* out);\n')
+                fw('bool HAL_CANlib_ReadFrameFromFIFO(CAN_HandleTypeDef *hcan, uint32_t RxFifo, Frame* out);\n')
             except KeyError:
-                pass # No CAN messages received by this board
+                pass  # No CAN messages received by this board
 
             fw('\n#ifdef __cplusplus\n} // extern "C"\n#endif // __cplusplus\n\n')
 
             fw(endif(header_name))
-

generator/send_receive.py

@@ -25,13 +25,15 @@ def define_pub_frame(frame, name_prepends, busnm, fw):
 def define_sub_frame(frame, name_prepends, fw):
     tot_name = coord(name_prepends, frame.name,
         prefix=False)
-    fw('void CANlib_Handle_{}(Frame *frame)'.format(
-        tot_name, tot_name) + ' {\n' + '\tCANlib_Unpack_{}(frame, &CANlib_{}_Input);\n'.format(tot_name, tot_name) + '}\n\n')
+    fw('void CANlib_Handle_{}(TimestampedFrame *ts_frame) {{\n'.format(tot_name, tot_name))
+    fw('\tCANlib_{}_Input.stamp = ts_frame->stamp;\n'.format(tot_name))
+    fw('\tCANlib_Unpack_{}(&(ts_frame->frame), &(CANlib_{}_Input.msg));\n'.format(tot_name,tot_name))
+    fw('}\n\n')
 
 
 def define_struct(frame, name_prepends, fw):
     tot_name = coord(name_prepends, frame.name)
-    fw('{}_T {}_Input;\n'.format(
+    fw('{}_Timestamped_T {}_Input;\n'.format(
         tot_name, tot_name))
 
 

generator/structs.py

@@ -17,6 +17,13 @@ def msg_handler(frame, name_prepends, fw):
     fw('} ' + '{}_T;\n\n'.format(coord(name_prepends, frame.name)))
 
 
+def timestamped_msg_handler(frame, name_prepends, fw):
+    fw('typedef struct {\n')
+    fw('\ttime_t stamp;\n')
+    fw('\t{}_T msg;\n'.format(coord(name_prepends, frame.name)))
+    fw('} ' + '{}_Timestamped_T;\n\n'.format(coord(name_prepends, frame.name)))
+
+
 def write(can, output_path=structs_path):
     header_name = '_CAN_LIBRARY_STRUCTS'
 
@@ -25,10 +32,12 @@ def write(can, output_path=structs_path):
 
         fw(ifndef(header_name))
         fw('#include <stdint.h>\n')
-        fw('#include <stdbool.h>\n\n')
+        fw('#include <stdbool.h>\n')
+        fw('#include <time.h>\n')
         fw('#include "enum_atom.h"\n\n')
 
         for bus in can.bus:
             for msg in bus.frame:
                 frame_handler(msg, bus.name, msg_handler, fw)
+                frame_handler(msg, bus.name, timestamped_msg_handler, fw)
         fw(endif(header_name))

src/driver.h

@@ -3,9 +3,19 @@
 
 #include "drivers/inc/stm32f4xx.h"
 #include "bus.h"
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
 
 CANlib_Transmit_Error_T CANlib_TransmitFrame(Frame *frame, CANlib_Bus_T bus);
-void CANlib_ReadFrame(Frame *frame, CANlib_Bus_T bus);
+bool HAL_CANlib_ReadFrame(CAN_HandleTypeDef *hcan, Frame* out);
+bool HAL_CANlib_ReadFrameFromFIFO(CAN_HandleTypeDef *hcan, uint32_t RxFifo, Frame* out);
 CAN_Raw_Bus_T CANlib_GetRawBus(CANlib_Bus_T bus);
 
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus
+
 #endif // __DRIVER_H

src/drivers/inc/stm32f4xx.h

@@ -6,12 +6,22 @@
 #include "bus.h"
 
 #include <stdint.h>
+#include <stdbool.h>
 
 typedef uint32_t Time_T; // in ms
 typedef HAL_StatusTypeDef CANlib_Transmit_Error_T;
 typedef HAL_StatusTypeDef CANlib_Init_Error_T;
 
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
 CANlib_Transmit_Error_T CANlib_TransmitFrame(Frame *frame, CANlib_Bus_T bus);
-void CANlib_ReadFrame(Frame *frame, CANlib_Bus_T bus);
+bool HAL_CANlib_ReadFrame(CAN_HandleTypeDef *hcan, Frame* out);
+bool HAL_CANlib_ReadFrameFromFIFO(CAN_HandleTypeDef *hcan, uint32_t RxFifo, Frame* out);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus
 
 #endif // __STM32F4XX_CAN_H

src/drivers/src/stm32f4xx.c

@@ -5,6 +5,7 @@
 #include "driver.h"
 #include <stdint.h>
 #include <string.h>
+#include <stdbool.h>
 
 extern CAN_HandleTypeDef hcan1;
 extern CAN_HandleTypeDef hcan2;
@@ -47,36 +48,30 @@ HAL_StatusTypeDef CANlib_TransmitFrame(Frame *frame, CANlib_Bus_T bus) {
   return HAL_CAN_AddTxMessage(hcan, &pHeader, frame->data, &pTxMailbox);
 }
 
-void CANlib_ReadFrame(Frame *frame, CANlib_Bus_T bus) {
-  CAN_Raw_Bus_T raw_bus = CANlib_GetRawBus(bus);
-  CAN_HandleTypeDef *hcan;
-  switch(raw_bus) {
-    case CAN_1:
-      hcan = &hcan1;
-      break;
-    case CAN_2:
-      hcan = &hcan2;
-      break;
-    case CAN_3:
-      hcan = &hcan3;
-      break;
-    default:
-      return;
-  }
+static void HAL_CANlib_ConvertFrame(CAN_RxHeaderTypeDef* pHeader, uint8_t data[8], Frame *out) {
+  out->id = pHeader->IDE == CAN_ID_STD ? pHeader->StdId : pHeader->ExtId;
+  out->dlc = pHeader->DLC;
+  memcpy(out->data, data, 8);
+  out->extended = pHeader->IDE == CAN_ID_EXT;
+}
 
+bool HAL_CANlib_ReadFrameFromFIFO(CAN_HandleTypeDef *hcan, uint32_t RxFifo, Frame* out) {
   uint8_t data[8] = {};
   CAN_RxHeaderTypeDef pHeader;
-  for (int fifo = 0; fifo < 2; fifo++) { // There are 2 receive FIFOs
-      if (HAL_CAN_GetRxFifoFillLevel(hcan, fifo) > 0) {
-        HAL_CAN_GetRxMessage(hcan, fifo, &pHeader, data);
-        frame->id = pHeader.IDE == CAN_ID_STD ? pHeader.StdId : pHeader.ExtId;
-        frame->dlc = pHeader.DLC;
-
-        memcpy(frame->data, data, sizeof(data));
-        frame->extended = pHeader.IDE == CAN_ID_EXT;
-        return;
-      }
+  if (HAL_CAN_GetRxFifoFillLevel(hcan, RxFifo) > 0) {
+    if (HAL_CAN_GetRxMessage(hcan, RxFifo, &pHeader, data) == HAL_OK) {
+        HAL_CANlib_ConvertFrame(&pHeader, data, out);
+        return true;
+    }
   }
+  return false;
 }
 
-
+bool HAL_CANlib_ReadFrame(CAN_HandleTypeDef *hcan, Frame* out) {
+  for (uint8_t fifo = 0; fifo < 2; fifo++) {
+    if (HAL_CANlib_ReadFrameFromFIFO(hcan, fifo, out)) {
+      return true;
+    }
+  }
+  return false;
+}

src/static.h

@@ -3,6 +3,7 @@
 
 #include <stdint.h>
 #include <stdbool.h>
+#include <time.h>
 
 typedef struct {
   uint32_t id;
@@ -11,6 +12,11 @@ typedef struct {
   bool extended;
 } Frame;
 
+typedef struct {
+  time_t stamp;
+  Frame frame;
+} TimestampedFrame;
+
 #define LIMIT(name)                                         \
   static Time_T last_sent = 0;                              \
   if (HAL_GetTick() - last_sent < name ## _period) return;  \