채널 매개변수를 추가하여 RX 및 TX 함수에서 CAN 채널을 동적으로 처리하도록 수정

DBC_Converter_RX.py

@@ -1,4 +1,5 @@
 import sys
+import json
 from DBC_Converter_Data_Parsing import load_dbc_file
 
 #============================== Generate Globals ==============================#
@@ -31,7 +32,7 @@ def generate_globals(signals, C_file, header_file):
     print(f"[INFO] Globals and extern declarations written to {C_file} and {header_file}")
 
 #============================== Generate VCU RX Function ==============================#
-def generate_vcu_rx_function_with_factors(signals, output_file):
+def generate_vcu_rx_function_with_factors(signals, channel, output_file):
     if not signals:
         print("[ERROR] No signals to generate VCU RX functions for.")
         return
@@ -101,28 +102,28 @@ void Receive_{message_name}_{message_info['ID']}(void)
                 lsb = signal["msb"] + 8*(signal_length // 8) - (signal_length % 8 - 1)
                 if signal_length > 8:
                     # Handle multi-byte signals
-                    shift_expr = f"(CAN_ch[0].rx.buf[{start_byte}] << shift{7 - start_bit})"
+                    shift_expr = f"(CAN_ch[{channel}].rx.buf[{start_byte}] << shift{7 - start_bit})"
                     multi_byte_expr = []
                     for i in range((signal_length + 7) // 8):
                         byte_shift = (7 - start_bit) + (i * 8)
                         if i == 0:
-                            multi_byte_expr.append(f"(CAN_ch[0].rx.buf[{start_byte + i}] << shift{7 - start_bit})")
+                            multi_byte_expr.append(f"(CAN_ch[{channel}].rx.buf[{start_byte + i}] << shift{7 - start_bit})")
                         else:
-                            multi_byte_expr.append(f"(CAN_ch[0].rx.buf[{start_byte + i}] >> shift{byte_shift})")
+                            multi_byte_expr.append(f"(CAN_ch[{channel}].rx.buf[{start_byte + i}] >> shift{byte_shift})")
                     shift_expr = " | ".join(multi_byte_expr)
                 else :
-                    shift_expr = f"(CAN_ch[0].rx.buf[{start_byte}] >> shift{lsb % 8})"
+                    shift_expr = f"(CAN_ch[{channel}].rx.buf[{start_byte}] >> shift{lsb % 8})"
             else:  # Intel (Little Endian)
-                shift_expr = f"(CAN_ch[0].rx.buf[{start_byte}] >> shift{start_bit})"
+                shift_expr = f"(CAN_ch[{channel}].rx.buf[{start_byte}] >> shift{start_bit})"
                 if signal_length > 8:
                     # Handle multi-byte signals
                     multi_byte_expr = []
                     for i in range((signal_length + 7) // 8):
                         byte_shift = i * 8
                         if i == 0:
-                            multi_byte_expr.append(f"(CAN_ch[0].rx.buf[{start_byte + i}] >> shift{start_bit})")
+                            multi_byte_expr.append(f"(CAN_ch[{channel}].rx.buf[{start_byte + i}] >> shift{start_bit})")
                         else:
-                            multi_byte_expr.append(f"(CAN_ch[0].rx.buf[{start_byte + i}] << shift{byte_shift})")
+                            multi_byte_expr.append(f"(CAN_ch[{channel}].rx.buf[{start_byte + i}] << shift{byte_shift})")
                     shift_expr = " | ".join(multi_byte_expr)
             c_file_content += f"    {temp_struct_name}.{signal['Signal name']}_temp = ({shift_expr}) & _{signal_length}bit;\n"
 
@@ -147,7 +148,7 @@ void Receive_{message_name}_{message_info['ID']}(void)
     print(f"Generated RX function C file with Factors and Offsets: {output_file}")
 
 #============================== Generate Input Function ==============================#
-def generate_input_functions(signals, output_file):
+def generate_input_functions(signals, channel, output_file):
     if not signals:
         print("[WARNING] No signals to generate Input functions for.")
         return
@@ -155,15 +156,15 @@ def generate_input_functions(signals, output_file):
     with open(output_file, 'w') as f:
         for message_name, message_info in signals.items():
             hex_id = message_info["ID"]
-            function_name = f"void Input_Data_Set_{message_name}_CH0_{hex_id}(void)"
+            function_name = f"void Input_Data_Set_{message_name}_CH{channel}_{hex_id}(void)"
             f.write(f"{function_name}\n{{\n")
             for signal in message_info["Signals"]:
-                f.write(f"    GV_{signal['Signal name']} = VCU.RX.CH0_RX_{message_name}_{hex_id}.{signal['Signal name']};\n")
+                f.write(f"    GV_{signal['Signal name']} = VCU.RX.CH{channel}_RX_{message_name}_{hex_id}.{signal['Signal name']};\n")
             f.write("}\n\n")
     print(f"[INFO] Input functions written to {output_file}")
 
 #============================== Generate Initialization ==============================#
-def generate_initialization(signals, output_file):
+def generate_initialization(signals, channel, output_file):
     if not signals:
         print("[WARNING] No signals to generate initialization for.")
         return
@@ -172,7 +173,7 @@ def generate_initialization(signals, output_file):
         f.write("void VCU_Data_Init(void)\n{\n")
         for message_name, message_info in signals.items():
             hex_id = message_info["ID"]
-            struct_prefix = f"VCU.RX.CH0_RX_{message_name}_{hex_id}"
+            struct_prefix = f"VCU.RX.CH{channel}_RX_{message_name}_{hex_id}"
             for signal in message_info["Signals"]:
                 if signal["Offset"] != 0.0:
                     if signal["Length"] <= 32:
@@ -192,6 +193,24 @@ def generate_initialization(signals, output_file):
 if __name__ == "__main__":
     dbc_file_path = sys.argv[1]
     output_dir = sys.argv[2]
+    channel = sys.argv[3]
+
+    channel = json.loads(channel)
+
+    if list(channel.values())[-1] == "CH0":
+        channel = 0
+    elif list(channel.values())[-1] == "CH1":
+        channel = 1
+    elif list(channel.values())[-1] == "CH2":
+        channel = 2
+    elif list(channel.values())[-1] == "CH3":
+        channel = 3
+    elif list(channel.values())[-1] == "CH4":
+        channel = 4
+    elif list(channel.values())[-1] == "CH5":
+        channel = 5
+    else:
+        print("[ERROR] Invalid channel specified. Must be one of CH0, CH1, CH2, CH3, CH4, or CH5.")
 
     output_globals_C_file = f"{output_dir}/generated_RX_globals.c"
     output_globals_header_file = f"{output_dir}/generated_RX_globals.h"
@@ -202,6 +221,6 @@ if __name__ == "__main__":
     signals = load_dbc_file(dbc_file_path)
 
     generate_globals(signals, output_globals_C_file, output_globals_header_file)
-    generate_vcu_rx_function_with_factors(signals, output_c_file)
+    generate_vcu_rx_function_with_factors(signals, channel, output_c_file)
-    generate_input_functions(signals, output_input_file)
+    generate_input_functions(signals, channel, output_input_file)
-    generate_initialization(signals, output_initialization_file)
+    generate_initialization(signals, channel, output_initialization_file)

DBC_Converter_TX.py

@@ -1,8 +1,8 @@
 import sys
+import json
 from DBC_Converter_Data_Parsing import load_dbc_file
 
 
-
 #============================== Generate TX Globals ==============================#
 def generate_tx_globals(signals, output_file, header_file):
     if not signals:
@@ -32,7 +32,7 @@ def generate_tx_globals(signals, output_file, header_file):
 
 
 #============================== Generate TX Functions ==============================#
-def generate_tx_functions(signals, output_file):
+def generate_tx_functions(signals, channel, output_file):
     if not signals:
         print("[WARNING] No signals to generate TX functions for.")
         return
@@ -40,14 +40,14 @@ def generate_tx_functions(signals, output_file):
     with open(output_file, 'w') as f:
         for message_name, message_info in signals.items():
             hex_id = message_info["ID"]
-            function_name = f"void Output_Data_Set_{message_name}_CH0_{hex_id}(void)"
+            function_name = f"void Output_Data_Set_{message_name}_CH{channel}_{hex_id}(void)"
             f.write(f"{function_name}\n{{\n")
             for signal in message_info["Signals"]:
                 factor_str = f"/ {signal['Factor']}" if signal["Factor"] != 1.0 else ""
                 offset_str = f"- {signal['Offset']}" if signal["Offset"] != 0.0 else ""
                 mask = f"_{signal['Length']}bit"
                 f.write(
-                    f"    VCU.TX.CH0_{message_name}_{hex_id}.{signal['Signal name']} = "
+                    f"    VCU.TX.CH{channel}_{message_name}_{hex_id}.{signal['Signal name']} = "
                     f"(int)((GV_{signal['Signal name']} {offset_str}) {factor_str}) & {mask};\n"
                 )
             f.write("}\n\n")
@@ -55,7 +55,7 @@ def generate_tx_functions(signals, output_file):
 
 
 #============================== Generate TX Initialization ==============================#
-def generate_tx_initialization(signals, output_file):
+def generate_tx_initialization(signals, channel, output_file):
     if not signals:
         print("[WARNING] No TX signals found for initialization generation.")
         return
@@ -66,14 +66,14 @@ def generate_tx_initialization(signals, output_file):
             hex_id = message_info["ID"]
             f.write(f"    // {message_name} ({hex_id})\n")
             for signal in message_info["Signals"]:
-                f.write(f"    VCU.TX.CH0_{message_name}_{hex_id}.{signal['Signal name']} = 0;\n")
+                f.write(f"    VCU.TX.CH{channel}_{message_name}_{hex_id}.{signal['Signal name']} = 0;\n")
             f.write("\n")
         f.write("}\n")
     print(f"[INFO] TX initialization function written to {output_file}")
 
 
 #============================== Generate TX Enum ==============================#
-def generate_tx_enum(signals, output_file, cycle):
+def generate_tx_enum(signals, channel, output_file, cycle):
     if not signals:
         print("[WARNING] No TX messages found for enum generation.")
         return
@@ -81,15 +81,15 @@ def generate_tx_enum(signals, output_file, cycle):
     with open(output_file, 'w') as f:
         f.write("typedef enum {\n")
         for idx, message_name in enumerate(signals.keys()):
-            enum_name = f"VCU_CH0_TX_{message_name}_{cycle}"
+            enum_name = f"VCU_CH{channel}_TX_{message_name}_{cycle}"
             f.write(f"    {enum_name} = {idx},\n")
-        f.write("    NUMBER_OF_VCU_CH0_TX_MESSAGE,\n")
+        f.write(f"    NUMBER_OF_VCU_CH{channel}_TX_MESSAGE,\n")
-        f.write("} VCU_CH0_TX;\n")
+        f.write(f"} VCU_CH{channel}_TX;\n")
     print(f"[INFO] TX enum written to {output_file}")
 
 
 #============================== Generate TX C File ==============================#
-def generate_vcu_can_transmit_single_c_file(signals, output_file):
+def generate_vcu_can_transmit_single_c_file(signals, channel, output_file):
     if not signals:
         print("[ERROR] No signals to generate VCU CAN transmit functions for.")
         return
@@ -108,7 +108,7 @@ def generate_vcu_can_transmit_single_c_file(signals, output_file):
 
         # Add the function definition for the message
         c_file_content += f"""
-void Transmit_{message_name}_CH0_{message_info['ID']}(void)
+void Transmit_{message_name}_CH{channel}_{message_info['ID']}(void)
 {{
 """
 
@@ -118,7 +118,7 @@ void Transmit_{message_name}_CH0_{message_info['ID']}(void)
             start_byte = signal["msb"] // 8
             start_bit = signal["msb"] % 8
             signal_length = signal["Length"]
-            signal_name = f"VCU.TX.CH0_{message_name}_{message_info['ID']}.{signal['Signal name']}"
+            signal_name = f"VCU.TX.CH{channel}_{message_name}_{message_info['ID']}.{signal['Signal name']}"
 
             # Handle 8-bit chunks
             while signal_length > 0:
@@ -152,11 +152,11 @@ void Transmit_{message_name}_CH0_{message_info['ID']}(void)
         # Write buffer assignments to the function
         for i, assignment in enumerate(buffer_assignments):
             if assignment:
-                c_file_content += f"    CAN_ch[0].tx.buf[{i}] = ({assignment}) & _8bit;\n"
+                c_file_content += f"    CAN_ch[{channel}].tx.buf[{i}] = ({assignment}) & _8bit;\n"
 
         # Add the send function call
         c_file_content += f"""
-    can_send_config(CAN_INST_0, g_messageObjectConf_VCU_0ch_TX[VCU_CH0_TX_{message_name}_10ms]);
+    can_send_config(CAN_INST_0, g_messageObjectConf_VCU_{channel}ch_TX[VCU_CH{channel}_TX_{message_name}_10ms]);
 }}
 """
 
@@ -170,6 +170,24 @@ void Transmit_{message_name}_CH0_{message_info['ID']}(void)
 if __name__ == "__main__":
     dbc_file_path = sys.argv[1]
     output_dir = sys.argv[2]
+    channel = sys.argv[3]
+
+    channel = json.loads(channel)
+
+    if list(channel.values())[-1] == "CH0":
+        channel = 0
+    elif list(channel.values())[-1] == "CH1":
+        channel = 1
+    elif list(channel.values())[-1] == "CH2":
+        channel = 2
+    elif list(channel.values())[-1] == "CH3":
+        channel = 3
+    elif list(channel.values())[-1] == "CH4":
+        channel = 4
+    elif list(channel.values())[-1] == "CH5":
+        channel = 5
+    else:
+        print("[ERROR] Invalid channel specified. Must be one of CH0, CH1, CH2, CH3, CH4, or CH5.")
 
     output_structs_file = f"{output_dir}/generated_TX_structs.h"
     output_globals_file = f"{output_dir}/generated_TX_globals.c"
@@ -186,7 +204,7 @@ if __name__ == "__main__":
         sys.exit(1)
 
     generate_tx_globals(signals, output_globals_file, output_globals_header)
-    generate_tx_functions(signals, output_tx_functions_file)
+    generate_tx_functions(signals, channel, output_tx_functions_file)
-    generate_tx_initialization(signals, output_tx_initialization)
+    generate_tx_initialization(signals, channel, output_tx_initialization)
-    generate_tx_enum(signals, output_enum_file, cycle_time)
+    generate_tx_enum(signals, channel, output_enum_file, cycle_time)
-    generate_vcu_can_transmit_single_c_file(signals, output_c_file)
+    generate_vcu_can_transmit_single_c_file(signals, channel, output_c_file)