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

@@ -11,7 +11,7 @@ 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'
     )
 
@@ -20,7 +20,7 @@ def multplxd_handler(frame, name_prepends, num_tabs, fw):
     fw('\t' * num_tabs + 'case {}_key:\n'.format(coord(name_prepends, frame.name)))
     key_size = ceil(frame.slice.length / 8) * 8
     key_name = '_'.join([name_prepends,frame.name, 'key'])
-    fw('\t' * (num_tabs + 1) + 'to_bitstring(frame.data, &bitstring);' '\n')
+    fw('\t' * (num_tabs + 1) + 'to_bitstring(frame->data, &bitstring);' '\n')
     fw(
         '\t' * (num_tabs + 1) + 'uint{}_t {} = EXTRACT(bitstring, {}, {});\n'.format(key_size, key_name, frame.slice.start, frame.slice.length) + '\t' * (num_tabs + 1) + 'switch(' + key_name + ') {' '\n'
     )
@@ -78,28 +78,68 @@ def write(can, computers, output_path=computer_c_dir_path):
 
             fw('\t}\n}\n\n')
 
+            fw(
+              'CAN_Raw_Bus_T CANlib_GetConceptualBus(CAN_Raw_Bus_T bus) {\n'
+              '\tswitch (bus) {\n'
+            )
+
+            for busnm, rawnm in computer.participation['name']['can'].mapping.items():
+                fw('\t\tcase {}:\n'.format(rawnm) + '\t\t\treturn {};\n'.format(busnm))
+
+            fw('\t\tdefault:\n\t\t\treturn INVALID_BUS;\n')
+
+            fw('\t}\n}\n\n')
+
             for busnm, bus in computer.participation['name']['can'].subscribe.items():
                 fw(
-                    'static void CANlib_update_can_{}(void)'.format(busnm) + '{\n' +
-                    '\tFrame frame;\n'
-                )
-                if any(is_multplxd(msg) for msg in bus):
-                    fw('\tuint64_t bitstring;\n')
-                fw(
-                    '\tCANlib_ReadFrame(&frame, {});\n'.format(busnm) +
-                    '\tswitch(frame.id) {\n'
+                    'static void CANlib_HandleFrame_{}(Timestamped_Frame* ts_frame)'.format(busnm) + '{\n' +
+                        '\tswitch(ts_frame->frame.id) {\n'
                 )
 
                 for msg in bus:
                     msg_handler(msg, busnm, fw)
 
+                fw('\t\tdefault:\n\t\t\treturn;\n')
                 fw('\t}\n')
 
                 fw(
                     '}\n\n'
                 )
 
+            for busnm, bus in computer.participation['name']['can'].subscribe.items():
+                fw(
+                    'static void CANlib_update_can_{}(void)'.format(busnm) + '{\n' +
+                    '\tTimestamped_Frame ts_frame;\n'
+                )
+                if any(is_multplxd(msg) for msg in bus):
+                    fw('\tuint64_t bitstring;\n')
+
+                fw(
+                    '\tif (CANlib_ReadFrame(&(ts_frame.frame), {})) {{\n'.format(busnm) +
+                    '\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('}\n\n')
+
+            fw('void CANlib_HandleFrame(CAN_Raw_Bus_T raw_bus) {\n')
+            if len(computer.participation['name']['can'].subscribe.keys()) > 0: # check if computer receives messages
+                fw('\tTimestamped_Frame ts_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\tif (CANlib_ReadFrame(&(ts_frame.frame), {})) {{\n'.format(bus) +
+                        '\t\t\t\tCANlib_HandleFrame_{}(&ts_frame);\n'.format(bus) +
+                        '\t\t\t}\n' +
+                        '\t\t\tbreak;\n'
+                    )
+                fw('\t\tdefault:\n\t\t\tbreak;\n')
+                fw('\t}\n')
+            else: # prevent unused warning
+                fw('\tUNUSED(raw_bus);\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_{}(Timestamped_Frame *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:
@@ -41,7 +41,8 @@ def write(can, computers, output_path=computer_h_dir_path):
             fw('#include "structs.h"\n')
             fw('#include "static.h"\n')
             fw('#include "evil_macros.h"\n')
-            fw('#include "pack_unpack.h"\n\n')
+            fw('#include "pack_unpack.h"\n')
+            fw('#include "bus.h"\n\n')
 
             fw('\n')
 
@@ -53,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,8 +65,9 @@ def write(can, computers, output_path=computer_h_dir_path):
                         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);\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')
 

generator/send_receive.py

@@ -25,19 +25,22 @@ 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_{}(Timestamped_Frame *ts_frame) {{\n'.format(tot_name, tot_name))
+    fw('\tCANlib_{}_Input.timestamp = HAL_GetTick();\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))
 
 
 def write(can, output_path=send_recieve_path):
     with open(output_path, 'w') as f:
         fw = f.write
+        fw('#include <stm32f4xx_hal.h>\n')
         fw('#include "pack_unpack.h"\n\n')
 
         for bus in can.bus:

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('\t{}_T msg;\n'.format(coord(name_prepends, frame.name)))
+    fw('\ttime_t timestamp;\n')
+    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,10 @@
 
 #include "drivers/inc/stm32f4xx.h"
 #include "bus.h"
+#include <stdbool.h>
 
 CANlib_Transmit_Error_T CANlib_TransmitFrame(Frame *frame, CANlib_Bus_T bus);
-void CANlib_ReadFrame(Frame *frame, CANlib_Bus_T bus);
+bool CANlib_ReadFrame(Frame *frame, CANlib_Bus_T bus);
 CAN_Raw_Bus_T CANlib_GetRawBus(CANlib_Bus_T bus);
 
 #endif // __DRIVER_H

src/drivers/inc/stm32f4xx.h

@@ -6,12 +6,13 @@
 #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;
 
 CANlib_Transmit_Error_T CANlib_TransmitFrame(Frame *frame, CANlib_Bus_T bus);
-void CANlib_ReadFrame(Frame *frame, CANlib_Bus_T bus);
+bool CANlib_ReadFrame(Frame *frame, CANlib_Bus_T bus);
 
 #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;
@@ -38,7 +39,7 @@ 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) {
+bool CANlib_ReadFrame(Frame *frame, CANlib_Bus_T bus) {
   CAN_Raw_Bus_T raw_bus = CANlib_GetRawBus(bus);
   CAN_HandleTypeDef *hcan;
   switch(raw_bus) {
@@ -52,22 +53,23 @@ void CANlib_ReadFrame(Frame *frame, CANlib_Bus_T bus) {
       hcan = &hcan3;
       break;
     default:
-      return;
+      return false;
   }
 
   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);
+        if (HAL_CAN_GetRxMessage(hcan, fifo, &pHeader, data) != HAL_OK) {
+          continue;
+        }
         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;
+        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 {
+  Frame frame;
+  time_t timestamp;
+} Timestamped_Frame;
+
 #define LIMIT(name)                                         \
   static Time_T last_sent = 0;                              \
   if (HAL_GetTick() - last_sent < name ## _period) return;  \