From 233f6e68c4a97ffab3906f6a05da717b4883c184 Mon Sep 17 00:00:00 2001 From: Gabriel Cojocaru Date: Sun, 1 Nov 2020 20:58:41 +0200 Subject: [PATCH 01/17] first draft --- generator/computers_c.py | 10 - generator/computers_cpp.py | 10 + generator/computers_h.py | 11 - generator/computers_hpp.py | 11 + generator/drivers_inc.py | 9 +- generator/main.py | 61 ++- generator/templates/bus.cpp.j2 | 52 ++ generator/templates/bus.h.j2 | 34 -- generator/templates/bus.hpp.j2 | 40 ++ generator/templates/computer.c.j2 | 134 ----- generator/templates/computer.cpp.j2 | 56 ++ generator/templates/computer.h.j2 | 55 -- generator/templates/computer.hpp.j2 | 20 + generator/templates/constants.h.j2 | 31 -- .../templates/drivers/inc/stm32f2xx.h.j2 | 11 - .../templates/drivers/inc/stm32f2xx.hpp.j2 | 14 + .../templates/drivers/inc/stm32f4xx.h.j2 | 33 -- .../templates/drivers/inc/stm32f4xx.hpp.j2 | 34 ++ .../templates/drivers/inc/testfamily.hpp.j2 | 48 ++ generator/templates/enum_atom.h.j2 | 32 -- generator/templates/pack_unpack.c.j2 | 145 ----- generator/templates/pack_unpack.cpp.j2 | 140 +++++ generator/templates/pack_unpack.h.j2 | 27 - .../templates/pack_unpack.hpp.j2 | 36 +- generator/templates/send_receive.c.j2 | 55 -- generator/templates/structs.cpp.j2 | 139 +++++ generator/templates/structs.h.j2 | 31 -- generator/templates/structs.hpp.j2 | 119 +++++ src/clock.hpp | 22 + src/driver.h | 21 - src/driver.hpp | 24 + .../src/{stm32f2xx.c => stm32f2xx.cpp} | 14 +- .../src/{stm32f4xx.c => stm32f4xx.cpp} | 34 +- src/drivers/src/test.c | 12 - src/drivers/src/testfamily.cpp | 57 ++ src/{static.h => static.hpp} | 4 +- test/CMakeLists.txt | 36 ++ test/Makefile | 90 ++++ test/can_spec.yml | 504 ++++++++++++++++++ test/tests/inc/test.hpp | 19 + test/tests/main.cpp | 15 + test/tests/src/arch0.cpp | 47 ++ test/tests/src/arch1.cpp | 47 ++ test/tests/src/arch2.cpp | 47 ++ test/tests/src/constants.cpp | 304 +++++++++++ test/tests/src/identify.cpp | 99 ++++ test/tests/src/message.cpp | 93 ++++ test/tests/src/send.cpp | 104 ++++ 48 files changed, 2294 insertions(+), 697 deletions(-) delete mode 100644 generator/computers_c.py create mode 100644 generator/computers_cpp.py delete mode 100644 generator/computers_h.py create mode 100644 generator/computers_hpp.py create mode 100644 generator/templates/bus.cpp.j2 delete mode 100644 generator/templates/bus.h.j2 create mode 100644 generator/templates/bus.hpp.j2 delete mode 100644 generator/templates/computer.c.j2 create mode 100644 generator/templates/computer.cpp.j2 delete mode 100644 generator/templates/computer.h.j2 create mode 100644 generator/templates/computer.hpp.j2 delete mode 100644 generator/templates/constants.h.j2 delete mode 100644 generator/templates/drivers/inc/stm32f2xx.h.j2 create mode 100644 generator/templates/drivers/inc/stm32f2xx.hpp.j2 delete mode 100644 generator/templates/drivers/inc/stm32f4xx.h.j2 create mode 100644 generator/templates/drivers/inc/stm32f4xx.hpp.j2 create mode 100644 generator/templates/drivers/inc/testfamily.hpp.j2 delete mode 100644 generator/templates/enum_atom.h.j2 delete mode 100644 generator/templates/pack_unpack.c.j2 create mode 100644 generator/templates/pack_unpack.cpp.j2 delete mode 100644 generator/templates/pack_unpack.h.j2 rename src/evil_macros.h => generator/templates/pack_unpack.hpp.j2 (68%) delete mode 100644 generator/templates/send_receive.c.j2 create mode 100644 generator/templates/structs.cpp.j2 delete mode 100644 generator/templates/structs.h.j2 create mode 100644 generator/templates/structs.hpp.j2 create mode 100644 src/clock.hpp delete mode 100644 src/driver.h create mode 100644 src/driver.hpp rename src/drivers/src/{stm32f2xx.c => stm32f2xx.cpp} (91%) rename src/drivers/src/{stm32f4xx.c => stm32f4xx.cpp} (65%) delete mode 100644 src/drivers/src/test.c create mode 100644 src/drivers/src/testfamily.cpp rename src/{static.h => static.hpp} (82%) create mode 100644 test/CMakeLists.txt create mode 100644 test/Makefile create mode 100644 test/can_spec.yml create mode 100644 test/tests/inc/test.hpp create mode 100644 test/tests/main.cpp create mode 100644 test/tests/src/arch0.cpp create mode 100644 test/tests/src/arch1.cpp create mode 100644 test/tests/src/arch2.cpp create mode 100644 test/tests/src/constants.cpp create mode 100644 test/tests/src/identify.cpp create mode 100644 test/tests/src/message.cpp create mode 100644 test/tests/src/send.cpp diff --git a/generator/computers_c.py b/generator/computers_c.py deleted file mode 100644 index 188b2e5..0000000 --- a/generator/computers_c.py +++ /dev/null @@ -1,10 +0,0 @@ -import os - - -def write(env, computers, input_path, output_path): - os.makedirs(output_path, exist_ok=True) - template = env.get_template(str(input_path)) - for computer in computers: - f_path = os.path.join(output_path, 'canlib_{}.c'.format(computer.name)) - with open(f_path, 'w') as f: - f.write(template.render(computer=computer)) diff --git a/generator/computers_cpp.py b/generator/computers_cpp.py new file mode 100644 index 0000000..c2d8e18 --- /dev/null +++ b/generator/computers_cpp.py @@ -0,0 +1,10 @@ +import os + + +def write(env, computers, input_path, output_path, testing): + os.makedirs(output_path, exist_ok=True) + template = env.get_template(str(input_path)) + for computer in computers: + f_path = os.path.join(output_path, 'canlib_{}.cpp'.format(computer.name)) + with open(f_path, 'w') as f: + f.write(template.render(computer=computer, testing=testing)) diff --git a/generator/computers_h.py b/generator/computers_h.py deleted file mode 100644 index dc5833b..0000000 --- a/generator/computers_h.py +++ /dev/null @@ -1,11 +0,0 @@ -import os - - -def write(env, computers, input_path, output_path): - os.makedirs(output_path, exist_ok=True) - template = env.get_template(str(input_path)) - - for computer in computers: - f_path = os.path.join(output_path, 'canlib_{}.h'.format(computer.name)) - with open(f_path, 'w') as f: - f.write(template.render(computer=computer)) diff --git a/generator/computers_hpp.py b/generator/computers_hpp.py new file mode 100644 index 0000000..c912942 --- /dev/null +++ b/generator/computers_hpp.py @@ -0,0 +1,11 @@ +import os + + +def write(env, computers, input_path, output_path, testing): + os.makedirs(output_path, exist_ok=True) + template = env.get_template(str(input_path)) + + for computer in computers: + f_path = os.path.join(output_path, 'canlib_{}.hpp'.format(computer.name)) + with open(f_path, 'w') as f: + f.write(template.render(computer=computer, testing=testing)) diff --git a/generator/drivers_inc.py b/generator/drivers_inc.py index 3efa784..da61641 100644 --- a/generator/drivers_inc.py +++ b/generator/drivers_inc.py @@ -13,16 +13,17 @@ def find_architecture(system, template): return None -def write(env, system, input_path, output_path): +def write(env, system, input_path, output_path, testing = False): input_path = Path(input_path) output_path = Path(output_path) output_path.mkdir(parents=True, exist_ok=True) for template_path in input_path.glob('*'): - architecture_name = template_path.stem.strip('.h') + architecture_name = template_path.stem.strip('.hpp') architecture = find_architecture(system, architecture_name) output_file = output_path.joinpath(template_path.stem) template = env.get_template(str(template_path)) - with open(output_file, 'w') as f: - f.write(template.render(architecture=architecture)) + if (testing == (architecture_name == 'testfamily')): + with open(output_file, 'w') as f: + f.write(template.render(architecture=architecture)) diff --git a/generator/main.py b/generator/main.py index e059e75..6e848c5 100644 --- a/generator/main.py +++ b/generator/main.py @@ -9,23 +9,35 @@ import ParseCAN.ParseCAN as ParseCAN import constants -import computers_h -import computers_c +import computers_hpp +import computers_cpp import drivers_inc -src_dir = Path('../src/') -constants_path = src_dir.joinpath('constants.h') -drivers_inc_dir_path = src_dir.joinpath('drivers/inc') -computer_h_dir_path = src_dir.joinpath('computers/inc') -computer_c_dir_path = src_dir.joinpath('computers/src') +src_dir = Path('../src/src/') +inc_dir = Path('../src/inc/') +drivers_inc_dir_path = inc_dir.joinpath('drivers/') +computer_hpp_dir_path = inc_dir.joinpath('computers/') +computer_cpp_dir_path = src_dir.joinpath('computers/') template_dir = Path('./templates/') -computer_c_template_path = template_dir.joinpath('computer.c.j2') -computer_h_template_path = template_dir.joinpath('computer.h.j2') -constants_template_path = template_dir.joinpath('constants.h.j2') +computer_cpp_template_path = template_dir.joinpath('computer.cpp.j2') +computer_hpp_template_path = template_dir.joinpath('computer.hpp.j2') drivers_inc_template_dir_path = template_dir.joinpath('drivers/inc') +from pint import UnitRegistry +def get_ms(period_str): + if type(period_str) is int: + # If it's set as an integer, assume ms + return period_str + + ur = UnitRegistry() + return (int)(ur[period_str].to('ms').magnitude) + +def get_msg_len(msg): + if hasattr(msg, "frame"): + return 1 + sum([get_msg_len(sub_frame) for sub_frame in msg.frame]) + return 1 # FROM: https://github.com/duelafn/python-jinja2-apci/blob/master/jinja2_apci/error.py class RaiseExtension(Extension): @@ -51,15 +63,19 @@ def parse(self, parser): def _raise(self, msg, caller): raise TemplateRuntimeError(msg) - def render_template_from_to(env, input_path, output_path): template = env.get_template(str(input_path)) with open(output_path, 'w') as f: - f.write(template.render()) - + if output_path in [inc_dir.joinpath("structs.hpp"), src_dir.joinpath("structs.cpp")]: + f.write(template.render(get_ms = get_ms, get_msg_len = get_msg_len)) + else: + f.write(template.render()) def render_template(env, relative_path): - render_template_from_to(env, template_dir.joinpath(f"{relative_path}.j2"), src_dir.joinpath(relative_path)) + if relative_path.endswith('hpp') or relative_path.endswith('h'): + render_template_from_to(env, template_dir.joinpath(f"{relative_path}.j2"), inc_dir.joinpath(relative_path)) + else: + render_template_from_to(env, template_dir.joinpath(f"{relative_path}.j2"), src_dir.joinpath(relative_path)) if __name__ == '__main__': @@ -78,10 +94,17 @@ def render_template(env, relative_path): template_env.globals["can"] = can template_env.globals["system"] = system - for filename in ["pack_unpack.c", "pack_unpack.h", "enum_atom.h", "send_receive.c", "structs.h", "bus.h"]: + for filename in ["pack_unpack.cpp", "pack_unpack.hpp", "structs.hpp", "bus.hpp", "bus.cpp", "structs.cpp"]: render_template(template_env, filename) - constants.write(template_env, constants_template_path, constants_path) - computers_h.write(template_env, system.computer, computer_h_template_path, computer_h_dir_path) - computers_c.write(template_env, system.computer, computer_c_template_path, computer_c_dir_path) - drivers_inc.write(template_env, system, drivers_inc_template_dir_path, drivers_inc_dir_path) + testing = '--testing' in sys.argv + computers_hpp.write(template_env, system.computer, computer_hpp_template_path, computer_hpp_dir_path, testing) + computers_cpp.write(template_env, system.computer, computer_cpp_template_path, computer_cpp_dir_path, testing) + drivers_inc.write(template_env, system, drivers_inc_template_dir_path, drivers_inc_dir_path, testing) + import os + try: + os.system('clang-format -i ../src/inc/drivers/* ../src/src/drivers/*') + os.system('clang-format -i ../src/inc/*') + os.system('clang-format -i ../src/src/*') + except: + print('Error during clang-format, is it installed?') diff --git a/generator/templates/bus.cpp.j2 b/generator/templates/bus.cpp.j2 new file mode 100644 index 0000000..739a201 --- /dev/null +++ b/generator/templates/bus.cpp.j2 @@ -0,0 +1,52 @@ +{%- macro key_type(num_bits) -%} uint{{ (((num_bits / 8) | round(method='ceil')) * 8) | int }}_t {%- endmacro -%} + +#include "static.hpp" +#include "bus.hpp" +#include "structs.hpp" +#include "pack_unpack.hpp" +# + +namespace CANlib { +extern const std::pair* frame_id_range[static_cast(Bus_Names_T::INVALID_NAME)]; +extern const uint32_t* frame_len[static_cast(Bus_Names_T::INVALID_NAME)]; +extern const uint32_t* keys[static_cast(Bus_Names_T::INVALID_NAME)]; +//extern const size_t can_size[static_cast(Bus_Names_T::INVALID_NAME)]; +extern Message_T** messages[static_cast(Bus_Names_T::INVALID_NAME)]; +} + +using namespace CANlib; + +static uint32_t Identify_internal(const uint32_t key, const Frame& frame, int l, int r, int bus_idx) { + for (int i = l;i <= r;++i) { + if (keys[bus_idx][i] == key) { + int left_bound = frame_id_range[bus_idx][i].first; + int right_bound = frame_id_range[bus_idx][i].second; + if (left_bound <= right_bound) { + uint64_t bitstring; + to_bitstring((uint8_t*)frame.data, &bitstring); + return Identify_internal(EXTRACT(bitstring, left_bound, right_bound), frame, i + 1, i + 1 + frame_len[bus_idx][i], bus_idx); + } else { + return i; + } + } + } + return 0; +} + + +uint32_t CANlib::Identify(Bus_Names_T bus, const Frame& frame) { + const int bus_idx = static_cast(bus); +// return Identify_internal(frame.id, frame, 1, can_size[bus_idx], bus_idx); +} + +void CANlib::HandleFrame(Bus_Names_T bus_name, const Frame& frame) { + if (bus_name == Bus_Names_T::INVALID_NAME) { + return; + } + + uint32_t message_idx = Identify(bus_name, frame); + uint32_t bus_idx = static_cast(bus_name); + if (message_idx > 0) { + messages[bus_idx][message_idx]->pack(frame); + } +} diff --git a/generator/templates/bus.h.j2 b/generator/templates/bus.h.j2 deleted file mode 100644 index 8524ebb..0000000 --- a/generator/templates/bus.h.j2 +++ /dev/null @@ -1,34 +0,0 @@ -{%- set ns = namespace(first_frame=true) -%} - -{%- macro enum_name(bus, msg, msg_name=msg.name) -%} -{%- if msg.frame is defined -%} -{% for sub_frame in msg.frame -%} -{{ enum_name(bus, sub_frame, msg_name + '_' + sub_frame.name) }} -{%- endfor -%} -{%- else %} - CANlib_{{ bus.name }}_{{ msg_name }}{%- if ns.first_frame %} = 2 - {%- set ns.first_frame = false -%} - {%- endif -%}, -{%- endif -%} -{%- endmacro -%} -#pragma once - -#include "static.h" - -#define CANlib_UNKNOWN_MSG 0 - -typedef enum { -{%- for bus in can.bus %} - {{ bus.name }}, -{%- endfor %} -} CANlib_Bus_T; -{% for bus in can.bus %} -{%- set ns.first_frame = true %} -typedef enum { -{%- for msg in bus.frame -%} -{{- enum_name(bus, msg) }} -{%- endfor %} -} CANlib_{{ bus.name }}_T; - -CANlib_{{ bus.name }}_T CANlib_Identify_{{ bus.name }}(Frame* frame); -{% endfor -%} diff --git a/generator/templates/bus.hpp.j2 b/generator/templates/bus.hpp.j2 new file mode 100644 index 0000000..150e782 --- /dev/null +++ b/generator/templates/bus.hpp.j2 @@ -0,0 +1,40 @@ +{%- set ns = namespace(first_frame=true) -%} + +{%- macro enum_name(msg, msg_name=msg.name) -%} + {%- if msg.frame is defined -%} + {% for sub_frame in msg.frame -%} + {{ enum_name(sub_frame, msg_name + '_' + sub_frame.name) }} + {%- endfor -%} + {%- else %} + {{ msg_name }}, + {%- endif -%} +{%- endmacro -%} +#pragma once + +#include "static.hpp" + +namespace CANlib { + +enum class Bus_Names_T { + {%- for bus in can.bus %} + {{ bus.name }}, + {%- endfor %} + INVALID_NAME, +}; + +uint32_t Identify(Bus_Names_T, const Frame&); +void HandleFrame(Bus_Names_T, const Frame&); + +{% for bus in can.bus %} + namespace {{bus.name}} { + {%- set ns.first_frame = true %} + enum class Message_Type_T { + UNKNOWN_MSG = 0, + {%- for msg in bus.frame -%} + {{- enum_name(msg) }} + {%- endfor %} + }; + } // {{bus.name}} +{% endfor -%} + +} // CANlib diff --git a/generator/templates/computer.c.j2 b/generator/templates/computer.c.j2 deleted file mode 100644 index 5f7fc82..0000000 --- a/generator/templates/computer.c.j2 +++ /dev/null @@ -1,134 +0,0 @@ -{%- macro key_type(num_bits) -%} uint{{ (((num_bits / 8) | round(method='ceil')) * 8) | int }}_t {%- endmacro -%} - -{%- macro handle_case(busnm, msg, msg_name=msg.name, indent=2) -%} -{%- if msg.frame is defined -%} -case CANlib_{{ busnm }}_{{ msg_name }}_key: { - uint64_t bitstring; - to_bitstring(frame->data, &bitstring); - {{ key_type(msg.slice.length) }} {{ busnm }}_{{ msg_name }}_key = EXTRACT(bitstring, {{ msg.slice.start }}, {{ msg.slice.length }}); - switch ({{ busnm }}_{{ msg_name }}_key) { - {%- for sub_frame in msg.frame %} - {{ handle_case(busnm, sub_frame, msg_name + '_' + sub_frame.name, indent + 2) | indent(indent + 2) }} - {%- endfor %} - default: - return; - } - break; -} -{%- else -%} -case CANlib_{{ busnm }}_{{ msg_name }}_key: - CANlib_Handle_{{ busnm }}_{{ msg_name }}(frame); - break; -{%- endif -%} -{%- endmacro -%} - -{%- macro identify_case(busnm, msg, msg_name=msg.name, indent=2) -%} -{%- if msg.frame is defined -%} -case CANlib_{{ busnm }}_{{ msg_name }}_key: { - uint64_t bitstring; - to_bitstring(frame->data, &bitstring); - {{ key_type(msg.slice.length) }} {{ busnm }}_{{ msg_name }}_key = EXTRACT(bitstring, {{ msg.slice.start }}, {{ msg.slice.length }}); - switch ({{ busnm }}_{{ msg_name }}_key) { - {%- for sub_frame in msg.frame %} - {{ identify_case(busnm, sub_frame, msg_name + '_' + sub_frame.name, indent + 2) | indent(indent + 2) }} - {%- endfor %} - default: - return CANlib_UNKNOWN_MSG; - break; - } - break; -} -{%- else -%} -case CANlib_{{ busnm }}_{{ msg_name }}_key: - return CANlib_{{ busnm }}_{{ msg_name }}; - break; -{%- endif -%} -{%- endmacro -%} - -#include "canlib_{{ computer.name }}.h" -#include "constants.h" -#include "bus.h" -#include "pack_unpack.h" -#include "evil_macros.h" -#include "drivers/inc/{{ system.architecture['name'][computer.architecture].family }}.h" - -#ifndef UNUSED -#define UNUSED(X) (void)X -#endif - -CAN_Raw_Bus_T CANlib_GetRawBus(CANlib_Bus_T bus) { - switch (bus) { -{%- for busnm, rawnm in computer.participation['name']['can'].mapping.items() %} - case {{ busnm }}: - return {{ rawnm }}; -{%- endfor %} - default: - return INVALID_BUS; - } -} - -CAN_Raw_Bus_T CANlib_GetConceptualBus(CAN_Raw_Bus_T bus) { - switch (bus) { -{%- for busnm, rawnm in computer.participation['name']['can'].mapping.items() %} - case {{ rawnm }}: - return {{ busnm }}; -{%- endfor %} - default: - return INVALID_BUS; - } -} - -{%- for busnm, bus in computer.participation['name']['can'].subscribe.items() %} - -CANlib_{{ busnm }}_T CANlib_Identify_{{ busnm }}(Frame* frame) { - switch (frame->id) { - {%- for frame in bus %} - {{ identify_case(busnm, frame) | indent(4) }} - {%- endfor %} - default: - return CANlib_UNKNOWN_MSG; - break; - } -} -{%- endfor %} - -{%- for busnm, bus in computer.participation['name']['can'].subscribe.items() %} - -static void CANlib_HandleFrame_{{ busnm }}(Frame *frame) { - switch (frame->id) { -{%- for frame in bus %} - {{ handle_case(busnm, frame) | indent(4) }} -{%- endfor %} - default: - return; - } -} -{%- endfor %} - -void CANlib_HandleFrame(CAN_Raw_Bus_T raw_bus, Frame* frame) { - switch (raw_bus) { -{%- for busnm in computer.participation['name']['can'].subscribe.keys() %} - case {{computer.participation['name']['can'].mapping[busnm] }}: - CANlib_HandleFrame_{{ busnm }}(frame); - break; -{%- endfor %} - default: - UNUSED(frame); - break; - } -} - -{%- for busnm in computer.participation['name']['can'].subscribe.keys() %} - -static void CANlib_update_can_{{ busnm }}(void) { - Frame frame; - CANlib_ReadFrame(&frame, {{ busnm }}); - CANlib_HandleFrame_{{ busnm }}(&frame); -} -{%- endfor %} - -void CANlib_update_can(void) { -{%- for busnm in computer.participation['name']['can'].subscribe.keys() %} - CANlib_update_can_{{ busnm }}(); -{%- endfor %} -} diff --git a/generator/templates/computer.cpp.j2 b/generator/templates/computer.cpp.j2 new file mode 100644 index 0000000..83d5ddf --- /dev/null +++ b/generator/templates/computer.cpp.j2 @@ -0,0 +1,56 @@ +#include "canlib_{{ computer.name }}.hpp" +#include "bus.hpp" +#include "drivers/{{ system.architecture['name'][computer.architecture].family }}.hpp" + +using namespace CANlib; + +{% if testing %} +Raw_Bus_T CANlib::GetRawBus(Bus_Names_T bus) { +{% else %} +Raw_Bus_T CANlib::GetRawBus(Bus_Names_T bus) { +{% endif %} + switch (bus) { +{%- for busnm, rawnm in computer.participation['name']['can'].mapping.items() %} + case Bus_Names_T::{{ busnm }}: + return Raw_Bus_T::{{ rawnm }}; +{%- endfor %} + default: + return Raw_Bus_T::INVALID_BUS; + } +} + +{% if testing %} +Bus_Names_T CANlib::GetBusName(Raw_Bus_T bus) { +{% else %} +Bus_Names_T CANlib::GetBusName(Raw_Bus_T bus) { +{% endif %} + switch (bus) { +{%- for busnm, rawnm in computer.participation['name']['can'].mapping.items() %} + case Raw_Bus_T::{{ rawnm }}: + return Bus_Names_T::{{ busnm }}; +{%- endfor %} + default: + return Bus_Names_T::INVALID_NAME; + } +} + + +namespace CANlib { +{%- for busnm, rawnm in computer.participation['name']['can'].mapping.items() %} +{% if testing %} +void {{busnm}}_update_can() { +{% else %} +static void {{busnm}}_update_can() { +{% endif %} + Frame frame; + ReadFrame(frame, Bus_Names_T::{{ busnm }}); + HandleFrame(Bus_Names_T::{{busnm}}, frame); +} +{%- endfor %} +void update_can(void) { +{%- for busnm in computer.participation['name']['can'].subscribe.keys() %} + {{ busnm }}_update_can(); +{%- endfor %} +} +} + diff --git a/generator/templates/computer.h.j2 b/generator/templates/computer.h.j2 deleted file mode 100644 index 93197dc..0000000 --- a/generator/templates/computer.h.j2 +++ /dev/null @@ -1,55 +0,0 @@ -{%- macro send_declaration(bus_name, msg, msg_name=msg.name) -%} -{%- if msg.frame is defined -%} -{%- for sub_frame in msg.frame -%} -{{ send_declaration(bus_name, sub_frame, msg_name + '_' + sub_frame.name) }} -{%- endfor -%} -{%- else -%} -void CANlib_Send_{{ bus_name }}_{{ msg_name }}(CANlib_{{ bus_name }}_{{ msg_name }}_T *inp); -{% endif -%} -{%- endmacro -%} - -{%- macro handle_stuff(bus_name, msg, msg_name=msg.name) -%} -{%- if msg.frame is defined -%} -{%- for sub_frame in msg.frame -%} -{{ handle_stuff(bus_name, sub_frame, msg_name + '_' + sub_frame.name) }} -{%- endfor -%} -{%- else -%} -extern CANlib_{{ bus_name }}_{{ msg_name }}_T CANlib_{{ bus_name }}_{{ msg_name }}_Input; -void CANlib_Handle_{{ bus_name }}_{{ msg_name }}(Frame *frame); -{% endif -%} -{%- endmacro -%} - -#pragma once - -#include -#include - -#include "driver.h" -#include "constants.h" -#include "enum_atom.h" -#include "structs.h" -#include "static.h" -#include "evil_macros.h" -#include "bus.h" -#include "pack_unpack.h" - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus -{% for bus_name, bus in computer.participation['name']['can'].publish.items() %} -{% for frame in bus -%} -{{ send_declaration(bus_name, frame) -}} -{%- endfor -%} -{% endfor -%} - -{% for bus_name, bus in computer.participation['name']['can'].subscribe.items() %} -{% for frame in bus -%} -{{ handle_stuff(bus_name, frame) -}} -{%- endfor -%} -{% endfor %} -void CANlib_update_can(void); -void CANlib_HandleFrame(CAN_Raw_Bus_T raw_bus, Frame* frame); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus diff --git a/generator/templates/computer.hpp.j2 b/generator/templates/computer.hpp.j2 new file mode 100644 index 0000000..62c96f3 --- /dev/null +++ b/generator/templates/computer.hpp.j2 @@ -0,0 +1,20 @@ +#pragma once + +#include +#include + +#include "driver.hpp" +#include "structs.hpp" +#include "static.hpp" +#include "bus.hpp" + +namespace CANlib { + {%- if testing -%} + {%- for busnm, rawnm in computer.participation['name']['can'].mapping.items() %} + void {{busnm}}_update_can(); + {%- endfor %} + {% endif %} + void update_can(void); + Raw_Bus_T GetRawBus(Bus_Names_T bus); + Bus_Names_T GetBusName(Raw_Bus_T bus); +} diff --git a/generator/templates/constants.h.j2 b/generator/templates/constants.h.j2 deleted file mode 100644 index 7682f13..0000000 --- a/generator/templates/constants.h.j2 +++ /dev/null @@ -1,31 +0,0 @@ -{%- macro key_defines(bus, msg, msg_name=msg.name) -%} -{%- if msg.frame is defined -%} -#define CANlib_{{ bus.name }}_{{ msg_name }}_key 0x{{ '%0X' % msg.key }} -{% for sub_frame in msg.frame -%} -{{ key_defines(bus, sub_frame, msg_name + '_' + sub_frame.name) }} -{% endfor -%} -{%- else -%} -#define CANlib_{{ bus.name }}_{{ msg_name }}_key 0x{{ '%0X' % msg.key }} -{%- endif %} -{%- endmacro -%} -#pragma once - -// CAN IDs -{%- for bus in can.bus %} - -// {{ bus.name }} -{%- for msg in bus.frame %} -{{ key_defines(bus, msg) }} -{%- endfor %} -{%- endfor %} - -// Periods (ms) -{%- for bus in can.bus %} - -// {{ bus.name }} -{%- for msg in bus.frame %} -{%- if msg.period %} -#define CANlib_{{ bus.name }}_{{ msg.name }}_period {{ get_ms(msg.period) }} -{%- endif %} -{%- endfor %} -{%- endfor %} diff --git a/generator/templates/drivers/inc/stm32f2xx.h.j2 b/generator/templates/drivers/inc/stm32f2xx.h.j2 deleted file mode 100644 index a90b72f..0000000 --- a/generator/templates/drivers/inc/stm32f2xx.h.j2 +++ /dev/null @@ -1,11 +0,0 @@ -#pragma once - -#include "static.h" - -#include "stm32f2xx_hal_can.h" -#include - -typedef HAL_StatusTypeDef CANlib_Transmit_Error_T; - -HAL_StatusTypeDef CANlib_Init(uint32_t baudrate); -HAL_StatusTypeDef CANlib_TransmitFrame(Frame *frame); diff --git a/generator/templates/drivers/inc/stm32f2xx.hpp.j2 b/generator/templates/drivers/inc/stm32f2xx.hpp.j2 new file mode 100644 index 0000000..78b3b39 --- /dev/null +++ b/generator/templates/drivers/inc/stm32f2xx.hpp.j2 @@ -0,0 +1,14 @@ +#pragma once + +#include "static.hpp" + +#include "stm32f2xx_hal_can.h" +#include + +namespace CANlib { + + typedef HAL_StatusTypeDef CANlib_Transmit_Error_T; + + HAL_StatusTypeDef Init(uint32_t baudrate); + HAL_StatusTypeDef TransmitFrame(Frame& frame); +} diff --git a/generator/templates/drivers/inc/stm32f4xx.h.j2 b/generator/templates/drivers/inc/stm32f4xx.h.j2 deleted file mode 100644 index af0bed1..0000000 --- a/generator/templates/drivers/inc/stm32f4xx.h.j2 +++ /dev/null @@ -1,33 +0,0 @@ -#pragma once - -#include "static.h" -#include "stm32f4xx_hal.h" -#include "bus.h" - -#include - -#ifdef __cplusplus -extern "C" { -#endif // __cplusplus - -typedef enum { -{%- for bus in architecture.participation['name']['can'].buses -%} -{%- if bus == 'INVALID_BUS' -%} - {%- raise "INVALID_BUS is a reserved bus name" -%} -{%- endif %} - {{ bus }}, -{%- endfor %} - INVALID_BUS -} CAN_Raw_Bus_T; - -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); -Time_T CANlib_GetTick(void); - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus diff --git a/generator/templates/drivers/inc/stm32f4xx.hpp.j2 b/generator/templates/drivers/inc/stm32f4xx.hpp.j2 new file mode 100644 index 0000000..e76d2cc --- /dev/null +++ b/generator/templates/drivers/inc/stm32f4xx.hpp.j2 @@ -0,0 +1,34 @@ +#pragma once + +#include "static.hpp" +#include "stm32f4xx_hal.h" +#include "bus.hpp" +#include "clock.h" + +#include + +Clock::time_point Clock::now() noexcept { + static const auto start_time = HAL_GetTick(); + const auto time_passed = HAL_GetTick() - start_time; + return time_point(std::chrono::milliseconds(time_passed)); +} + +namespace CANlib { + +enum class Raw_Bus_T { +{%- for bus in architecture.participation['name']['can'].buses -%} +{%- if bus == 'INVALID_BUS' -%} + {%- raise "INVALID_BUS is a reserved bus name" -%} +{%- endif %} + {{ bus }}, +{%- endfor %} + INVALID_BUS +}; + +typedef HAL_StatusTypeDef Transmit_Error_T; +typedef HAL_StatusTypeDef Init_Error_T; + +Transmit_Error_T TransmitFrame(const Frame& frame, Bus_Names_T bus); +void ReadFrame(Frame& frame, Bus_Names_T bus); + +} // CANlib diff --git a/generator/templates/drivers/inc/testfamily.hpp.j2 b/generator/templates/drivers/inc/testfamily.hpp.j2 new file mode 100644 index 0000000..af2941e --- /dev/null +++ b/generator/templates/drivers/inc/testfamily.hpp.j2 @@ -0,0 +1,48 @@ +#pragma once + +#include "static.hpp" +#include "bus.hpp" + +#include +#include +#include +#include +#include +#include "clock.hpp" + + +namespace CANlib { + + +class CAN { +public: + void setFrameToSend(const Frame& f) {frame_to_send = f;} + void receiveFrame(const Frame& f) {frames_received.push_back(f);} + size_t framesReceived() {return frames_received.size();} + void popFrame() {frames_received.pop_back();} + Frame topFrame() {return frames_received.back();} + Frame frameToSend() {return frame_to_send;} + void clear() {frames_received.clear(); memset(&frame_to_send, 0, sizeof(frame_to_send));} +protected: + std::vector frames_received; + Frame frame_to_send; +}; + +enum class Raw_Bus_T { +{%- for bus in architecture.participation['name']['can'].buses -%} +{%- if bus == 'INVALID_BUS' -%} + {%- raise "INVALID_BUS is a reserved bus name" -%} +{%- endif %} + {{ bus }}, +{%- endfor %} + INVALID_BUS +}; + +typedef bool Transmit_Error_T; + +Transmit_Error_T TransmitFrame(const Frame& frame, Bus_Names_T bus); +void ReadFrame(Frame& frame, Bus_Names_T bus); +Raw_Bus_T GetRawBus(Bus_Names_T); +Bus_Names_T GetBusName(Raw_Bus_T); + +} // CANlib diff --git a/generator/templates/enum_atom.h.j2 b/generator/templates/enum_atom.h.j2 deleted file mode 100644 index 8fb0a16..0000000 --- a/generator/templates/enum_atom.h.j2 +++ /dev/null @@ -1,32 +0,0 @@ -{%- macro enums(bus, msg, msg_name=msg.name) -%} -{%- if msg.frame is defined -%} -{% for sub_frame in msg.frame -%} -{{ enums(bus, sub_frame, msg_name + '_' + sub_frame.name) }} -{%- endfor -%} -{%- else -%} -{%- for atom in msg.atom -%} -{%- if atom.type.isenum() -%} -typedef enum { -{%- for enum in atom.type.enum -%} -{%- if enum.name == 'NUM_FIELDS' -%} - {%- raise "Enum name for {{ atom.name }} cannot be NUM_FIELDS" -%} -{%- else %} - CANlib_{{ bus.name }}_{{ msg_name }}_{{ atom.name }}_{{ enum.name }} = {{ enum.value }}, -{%- endif -%} -{%- endfor %} - CANlib_{{ bus.name }}_{{ msg_name }}_{{ atom.name }}_NUM_FIELDS = {{ atom.type.enum | length }} -} CANlib_{{ bus.name }}_{{ msg_name }}_{{ atom.name }}_T; - -{% endif -%} -{%- endfor -%} -{%- endif -%} -{%- endmacro -%} - -#pragma once - -{% for bus in can.bus -%} -// {{ bus.name }} -{% for msg in bus.frame -%} - {{ enums(bus, msg) }} -{%- endfor -%} -{%- endfor -%} diff --git a/generator/templates/pack_unpack.c.j2 b/generator/templates/pack_unpack.c.j2 deleted file mode 100644 index bf60f12..0000000 --- a/generator/templates/pack_unpack.c.j2 +++ /dev/null @@ -1,145 +0,0 @@ -{%- macro can_pack_handler(frame, name_prepends, bus_ext, parent_slices = []) -%} -{%- if frame.frame is defined -%} -{% for sub_frame in frame.frame -%} -{{ can_pack_handler(sub_frame, name_prepends + [frame.name], bus_ext, parent_slices + [frame.slice]) }} - -{% endfor -%} -{%- else -%} -{%- set name_prepends = name_prepends + [frame.name] -%} -{%- set tot_name = '_'.join(name_prepends) -%} -void CANlib_Pack_{{ tot_name }}(CANlib_{{ tot_name }}_T *type_in, Frame *can_out) { - uint64_t bitstring = 0; -{%- for i in range(parent_slices | length) -%} -{%- set part_name = '_'.join(name_prepends[:i + 3]) %} - bitstring = INSERT(CANlib_{{ part_name }}_key, bitstring, {{ parent_slices[i].start }}, {{ parent_slices[i].length }}); -{% endfor -%} -{%- set ns = namespace(length=0) -%} -{%- for atom in frame.atom %} - bitstring = INSERT({%- if atom.type.endianness.islittle() and not atom.type.isbool() -%}swap_{{ atom.type.type }}{%- endif -%}(type_in->{{ atom.name }}), bitstring, {{ atom.slice.start }}, {{ atom.slice.length }}); -{%- set ns.length = [ns.length, atom.slice.start + atom.slice.length] | max -%} -{%- endfor %} - from_bitstring(&bitstring, can_out->data); - can_out->id = CANlib_{{ '_'.join(name_prepends[:2]) }}_key; - can_out->dlc = {{ (ns.length / 8) | round(method='ceil') | int }}; - can_out->extended = {{ bus_ext | lower }}; -} -{%- endif %} -{%- endmacro -%} - -{%- macro can_unpack_handler(frame, name_prepends) -%} -{%- if frame.frame is defined -%} -{% for sub_frame in frame.frame -%} -{{ can_unpack_handler(sub_frame, name_prepends + '_' + frame.name) }} - -{% endfor -%} -{%- else -%} -{%- set tot_name = name_prepends + '_' + frame.name -%} -void CANlib_Unpack_{{ tot_name }}(Frame *can_in, CANlib_{{ tot_name }}_T *type_out) { - uint64_t bitstring = 0; - to_bitstring(can_in->data, &bitstring); -{%- for atom in frame.atom %} - type_out->{{ atom.name }} = {% if 0 %}{% endif %} - {%- if atom.type.isenum() -%} - (CANlib_{{ tot_name }}_{{ atom.name }}_T) - {%- endif -%} - {%- if atom.type.issigned() -%} - SIGN( - {%- endif -%} - {%- if atom.type.endianness.islittle() and not atom.type.isbool() -%} - swap_{{ atom.type.type }}( - {%- endif -%} - EXTRACT(bitstring, {{ atom.slice.start }}, {{ atom.slice.length }}) - {%- if atom.type.endianness.islittle() and not atom.type.isbool() -%} - ) - {%- endif -%} - {%- if atom.type.issigned() -%} - , {{ atom.slice.length }}) - {%- endif -%} - ; -{%- endfor %} -} -{%- endif %} -{%- endmacro -%} -#include "pack_unpack.h" -#include "evil_macros.h" - -typedef union { - uint8_t byte[8]; - uint64_t bitstring; -} DATA_T; - -// utility functions -void data_transfer(DATA_T *in, DATA_T *out) { - uint8_t i; - for (i = 0; i < 8; i++) { - (*out).byte[7 - i] = (*in).byte[i]; - } -} - -void to_bitstring(uint8_t in[], uint64_t *out) { - data_transfer((DATA_T*)in, (DATA_T*)out); -} - -void from_bitstring(uint64_t *in, uint8_t out[]) { - data_transfer((DATA_T*)in, (DATA_T*)out); -} - -// Shameless copypasta-ing from Stack Overflow for trivial endian swap. -// https://stackoverflow.com/a/2637138 -uint8_t swap_uint8(uint8_t val) { - return val; -} - -int8_t swap_int8(int8_t val) { - return val; -} - -uint16_t swap_uint16(uint16_t val) { - return (val << 8) | (val >> 8); -} - -int16_t swap_int16(int16_t val) { - return (val << 8) | ((val >> 8) & 0xFF); -} - -uint32_t swap_uint32(uint32_t val) { - val = ((val << 8) & 0xFF00FF00) | ((val >> 8) & 0xFF00FF); - return (val << 16) | (val >> 16); -} - -int32_t swap_int32(int32_t val) { - val = ((val << 8) & 0xFF00FF00) | ((val >> 8) & 0xFF00FF); - return (val << 16) | ((val >> 16) & 0xFFFF); -} - -int64_t swap_int64(int64_t val) { - val = ((val << 8) & 0xFF00FF00FF00FF00ULL) | - ((val >> 8) & 0x00FF00FF00FF00FFULL); - val = ((val << 16) & 0xFFFF0000FFFF0000ULL) | - ((val >> 16) & 0x0000FFFF0000FFFFULL); - return (val << 32) | ((val >> 32) & 0xFFFFFFFFULL); -} - -uint64_t swap_uint64(uint64_t val) { - val = ((val << 8) & 0xFF00FF00FF00FF00ULL) | - ((val >> 8) & 0x00FF00FF00FF00FFULL); - val = ((val << 16) & 0xFFFF0000FFFF0000ULL) | - ((val >> 16) & 0x0000FFFF0000FFFFULL); - return (val << 32) | (val >> 32); -} - -// Pack functions -{% for bus in can.bus %} -{%- for msg in bus.frame -%} -{{ can_pack_handler(msg, [bus.name], bus.extended) }} - -{% endfor %} -{% endfor %} - -// Unpack functions -{% for bus in can.bus %} -{%- for msg in bus.frame -%} -{{ can_unpack_handler(msg, bus.name) }} - -{% endfor %} -{% endfor %} diff --git a/generator/templates/pack_unpack.cpp.j2 b/generator/templates/pack_unpack.cpp.j2 new file mode 100644 index 0000000..3040262 --- /dev/null +++ b/generator/templates/pack_unpack.cpp.j2 @@ -0,0 +1,140 @@ +{%- macro can_pack_handler(frame, name_prepends, bus_ext, parent_slices = []) -%} +{%- if frame.frame is defined -%} + {% for sub_frame in frame.frame -%} + {{ can_pack_handler(sub_frame, name_prepends + [frame.name], bus_ext, parent_slices + [frame.slice]) }} + {% endfor -%} +{%- else -%} + {%- set name_prepends = name_prepends + [frame.name + '_T'] -%} + {%- set tot_name = '::'.join(name_prepends) -%} + void {{tot_name}}::unpack(Frame& can_out) { + uint64_t bitstring = 0; + {%- for i in range(parent_slices | length) -%} + {%- set part_name = '::'.join(name_prepends[:i + 3]) %} + bitstring = INSERT(CANlib::{{ part_name }}::key, bitstring, {{ parent_slices[i].start }}, {{ parent_slices[i].length }}); + {% endfor -%} + {%- set ns = namespace(length=0) -%} + {%- for atom in frame.atom %} + bitstring = INSERT({%- if atom.type.endianness.islittle() and not atom.type.isbool() -%}swap_{{ atom.type.type }}(static_cast<{{atom.type.type}}_t>(this->{{ atom.name }})) {% else %} (static_cast(this->{{ atom.name }})) {%- endif -%}, bitstring, {{ atom.slice.start }}, {{ atom.slice.length }}); + {%- set ns.length = [ns.length, atom.slice.start + atom.slice.length] | max -%} + {%- endfor %} + from_bitstring(&bitstring, can_out.data); + can_out.id = CANlib::{{ "::".join(name_prepends[:2]) }}::key; + can_out.dlc = {{ (ns.length / 8) | round(method='ceil') | int }}; + can_out.extended = {{ bus_ext | lower }}; + } +{%- endif %} +{%- endmacro -%} + +{%- macro can_unpack_handler(frame, name_prepends) -%} +{%- if frame.frame is defined -%} + {% for sub_frame in frame.frame -%} + {{ can_unpack_handler(sub_frame, name_prepends + [sub_frame.name]) }} + {% endfor -%} +{%- else -%} + {%- set tot_name = "::".join(name_prepends) -%} + void {{ tot_name }}_T::pack(const Frame& can_in) { + uint64_t bitstring = 0; + to_bitstring((uint8_t*)can_in.data, &bitstring); + {%- for atom in frame.atom %} + this->{{ atom.name }} = {% if 0 %}{% endif %} + {%- if atom.type.isenum() -%} + ({{ atom.name }}_T) + {%- endif -%} + {%- if atom.type.issigned() -%} + SIGN( + {%- endif -%} + {%- if atom.type.endianness.islittle() and not atom.type.isbool() -%} + swap_{{ atom.type.type }}( + {%- endif -%} + EXTRACT(bitstring, {{ atom.slice.start }}, {{ atom.slice.length }}) + {%- if atom.type.endianness.islittle() and not atom.type.isbool() -%} + ) + {%- endif -%} + {%- if atom.type.issigned() -%} + , {{ atom.slice.length }}) + {%- endif -%} + ; + {%- endfor %} + } +{%- endif %} +{%- endmacro -%} +#include "structs.hpp" +#include "pack_unpack.hpp" + +using namespace CANlib; + +// utility functions +void data_transfer(DATA_T *in, DATA_T *out) { + uint8_t i; + for (i = 0; i < 8; i++) { + (*out).byte[7 - i] = (*in).byte[i]; + } +} + +void to_bitstring(uint8_t in[], uint64_t *out) { + data_transfer((DATA_T*)in, (DATA_T*)out); +} + +void from_bitstring(uint64_t *in, uint8_t out[]) { + data_transfer((DATA_T*)in, (DATA_T*)out); +} + +// Shameless copypasta-ing from Stack Overflow for trivial endian swap. +// https://stackoverflow.com/a/2637138 +uint8_t swap_uint8(uint8_t val) { + return val; +} + +int8_t swap_int8(int8_t val) { + return val; +} + +uint16_t swap_uint16(uint16_t val) { + return (val << 8) | (val >> 8); +} + +int16_t swap_int16(int16_t val) { + return (val << 8) | ((val >> 8) & 0xFF); +} + +uint32_t swap_uint32(uint32_t val) { + val = ((val << 8) & 0xFF00FF00) | ((val >> 8) & 0xFF00FF); + return (val << 16) | (val >> 16); +} + +int32_t swap_int32(int32_t val) { + val = ((val << 8) & 0xFF00FF00) | ((val >> 8) & 0xFF00FF); + return (val << 16) | ((val >> 16) & 0xFFFF); +} + +int64_t swap_int64(int64_t val) { + val = ((val << 8) & 0xFF00FF00FF00FF00ULL) | + ((val >> 8) & 0x00FF00FF00FF00FFULL); + val = ((val << 16) & 0xFFFF0000FFFF0000ULL) | + ((val >> 16) & 0x0000FFFF0000FFFFULL); + return (val << 32) | ((val >> 32) & 0xFFFFFFFFULL); +} + +uint64_t swap_uint64(uint64_t val) { + val = ((val << 8) & 0xFF00FF00FF00FF00ULL) | + ((val >> 8) & 0x00FF00FF00FF00FFULL); + val = ((val << 16) & 0xFFFF0000FFFF0000ULL) | + ((val >> 16) & 0x0000FFFF0000FFFFULL); + return (val << 32) | (val >> 32); +} + +// Pack functions +{% for bus in can.bus %} +{%- for msg in bus.frame -%} +{{ can_pack_handler(msg, [bus.name], bus.extended) }} + +{% endfor %} +{% endfor %} + +// Unpack functions +{% for bus in can.bus %} +{%- for msg in bus.frame -%} +{{ can_unpack_handler(msg, [bus.name, msg.name]) }} + +{% endfor %} +{% endfor %} diff --git a/generator/templates/pack_unpack.h.j2 b/generator/templates/pack_unpack.h.j2 deleted file mode 100644 index 90b043d..0000000 --- a/generator/templates/pack_unpack.h.j2 +++ /dev/null @@ -1,27 +0,0 @@ -{%- macro function_declarations(bus, msg, msg_name=msg.name) -%} -{%- if msg.frame is defined -%} -{% for sub_frame in msg.frame -%} -{{ function_declarations(bus, sub_frame, msg_name + '_' + sub_frame.name) }} -{% endfor -%} -{%- else -%} -void CANlib_Pack_{{ bus.name }}_{{ msg_name }}(CANlib_{{ bus.name }}_{{ msg_name }}_T *type_in, Frame *can_out); -void CANlib_Unpack_{{ bus.name }}_{{ msg_name }}(Frame *can_in, CANlib_{{ bus.name }}_{{ msg_name }}_T *type_out); -{% endif %} -{%- endmacro -%} -#pragma once - -#include -#include - -#include "static.h" -#include "constants.h" -#include "structs.h" - -{%- for bus in can.bus %} - -// {{ bus.name }} -{%- for msg in bus.frame %} -{{ function_declarations(bus, msg) }} -{%- endfor %} -{%- endfor %} -void to_bitstring(uint8_t in[], uint64_t *out); diff --git a/src/evil_macros.h b/generator/templates/pack_unpack.hpp.j2 similarity index 68% rename from src/evil_macros.h rename to generator/templates/pack_unpack.hpp.j2 index 54a7746..dea7e0a 100644 --- a/src/evil_macros.h +++ b/generator/templates/pack_unpack.hpp.j2 @@ -1,8 +1,5 @@ -#ifndef _CAN_LIBRARY_EVIL_MACROS_H -#define _CAN_LIBRARY_EVIL_MACROS_H - -#include -#include +#pragma once +#include #define TOGGLE(input, test, idx) \ if (test) { \ @@ -38,4 +35,31 @@ #define BIT_GET(input, bit_idx) (bool)((input) & (1UL << (bit_idx))) -#endif // _CAN_LIBRARY_EVIL_MACROS_H +struct DATA_T { + uint8_t byte[8]; + uint64_t bitstring; +}; + +// utility functions +void data_transfer(DATA_T *in, DATA_T *out); + +void to_bitstring(uint8_t in[], uint64_t *out); + +void from_bitstring(uint64_t *in, uint8_t out[]); + +uint8_t swap_uint8(uint8_t val); + +int8_t swap_int8(int8_t val); + +uint16_t swap_uint16(uint16_t val); + +int16_t swap_int16(int16_t val); + +uint32_t swap_uint32(uint32_t val); + +int32_t swap_int32(int32_t val); + +int64_t swap_int64(int64_t val); + +uint64_t swap_uint64(uint64_t val); + diff --git a/generator/templates/send_receive.c.j2 b/generator/templates/send_receive.c.j2 deleted file mode 100644 index 7754b0b..0000000 --- a/generator/templates/send_receive.c.j2 +++ /dev/null @@ -1,55 +0,0 @@ -{%- macro struct_declarations(bus, msg, msg_name=msg.name) -%} -{%- if msg.frame is defined -%} -{%- for sub_frame in msg.frame -%} -{{ struct_declarations(bus, sub_frame, msg_name + '_' + sub_frame.name) }} -{%- endfor -%} -{%- else -%} -CANlib_{{ bus.name }}_{{ msg_name }}_T CANlib_{{ bus.name }}_{{ msg_name }}_Input; -{% endif -%} -{%- endmacro -%} - -{%- macro function_definitions(bus, msg, msg_name=msg.name) -%} -{%- if msg.frame is defined -%} -{% for sub_frame in msg.frame -%} -{{ function_definitions(bus, sub_frame, msg_name + '_' + sub_frame.name) }} -{%- endfor -%} -{%- else %} -void CANlib_Send_{{ bus.name }}_{{ msg_name }}(CANlib_{{ bus.name }}_{{ msg_name }}_T *inp) { -{%- if msg.period is not none %} - LIMIT(CANlib_{{ bus.name }}_{{ msg_name }}); -{%- endif %} - Frame frame; - CANlib_Pack_{{ bus.name }}_{{ msg_name }}(inp, &frame); - CANlib_TransmitFrame(&frame, {{ bus.name }}); -} - -void CANlib_Handle_{{ bus.name }}_{{ msg_name }}(Frame *frame) { - CANlib_Unpack_{{ bus.name }}_{{ msg_name }}(frame, &CANlib_{{ bus.name }}_{{ msg_name }}_Input); -} -{% endif -%} -{%- endmacro -%} - -#include "pack_unpack.h" -#include "bus.h" -#include "driver.h" - -#define LIMIT(name) \ - static Time_T last_sent = 0; \ - if (CANlib_GetTick() - last_sent < name##_period) return; \ - last_sent = CANlib_GetTick(); - -// Input Structs -{% for bus in can.bus %} -// {{ bus.name }} -{% for msg in bus.frame -%} -{{ struct_declarations(bus, msg) }} -{%- endfor %} -{%- endfor %} - -// Functions -{% for bus in can.bus %} -// {{ bus.name }} -{% for msg in bus.frame -%} -{{- function_definitions(bus, msg) -}} -{%- endfor -%} -{%- endfor -%} diff --git a/generator/templates/structs.cpp.j2 b/generator/templates/structs.cpp.j2 new file mode 100644 index 0000000..6b52d7d --- /dev/null +++ b/generator/templates/structs.cpp.j2 @@ -0,0 +1,139 @@ +{%- macro struct_declarations(bus, msg, msg_name) -%} +{%- if msg.frame is defined %} + namespace {{msg.name}} { + {% for sub_frame in msg.frame %} + {{ struct_declarations(bus, sub_frame, msg_name + '::' + sub_frame.name) }} + {% endfor %} + } + +{% else %} + {{msg.name}}_T {{msg.name}}_input; +{% endif %} +{%- endmacro -%} + +{%- macro get_messages(msg, msg_names) -%} +{%- if msg.frame is defined -%} + nullptr, + {%- for sub_frame in msg.frame -%} + {{ get_messages(sub_frame, msg_names + [sub_frame.name]) }} + {%- endfor -%} +{%- else -%} + &{{'::'.join(msg_names)}}_input, +{%- endif -%} +{%- endmacro -%} + +{%- macro get_keys(msg, msg_names) -%} +{%- if msg.frame is defined -%} + {{ "::".join(msg_names) }}::key, + {%- for sub_frame in msg.frame -%} + {{ get_keys(sub_frame, msg_names + [sub_frame.name]) }} + {%- endfor -%} +{%- else -%} + {{"::".join(msg_names)}}_T::key, +{%- endif -%} +{%- endmacro -%} + +{%- macro get_message_ranges(msg, msg_names) -%} +{%- if msg.frame is defined -%} + std::make_pair({{ msg.slice.start }}, {{ msg.slice.length }}), + {%- for sub_frame in msg.frame -%} + {{ get_message_ranges(sub_frame, msg_names + [sub_frame.name]) }} + {%- endfor -%} +{%- else -%} + std::make_pair(1, 0), +{%- endif -%} +{%- endmacro -%} + +{%- macro get_frame_ranges(msg, msg_names, cnt = 0) -%} +{%- if msg.frame is defined -%} + {{ get_msg_len(msg) }}, + {%- for sub_frame in msg.frame -%} + {{ get_frame_ranges(sub_frame, msg_names + [sub_frame.name], cnt + 1) }} + {%- endfor -%} +{%- else -%} + 0, +{%- endif -%} +{%- endmacro -%} + +#include +#include +#include +#include "static.hpp" +#include "bus.hpp" +#include "structs.hpp" + +namespace CANlib { + +void send(Clock::time_point &last_sent_, Message_T* msg) { + if (Clock::now() - last_sent_ > msg->period_) { + last_sent_ = Clock::now(); + Frame frame; + msg->pack(frame); + TransmitFrame(frame, msg->name_); + } +} + +{%- for bus in can.bus %} +namespace {{bus.name}} { +{% for msg in bus.frame -%} +{{ struct_declarations(bus, msg, msg.name) }} +{%- endfor -%} +} + +const uint32_t {{bus.name}}_keys[] = { + {% for msg in bus.frame -%} + {{ get_keys(msg, [bus.name, msg.name]) }} + {%- endfor -%} +}; + +const std::pair {{bus.name}}_frame_id_range[] = { + std::make_pair(1,0), + {% for msg in bus.frame -%} + {{ get_message_ranges(msg, [bus.name, msg.name]) }} + {%- endfor -%} +}; + +const uint32_t {{bus.name}}_frame_len[] = { + {% for msg in bus.frame -%} + {{ get_frame_ranges(msg, [bus.name, msg.name]) }} + {%- endfor -%} +}; + +Message_T* {{bus.name}}_messages[] = { + {%- for msg in bus.frame -%} + {{ get_messages(msg, ['CANlib', bus.name, msg.name]) }} + {%- endfor -%} +}; +{%- endfor -%} + +const uint32_t* keys[static_cast(Bus_Names_T::INVALID_NAME)] = { +{%- for bus in can.bus -%} +{{bus.name}}_keys, +{%- endfor -%} +}; + +const std::pair* frame_id_range[static_cast(Bus_Names_T::INVALID_NAME)] = { +{%- for bus in can.bus -%} +{{bus.name}}_frame_id_range, +{%- endfor -%} +}; + +const uint32_t* frame_len[static_cast(Bus_Names_T::INVALID_NAME)] = { +{%- for bus in can.bus -%} +{{bus.name}}_frame_len, +{%- endfor -%} +}; + +//const size_t can_size[static_cast(Bus_Names_T::INVALID_NAME)] = { +//{%- for bus in can.bus -%} +//{{ get_msg_len(bus.frame) }}, +//{%- endfor -%} +//}; + +Message_T** messages[static_cast(Bus_Names_T::INVALID_NAME)] = { +{%- for bus in can.bus -%} +{{bus.name}}_messages, +{%- endfor -%} + +}; +} diff --git a/generator/templates/structs.h.j2 b/generator/templates/structs.h.j2 deleted file mode 100644 index 6f78075..0000000 --- a/generator/templates/structs.h.j2 +++ /dev/null @@ -1,31 +0,0 @@ -{%- macro struct_declarations(bus, msg, msg_name=msg.name) -%} -{%- if msg.frame is defined -%} -{%- for sub_frame in msg.frame -%} -{{ struct_declarations(bus, sub_frame, msg_name + '_' + sub_frame.name) }} -{%- endfor -%} -{%- else %} -typedef struct { -{%- for atom in msg.atom %} -{%- if atom.type.isenum() %} - CANlib_{{ bus.name }}_{{ msg_name }}_{{ atom.name }}_T {{ atom.name }}; -{%- else %} - {{ atom.type.ctype() }} {{ atom.name }}; -{%- endif -%} -{% endfor %} -} CANlib_{{ bus.name }}_{{ msg_name }}_T; -{% endif %} -{%- endmacro -%} - -#pragma once - -#include -#include - -#include "enum_atom.h" - -{% for bus in can.bus -%} -// {{ bus.name }} -{% for msg in bus.frame -%} -{{ struct_declarations(bus, msg) }} -{%- endfor -%} -{%- endfor -%} diff --git a/generator/templates/structs.hpp.j2 b/generator/templates/structs.hpp.j2 new file mode 100644 index 0000000..9c49fa6 --- /dev/null +++ b/generator/templates/structs.hpp.j2 @@ -0,0 +1,119 @@ +{%- macro struct_declarations(bus, msg, msg_name=msg.name) -%} +{%- if msg.frame is defined %} + namespace {{msg_name}} { + const uint32_t key = 0x{{ '%0X' % msg.key }}; + {% for sub_frame in msg.frame %} + {{ struct_declarations(bus, sub_frame) }} + {% endfor %} + } // {{msg_name}} + +{% else %} + struct {{msg_name}}_T : public Message_T { + void unpack(Frame&) override; + void pack(const Frame&) override; + uint32_t get_key() override { + return key; + } + void send() override { + CANlib::send(this->last_sent_, this); + } + {% for atom in msg.atom %} + {%- if atom.type.isenum() -%} + enum class {{ atom.name }}_T { + {%- for enum in atom.type.enum -%} + {%- if enum.name == 'NUM_FIELDS' -%} + {%- raise "Enum name for {{ atom.name }} cannot be NUM_FIELDS" -%} + {%- else %} + {{ enum.name }} = {{ enum.value }}, + {%- endif -%} + {%- endfor %} + NUM_FIELDS = {{ atom.type.enum | length }} + }; + {% endif -%} + {% endfor %} + {%- for atom in msg.atom %} + {%- if atom.type.isenum() %} + {{ atom.name }}_T {{ atom.name }}; + {%- else %} + {{ atom.type.ctype() }} {{ atom.name }}; + {%- endif -%} + {% endfor %} + const Bus_Names_T name_ = Bus_Names_T::{{ bus.name }}; + Clock::time_point last_sent_; + {% if msg.period %} + const Clock::duration period_ = std::chrono::milliseconds({{ get_ms(msg.period) }}); + {% endif %} + static const uint32_t key = 0x{{ '%0X' % msg.key }}; + }; +{% endif %} +{%- endmacro -%} + +{%- macro get_keys(msg, msg_names) -%} +{%- if msg.frame is defined -%} + {{ "::".join(msg_names) }}::key, + {%- for sub_frame in msg.frame -%} + {{ get_keys(sub_frame, msg_names + [sub_frame.name]) }} + {%- endfor -%} +{%- else -%} + {{"::".join(msg_names)}}_T::key, +{%- endif -%} +{%- endmacro -%} + +{%- macro get_message_ranges(msg, msg_names) -%} +{%- if msg.frame is defined -%} + std::make_pair({{ msg.slice.start }}, {{ msg.slice.length }}), + {%- for sub_frame in msg.frame -%} + {{ get_message_ranges(sub_frame, msg_names + [sub_frame.name]) }} + {%- endfor -%} +{%- else -%} + std::make_pair(1, 0), +{%- endif -%} +{%- endmacro -%} + +{%- macro get_frame_ranges(msg, msg_names, cnt = 0) -%} +{%- if msg.frame is defined -%} + {{ get_msg_len(msg) }}, + {%- for sub_frame in msg.frame -%} + {{ get_frame_ranges(sub_frame, msg_names + [sub_frame.name], cnt + 1) }} + {%- endfor -%} +{%- else -%} + 0, +{%- endif -%} +{%- endmacro -%} + +#pragma once + +#include +#include +#include +#include "driver.hpp" +#include "static.hpp" +#include "clock.hpp" + +namespace CANlib { + +struct Message_T { + virtual void unpack(Frame&) = 0; + virtual void pack(const Frame&) = 0; + virtual uint32_t get_key() = 0; + virtual void send() = 0; + const Clock::duration period_ = std::chrono::milliseconds(0); + const Bus_Names_T name_ = Bus_Names_T::INVALID_NAME; +}; + +void send(Clock::time_point &last_sent_, Message_T* msg); + +{%- for bus in can.bus %} + + namespace {{ bus.name }} { + + {% for msg in bus.frame -%} + {{ struct_declarations(bus, msg) }} + {%- endfor %} + + } // {{ bus.name }} + +{% endfor %} + + +} // CANlib diff --git a/src/clock.hpp b/src/clock.hpp new file mode 100644 index 0000000..1da4c7e --- /dev/null +++ b/src/clock.hpp @@ -0,0 +1,22 @@ +#pragma once + +#include +#include + +namespace CANlib { + +// a generic clock interface that when implemented should statisfy TrivialClock requirements +// implementation should be provided in a source file +// https://en.cppreference.com/w/cpp/named_req/TrivialClock +struct Clock { + typedef int32_t rep; + typedef std::milli period; + typedef std::chrono::duration duration; + typedef std::chrono::time_point time_point; + + static time_point now() noexcept; + + static constexpr bool is_steady = true; +}; + +} // namespace CANlib diff --git a/src/driver.h b/src/driver.h deleted file mode 100644 index 82ba4f1..0000000 --- a/src/driver.h +++ /dev/null @@ -1,21 +0,0 @@ -#pragma once - -// INCLUDE THIS AFTER YOUR DRIVER - -#ifndef CANLIB_ARCH -#error "No architecture specified!" -#endif - -#if CANLIB_ARCH == STM32F4xx -#include "drivers/inc/stm32f4xx.h" -#elif CANLIB_ARCH == STM32F2xx -#include "drivers/inc/stm32f2xx.h" -#else -#error "Architecture not supported!" -#endif - -#include "bus.h" - -CANlib_Transmit_Error_T CANlib_TransmitFrame(Frame *frame, CANlib_Bus_T bus); -void CANlib_ReadFrame(Frame *frame, CANlib_Bus_T bus); -CAN_Raw_Bus_T CANlib_GetRawBus(CANlib_Bus_T bus); diff --git a/src/driver.hpp b/src/driver.hpp new file mode 100644 index 0000000..61517da --- /dev/null +++ b/src/driver.hpp @@ -0,0 +1,24 @@ +#pragma once + +// INCLUDE THIS AFTER YOUR DRIVER + +//#if !(CANLIB_ARCH_STM32F4XX || CANLIB_ARCH_STM32F2XX || CANLIB_ARCH_TESTFAMILY) +//#error "No architecture specified!" +//#endif + +#ifdef CANLIB_ARCH_STM32F4xx +#include "drivers/inc/stm32f4xx.hpp" +#elif defined(CANLIB_ARCH_STM32F2XX) +#include "drivers/inc/stm32f2xx.hpp" +#elif defined(CANLIB_ARCH_TESTFAMILY) +#include "drivers/inc/testfamily.hpp" +#else +#error "No architecture specified!" +#endif + +#include "bus.hpp" + +namespace CANlib { + Transmit_Error_T TransmitFrame(const Frame &frame, Bus_Names_T bus); + void ReadFrame(Frame &frame, Bus_Names_T bus); +} diff --git a/src/drivers/src/stm32f2xx.c b/src/drivers/src/stm32f2xx.cpp similarity index 91% rename from src/drivers/src/stm32f2xx.c rename to src/drivers/src/stm32f2xx.cpp index 79548b7..5831517 100644 --- a/src/drivers/src/stm32f2xx.c +++ b/src/drivers/src/stm32f2xx.cpp @@ -1,7 +1,8 @@ -#include "static.h" +#ifdef CANLIB_ARCH_STM32F2XX +#include "static.hpp" -#include "stm32f2xx_hal_can.h" #include +#include "stm32f2xx_hal_can.h" CAN_HandleTypeDef CanHandle; @@ -11,7 +12,7 @@ HAL_StatusTypeDef CANlib_Init(uint32_t baudrate) { // Can change prescaler to change this // 2 Mbaud / prescaler = baudrate (prescaler goes from 1 to 1024) - CAN_FilterConfTypeDef sFilterConfig; + CAN_FilterConfTypeDef sFilterConfig; static CanTxMsgTypeDef TxMessage; static CanRxMsgTypeDef RxMessage; @@ -31,7 +32,6 @@ HAL_StatusTypeDef CANlib_Init(uint32_t baudrate) { CanHandle.Init.BS2 = CAN_BS2_8TQ; CanHandle.Init.Prescaler = 4; - HAL_StatusTypeDef status; if ((status = HAL_CAN_Init(&CanHandle)) != HAL_OK) { @@ -41,7 +41,6 @@ HAL_StatusTypeDef CANlib_Init(uint32_t baudrate) { return status; } - // TODO: Might want to comment this out sFilterConfig.FilterNumber = 0; sFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK; @@ -85,9 +84,9 @@ HAL_StatusTypeDef CANlib_TransmitFrame(Frame *frame) { if (CAN_TX_STATUS != HAL_OK) { // TODO handle error - printf("[CAN TX] ERROR: HAL_StatusTypeDef is %d\r\n", (int) CAN_TX_STATUS); + printf("[CAN TX] ERROR: HAL_StatusTypeDef is %d\r\n", (int)CAN_TX_STATUS); printf("[CAN TX] ERROR: HAL_CAN_StateTypeDef is %d\r\n", CanHandle.State); - printf("[CAN TX] ERROR: ErrorCode is %d\r\n", CanHandle.ErrorCode); + printf("[CAN TX] ERROR: ErrorCode is %d\r\n", CanHandle.ErrorCode); return CAN_TX_STATUS; } @@ -97,3 +96,4 @@ HAL_StatusTypeDef CANlib_TransmitFrame(Frame *frame) { return HAL_OK; } +#endif diff --git a/src/drivers/src/stm32f4xx.c b/src/drivers/src/stm32f4xx.cpp similarity index 65% rename from src/drivers/src/stm32f4xx.c rename to src/drivers/src/stm32f4xx.cpp index ae01576..ff0a189 100644 --- a/src/drivers/src/stm32f4xx.c +++ b/src/drivers/src/stm32f4xx.cpp @@ -1,10 +1,11 @@ +#ifdef CANLIB_ARCH_STM32F4XX #include "static.h" #include #include #include "bus.h" #include "driver.h" -#include "drivers/inc/stm32f4xx.h" +#include "drivers/inc/stm32f4xx.hpp" #include "stm32f4xx_hal.h" #ifdef USING_LOGGING_CALLBACK #include "log.h" @@ -14,8 +15,10 @@ extern CAN_HandleTypeDef hcan1; extern CAN_HandleTypeDef hcan2; extern CAN_HandleTypeDef hcan3; -HAL_StatusTypeDef CANlib_TransmitFrame(Frame *frame, CANlib_Bus_T bus) { - CAN_Raw_Bus_T raw_bus = CANlib_GetRawBus(bus); +using namespace CANlib; + +Transmit_Error_T CANlib::TransmitFrame(const Frame &frame, Bus_Names_T bus_name) { + Raw_Bus_T raw_bus = GetRawBus(bus); int bus_num; CAN_HandleTypeDef *hcan; switch (raw_bus) { @@ -38,9 +41,9 @@ HAL_StatusTypeDef CANlib_TransmitFrame(Frame *frame, CANlib_Bus_T bus) { CAN_TxHeaderTypeDef pHeader; uint32_t pTxMailbox = 0; - pHeader.DLC = frame->dlc; - pHeader.StdId = frame->id; - pHeader.IDE = frame->extended ? CAN_ID_EXT : CAN_ID_STD; + pHeader.DLC = frame.dlc; + pHeader.StdId = frame.id; + pHeader.IDE = frame.extended ? CAN_ID_EXT : CAN_ID_STD; pHeader.RTR = CAN_RTR_DATA; // Data frame (as opposed to a remote frame) pHeader.TransmitGlobalTime = DISABLE; // Don't replace last 2 bytes of data with TX time. #ifdef USING_LOGGING_CALLBACK @@ -48,11 +51,11 @@ HAL_StatusTypeDef CANlib_TransmitFrame(Frame *frame, CANlib_Bus_T bus) { #else UNUSED(bus_num); #endif - return HAL_CAN_AddTxMessage(hcan, &pHeader, frame->data, &pTxMailbox); + 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); +void ReadFrame(Frame &frame, Bus_Names_T bus) { + Raw_Bus_T raw_bus = GetRawBus(bus); CAN_HandleTypeDef *hcan; switch (raw_bus) { case CAN_1: @@ -73,16 +76,13 @@ void CANlib_ReadFrame(Frame *frame, CANlib_Bus_T bus) { 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; + 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; + memcpy(frame.data, data, sizeof(data)); + frame.extended = pHeader.IDE == CAN_ID_EXT; return; } } } - -Time_T CANlib_GetTick(void) { - return HAL_GetTick(); -} +#endif diff --git a/src/drivers/src/test.c b/src/drivers/src/test.c deleted file mode 100644 index b857e45..0000000 --- a/src/drivers/src/test.c +++ /dev/null @@ -1,12 +0,0 @@ -#include "../inc/test.h" -#include - -CANlib_Transmit_Error_T CANlib_TransmitFrame(Frame *frame){ - printf("id: %d dlc: %d\n", frame->id, frame->dlc); - return true; -} - -CANlib_Init_Error_T CANlib_Init(uint32_t baudrate) { - printf("Initialized %d!\n", baudrate); - return true; -} diff --git a/src/drivers/src/testfamily.cpp b/src/drivers/src/testfamily.cpp new file mode 100644 index 0000000..3abd49b --- /dev/null +++ b/src/drivers/src/testfamily.cpp @@ -0,0 +1,57 @@ +#ifdef CANLIB_ARCH_TESTFAMILY +#include "static.h" + +#include +#include +#include "bus.hpp" +#include "driver.hpp" +#include "drivers/inc/testfamily.hpp" + +using namespace CANlib; + +CAN can1; +CAN can2; +CAN can3; + +Clock::time_point Clock::now() noexcept { + static const auto start_time = std::chrono::system_clock::now(); + const auto time_passed = std::choron::system_clock::now() - start_time; + return time_point(std::chrono::milliseconds(time_passed)); +} + +Transmit_Error_T CANlib::TransmitFrame(const Frame &frame, Bus_Names_T bus_name) { + Raw_Bus_T raw_bus = GetRawBus(bus); + switch (raw_bus) { + case CAN_1: + can1.receiveFrame(frame); + break; + case CAN_2: + can2.receiveFrame(frame); + break; + case CAN_3: + can3.receiveFrame(frame); + break; + default: + return true; + } + + return false; +} + +void CANLib::ReadFrame(Frame &frame, Bus_Names_T bus) { + Raw_Bus_T raw_bus = GetRawBus(bus); + switch (raw_bus) { + case CAN_1: + frame = can1.frameToSend(); + break; + case CAN_2: + frame = can2.frameToSend(); + break; + case CAN_3: + frame = can3.frameToSend(); + break; + default: + return; + } +} +#endif diff --git a/src/static.h b/src/static.hpp similarity index 82% rename from src/static.h rename to src/static.hpp index e4934ef..e4a2b46 100644 --- a/src/static.h +++ b/src/static.hpp @@ -3,9 +3,9 @@ #include #include -typedef struct { +struct Frame { uint32_t id; uint8_t data[8]; uint8_t dlc; bool extended; -} Frame; +}; diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt new file mode 100644 index 0000000..74f07b1 --- /dev/null +++ b/test/CMakeLists.txt @@ -0,0 +1,36 @@ +cmake_minimum_required(VERSION 3.1.3) + +set(CMAKE_CXX_STANDARD 17) + +project(canlib C CXX) + + +set(GCC_COVERAGE_COMPILE_FLAGS "-fprofile-arcs -ftest-coverage --coverage") +set(GCC_COVERAGE_LINK_FLAGS "-lgcov --coverage") +set(GCC_DEBUG_FLAGS "-g -ggdb -Og") +set(GCC_WARNING_FLAGS "-Wall -Wextra -fdiagnostics-color=always -Werror") + +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${GCC_COVERAGE_COMPILE_FLAGS} ${GCC_WARNING_FLAGS}") +set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${GCC_COVERAGE_LINK_FLAGS}") + +include_directories(../src) +include_directories(./tests/inc) +include_directories(../src/drivers/inc) +include_directories(../src/computers/inc) + +file(GLOB CANLIB_SOURCES "../src/*.cpp" "../src/*.c" "../src/drivers/src/*.cpp" "../src/drivers/src/*.c" "../src/computers/src/canlib_testcomp0.cpp") +add_library(canlib_src SHARED ${CANLIB_SOURCES}) +target_compile_features(canlib_src INTERFACE cxx_strong_enums) +target_compile_definitions(canlib_src PUBLIC CANLIB_ARCH_TESTFAMILY) + +file(GLOB_RECURSE TEST_SOURCES "./tests/src/*.cpp") +add_library(canlib_tests SHARED ${TEST_SOURCES}) +target_link_libraries(canlib_tests PUBLIC canlib_src) + +add_executable(${PROJECT_NAME} "./tests/main.cpp") + +target_link_libraries(${PROJECT_NAME} PUBLIC canlib_src) +target_link_libraries(${PROJECT_NAME} PUBLIC canlib_tests) + +enable_testing() +add_test(Tests ${PROJECT_NAME}) diff --git a/test/Makefile b/test/Makefile new file mode 100644 index 0000000..d273553 --- /dev/null +++ b/test/Makefile @@ -0,0 +1,90 @@ +TARGET_EXEC := canlib-tests + +BUILD_DIR := ./build +SRCS_DIR := ../src/src tests/src + +SRCS := $(shell find $(SRC_DIRS) -name *.cpp -or -name *.c) + +COMP_SRC := ../src/src/computers/*.cpp + +# String substitution for every C/C++ file. +# As an example, hello.cpp turns into ./build/hello.cpp.o + +# String substitution (suffix version without %). +# As an example, ./build/hello.cpp.o turns into ./build/hello.cpp.d +#DEPS := $(OBJS:.o=.d) + +# Every folder in ./src will need to be passed to GCC so that it can find header files +INC_DIRS := $(shell find ../src/inc tests/inc -type d) +# Add a prefix to INC_DIRS. So moduleA would become -ImoduleA. GCC understands this -I flag +INC_FLAGS := -I../src/inc -Itests/inc +COMPUTER_FLAGS := -I../src/inc/drivers -I../src/inc/computers + +# The -MMD and -MP flags together generate Makefiles for us! +# These files will have .d instead of .o as the output. +CPPFLAGS := $(INC_FLAGS) -std=c++17 + +# The final build step. +main0: + g++ $(CPPFLAGS) $(COMPUTER_FLAGS) $(CXXFLAGS) ../src/src/bus.cpp ../src/src/structs.cpp ../src/src/drivers/testfamily.cpp ../src/src/pack_unpack.cpp ../src/src/computers/canlib_testcomp0.cpp tests/src/identify.cpp tests/src/message.cpp tests/src/send.cpp tests/src/constants.cpp tests/src/arch0.cpp tests/main.cpp -o main0 +main1: + g++ $(CPPFLAGS) $(COMPUTER_FLAGS) $(CXXFLAGS) ../src/src/bus.cpp ../src/src/structs.cpp ../src/src/drivers/testfamily.cpp ../src/src/pack_unpack.cpp ../src/src/computers/canlib_testcomp1.cpp tests/src/send.cpp tests/src/constants.cpp tests/src/arch1.cpp tests/main.cpp -o main1 +main2: + g++ $(CPPFLAGS) $(COMPUTER_FLAGS) $(CXXFLAGS) ../src/src/bus.cpp ../src/src/structs.cpp ../src/src/drivers/testfamily.cpp ../src/src/pack_unpack.cpp ../src/src/computers/canlib_testcomp2.cpp tests/src/send.cpp tests/src/constants.cpp tests/src/arch2.cpp tests/main.cpp -o main2 + +$(BUILD_DIR): + mkdir -p build/src/src + mkdir -p build/src/drivers + mkdir -p build/src/src/computers + mkdir -p build/tests/src + +# Build step for C++ source +$(BUILD_DIR)/src/src/bus.cpp.o: $(BUILD_DIR) + g++ ../src/src/bus.cpp $(CPPFLAGS) $(CXXFLAGS) -c $< -o $(BUILD_DIR)/src/src/bus.cpp.o + +$(BUILD_DIR)/src/src/structs.cpp.o: $(BUILD_DIR) + g++ ../src/src/structs.cpp $(CPPFLAGS) $(CXXFLAGS) -c $< -o $(BUILD_DIR)/src/src/structs.cpp.o + +$(BUILD_DIR)/src/src/pack_unpack.cpp.o: $(BUILD_DIR) + g++ ../src/src/pack_unpack.cpp $(CPPFLAGS) $(CXXFLAGS) -c $< -o $(BUILD_DIR)/src/src/pack_unpack.cpp.o + +$(BUILD_DIR)/tests/src/send.cpp.o: $(BUILD_DIR) + g++ tests/src/send.cpp $(CPPFLAGS) $(COMPUTER_FLAGS) $(CXXFLAGS) -c $< -o $(BUILD_DIR)/tests/src/send.cpp.o + +$(BUILD_DIR)/tests/src/constants.cpp.o: $(BUILD_DIR) + g++ tests/src/constants.cpp $(CPPFLAGS) $(COMPUTER_FLAGS) $(CXXFLAGS) -c $< -o $(BUILD_DIR)/tests/src/constants.cpp.o + +$(BUILD_DIR)/tests/src/identify.cpp.o: $(BUILD_DIR) + g++ tests/src/identify.cpp $(CPPFLAGS) $(COMPUTER_FLAGS) $(CXXFLAGS) -c $< -o $(BUILD_DIR)/tests/src/identify.cpp.o + +$(BUILD_DIR)/tests/src/arch0.cpp.o: $(BUILD_DIR) + g++ tests/src/arch0.cpp $(CPPFLAGS) $(COMPUTER_FLAGS) $(CXXFLAGS) -c $< -o $(BUILD_DIR)/tests/src/arch0.cpp.o + +$(BUILD_DIR)/tests/src/arch1.cpp.o: $(BUILD_DIR) + g++ tests/src/arch1.cpp $(CPPFLAGS) $(COMPUTER_FLAGS) $(CXXFLAGS) -c $< -o $(BUILD_DIR)/tests/src/arch1.cpp.o + +$(BUILD_DIR)/tests/src/arch2.cpp.o: $(BUILD_DIR) + g++ tests/src/arch2.cpp $(CPPFLAGS) $(COMPUTER_FLAGS) $(CXXFLAGS) -c $< -o $(BUILD_DIR)/tests/src/arch2.cpp.o + +$(BUILD_DIR)/tests/src/message.cpp.o: $(BUILD_DIR) + g++ tests/src/message.cpp $(CPPFLAGS) $(COMPUTER_FLAGS) $(CXXFLAGS) -c $< -o $(BUILD_DIR)/tests/src/message.cpp.o + +$(BUILD_DIR)/src/src/drivers/testfamily.cpp.o: $(BUILD_DIR) + g++ ../src/src/drivers/testfamily.cpp $(CPPFLAGS) $(COMPUTER_FLAGS) $(CXXFLAGS) -c $< -o $(BUILD_DIR)/src/src/drivers/testfamily.cpp.o + +$(BUILD_DIR)/tests/main.cpp.o: $(BUILD_DIR) + g++ tests/main.cpp $(CPPFLAGS) $(COMPUTER_FLAGS) $(CXXFLAGS) -c $< -o $(BUILD_DIR)/./tests/main.cpp.o + +$(BUILD_DIR)/src/src/computers/canlib_testcomp0.cpp.o: $(BUILD_DIR) + g++ ../src/src/computers/canlib_testcomp0.cpp $(CPPFLAGS) $(COMPUTER_FLAGS) $(CXXFLAGS) -c $< -o $(BUILD_DIR)/src/src/computers/canlib_testcomp0.cpp.o + +$(BUILD_DIR)/src/src/computers/canlib_testcomp1.cpp.o: $(BUILD_DIR) + g++ ../src/src/computers/canlib_testcomp1.cpp $(CPPFLAGS) $(COMPUTER_FLAGS) $(CXXFLAGS) -c $< -o $(BUILD_DIR)/src/src/computers/canlib_testcomp1.cpp.o + +$(BUILD_DIR)/src/src/computers/canlib_testcomp2.cpp.o: $(BUILD_DIR) + g++ ../src/src/computers/canlib_testcomp2.cpp $(CPPFLAGS) $(COMPUTER_FLAGS) $(CXXFLAGS) -c $< -o $(BUILD_DIR)/src/src/computers/canlib_testcomp2.cpp.o + +.PHONY: clean +clean: + rm -r $(BUILD_DIR) + diff --git a/test/can_spec.yml b/test/can_spec.yml new file mode 100644 index 0000000..7663441 --- /dev/null +++ b/test/can_spec.yml @@ -0,0 +1,504 @@ +name: MY20 +units: + - newtonmeter = N * m = J = Nm + - tick = 3 ms + - RPM = 360 deg / min + - pct = 0.01 + - halfpct = 0.5 pct + - tenthpct = 0.1 pct +architecture: + testarch: + family: testfamily + participation: + can: + buses: + - CAN_1 + - CAN_2 + - CAN_3 +computer: + testcomp0: + architecture: testarch + participation: + can: + mapping: + map1: CAN_2 + map2: CAN_1 + publish: + map1: + - B + - E + subscribe: + map2: + - F + - M + - N + map1: + - A + - C + - D + testcomp1: + architecture: testarch + participation: + can: + mapping: + map1: CAN_2 + map2: CAN_3 + publish: + map2: + - F + - H + - J + map1: + - A + - D + subscribe: + map1: + - B + map2: + - I + - K + - L + - M + testcomp2: + architecture: testarch + participation: + can: + mapping: + map1: CAN_3 + map2: CAN_1 + publish: + map1: + - A + - B + - C + map2: + - G + - I + - L + subscribe: + map1: + - D + - E + map2: + - F + - H + - J + - K + - M + - N +protocol: + can: + bus: + map1: + version: 2.0B + baudrate: 500000 + extended: false + frame: + A: + key: 0x2FF + period: 50ms + atom: + ARG0: + slice: 7 + 1 + type: bool little + ARG1: + slice: 8 + 16 + type: uint16 little + ARG2: + slice: 24 + 16 + type: uint16 little + ARG3: + slice: 40 + 16 + type: uint16 little + B: + key: 0x305 + period: 200ms + atom: + ARG0: + slice: 5 + 3 + type: + endianness: big + enum: + IDLE: 1 + CHARGE: 2 + RECOVERABLE_ERROR: 3 + NONRECOVERABLE_ERROR: 4 + ARG1: + slice: 8 + 16 + type: uint16 little + ARG2: + slice: 24 + 16 + type: uint16 little + ARG3: + slice: 40 + 16 + type: uint16 little + ARG4: + slice: 56 + 8 + type: uint8 little + C: + key: 0x306 + period: 200ms + atom: + ARG0: + slice: 0 + 8 + type: int8 little + ARG1: + slice: 8 + 8 + type: int8 little + ARG2: + slice: 16 + 16 + type: uint16 little + ARG3: + slice: 32 + 16 + type: uint16 little + ARG4: + slice: 48 + 8 + type: uint8 little + D: + key: 0x307 + period: 200ms + atom: + ARG0: + slice: 0 + 1 + type: &bit_type + endianness: big + enum: + LO: 0 + HI: 1 + ARG1: + slice: 2 + 1 + type: *bit_type + ARG2: + slice: 3 + 1 + type: *bit_type + ARG3: + slice: 4 + 1 + type: *bit_type + ARG4: + slice: 5 + 1 + type: *bit_type + ARG5: + slice: 6 + 1 + type: *bit_type + ARG6: + slice: 7 + 1 + type: *bit_type + ARG7: + slice: 9 + 1 + type: *bit_type + ARG8: + slice: 16 + 1 + type: *bit_type + ARG9: + slice: 17 + 1 + type: *bit_type + E: + key: 0x308 + period: 1000ms + atom: + ARG0: + slice: 0 + 48 + type: uint64 little + ARG1: + slice: 48 + 16 + type: uint16 little + map2: + version: 2.0B + baudrate: 1000000 + extended: false + frame: + F: + key: 0x016 + period: 101ms + atom: + ARG0: + slice: 0 + 10 + type: int16 big + ARG1: + slice: 10 + 8 + type: uint8 big + ARG2: + slice: 18 + 10 + type: int16 big + ARG3: + slice: 28 + 8 + type: uint8 big + ARG4: + slice: 36 + 10 + type: int16 big + ARG5: + slice: 46 + 8 + type: uint8 big + ARG6: + slice: 54 + 10 + type: int16 big + G: + key: 0x017 + period: 31ms + atom: + ARG0: + slice: 0 + 14 + type: uint16 big + ARG1: + slice: 14 + 14 + type: uint16 big + ARG2: + slice: 28 + 32 + type: uint32 big + H: + key: 0x0A0 + atom: + <<: &rms_temps + a_temp: + slice: 0 + 16 + unit: decidegC + type: int16 little + b_temp: + slice: 16 + 16 + unit: decidegC + type: int16 little + c_temp: + slice: 32 + 16 + unit: decidegC + type: int16 little + d_temp: + slice: 48 + 16 + unit: decidegC + type: int16 little + I: + key: 0xA2 + atom: + ARG0: + slice: 0 + 16 + type: int16 little + ARG1: + slice: 16 + 16 + type: int16 little + ARG2: + slice: 32 + 16 + type: int16 little + ARG3: + slice: 48 + 16 + type: int16 little + J: + key: 0x0C2 + slice: 0 + 8 + frame: + AA: + key: 0 + <<: &rms_bool_data + atom: + write_success: + slice: 23 + 1 + type: bool little + data: + slice: 39 + 1 + type: bool little + BB: + key: 0x14 + <<: *rms_bool_data + #Required to correctly parse the data with the script, as this parameter is constantly + #being transmitted over the CAN bus. + CC: + key: 0x64 + slice: 8 + 8 + frame: + AAA: + key: 0x69 + atom: + <<: &rms_c_write_success + write_success: # whether EEPROM has been re-written + slice: 23 + 1 + type: bool little + data: + <<: &rms_c_signed_int_data + slice: 32 + 16 + type: int16 little + BBB: + key: 0x70 + atom: + <<: *rms_c_write_success + data: + <<: *rms_c_signed_int_data + CCC: + key: 0x71 + atom: + <<: *rms_c_write_success + data: + <<: *rms_c_signed_int_data + DDD: + key: 0x72 + atom: + <<: *rms_c_write_success + data: + <<: *rms_c_signed_int_data + DD: + key: 0x65 + atom: + <<: &rms_write_success + write_success: # whether EEPROM has been re-written + slice: 23 + 1 + type: bool little + data: + <<: &rms_signed_int_data + slice: 32 + 16 + type: int16 little + EE: + key: 0x66 + atom: + <<: *rms_write_success + data: + <<: *rms_signed_int_data + FF: + key: 0x67 + atom: + <<: *rms_write_success + data: + <<: *rms_signed_int_data + GG: + key: 0x68 + atom: + <<: *rms_write_success + data: + <<: *rms_signed_int_data + HH: + key: 0x6a + atom: + <<: *rms_write_success + data: + <<: *rms_signed_int_data + II: + key: 0x6b + atom: + <<: *rms_write_success + data: + <<: &rms_unsigned_int_data + slice: 32 + 16 + type: uint16 little + JJ: + key: 0x6c + atom: + <<: *rms_write_success + data: + <<: *rms_unsigned_int_data + KK: + key: 0x6d + atom: + <<: *rms_write_success + data: + <<: *rms_unsigned_int_data + LL: + key: 0x6f + atom: + <<: *rms_write_success + data: + <<: *rms_signed_int_data + MM: + key: 0xab + <<: *rms_bool_data + NN: + key: 0x91 + <<: *rms_bool_data + K: + key: 0x0BB + atom: + ARG0: + slice: 0 + 16 + type: uint16 big + ARG1: + slice: 16 + 16 + type: uint16 big + L: + key: 0x0DF + period: 103ms + atom: + ARG0: + slice: 0 + 1 + type: bool big + ARG1: + slice: 1 + 1 + type: bool big + ARG2: + slice: 2 + 1 + type: bool big + ARG3: + slice: 3 + 1 + type: bool big + ARG4: + slice: 4 + 1 + type: bool big + ARG5: + slice: 5 + 1 + type: bool big + ARG6: + slice: 6 + 1 + type: bool big + ARG7: + slice: 7 + 1 + type: bool big + ARG8: + slice: 8 + 1 + type: bool big + ARG9: + slice: 9 + 1 + type: bool big + ARG10: + slice: 10 + 1 + type: bool big + ARG11: + slice: 11 + 1 + type: bool big + ARG12: + slice: 12 + 1 + type: bool big + ARG13: + slice: 13 + 1 + type: bool big + ARG14: + slice: 14 + 1 + type: bool big + ARG15: + slice: 15 + 1 + type: bool big + ARG16: + slice: 16 + 1 + type: bool big + ARG17: + slice: 17 + 8 + type: uint8 big + M: + key: 0x0F0 + period: 103ms + atom: + ARG0: + slice: 0 + 10 + type: int16 big + ARG1: + slice: 10 + 16 + type: uint16 big + N: + key: 0x400 + atom: + ARG0: + slice: 3 + 1 + type: bool big + ARG1: + slice: 4 + 3 + type: + endianness: big + enum: + x1: 0 + x2: 1 + x4: 2 + x8: 3 + x16: 4 + x32: 5 + ARG2: + slice: 8 + 1 + type: bool big + ARG3: + slice: 9 + 1 + type: bool big + ARG4: + slice: 10 + 1 + type: bool big diff --git a/test/tests/inc/test.hpp b/test/tests/inc/test.hpp new file mode 100644 index 0000000..68011e6 --- /dev/null +++ b/test/tests/inc/test.hpp @@ -0,0 +1,19 @@ +#pragma once +#include +#include "bus.hpp" +#include "structs.hpp" +#include "testfamily.hpp" +#include "driver.hpp" + +#define get_bitmask(l, r) (!l ? ((1ULL << (r - 1)) - 1) : ((1ULL << (r - 1)) - (1ULL << (l - 1)))) + +extern std::default_random_engine generator; +extern std::uniform_int_distribution distribution; + +void testArch(); +void testPackUnpack(); +void testKeys(); +void testPeriod(); +void testMessageType(); +void testIdentify(); +void testSend(); diff --git a/test/tests/main.cpp b/test/tests/main.cpp new file mode 100644 index 0000000..8708f31 --- /dev/null +++ b/test/tests/main.cpp @@ -0,0 +1,15 @@ +#include "test.hpp" + +std::default_random_engine generator; +std::uniform_int_distribution distribution(0,511); + +int main() { + testIdentify(); + testSend(); + testArch(); + testKeys(); + testPeriod(); + testMessageType(); + testPackUnpack(); + return 0; +} diff --git a/test/tests/src/arch0.cpp b/test/tests/src/arch0.cpp new file mode 100644 index 0000000..ffc1be9 --- /dev/null +++ b/test/tests/src/arch0.cpp @@ -0,0 +1,47 @@ +#include +#include "canlib_testcomp0.hpp" +#include "test.hpp" + +using namespace CANlib; + +extern CAN can1; +extern CAN can2; +extern CAN can3; + +void testArch() { + assert(GetRawBus(Bus_Names_T::map1) == Raw_Bus_T::CAN_2); + assert(GetRawBus(Bus_Names_T::map2) == Raw_Bus_T::CAN_1); + assert(GetRawBus(Bus_Names_T::INVALID_NAME) == Raw_Bus_T::INVALID_BUS); + assert(GetBusName(Raw_Bus_T::CAN_2) == Bus_Names_T::map1); + assert(GetBusName(Raw_Bus_T::CAN_1) == Bus_Names_T::map2); + assert(GetBusName(Raw_Bus_T::CAN_3) == Bus_Names_T::INVALID_NAME); + assert(GetBusName(Raw_Bus_T::INVALID_BUS) == Bus_Names_T::INVALID_NAME); + can1.clear(); + can2.clear(); + can3.clear(); + update_can(); + assert(1 == can1.framesReceived()); + assert(1 == can2.framesReceived()); + assert(0 == can3.framesReceived()); + can1.clear(); + can2.clear(); + can3.clear(); + Frame f; + f.id = 69; + can2.setFrameToSend(f); + map1_update_can(); + assert(69 == can2.topFrame().id); + assert(0 == can1.framesReceived()); + assert(1 == can2.framesReceived()); + assert(0 == can3.framesReceived()); + can1.clear(); + can2.clear(); + can3.clear(); + f.id = 69; + can1.setFrameToSend(f); + map2_update_can(); + assert(69 == can1.topFrame().id); + assert(1 == can1.framesReceived()); + assert(0 == can2.framesReceived()); + assert(0 == can3.framesReceived()); +} diff --git a/test/tests/src/arch1.cpp b/test/tests/src/arch1.cpp new file mode 100644 index 0000000..38a92a3 --- /dev/null +++ b/test/tests/src/arch1.cpp @@ -0,0 +1,47 @@ +#include +#include "canlib_testcomp1.hpp" +#include "test.hpp" + +using namespace CANlib; + +extern CAN can1; +extern CAN can2; +extern CAN can3; + +void testArch() { + assert(GetRawBus(Bus_Names_T::map1) == Raw_Bus_T::CAN_2); + assert(GetRawBus(Bus_Names_T::map2) == Raw_Bus_T::CAN_3); + assert(GetRawBus(Bus_Names_T::INVALID_NAME) == Raw_Bus_T::INVALID_BUS); + assert(GetBusName(Raw_Bus_T::CAN_2) == Bus_Names_T::map1); + assert(GetBusName(Raw_Bus_T::CAN_3) == Bus_Names_T::map2); + assert(GetBusName(Raw_Bus_T::CAN_1) == Bus_Names_T::INVALID_NAME); + assert(GetBusName(Raw_Bus_T::INVALID_BUS) == Bus_Names_T::INVALID_NAME); + can1.clear(); + can2.clear(); + can3.clear(); + update_can(); + assert(0 == can1.framesReceived()); + assert(1 == can2.framesReceived()); + assert(1 == can3.framesReceived()); + can1.clear(); + can2.clear(); + can3.clear(); + Frame f; + f.id = 69; + can2.setFrameToSend(f); + map1_update_can(); + assert(69 == can2.topFrame().id); + assert(0 == can1.framesReceived()); + assert(1 == can2.framesReceived()); + assert(0 == can3.framesReceived()); + can1.clear(); + can2.clear(); + can3.clear(); + f.id = 69; + can3.setFrameToSend(f); + map2_update_can(); + assert(69 == can3.topFrame().id); + assert(0 == can1.framesReceived()); + assert(0 == can2.framesReceived()); + assert(1 == can3.framesReceived()); +} diff --git a/test/tests/src/arch2.cpp b/test/tests/src/arch2.cpp new file mode 100644 index 0000000..b92ab7f --- /dev/null +++ b/test/tests/src/arch2.cpp @@ -0,0 +1,47 @@ +#include +#include "canlib_testcomp2.hpp" +#include "test.hpp" + +using namespace CANlib; + +extern CAN can1; +extern CAN can2; +extern CAN can3; + +void testArch() { + assert(GetRawBus(Bus_Names_T::map1) == Raw_Bus_T::CAN_3); + assert(GetRawBus(Bus_Names_T::map2) == Raw_Bus_T::CAN_1); + assert(GetRawBus(Bus_Names_T::INVALID_NAME) == Raw_Bus_T::INVALID_BUS); + assert(GetBusName(Raw_Bus_T::CAN_2) == Bus_Names_T::map1); + assert(GetBusName(Raw_Bus_T::CAN_1) == Bus_Names_T::map2); + assert(GetBusName(Raw_Bus_T::CAN_3) == Bus_Names_T::INVALID_NAME); + assert(GetBusName(Raw_Bus_T::INVALID_BUS) == Bus_Names_T::INVALID_NAME); + can1.clear(); + can2.clear(); + can3.clear(); + update_can(); + assert(1 == can1.framesReceived()); + assert(0 == can2.framesReceived()); + assert(1 == can3.framesReceived()); + can1.clear(); + can2.clear(); + can3.clear(); + Frame f; + f.id = 69; + can3.setFrameToSend(f); + testcomp2::map1::update_can(); + assert(69 == can3.topFrame().id); + assert(0 == can1.framesReceived()); + assert(0 == can2.framesReceived()); + assert(1 == can3.framesReceived()); + can1.clear(); + can2.clear(); + can3.clear(); + f.id = 69; + can1.setFrameToSend(f); + testcomp2::map2::update_can(); + assert(69 == can1.topFrame().id); + assert(1 == can1.framesReceived()); + assert(0 == can2.framesReceived()); + assert(0 == can3.framesReceived()); +} diff --git a/test/tests/src/constants.cpp b/test/tests/src/constants.cpp new file mode 100644 index 0000000..ce5d1bf --- /dev/null +++ b/test/tests/src/constants.cpp @@ -0,0 +1,304 @@ +#include "test.hpp" +#include +#include + +using namespace CANlib; +using namespace map1; +using namespace map2; +using namespace J; +using namespace CC; +using namespace std::chrono_literals; + + +void testKeys() { + A_T A_input; + B_T B_input; + C_T C_input; + D_T D_input; + E_T E_input; + F_T F_input; + G_T G_input; + H_T H_input; + I_T I_input; + AA_T AA_input; + BB_T BB_input; + AAA_T AAA_input; + BBB_T BBB_input; + CCC_T CCC_input; + DDD_T DDD_input; + DD_T DD_input; + EE_T EE_input; + FF_T FF_input; + GG_T GG_input; + HH_T HH_input; + II_T II_input; + JJ_T JJ_input; + KK_T KK_input; + LL_T LL_input; + MM_T MM_input; + NN_T NN_input; + K_T K_input; + L_T L_input; + M_T M_input; + N_T N_input; + assert(A_input.get_key() == 0x2FF); + assert(map1::A_T::key == 0x2FF); + assert(B_input.get_key() == 0x305); + assert(map1::B_T::key == 0x305); + assert(C_input.get_key() == 0x306); + assert(map1::C_T::key == 0x306); + assert(D_input.get_key() == 0x307); + assert(map1::D_T::key == 0x307); + assert(E_input.get_key() == 0x308); + assert(map1::E_T::key == 0x308); + assert(F_input.get_key() == 0x16); + assert(map2::F_T::key == 0x16); + assert(G_input.get_key() == 0x17); + assert(map2::G_T::key == 0x17); + assert(H_input.get_key() == 0xA0); + assert(map2::H_T::key == 0xA0); + assert(I_input.get_key() == 0xA2); + assert(map2::I_T::key == 0xA2); + assert(map2::J::key == 0xC2); + assert(AA_input.get_key() == 0x0); + assert(map2::J::AA_T::key == 0x0); + assert(BB_input.get_key() == 0x14); + assert(map2::J::BB_T::key == 0x14); + assert(map2::J::CC::key == 0x64); + assert(AAA_input.get_key() == 0x69); + assert(map2::J::CC::AAA_T::key == 0x69); + assert(BBB_input.get_key() == 0x70); + assert(map2::J::CC::BBB_T::key == 0x70); + assert(CCC_input.get_key() == 0x71); + assert(map2::J::CC::CCC_T::key == 0x71); + assert(DDD_input.get_key() == 0x72); + assert(map2::J::CC::DDD_T::key == 0x72); + assert(DD_input.get_key() == 0x65); + assert(map2::J::DD_T::key == 0x65); + assert(EE_input.get_key() == 0x66); + assert(map2::J::EE_T::key == 0x66); + assert(FF_input.get_key() == 0x67); + assert(map2::J::FF_T::key == 0x67); + assert(GG_input.get_key() == 0x68); + assert(map2::J::GG_T::key == 0x68); + assert(HH_input.get_key() == 0x6A); + assert(map2::J::HH_T::key == 0x6A); + assert(II_input.get_key() == 0x6B); + assert(map2::J::II_T::key == 0x6B); + assert(JJ_input.get_key() == 0x6C); + assert(map2::J::JJ_T::key == 0x6C); + assert(KK_input.get_key() == 0x6D); + assert(map2::J::KK_T::key == 0x6D); + assert(LL_input.get_key() == 0x6F); + assert(map2::J::LL_T::key == 0x6F); + assert(MM_input.get_key() == 0xAB); + assert(map2::J::MM_T::key == 0xAB); + assert(NN_input.get_key() == 0x91); + assert(map2::J::NN_T::key == 0x91); + assert(K_input.get_key() == 0xBB); + assert(map2::K_T::key == 0xBB); + assert(L_input.get_key() == 0xDF); + assert(map2::L_T::key == 0xDF); + assert(M_input.get_key() == 0xF0); + assert(map2::M_T::key == 0xF0); + assert(N_input.get_key() == 0x400); + assert(map2::N_T::key == 0x400); +} + +void testPeriod() { + A_T A_input; + B_T B_input; + C_T C_input; + D_T D_input; + E_T E_input; + F_T F_input; + G_T G_input; + H_T H_input; + I_T I_input; + AA_T AA_input; + BB_T BB_input; + AAA_T AAA_input; + BBB_T BBB_input; + CCC_T CCC_input; + DDD_T DDD_input; + DD_T DD_input; + EE_T EE_input; + FF_T FF_input; + GG_T GG_input; + HH_T HH_input; + II_T II_input; + JJ_T JJ_input; + KK_T KK_input; + LL_T LL_input; + MM_T MM_input; + NN_T NN_input; + K_T K_input; + L_T L_input; + M_T M_input; + N_T N_input; + assert(A_input.period_ == 50ms); + assert(B_input.period_ == 200ms); + assert(C_input.period_ == 200ms); + assert(D_input.period_ == 200ms); + assert(E_input.period_ == 1000ms); + assert(F_input.period_ == 101ms); + assert(G_input.period_ == 31ms); + assert(H_input.period_ == 0ms); + assert(I_input.period_ == 0ms); + assert(AA_input.period_ == 0ms); + assert(BB_input.period_ == 0ms); + assert(AAA_input.period_ == 0ms); + assert(BBB_input.period_ == 0ms); + assert(CCC_input.period_ == 0ms); + assert(DDD_input.period_ == 0ms); + assert(DD_input.period_ == 0ms); + assert(EE_input.period_ == 0ms); + assert(FF_input.period_ == 0ms); + assert(GG_input.period_ == 0ms); + assert(HH_input.period_ == 0ms); + assert(II_input.period_ == 0ms); + assert(JJ_input.period_ == 0ms); + assert(KK_input.period_ == 0ms); + assert(LL_input.period_ == 0ms); + assert(MM_input.period_ == 0ms); + assert(NN_input.period_ == 0ms); + assert(K_input.period_ == 0ms); + assert(L_input.period_ == 103ms); + assert(M_input.period_ == 103ms); + assert(N_input.period_ == 0ms); +} + +#define CREATE_TEST(ID, bus_idx, key, msg) \ + static void testMessageType##ID() { \ + ID##_T ID##_input;\ + Frame f; \ + ID##_input.unpack(f); \ + int idx = Identify(Bus_Names_T::map##bus_idx, f); \ + assert(static_cast (idx) == map##bus_idx::Message_Type_T::msg); \ + } +CREATE_TEST(A, 1, 0X2FF, A) +CREATE_TEST(B, 1, 0X305, B) +CREATE_TEST(C, 1, 0X306, C) +CREATE_TEST(D, 1, 0X307, D) +CREATE_TEST(E, 1, 0X308, E) +CREATE_TEST(F, 2, 0X016, F) +CREATE_TEST(G, 2, 0X017, G) +CREATE_TEST(H, 2, 0X0A0, H) +CREATE_TEST(I, 2, 0XA2, I) +CREATE_TEST(AA, 2, 0, J_AA) +CREATE_TEST(BB, 2, 0X14, J_BB) +CREATE_TEST(AAA, 2, 0X69, J_CC_AAA) +CREATE_TEST(BBB, 2, 0X70, J_CC_BBB) +CREATE_TEST(CCC, 2, 0X71, J_CC_CCC) +CREATE_TEST(DDD, 2, 0X72, J_CC_DDD) +CREATE_TEST(DD, 2, 0X65, J_DD) +CREATE_TEST(EE, 2, 0X66, J_EE) +CREATE_TEST(FF, 2, 0X67, J_FF) +CREATE_TEST(GG, 2, 0X68, J_GG) +CREATE_TEST(HH, 2, 0X6A, J_HH) +CREATE_TEST(II, 2, 0X6B, J_II) +CREATE_TEST(JJ, 2, 0X6C, J_JJ) +CREATE_TEST(KK, 2, 0X6D, J_KK) +CREATE_TEST(LL, 2, 0X6F, J_LL) +CREATE_TEST(MM, 2, 0XAB, J_MM) +CREATE_TEST(NN, 2, 0X91, J_NN) +CREATE_TEST(K, 2, 0X0BB, K) +CREATE_TEST(L, 2, 0X0DF, L) +CREATE_TEST(M, 2, 0X0F0, M) +CREATE_TEST(N, 2, 0X400, N) + +void testMessageType() { + testMessageTypeA(); + testMessageTypeB(); + testMessageTypeC(); + testMessageTypeD(); + testMessageTypeE(); + testMessageTypeF(); + testMessageTypeG(); + testMessageTypeH(); + testMessageTypeI(); + testMessageTypeAA(); + testMessageTypeBB(); + testMessageTypeAAA(); + testMessageTypeBBB(); + testMessageTypeCCC(); + testMessageTypeDDD(); + testMessageTypeDD(); + testMessageTypeEE(); + testMessageTypeFF(); + testMessageTypeGG(); + testMessageTypeHH(); + testMessageTypeII(); + testMessageTypeJJ(); + testMessageTypeKK(); + testMessageTypeLL(); + testMessageTypeMM(); + testMessageTypeNN(); + testMessageTypeK(); + testMessageTypeL(); + testMessageTypeM(); + testMessageTypeN(); +} + +void testBusNames() { + A_T A_input; + B_T B_input; + C_T C_input; + D_T D_input; + E_T E_input; + F_T F_input; + G_T G_input; + H_T H_input; + I_T I_input; + AA_T AA_input; + BB_T BB_input; + AAA_T AAA_input; + BBB_T BBB_input; + CCC_T CCC_input; + DDD_T DDD_input; + DD_T DD_input; + EE_T EE_input; + FF_T FF_input; + GG_T GG_input; + HH_T HH_input; + II_T II_input; + JJ_T JJ_input; + KK_T KK_input; + LL_T LL_input; + MM_T MM_input; + NN_T NN_input; + K_T K_input; + L_T L_input; + M_T M_input; + N_T N_input; + assert(A_input.name_ == Bus_Names_T::map1); + assert(B_input.name_ == Bus_Names_T::map1); + assert(C_input.name_ == Bus_Names_T::map1); + assert(D_input.name_ == Bus_Names_T::map1); + assert(E_input.name_ == Bus_Names_T::map1); + assert(F_input.name_ == Bus_Names_T::map2); + assert(G_input.name_ == Bus_Names_T::map2); + assert(H_input.name_ == Bus_Names_T::map2); + assert(I_input.name_ == Bus_Names_T::map2); + assert(AA_input.name_ == Bus_Names_T::map2); + assert(BB_input.name_ == Bus_Names_T::map2); + assert(AAA_input.name_ == Bus_Names_T::map2); + assert(BBB_input.name_ == Bus_Names_T::map2); + assert(CCC_input.name_ == Bus_Names_T::map2); + assert(DDD_input.name_ == Bus_Names_T::map2); + assert(DD_input.name_ == Bus_Names_T::map2); + assert(EE_input.name_ == Bus_Names_T::map2); + assert(FF_input.name_ == Bus_Names_T::map2); + assert(GG_input.name_ == Bus_Names_T::map2); + assert(HH_input.name_ == Bus_Names_T::map2); + assert(II_input.name_ == Bus_Names_T::map2); + assert(JJ_input.name_ == Bus_Names_T::map2); + assert(KK_input.name_ == Bus_Names_T::map2); + assert(LL_input.name_ == Bus_Names_T::map2); + assert(MM_input.name_ == Bus_Names_T::map2); + assert(NN_input.name_ == Bus_Names_T::map2); + assert(K_input.name_ == Bus_Names_T::map2); + assert(L_input.name_ == Bus_Names_T::map2); + assert(M_input.name_ == Bus_Names_T::map2); + assert(N_input.name_ == Bus_Names_T::map2); +} diff --git a/test/tests/src/identify.cpp b/test/tests/src/identify.cpp new file mode 100644 index 0000000..6dbdf69 --- /dev/null +++ b/test/tests/src/identify.cpp @@ -0,0 +1,99 @@ +#include "test.hpp" +#include + +namespace CANlib { +extern Message_T** messages[2]; +} + +using namespace CANlib; +using namespace map1; +using namespace map2; +using namespace J; +using namespace CC; + +#define CREATE_TEST0(ID, bus_idx, key) \ + static void test##ID() { \ + for (int cs = 0;cs < 100;++cs) { \ + Frame f; \ + f.dlc = distribution(generator); \ + for (int i = 0;i < 8;++i) { \ + f.data[i] = distribution(generator); \ + } \ + f.id = key; \ + Message_T* msg = messages[bus_idx][Identify(Bus_Names_T::map##bus_idx, f)]; \ + assert((dynamic_cast (msg)) != nullptr); \ + } \ + } + +#define CREATE_TEST1(ID, bus_idx, key) \ + static void test##ID() { \ + ID##_T ID##_input; \ + Frame f; \ + ID##_input.unpack(f); \ + Message_T* msg = messages[bus_idx][Identify(Bus_Names_T::map##bus_idx, f)]; \ + assert((dynamic_cast (msg)) != nullptr); \ + } + +CREATE_TEST0(A, 1, 0X2FF) +CREATE_TEST0(B, 1, 0X305) +CREATE_TEST0(C, 1, 0X306) +CREATE_TEST0(D, 1, 0X307) +CREATE_TEST0(E, 1, 0X308) +CREATE_TEST0(F, 2, 0X016) +CREATE_TEST0(G, 2, 0X017) +CREATE_TEST0(H, 2, 0X0A0) +CREATE_TEST0(I, 2, 0XA2) +CREATE_TEST1(AA, 2, 0) +CREATE_TEST1(BB, 2, 0X14) +CREATE_TEST1(AAA, 2, 0X69) +CREATE_TEST1(BBB, 2, 0X70) +CREATE_TEST1(CCC, 2, 0X71) +CREATE_TEST1(DDD, 2, 0X72) +CREATE_TEST1(DD, 2, 0X65) +CREATE_TEST1(EE, 2, 0X66) +CREATE_TEST1(FF, 2, 0X67) +CREATE_TEST1(GG, 2, 0X68) +CREATE_TEST1(HH, 2, 0X6A) +CREATE_TEST1(II, 2, 0X6B) +CREATE_TEST1(JJ, 2, 0X6C) +CREATE_TEST1(KK, 2, 0X6D) +CREATE_TEST1(LL, 2, 0X6F) +CREATE_TEST1(MM, 2, 0XAB) +CREATE_TEST1(NN, 2, 0X91) +CREATE_TEST0(K, 2, 0X0BB) +CREATE_TEST0(L, 2, 0X0DF) +CREATE_TEST0(M, 2, 0X0F0) +CREATE_TEST0(N, 2, 0X400) + +void testIdentify() { + testA(); + testB(); + testC(); + testD(); + testE(); + testF(); + testG(); + testH(); + testI(); + testAA(); + testBB(); + testAAA(); + testBBB(); + testCCC(); + testDDD(); + testDD(); + testEE(); + testFF(); + testGG(); + testHH(); + testII(); + testJJ(); + testKK(); + testLL(); + testMM(); + testNN(); + testK(); + testL(); + testM(); + testN(); +} diff --git a/test/tests/src/message.cpp b/test/tests/src/message.cpp new file mode 100644 index 0000000..48c1d38 --- /dev/null +++ b/test/tests/src/message.cpp @@ -0,0 +1,93 @@ +#include "test.hpp" +#include "pack_unpack.hpp" +#include + +using namespace CANlib; +using namespace map1; +using namespace map2; +using namespace J; +using namespace CC; + +#define CREATE_TEST(ID, BITMASK) \ + void test##ID() { \ + ID##_T ID##_input;\ + Frame f0; \ + for (int i = 0;i < 8;++i) { \ + f0.data[i] = distribution(generator); \ + } \ + uint64_t bitstring0; \ + to_bitstring((uint8_t*)f0.data, &bitstring0); \ + bitstring0 &= BITMASK; \ + ID##_input.pack(f0); \ + Frame f1; \ + ID##_input.unpack(f1); \ + uint64_t bitstring1;\ + to_bitstring((uint8_t*)f1.data, &bitstring1); \ + assert(bitstring0 == bitstring1); \ + } + + +CREATE_TEST(A, get_bitmask(7,56)) +CREATE_TEST(B, get_bitmask(5,64)) +CREATE_TEST(C, get_bitmask(0,56)) +CREATE_TEST(D, get_bitmask(0,18)) +CREATE_TEST(E, get_bitmask(0,64)) +CREATE_TEST(F, get_bitmask(0,10) | get_bitmask(18, 28) | get_bitmask(36, 46) | get_bitmask(54, 64)) +CREATE_TEST(G, get_bitmask(0,60)) +CREATE_TEST(H, get_bitmask(0,64)) +CREATE_TEST(I, get_bitmask(0,64)) +CREATE_TEST(AA, get_bitmask(23, 24) | get_bitmask(39, 40)) +CREATE_TEST(BB, get_bitmask(23, 24) | get_bitmask(39, 40)) +CREATE_TEST(AAA, get_bitmask(23, 24) | get_bitmask(32, 48)) +CREATE_TEST(BBB, get_bitmask(23, 24) | get_bitmask(32, 48)) +CREATE_TEST(CCC, get_bitmask(23, 24) | get_bitmask(32, 48)) +CREATE_TEST(DDD, get_bitmask(23, 24) | get_bitmask(32, 48)) +CREATE_TEST(DD, get_bitmask(23, 24) | get_bitmask(32, 48)) +CREATE_TEST(EE, get_bitmask(23, 24) | get_bitmask(32, 48)) +CREATE_TEST(FF, get_bitmask(23, 24) | get_bitmask(32, 48)) +CREATE_TEST(GG, get_bitmask(23, 24) | get_bitmask(32, 48)) +CREATE_TEST(HH, get_bitmask(23, 24) | get_bitmask(32, 48)) +CREATE_TEST(II, get_bitmask(23, 24) | get_bitmask(32, 48)) +CREATE_TEST(JJ, get_bitmask(23, 24) | get_bitmask(32, 48)) +CREATE_TEST(KK, get_bitmask(23, 24) | get_bitmask(32, 48)) +CREATE_TEST(LL, get_bitmask(23, 24) | get_bitmask(32, 48)) +CREATE_TEST(MM, get_bitmask(23, 24) | get_bitmask(39, 40)) +CREATE_TEST(NN, get_bitmask(23, 24) | get_bitmask(39, 40)) +CREATE_TEST(K, get_bitmask(0, 32)) +CREATE_TEST(L, get_bitmask(0, 25)) +CREATE_TEST(M, get_bitmask(0, 16)) +CREATE_TEST(N, get_bitmask(3, 11)) + + +void testPackUnpack() { + testA(); + testB(); + testC(); + testD(); + testE(); + testF(); + testG(); + testH(); + testI(); + testAA(); + testBB(); + testAAA(); + testBBB(); + testCCC(); + testDDD(); + testDD(); + testEE(); + testFF(); + testGG(); + testHH(); + testII(); + testJJ(); + testKK(); + testLL(); + testMM(); + testNN(); + testK(); + testL(); + testM(); + testN(); +} diff --git a/test/tests/src/send.cpp b/test/tests/src/send.cpp new file mode 100644 index 0000000..c097876 --- /dev/null +++ b/test/tests/src/send.cpp @@ -0,0 +1,104 @@ +#include +#include +#include +#include "pack_unpack.hpp" +#include "test.hpp" + +using namespace CANlib; +using namespace map1; +using namespace map2; +using namespace J; +using namespace CC; +using namespace std::chrono_literals; + +extern CAN can1; +extern CAN can2; +extern CAN can3; + +#define CREATE_TEST(ID, can_idx, BITMASK) \ + static void testSend##ID() { \ + ID##_T ID##_input; \ + can##can_idx.clear(); \ + auto starting_time = Clock::now(); \ + Frame f0; \ + for (int i = 0;i < 8;++i) { \ + f0.data[i] = distribution(generator); \ + } \ + uint64_t bitstring0; \ + to_bitstring((uint8_t*)f0.data, &bitstring0); \ + bitstring0 &= BITMASK; \ + ID##_input.unpack(f0); \ + while (Clock::now() - starting_time <= ID##_input.period_ + 5ms) { \ + send(starting_time, &ID##_input); \ + } \ + uint64_t bitstring1; \ + assert(can##can_idx.framesReceived() == 1); \ + Frame f1 = can##can_idx.topFrame(); \ + to_bitstring((uint8_t*)f1.data, &bitstring1); \ + bitstring1 &= BITMASK;\ + assert(bitstring0 == bitstring1); \ + } \ + +CREATE_TEST(A, 2, get_bitmask(7,56)) +CREATE_TEST(B, 2, get_bitmask(5,64)) +CREATE_TEST(C, 2, get_bitmask(0,56)) +CREATE_TEST(D, 2, get_bitmask(0,18)) +CREATE_TEST(E, 2, get_bitmask(0,64)) +CREATE_TEST(F, 1, get_bitmask(0,10) | get_bitmask(18, 28) | get_bitmask(36, 46) | get_bitmask(54, 64)) +CREATE_TEST(G, 1, get_bitmask(0,60)) +CREATE_TEST(H, 1, get_bitmask(0,64)) +CREATE_TEST(I, 1, get_bitmask(0,64)) +CREATE_TEST(AA, 1, get_bitmask(23, 24) | get_bitmask(39, 40)) +CREATE_TEST(BB, 1, get_bitmask(23, 24) | get_bitmask(39, 40)) +CREATE_TEST(AAA, 1, get_bitmask(23, 24) | get_bitmask(32, 48)) +CREATE_TEST(BBB, 1, get_bitmask(23, 24) | get_bitmask(32, 48)) +CREATE_TEST(CCC, 1, get_bitmask(23, 24) | get_bitmask(32, 48)) +CREATE_TEST(DDD, 1, get_bitmask(23, 24) | get_bitmask(32, 48)) +CREATE_TEST(DD, 1, get_bitmask(23, 24) | get_bitmask(32, 48)) +CREATE_TEST(EE, 1, get_bitmask(23, 24) | get_bitmask(32, 48)) +CREATE_TEST(FF, 1, get_bitmask(23, 24) | get_bitmask(32, 48)) +CREATE_TEST(GG, 1, get_bitmask(23, 24) | get_bitmask(32, 48)) +CREATE_TEST(HH, 1, get_bitmask(23, 24) | get_bitmask(32, 48)) +CREATE_TEST(II, 1, get_bitmask(23, 24) | get_bitmask(32, 48)) +CREATE_TEST(JJ, 1, get_bitmask(23, 24) | get_bitmask(32, 48)) +CREATE_TEST(KK, 1, get_bitmask(23, 24) | get_bitmask(32, 48)) +CREATE_TEST(LL, 1, get_bitmask(23, 24) | get_bitmask(32, 48)) +CREATE_TEST(MM, 1, get_bitmask(23, 24) | get_bitmask(39, 40)) +CREATE_TEST(NN, 1, get_bitmask(23, 24) | get_bitmask(39, 40)) +CREATE_TEST(K, 1, get_bitmask(0, 32)) +CREATE_TEST(L, 1, get_bitmask(0, 25)) +CREATE_TEST(M, 1, get_bitmask(0, 16)) +CREATE_TEST(N, 1, get_bitmask(3, 11)) + +void testSend() { + testSendA(); + testSendB(); + testSendC(); + testSendD(); + testSendE(); + testSendF(); + testSendG(); + testSendH(); + testSendI(); + testSendAA(); + testSendBB(); + testSendAAA(); + testSendBBB(); + testSendCCC(); + testSendDDD(); + testSendDD(); + testSendEE(); + testSendFF(); + testSendGG(); + testSendHH(); + testSendII(); + testSendJJ(); + testSendKK(); + testSendLL(); + testSendMM(); + testSendNN(); + testSendK(); + testSendL(); + testSendM(); + testSendN(); +} From ae434af9ec8ba004769371b869508aaa935a20c7 Mon Sep 17 00:00:00 2001 From: Gabriel Cojocaru Date: Sun, 18 Apr 2021 22:50:45 +0300 Subject: [PATCH 02/17] finished testing --- generator/main.py | 1 + generator/templates/bus.cpp.j2 | 18 +- generator/templates/pack_unpack.cpp.j2 | 9 +- generator/templates/structs.cpp.j2 | 44 +- generator/templates/structs.hpp.j2 | 21 +- src/inc/driver.hpp | 24 ++ src/inc/static.hpp | 27 ++ src/src/drivers/stm32f2xx.cpp | 99 +++++ src/src/drivers/stm32f4xx.cpp | 88 ++++ src/src/drivers/testfamily.cpp | 57 +++ test/Makefile | 23 +- test/tests/inc/test.hpp | 17 +- test/tests/main.cpp | 18 +- test/tests/src/arch0.cpp | 88 ++-- test/tests/src/arch1.cpp | 87 ++-- test/tests/src/arch2.cpp | 87 ++-- test/tests/src/constants.cpp | 544 +++++++++++++------------ test/tests/src/identify.cpp | 109 ++--- test/tests/src/message.cpp | 174 ++++---- test/tests/src/send.cpp | 188 +++++---- 20 files changed, 1099 insertions(+), 624 deletions(-) create mode 100644 src/inc/driver.hpp create mode 100644 src/inc/static.hpp create mode 100644 src/src/drivers/stm32f2xx.cpp create mode 100644 src/src/drivers/stm32f4xx.cpp create mode 100644 src/src/drivers/testfamily.cpp diff --git a/generator/main.py b/generator/main.py index 6e848c5..1646ce2 100644 --- a/generator/main.py +++ b/generator/main.py @@ -104,6 +104,7 @@ def render_template(env, relative_path): import os try: os.system('clang-format -i ../src/inc/drivers/* ../src/src/drivers/*') + os.system('clang-format -i ../src/inc/computers/* ../src/src/computers/*') os.system('clang-format -i ../src/inc/*') os.system('clang-format -i ../src/src/*') except: diff --git a/generator/templates/bus.cpp.j2 b/generator/templates/bus.cpp.j2 index 739a201..40f8237 100644 --- a/generator/templates/bus.cpp.j2 +++ b/generator/templates/bus.cpp.j2 @@ -1,17 +1,29 @@ {%- macro key_type(num_bits) -%} uint{{ (((num_bits / 8) | round(method='ceil')) * 8) | int }}_t {%- endmacro -%} +{%- macro last_sent_def(bus, msg, msg_name) -%} +{%- if msg.frame is defined %} + {% for sub_frame in msg.frame %} + {{ last_sent_def(bus, sub_frame, msg_name + '::' + sub_frame.name) }} + {% endfor %} +{% else %} + Clock::time_point {{msg_name}}_T::last_sent_; +{% endif %} +{%- endmacro -%} + #include "static.hpp" #include "bus.hpp" #include "structs.hpp" #include "pack_unpack.hpp" -# namespace CANlib { extern const std::pair* frame_id_range[static_cast(Bus_Names_T::INVALID_NAME)]; extern const uint32_t* frame_len[static_cast(Bus_Names_T::INVALID_NAME)]; extern const uint32_t* keys[static_cast(Bus_Names_T::INVALID_NAME)]; -//extern const size_t can_size[static_cast(Bus_Names_T::INVALID_NAME)]; +extern const size_t can_size[static_cast(Bus_Names_T::INVALID_NAME)]; extern Message_T** messages[static_cast(Bus_Names_T::INVALID_NAME)]; +{%- for bus in can.bus -%} +{{ last_sent_def(bus, bus, bus.name) }} +{%- endfor -%} } using namespace CANlib; @@ -36,7 +48,7 @@ static uint32_t Identify_internal(const uint32_t key, const Frame& frame, int l, uint32_t CANlib::Identify(Bus_Names_T bus, const Frame& frame) { const int bus_idx = static_cast(bus); -// return Identify_internal(frame.id, frame, 1, can_size[bus_idx], bus_idx); + return Identify_internal(frame.id, frame, 1, can_size[bus_idx] - 1, bus_idx); } void CANlib::HandleFrame(Bus_Names_T bus_name, const Frame& frame) { diff --git a/generator/templates/pack_unpack.cpp.j2 b/generator/templates/pack_unpack.cpp.j2 index 3040262..f8ad375 100644 --- a/generator/templates/pack_unpack.cpp.j2 +++ b/generator/templates/pack_unpack.cpp.j2 @@ -123,17 +123,10 @@ uint64_t swap_uint64(uint64_t val) { return (val << 32) | (val >> 32); } -// Pack functions +// Pack+Unpack functions {% for bus in can.bus %} {%- for msg in bus.frame -%} {{ can_pack_handler(msg, [bus.name], bus.extended) }} - -{% endfor %} -{% endfor %} - -// Unpack functions -{% for bus in can.bus %} -{%- for msg in bus.frame -%} {{ can_unpack_handler(msg, [bus.name, msg.name]) }} {% endfor %} diff --git a/generator/templates/structs.cpp.j2 b/generator/templates/structs.cpp.j2 index 6b52d7d..2355964 100644 --- a/generator/templates/structs.cpp.j2 +++ b/generator/templates/structs.cpp.j2 @@ -11,6 +11,17 @@ {% endif %} {%- endmacro -%} +{%- macro get_message_type(bus, msg, msg_names) -%} +{%- if msg.frame is defined -%} + {{bus.name}}::Message_Type_T::UNKNOWN_MSG, + {%- for sub_frame in msg.frame -%} + {{ get_message_type(bus, sub_frame, msg_names + [sub_frame.name]) }} + {%- endfor -%} +{%- else -%} + Message_Type_T::{{'_'.join(msg_names)}}, +{%- endif -%} +{%- endmacro -%} + {%- macro get_messages(msg, msg_names) -%} {%- if msg.frame is defined -%} nullptr, @@ -65,22 +76,37 @@ namespace CANlib { void send(Clock::time_point &last_sent_, Message_T* msg) { - if (Clock::now() - last_sent_ > msg->period_) { + if (Clock::now() - last_sent_ > msg->get_period()) { last_sent_ = Clock::now(); Frame frame; - msg->pack(frame); - TransmitFrame(frame, msg->name_); + msg->unpack(frame); + TransmitFrame(frame, msg->get_bus_name()); } } +void send(Message_T* msg) { + Frame frame; + msg->unpack(frame); + TransmitFrame(frame, msg->get_bus_name()); +} + {%- for bus in can.bus %} namespace {{bus.name}} { {% for msg in bus.frame -%} {{ struct_declarations(bus, msg, msg.name) }} {%- endfor -%} + +extern const Message_Type_T message_types[{{get_msg_len(bus)}}] = { + Message_Type_T::UNKNOWN_MSG, + {% for msg in bus.frame -%} + {{ get_message_type(bus, msg, [msg.name]) }} + {%- endfor -%} +}; + } const uint32_t {{bus.name}}_keys[] = { + 0, {% for msg in bus.frame -%} {{ get_keys(msg, [bus.name, msg.name]) }} {%- endfor -%} @@ -94,12 +120,14 @@ const std::pair {{bus.name}}_frame_id_range[] = { }; const uint32_t {{bus.name}}_frame_len[] = { + 0, {% for msg in bus.frame -%} {{ get_frame_ranges(msg, [bus.name, msg.name]) }} {%- endfor -%} }; Message_T* {{bus.name}}_messages[] = { + nullptr, {%- for msg in bus.frame -%} {{ get_messages(msg, ['CANlib', bus.name, msg.name]) }} {%- endfor -%} @@ -124,11 +152,11 @@ const uint32_t* frame_len[static_cast(Bus_Names_T::INVALID_NAME)] = { {%- endfor -%} }; -//const size_t can_size[static_cast(Bus_Names_T::INVALID_NAME)] = { -//{%- for bus in can.bus -%} -//{{ get_msg_len(bus.frame) }}, -//{%- endfor -%} -//}; +extern const size_t can_size[static_cast(Bus_Names_T::INVALID_NAME)] = { +{%- for bus in can.bus -%} +{{ get_msg_len(bus) }}, +{%- endfor -%} +}; Message_T** messages[static_cast(Bus_Names_T::INVALID_NAME)] = { {%- for bus in can.bus -%} diff --git a/generator/templates/structs.hpp.j2 b/generator/templates/structs.hpp.j2 index 9c49fa6..fffd326 100644 --- a/generator/templates/structs.hpp.j2 +++ b/generator/templates/structs.hpp.j2 @@ -17,6 +17,16 @@ void send() override { CANlib::send(this->last_sent_, this); } + Bus_Names_T get_bus_name() override { + return Bus_Names_T::{{ bus.name }}; + } + Clock::duration get_period() override { + {% if msg.period %} + return std::chrono::milliseconds({{ get_ms(msg.period) }}); + {% else %} + return std::chrono::milliseconds(0); + {% endif %} + } {% for atom in msg.atom %} {%- if atom.type.isenum() -%} enum class {{ atom.name }}_T { @@ -38,11 +48,7 @@ {{ atom.type.ctype() }} {{ atom.name }}; {%- endif -%} {% endfor %} - const Bus_Names_T name_ = Bus_Names_T::{{ bus.name }}; - Clock::time_point last_sent_; - {% if msg.period %} - const Clock::duration period_ = std::chrono::milliseconds({{ get_ms(msg.period) }}); - {% endif %} + static Clock::time_point last_sent_; static const uint32_t key = 0x{{ '%0X' % msg.key }}; }; {% endif %} @@ -97,11 +103,12 @@ struct Message_T { virtual void pack(const Frame&) = 0; virtual uint32_t get_key() = 0; virtual void send() = 0; - const Clock::duration period_ = std::chrono::milliseconds(0); - const Bus_Names_T name_ = Bus_Names_T::INVALID_NAME; + virtual Bus_Names_T get_bus_name() = 0; + virtual Clock::duration get_period() = 0; }; void send(Clock::time_point &last_sent_, Message_T* msg); +void send(Message_T* msg); {%- for bus in can.bus %} diff --git a/src/inc/driver.hpp b/src/inc/driver.hpp new file mode 100644 index 0000000..b9426f0 --- /dev/null +++ b/src/inc/driver.hpp @@ -0,0 +1,24 @@ +#pragma once + +// INCLUDE THIS AFTER YOUR DRIVER + +#if !(CANLIB_ARCH_STM32F4XX || CANLIB_ARCH_STM32F2XX || CANLIB_ARCH_TESTFAMILY) +#error "No architecture specified!" +#endif + +#ifdef CANLIB_ARCH_STM32F4xx +#include "drivers/stm32f4xx.hpp" +#elif defined(CANLIB_ARCH_STM32F2XX) +#include "drivers/stm32f2xx.hpp" +#elif defined(CANLIB_ARCH_TESTFAMILY) +#include "drivers/testfamily.hpp" +#else +#error "No architecture specified!" +#endif + +#include "bus.hpp" + +namespace CANlib { +Transmit_Error_T TransmitFrame(const Frame &frame, Bus_Names_T bus); +void ReadFrame(Frame &frame, Raw_Bus_T bus); +} // namespace CANlib diff --git a/src/inc/static.hpp b/src/inc/static.hpp new file mode 100644 index 0000000..8185213 --- /dev/null +++ b/src/inc/static.hpp @@ -0,0 +1,27 @@ +#pragma once + +#include +#include +#include + +struct Frame { + uint32_t id; + uint8_t data[8]; + uint8_t dlc; + bool extended; + Frame &operator=(const Frame &f) { + id = f.id; + for (int i = 0; i < 8; ++i) { + data[i] = f.data[i]; + } + dlc = f.dlc; + extended = f.extended; + return *this; + } + Frame() { + id = 0; + memset(data, 0, sizeof(data)); + dlc = 0; + extended = false; + } +}; diff --git a/src/src/drivers/stm32f2xx.cpp b/src/src/drivers/stm32f2xx.cpp new file mode 100644 index 0000000..5831517 --- /dev/null +++ b/src/src/drivers/stm32f2xx.cpp @@ -0,0 +1,99 @@ +#ifdef CANLIB_ARCH_STM32F2XX +#include "static.hpp" + +#include +#include "stm32f2xx_hal_can.h" + +CAN_HandleTypeDef CanHandle; + +HAL_StatusTypeDef CANlib_Init(uint32_t baudrate) { + // TODO calculate baudrate and set stuff accordingly + // Right now the baudrate is hard-coded to 500kbaud + // Can change prescaler to change this + // 2 Mbaud / prescaler = baudrate (prescaler goes from 1 to 1024) + + CAN_FilterConfTypeDef sFilterConfig; + static CanTxMsgTypeDef TxMessage; + static CanRxMsgTypeDef RxMessage; + + CanHandle.Instance = CAN1; + CanHandle.pTxMsg = &TxMessage; + CanHandle.pRxMsg = &RxMessage; + + CanHandle.Init.TTCM = DISABLE; + CanHandle.Init.ABOM = DISABLE; + CanHandle.Init.AWUM = DISABLE; + CanHandle.Init.NART = DISABLE; + CanHandle.Init.RFLM = DISABLE; + CanHandle.Init.TXFP = DISABLE; + CanHandle.Init.Mode = CAN_MODE_NORMAL; + CanHandle.Init.SJW = CAN_SJW_1TQ; + CanHandle.Init.BS1 = CAN_BS1_6TQ; + CanHandle.Init.BS2 = CAN_BS2_8TQ; + CanHandle.Init.Prescaler = 4; + + HAL_StatusTypeDef status; + + if ((status = HAL_CAN_Init(&CanHandle)) != HAL_OK) { + /* Initialization Error */ + + printf("[CAN INIT] ERROR\r\n"); + return status; + } + + // TODO: Might want to comment this out + sFilterConfig.FilterNumber = 0; + sFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK; + sFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT; + sFilterConfig.FilterIdHigh = 0x0000; + sFilterConfig.FilterIdLow = 0x0000; + sFilterConfig.FilterMaskIdHigh = 0x0000; + sFilterConfig.FilterMaskIdLow = 0x0000; + sFilterConfig.FilterFIFOAssignment = 0; + sFilterConfig.FilterActivation = ENABLE; + sFilterConfig.BankNumber = 14; + + if ((status = HAL_CAN_ConfigFilter(&CanHandle, &sFilterConfig)) != HAL_OK) { + return status; + } + + if ((status = HAL_CAN_Receive_IT(&CanHandle, CAN_FIFO0)) != HAL_OK) { + return status; + } + + return HAL_OK; +} + +HAL_StatusTypeDef CANlib_TransmitFrame(Frame *frame) { + if (frame->extended) { + CanHandle.pTxMsg->ExtId = frame->id; + CanHandle.pTxMsg->IDE = CAN_ID_EXT; + } else { + CanHandle.pTxMsg->StdId = frame->id; + CanHandle.pTxMsg->IDE = CAN_ID_STD; + } + + CanHandle.pTxMsg->DLC = frame->len; + CanHandle.pTxMsg->RTR = CAN_RTR_DATA; + + memcpy(CanHandle.pTxMsg->Data, frame->data, sizeof(frame->data)); + + __disable_irq(); + HAL_StatusTypeDef CAN_TX_STATUS = HAL_CAN_Transmit_IT(&CanHandle); + __enable_irq(); + + if (CAN_TX_STATUS != HAL_OK) { + // TODO handle error + printf("[CAN TX] ERROR: HAL_StatusTypeDef is %d\r\n", (int)CAN_TX_STATUS); + printf("[CAN TX] ERROR: HAL_CAN_StateTypeDef is %d\r\n", CanHandle.State); + printf("[CAN TX] ERROR: ErrorCode is %d\r\n", CanHandle.ErrorCode); + + return CAN_TX_STATUS; + } + + // ~HACK~ + HAL_CAN_Receive_IT(&CanHandle, CAN_FIFO0); + + return HAL_OK; +} +#endif diff --git a/src/src/drivers/stm32f4xx.cpp b/src/src/drivers/stm32f4xx.cpp new file mode 100644 index 0000000..ff0a189 --- /dev/null +++ b/src/src/drivers/stm32f4xx.cpp @@ -0,0 +1,88 @@ +#ifdef CANLIB_ARCH_STM32F4XX +#include "static.h" + +#include +#include +#include "bus.h" +#include "driver.h" +#include "drivers/inc/stm32f4xx.hpp" +#include "stm32f4xx_hal.h" +#ifdef USING_LOGGING_CALLBACK +#include "log.h" +#endif + +extern CAN_HandleTypeDef hcan1; +extern CAN_HandleTypeDef hcan2; +extern CAN_HandleTypeDef hcan3; + +using namespace CANlib; + +Transmit_Error_T CANlib::TransmitFrame(const Frame &frame, Bus_Names_T bus_name) { + Raw_Bus_T raw_bus = GetRawBus(bus); + int bus_num; + CAN_HandleTypeDef *hcan; + switch (raw_bus) { + case CAN_1: + hcan = &hcan1; + bus_num = 1; + break; + case CAN_2: + hcan = &hcan2; + bus_num = 2; + break; + case CAN_3: + hcan = &hcan3; + bus_num = 3; + break; + default: + return HAL_ERROR; + } + + CAN_TxHeaderTypeDef pHeader; + uint32_t pTxMailbox = 0; + + pHeader.DLC = frame.dlc; + pHeader.StdId = frame.id; + pHeader.IDE = frame.extended ? CAN_ID_EXT : CAN_ID_STD; + pHeader.RTR = CAN_RTR_DATA; // Data frame (as opposed to a remote frame) + pHeader.TransmitGlobalTime = DISABLE; // Don't replace last 2 bytes of data with TX time. +#ifdef USING_LOGGING_CALLBACK + log_frame(frame, bus_num); +#else + UNUSED(bus_num); +#endif + return HAL_CAN_AddTxMessage(hcan, &pHeader, frame.data, &pTxMailbox); +} + +void ReadFrame(Frame &frame, Bus_Names_T bus) { + Raw_Bus_T raw_bus = 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; + } + + 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; + } + } +} +#endif diff --git a/src/src/drivers/testfamily.cpp b/src/src/drivers/testfamily.cpp new file mode 100644 index 0000000..8c063d8 --- /dev/null +++ b/src/src/drivers/testfamily.cpp @@ -0,0 +1,57 @@ +//#ifdef CANLIB_ARCH_TESTFAMILY +#include "static.hpp" + +#include +#include +#include +#include "bus.hpp" +#include "driver.hpp" +#include "drivers/testfamily.hpp" + +using namespace CANlib; + +CAN can1; +CAN can2; +CAN can3; + +Clock::time_point Clock::now() noexcept { + static const auto start_time = std::chrono::system_clock::now(); + const auto time_passed = std::chrono::system_clock::now() - start_time; + std::chrono::milliseconds us = std::chrono::duration_cast(time_passed); + return time_point(std::chrono::milliseconds(us.count())); +} + +Transmit_Error_T CANlib::TransmitFrame(const Frame &frame, Bus_Names_T bus_name) { + switch (GetRawBus(bus_name)) { + case Raw_Bus_T::CAN_1: + can1.receiveFrame(frame); + break; + case Raw_Bus_T::CAN_2: + can2.receiveFrame(frame); + break; + case Raw_Bus_T::CAN_3: + can3.receiveFrame(frame); + break; + default: + return true; + } + + return false; +} + +void CANlib::ReadFrame(Frame &frame, Bus_Names_T bus_name) { + switch (GetRawBus(bus_name)) { + case Raw_Bus_T::CAN_1: + frame = can1.frameToSend(); + break; + case Raw_Bus_T::CAN_2: + frame = can2.frameToSend(); + break; + case Raw_Bus_T::CAN_3: + frame = can3.frameToSend(); + break; + default: + return; + } +} +//#endif diff --git a/test/Makefile b/test/Makefile index d273553..800fd06 100644 --- a/test/Makefile +++ b/test/Makefile @@ -25,12 +25,15 @@ COMPUTER_FLAGS := -I../src/inc/drivers -I../src/inc/computers CPPFLAGS := $(INC_FLAGS) -std=c++17 # The final build step. -main0: - g++ $(CPPFLAGS) $(COMPUTER_FLAGS) $(CXXFLAGS) ../src/src/bus.cpp ../src/src/structs.cpp ../src/src/drivers/testfamily.cpp ../src/src/pack_unpack.cpp ../src/src/computers/canlib_testcomp0.cpp tests/src/identify.cpp tests/src/message.cpp tests/src/send.cpp tests/src/constants.cpp tests/src/arch0.cpp tests/main.cpp -o main0 -main1: - g++ $(CPPFLAGS) $(COMPUTER_FLAGS) $(CXXFLAGS) ../src/src/bus.cpp ../src/src/structs.cpp ../src/src/drivers/testfamily.cpp ../src/src/pack_unpack.cpp ../src/src/computers/canlib_testcomp1.cpp tests/src/send.cpp tests/src/constants.cpp tests/src/arch1.cpp tests/main.cpp -o main1 -main2: - g++ $(CPPFLAGS) $(COMPUTER_FLAGS) $(CXXFLAGS) ../src/src/bus.cpp ../src/src/structs.cpp ../src/src/drivers/testfamily.cpp ../src/src/pack_unpack.cpp ../src/src/computers/canlib_testcomp2.cpp tests/src/send.cpp tests/src/constants.cpp tests/src/arch2.cpp tests/main.cpp -o main2 +gen: + python3 ../generator/main.py can_spec.yml --testing + +main0: gen + g++ $(CPPFLAGS) $(COMPUTER_FLAGS) $(CXXFLAGS) -DCANLIB_ARCH_TESTFAMILY -DARCH0 ../src/src/bus.cpp ../src/src/structs.cpp ../src/src/drivers/testfamily.cpp ../src/src/pack_unpack.cpp ../src/src/computers/canlib_testcomp0.cpp tests/src/identify.cpp tests/src/message.cpp tests/src/send.cpp tests/src/constants.cpp tests/src/arch0.cpp tests/main.cpp -o main0 +main1: gen + g++ $(CPPFLAGS) $(COMPUTER_FLAGS) $(CXXFLAGS) -DCANLIB_ARCH_TESTFAMILY -DARCH1 ../src/src/bus.cpp ../src/src/structs.cpp ../src/src/drivers/testfamily.cpp ../src/src/pack_unpack.cpp ../src/src/computers/canlib_testcomp1.cpp tests/src/identify.cpp tests/src/message.cpp tests/src/send.cpp tests/src/constants.cpp tests/src/arch1.cpp tests/main.cpp -o main1 +main2: gen + g++ $(CPPFLAGS) $(COMPUTER_FLAGS) $(CXXFLAGS) -DCANLIB_ARCH_TESTFAMILY -DARCH2 ../src/src/bus.cpp ../src/src/structs.cpp ../src/src/drivers/testfamily.cpp ../src/src/pack_unpack.cpp ../src/src/computers/canlib_testcomp2.cpp tests/src/identify.cpp tests/src/message.cpp tests/src/send.cpp tests/src/constants.cpp tests/src/arch2.cpp tests/main.cpp -o main2 $(BUILD_DIR): mkdir -p build/src/src @@ -84,7 +87,9 @@ $(BUILD_DIR)/src/src/computers/canlib_testcomp1.cpp.o: $(BUILD_DIR) $(BUILD_DIR)/src/src/computers/canlib_testcomp2.cpp.o: $(BUILD_DIR) g++ ../src/src/computers/canlib_testcomp2.cpp $(CPPFLAGS) $(COMPUTER_FLAGS) $(CXXFLAGS) -c $< -o $(BUILD_DIR)/src/src/computers/canlib_testcomp2.cpp.o -.PHONY: clean +.PHONY: clean build clean: - rm -r $(BUILD_DIR) - + rm main0 main1 main2 +build: main0 main1 main2 +run: + ./main0 & ./main1 & ./main2 diff --git a/test/tests/inc/test.hpp b/test/tests/inc/test.hpp index 68011e6..2dffd46 100644 --- a/test/tests/inc/test.hpp +++ b/test/tests/inc/test.hpp @@ -1,11 +1,24 @@ #pragma once #include #include "bus.hpp" +#include "driver.hpp" #include "structs.hpp" #include "testfamily.hpp" -#include "driver.hpp" -#define get_bitmask(l, r) (!l ? ((1ULL << (r - 1)) - 1) : ((1ULL << (r - 1)) - (1ULL << (l - 1)))) +#ifdef ARCH0 +#define MAP1_CAN can2 +#define MAP2_CAN can1 +#endif + +#ifdef ARCH1 +#define MAP1_CAN can2 +#define MAP2_CAN can3 +#endif + +#ifdef ARCH2 +#define MAP1_CAN can3 +#define MAP2_CAN can1 +#endif extern std::default_random_engine generator; extern std::uniform_int_distribution distribution; diff --git a/test/tests/main.cpp b/test/tests/main.cpp index 8708f31..ca95fcd 100644 --- a/test/tests/main.cpp +++ b/test/tests/main.cpp @@ -1,15 +1,15 @@ #include "test.hpp" std::default_random_engine generator; -std::uniform_int_distribution distribution(0,511); +std::uniform_int_distribution distribution(0, 511); int main() { - testIdentify(); - testSend(); - testArch(); - testKeys(); - testPeriod(); - testMessageType(); - testPackUnpack(); - return 0; + testIdentify(); + testArch(); + testKeys(); + testPeriod(); + testMessageType(); + testPackUnpack(); + testSend(); + return 0; } diff --git a/test/tests/src/arch0.cpp b/test/tests/src/arch0.cpp index ffc1be9..e199887 100644 --- a/test/tests/src/arch0.cpp +++ b/test/tests/src/arch0.cpp @@ -1,47 +1,65 @@ #include +#include #include "canlib_testcomp0.hpp" #include "test.hpp" +namespace CANlib { +namespace map1 { +extern A_T A_input; +} // namespace map1 +namespace map2 { +extern F_T F_input; +} // namespace map2 +} // namespace CANlib + using namespace CANlib; +using namespace map1; +using namespace map2; extern CAN can1; extern CAN can2; extern CAN can3; void testArch() { - assert(GetRawBus(Bus_Names_T::map1) == Raw_Bus_T::CAN_2); - assert(GetRawBus(Bus_Names_T::map2) == Raw_Bus_T::CAN_1); - assert(GetRawBus(Bus_Names_T::INVALID_NAME) == Raw_Bus_T::INVALID_BUS); - assert(GetBusName(Raw_Bus_T::CAN_2) == Bus_Names_T::map1); - assert(GetBusName(Raw_Bus_T::CAN_1) == Bus_Names_T::map2); - assert(GetBusName(Raw_Bus_T::CAN_3) == Bus_Names_T::INVALID_NAME); - assert(GetBusName(Raw_Bus_T::INVALID_BUS) == Bus_Names_T::INVALID_NAME); - can1.clear(); - can2.clear(); - can3.clear(); - update_can(); - assert(1 == can1.framesReceived()); - assert(1 == can2.framesReceived()); - assert(0 == can3.framesReceived()); - can1.clear(); - can2.clear(); - can3.clear(); - Frame f; - f.id = 69; - can2.setFrameToSend(f); - map1_update_can(); - assert(69 == can2.topFrame().id); - assert(0 == can1.framesReceived()); - assert(1 == can2.framesReceived()); - assert(0 == can3.framesReceived()); - can1.clear(); - can2.clear(); - can3.clear(); - f.id = 69; - can1.setFrameToSend(f); - map2_update_can(); - assert(69 == can1.topFrame().id); - assert(1 == can1.framesReceived()); - assert(0 == can2.framesReceived()); - assert(0 == can3.framesReceived()); + assert(GetRawBus(Bus_Names_T::map1) == Raw_Bus_T::CAN_2); + assert(GetRawBus(Bus_Names_T::map2) == Raw_Bus_T::CAN_1); + assert(GetRawBus(Bus_Names_T::INVALID_NAME) == Raw_Bus_T::INVALID_BUS); + assert(GetBusName(Raw_Bus_T::CAN_2) == Bus_Names_T::map1); + assert(GetBusName(Raw_Bus_T::CAN_1) == Bus_Names_T::map2); + assert(GetBusName(Raw_Bus_T::CAN_3) == Bus_Names_T::INVALID_NAME); + assert(GetBusName(Raw_Bus_T::INVALID_BUS) == Bus_Names_T::INVALID_NAME); + can1.clear(); + can2.clear(); + can3.clear(); + send(&A_input); + send(&F_input); + assert(1 == can1.framesReceived()); + assert(1 == can2.framesReceived()); + assert(0 == can3.framesReceived()); + can1.clear(); + can2.clear(); + can3.clear(); + Frame f; + map1::A_T A_copy; + A_copy.ARG0 = true; + A_copy.ARG1 = 69; + A_copy.ARG2 = 69; + A_copy.ARG3 = 69; + A_copy.unpack(f); + can2.setFrameToSend(f); + map1::A_T A_copy2; + map1_update_can(); + assert(A_input.ARG0 && A_input.ARG1 == 69 && A_input.ARG2 == 69 && A_input.ARG3 == 69); + map2::F_T F_copy; + F_copy.ARG0 = 69; + F_copy.ARG1 = 69; + F_copy.ARG2 = 69; + F_copy.ARG3 = 69; + F_copy.ARG4 = 69; + F_copy.ARG5 = 69; + F_copy.unpack(f); + can1.setFrameToSend(f); + map2_update_can(); + assert(F_input.ARG0 == 69 && F_input.ARG1 == 69 && F_input.ARG2 == 69 && F_input.ARG3 == 69 && + F_input.ARG4 == 69 && F_input.ARG5 == 69); } diff --git a/test/tests/src/arch1.cpp b/test/tests/src/arch1.cpp index 38a92a3..6afebe9 100644 --- a/test/tests/src/arch1.cpp +++ b/test/tests/src/arch1.cpp @@ -2,46 +2,63 @@ #include "canlib_testcomp1.hpp" #include "test.hpp" +namespace CANlib { +namespace map1 { +extern A_T A_input; +} // namespace map1 +namespace map2 { +extern F_T F_input; +} // namespace map2 +} // namespace CANlib + using namespace CANlib; +using namespace map1; +using namespace map2; extern CAN can1; extern CAN can2; extern CAN can3; void testArch() { - assert(GetRawBus(Bus_Names_T::map1) == Raw_Bus_T::CAN_2); - assert(GetRawBus(Bus_Names_T::map2) == Raw_Bus_T::CAN_3); - assert(GetRawBus(Bus_Names_T::INVALID_NAME) == Raw_Bus_T::INVALID_BUS); - assert(GetBusName(Raw_Bus_T::CAN_2) == Bus_Names_T::map1); - assert(GetBusName(Raw_Bus_T::CAN_3) == Bus_Names_T::map2); - assert(GetBusName(Raw_Bus_T::CAN_1) == Bus_Names_T::INVALID_NAME); - assert(GetBusName(Raw_Bus_T::INVALID_BUS) == Bus_Names_T::INVALID_NAME); - can1.clear(); - can2.clear(); - can3.clear(); - update_can(); - assert(0 == can1.framesReceived()); - assert(1 == can2.framesReceived()); - assert(1 == can3.framesReceived()); - can1.clear(); - can2.clear(); - can3.clear(); - Frame f; - f.id = 69; - can2.setFrameToSend(f); - map1_update_can(); - assert(69 == can2.topFrame().id); - assert(0 == can1.framesReceived()); - assert(1 == can2.framesReceived()); - assert(0 == can3.framesReceived()); - can1.clear(); - can2.clear(); - can3.clear(); - f.id = 69; - can3.setFrameToSend(f); - map2_update_can(); - assert(69 == can3.topFrame().id); - assert(0 == can1.framesReceived()); - assert(0 == can2.framesReceived()); - assert(1 == can3.framesReceived()); + assert(GetRawBus(Bus_Names_T::map1) == Raw_Bus_T::CAN_2); + assert(GetRawBus(Bus_Names_T::map2) == Raw_Bus_T::CAN_3); + assert(GetRawBus(Bus_Names_T::INVALID_NAME) == Raw_Bus_T::INVALID_BUS); + assert(GetBusName(Raw_Bus_T::CAN_2) == Bus_Names_T::map1); + assert(GetBusName(Raw_Bus_T::CAN_3) == Bus_Names_T::map2); + assert(GetBusName(Raw_Bus_T::CAN_1) == Bus_Names_T::INVALID_NAME); + assert(GetBusName(Raw_Bus_T::INVALID_BUS) == Bus_Names_T::INVALID_NAME); + can1.clear(); + can2.clear(); + can3.clear(); + send(&A_input); + send(&F_input); + assert(0 == can1.framesReceived()); + assert(1 == can2.framesReceived()); + assert(1 == can3.framesReceived()); + can1.clear(); + can2.clear(); + can3.clear(); + Frame f; + map1::A_T A_copy; + A_copy.ARG0 = true; + A_copy.ARG1 = 69; + A_copy.ARG2 = 69; + A_copy.ARG3 = 69; + A_copy.unpack(f); + can2.setFrameToSend(f); + map1::A_T A_copy2; + map1_update_can(); + assert(A_input.ARG0 && A_input.ARG1 == 69 && A_input.ARG2 == 69 && A_input.ARG3 == 69); + map2::F_T F_copy; + F_copy.ARG0 = 69; + F_copy.ARG1 = 69; + F_copy.ARG2 = 69; + F_copy.ARG3 = 69; + F_copy.ARG4 = 69; + F_copy.ARG5 = 69; + F_copy.unpack(f); + can3.setFrameToSend(f); + map2_update_can(); + assert(F_input.ARG0 == 69 && F_input.ARG1 == 69 && F_input.ARG2 == 69 && F_input.ARG3 == 69 && + F_input.ARG4 == 69 && F_input.ARG5 == 69); } diff --git a/test/tests/src/arch2.cpp b/test/tests/src/arch2.cpp index b92ab7f..bfa8f8e 100644 --- a/test/tests/src/arch2.cpp +++ b/test/tests/src/arch2.cpp @@ -2,46 +2,63 @@ #include "canlib_testcomp2.hpp" #include "test.hpp" +namespace CANlib { +namespace map1 { +extern A_T A_input; +} // namespace map1 +namespace map2 { +extern F_T F_input; +} // namespace map2 +} // namespace CANlib + using namespace CANlib; +using namespace map1; +using namespace map2; extern CAN can1; extern CAN can2; extern CAN can3; void testArch() { - assert(GetRawBus(Bus_Names_T::map1) == Raw_Bus_T::CAN_3); - assert(GetRawBus(Bus_Names_T::map2) == Raw_Bus_T::CAN_1); - assert(GetRawBus(Bus_Names_T::INVALID_NAME) == Raw_Bus_T::INVALID_BUS); - assert(GetBusName(Raw_Bus_T::CAN_2) == Bus_Names_T::map1); - assert(GetBusName(Raw_Bus_T::CAN_1) == Bus_Names_T::map2); - assert(GetBusName(Raw_Bus_T::CAN_3) == Bus_Names_T::INVALID_NAME); - assert(GetBusName(Raw_Bus_T::INVALID_BUS) == Bus_Names_T::INVALID_NAME); - can1.clear(); - can2.clear(); - can3.clear(); - update_can(); - assert(1 == can1.framesReceived()); - assert(0 == can2.framesReceived()); - assert(1 == can3.framesReceived()); - can1.clear(); - can2.clear(); - can3.clear(); - Frame f; - f.id = 69; - can3.setFrameToSend(f); - testcomp2::map1::update_can(); - assert(69 == can3.topFrame().id); - assert(0 == can1.framesReceived()); - assert(0 == can2.framesReceived()); - assert(1 == can3.framesReceived()); - can1.clear(); - can2.clear(); - can3.clear(); - f.id = 69; - can1.setFrameToSend(f); - testcomp2::map2::update_can(); - assert(69 == can1.topFrame().id); - assert(1 == can1.framesReceived()); - assert(0 == can2.framesReceived()); - assert(0 == can3.framesReceived()); + assert(GetRawBus(Bus_Names_T::map1) == Raw_Bus_T::CAN_3); + assert(GetRawBus(Bus_Names_T::map2) == Raw_Bus_T::CAN_1); + assert(GetRawBus(Bus_Names_T::INVALID_NAME) == Raw_Bus_T::INVALID_BUS); + assert(GetBusName(Raw_Bus_T::CAN_3) == Bus_Names_T::map1); + assert(GetBusName(Raw_Bus_T::CAN_1) == Bus_Names_T::map2); + assert(GetBusName(Raw_Bus_T::CAN_2) == Bus_Names_T::INVALID_NAME); + assert(GetBusName(Raw_Bus_T::INVALID_BUS) == Bus_Names_T::INVALID_NAME); + can1.clear(); + can2.clear(); + can3.clear(); + send(&A_input); + send(&F_input); + assert(1 == can1.framesReceived()); + assert(0 == can2.framesReceived()); + assert(1 == can3.framesReceived()); + can1.clear(); + can2.clear(); + can3.clear(); + Frame f; + map1::A_T A_copy; + A_copy.ARG0 = true; + A_copy.ARG1 = 69; + A_copy.ARG2 = 69; + A_copy.ARG3 = 69; + A_copy.unpack(f); + can3.setFrameToSend(f); + map1::A_T A_copy2; + map1_update_can(); + assert(A_input.ARG0 && A_input.ARG1 == 69 && A_input.ARG2 == 69 && A_input.ARG3 == 69); + map2::F_T F_copy; + F_copy.ARG0 = 69; + F_copy.ARG1 = 69; + F_copy.ARG2 = 69; + F_copy.ARG3 = 69; + F_copy.ARG4 = 69; + F_copy.ARG5 = 69; + F_copy.unpack(f); + can1.setFrameToSend(f); + map2_update_can(); + assert(F_input.ARG0 == 69 && F_input.ARG1 == 69 && F_input.ARG2 == 69 && F_input.ARG3 == 69 && + F_input.ARG4 == 69 && F_input.ARG5 == 69); } diff --git a/test/tests/src/constants.cpp b/test/tests/src/constants.cpp index ce5d1bf..95bac94 100644 --- a/test/tests/src/constants.cpp +++ b/test/tests/src/constants.cpp @@ -1,180 +1,214 @@ -#include "test.hpp" #include #include +#include "test.hpp" + +namespace CANlib { +namespace map1 { +extern Message_Type_T message_types[6]; +} +namespace map2 { +extern Message_Type_T message_types[28]; +} +} // namespace CANlib using namespace CANlib; -using namespace map1; -using namespace map2; -using namespace J; -using namespace CC; using namespace std::chrono_literals; - +using map1::A_T; +using map1::B_T; +using map1::C_T; +using map1::D_T; +using map1::E_T; +using map2::F_T; +using map2::G_T; +using map2::H_T; +using map2::I_T; +using map2::K_T; +using map2::L_T; +using map2::M_T; +using map2::N_T; +using map2::J::AA_T; +using map2::J::BB_T; +using map2::J::DD_T; +using map2::J::EE_T; +using map2::J::FF_T; +using map2::J::GG_T; +using map2::J::HH_T; +using map2::J::II_T; +using map2::J::JJ_T; +using map2::J::KK_T; +using map2::J::LL_T; +using map2::J::MM_T; +using map2::J::NN_T; +using map2::J::CC::AAA_T; +using map2::J::CC::BBB_T; +using map2::J::CC::CCC_T; +using map2::J::CC::DDD_T; void testKeys() { - A_T A_input; - B_T B_input; - C_T C_input; - D_T D_input; - E_T E_input; - F_T F_input; - G_T G_input; - H_T H_input; - I_T I_input; - AA_T AA_input; - BB_T BB_input; - AAA_T AAA_input; - BBB_T BBB_input; - CCC_T CCC_input; - DDD_T DDD_input; - DD_T DD_input; - EE_T EE_input; - FF_T FF_input; - GG_T GG_input; - HH_T HH_input; - II_T II_input; - JJ_T JJ_input; - KK_T KK_input; - LL_T LL_input; - MM_T MM_input; - NN_T NN_input; - K_T K_input; - L_T L_input; - M_T M_input; - N_T N_input; - assert(A_input.get_key() == 0x2FF); - assert(map1::A_T::key == 0x2FF); - assert(B_input.get_key() == 0x305); - assert(map1::B_T::key == 0x305); - assert(C_input.get_key() == 0x306); - assert(map1::C_T::key == 0x306); - assert(D_input.get_key() == 0x307); - assert(map1::D_T::key == 0x307); - assert(E_input.get_key() == 0x308); - assert(map1::E_T::key == 0x308); - assert(F_input.get_key() == 0x16); - assert(map2::F_T::key == 0x16); - assert(G_input.get_key() == 0x17); - assert(map2::G_T::key == 0x17); - assert(H_input.get_key() == 0xA0); - assert(map2::H_T::key == 0xA0); - assert(I_input.get_key() == 0xA2); - assert(map2::I_T::key == 0xA2); - assert(map2::J::key == 0xC2); - assert(AA_input.get_key() == 0x0); - assert(map2::J::AA_T::key == 0x0); - assert(BB_input.get_key() == 0x14); - assert(map2::J::BB_T::key == 0x14); - assert(map2::J::CC::key == 0x64); - assert(AAA_input.get_key() == 0x69); - assert(map2::J::CC::AAA_T::key == 0x69); - assert(BBB_input.get_key() == 0x70); - assert(map2::J::CC::BBB_T::key == 0x70); - assert(CCC_input.get_key() == 0x71); - assert(map2::J::CC::CCC_T::key == 0x71); - assert(DDD_input.get_key() == 0x72); - assert(map2::J::CC::DDD_T::key == 0x72); - assert(DD_input.get_key() == 0x65); - assert(map2::J::DD_T::key == 0x65); - assert(EE_input.get_key() == 0x66); - assert(map2::J::EE_T::key == 0x66); - assert(FF_input.get_key() == 0x67); - assert(map2::J::FF_T::key == 0x67); - assert(GG_input.get_key() == 0x68); - assert(map2::J::GG_T::key == 0x68); - assert(HH_input.get_key() == 0x6A); - assert(map2::J::HH_T::key == 0x6A); - assert(II_input.get_key() == 0x6B); - assert(map2::J::II_T::key == 0x6B); - assert(JJ_input.get_key() == 0x6C); - assert(map2::J::JJ_T::key == 0x6C); - assert(KK_input.get_key() == 0x6D); - assert(map2::J::KK_T::key == 0x6D); - assert(LL_input.get_key() == 0x6F); - assert(map2::J::LL_T::key == 0x6F); - assert(MM_input.get_key() == 0xAB); - assert(map2::J::MM_T::key == 0xAB); - assert(NN_input.get_key() == 0x91); - assert(map2::J::NN_T::key == 0x91); - assert(K_input.get_key() == 0xBB); - assert(map2::K_T::key == 0xBB); - assert(L_input.get_key() == 0xDF); - assert(map2::L_T::key == 0xDF); - assert(M_input.get_key() == 0xF0); - assert(map2::M_T::key == 0xF0); - assert(N_input.get_key() == 0x400); - assert(map2::N_T::key == 0x400); + map1::A_T A_input; + map1::B_T B_input; + map1::C_T C_input; + map1::D_T D_input; + map1::E_T E_input; + map2::F_T F_input; + map2::G_T G_input; + map2::H_T H_input; + map2::I_T I_input; + map2::J::AA_T AA_input; + map2::J::BB_T BB_input; + map2::J::CC::AAA_T AAA_input; + map2::J::CC::BBB_T BBB_input; + map2::J::CC::CCC_T CCC_input; + map2::J::CC::DDD_T DDD_input; + map2::J::DD_T DD_input; + map2::J::EE_T EE_input; + map2::J::FF_T FF_input; + map2::J::GG_T GG_input; + map2::J::HH_T HH_input; + map2::J::II_T II_input; + map2::J::JJ_T JJ_input; + map2::J::KK_T KK_input; + map2::J::LL_T LL_input; + map2::J::MM_T MM_input; + map2::J::NN_T NN_input; + map2::K_T K_input; + map2::L_T L_input; + map2::M_T M_input; + map2::N_T N_input; + assert(A_input.get_key() == 0x2FF); + assert(map1::A_T::key == 0x2FF); + assert(B_input.get_key() == 0x305); + assert(map1::B_T::key == 0x305); + assert(C_input.get_key() == 0x306); + assert(map1::C_T::key == 0x306); + assert(D_input.get_key() == 0x307); + assert(map1::D_T::key == 0x307); + assert(E_input.get_key() == 0x308); + assert(map1::E_T::key == 0x308); + assert(F_input.get_key() == 0x16); + assert(map2::F_T::key == 0x16); + assert(G_input.get_key() == 0x17); + assert(map2::G_T::key == 0x17); + assert(H_input.get_key() == 0xA0); + assert(map2::H_T::key == 0xA0); + assert(I_input.get_key() == 0xA2); + assert(map2::I_T::key == 0xA2); + assert(map2::J::key == 0xC2); + assert(AA_input.get_key() == 0x0); + assert(map2::J::AA_T::key == 0x0); + assert(BB_input.get_key() == 0x14); + assert(map2::J::BB_T::key == 0x14); + assert(map2::J::CC::key == 0x64); + assert(AAA_input.get_key() == 0x69); + assert(map2::J::CC::AAA_T::key == 0x69); + assert(BBB_input.get_key() == 0x70); + assert(map2::J::CC::BBB_T::key == 0x70); + assert(CCC_input.get_key() == 0x71); + assert(map2::J::CC::CCC_T::key == 0x71); + assert(DDD_input.get_key() == 0x72); + assert(map2::J::CC::DDD_T::key == 0x72); + assert(DD_input.get_key() == 0x65); + assert(map2::J::DD_T::key == 0x65); + assert(EE_input.get_key() == 0x66); + assert(map2::J::EE_T::key == 0x66); + assert(FF_input.get_key() == 0x67); + assert(map2::J::FF_T::key == 0x67); + assert(GG_input.get_key() == 0x68); + assert(map2::J::GG_T::key == 0x68); + assert(HH_input.get_key() == 0x6A); + assert(map2::J::HH_T::key == 0x6A); + assert(II_input.get_key() == 0x6B); + assert(map2::J::II_T::key == 0x6B); + assert(JJ_input.get_key() == 0x6C); + assert(map2::J::JJ_T::key == 0x6C); + assert(KK_input.get_key() == 0x6D); + assert(map2::J::KK_T::key == 0x6D); + assert(LL_input.get_key() == 0x6F); + assert(map2::J::LL_T::key == 0x6F); + assert(MM_input.get_key() == 0xAB); + assert(map2::J::MM_T::key == 0xAB); + assert(NN_input.get_key() == 0x91); + assert(map2::J::NN_T::key == 0x91); + assert(K_input.get_key() == 0xBB); + assert(map2::K_T::key == 0xBB); + assert(L_input.get_key() == 0xDF); + assert(map2::L_T::key == 0xDF); + assert(M_input.get_key() == 0xF0); + assert(map2::M_T::key == 0xF0); + assert(N_input.get_key() == 0x400); + assert(map2::N_T::key == 0x400); } void testPeriod() { - A_T A_input; - B_T B_input; - C_T C_input; - D_T D_input; - E_T E_input; - F_T F_input; - G_T G_input; - H_T H_input; - I_T I_input; - AA_T AA_input; - BB_T BB_input; - AAA_T AAA_input; - BBB_T BBB_input; - CCC_T CCC_input; - DDD_T DDD_input; - DD_T DD_input; - EE_T EE_input; - FF_T FF_input; - GG_T GG_input; - HH_T HH_input; - II_T II_input; - JJ_T JJ_input; - KK_T KK_input; - LL_T LL_input; - MM_T MM_input; - NN_T NN_input; - K_T K_input; - L_T L_input; - M_T M_input; - N_T N_input; - assert(A_input.period_ == 50ms); - assert(B_input.period_ == 200ms); - assert(C_input.period_ == 200ms); - assert(D_input.period_ == 200ms); - assert(E_input.period_ == 1000ms); - assert(F_input.period_ == 101ms); - assert(G_input.period_ == 31ms); - assert(H_input.period_ == 0ms); - assert(I_input.period_ == 0ms); - assert(AA_input.period_ == 0ms); - assert(BB_input.period_ == 0ms); - assert(AAA_input.period_ == 0ms); - assert(BBB_input.period_ == 0ms); - assert(CCC_input.period_ == 0ms); - assert(DDD_input.period_ == 0ms); - assert(DD_input.period_ == 0ms); - assert(EE_input.period_ == 0ms); - assert(FF_input.period_ == 0ms); - assert(GG_input.period_ == 0ms); - assert(HH_input.period_ == 0ms); - assert(II_input.period_ == 0ms); - assert(JJ_input.period_ == 0ms); - assert(KK_input.period_ == 0ms); - assert(LL_input.period_ == 0ms); - assert(MM_input.period_ == 0ms); - assert(NN_input.period_ == 0ms); - assert(K_input.period_ == 0ms); - assert(L_input.period_ == 103ms); - assert(M_input.period_ == 103ms); - assert(N_input.period_ == 0ms); + map1::A_T A_input; + map1::B_T B_input; + map1::C_T C_input; + map1::D_T D_input; + map1::E_T E_input; + map2::F_T F_input; + map2::G_T G_input; + map2::H_T H_input; + map2::I_T I_input; + map2::J::AA_T AA_input; + map2::J::BB_T BB_input; + map2::J::CC::AAA_T AAA_input; + map2::J::CC::BBB_T BBB_input; + map2::J::CC::CCC_T CCC_input; + map2::J::CC::DDD_T DDD_input; + map2::J::DD_T DD_input; + map2::J::EE_T EE_input; + map2::J::FF_T FF_input; + map2::J::GG_T GG_input; + map2::J::HH_T HH_input; + map2::J::II_T II_input; + map2::J::JJ_T JJ_input; + map2::J::KK_T KK_input; + map2::J::LL_T LL_input; + map2::J::MM_T MM_input; + map2::J::NN_T NN_input; + map2::K_T K_input; + map2::L_T L_input; + map2::M_T M_input; + map2::N_T N_input; + assert(A_input.get_period() == 50ms); + assert(B_input.get_period() == 200ms); + assert(C_input.get_period() == 200ms); + assert(D_input.get_period() == 200ms); + assert(E_input.get_period() == 1000ms); + assert(F_input.get_period() == 101ms); + assert(G_input.get_period() == 31ms); + assert(H_input.get_period() == 0ms); + assert(I_input.get_period() == 0ms); + assert(AA_input.get_period() == 0ms); + assert(BB_input.get_period() == 0ms); + assert(AAA_input.get_period() == 0ms); + assert(BBB_input.get_period() == 0ms); + assert(CCC_input.get_period() == 0ms); + assert(DDD_input.get_period() == 0ms); + assert(DD_input.get_period() == 0ms); + assert(EE_input.get_period() == 0ms); + assert(FF_input.get_period() == 0ms); + assert(GG_input.get_period() == 0ms); + assert(HH_input.get_period() == 0ms); + assert(II_input.get_period() == 0ms); + assert(JJ_input.get_period() == 0ms); + assert(KK_input.get_period() == 0ms); + assert(LL_input.get_period() == 0ms); + assert(MM_input.get_period() == 0ms); + assert(NN_input.get_period() == 0ms); + assert(K_input.get_period() == 0ms); + assert(L_input.get_period() == 103ms); + assert(M_input.get_period() == 103ms); + assert(N_input.get_period() == 0ms); } -#define CREATE_TEST(ID, bus_idx, key, msg) \ - static void testMessageType##ID() { \ - ID##_T ID##_input;\ - Frame f; \ - ID##_input.unpack(f); \ - int idx = Identify(Bus_Names_T::map##bus_idx, f); \ - assert(static_cast (idx) == map##bus_idx::Message_Type_T::msg); \ +#define CREATE_TEST(ID, bus_idx, key, msg) \ + static void testMessageType##ID() { \ + ID##_T ID##_input; \ + Frame f; \ + ID##_input.unpack(f); \ + int idx = Identify(Bus_Names_T::map##bus_idx, f); \ + assert(map##bus_idx::message_types[idx] == map##bus_idx::Message_Type_T::msg); \ } CREATE_TEST(A, 1, 0X2FF, A) CREATE_TEST(B, 1, 0X305, B) @@ -208,97 +242,97 @@ CREATE_TEST(M, 2, 0X0F0, M) CREATE_TEST(N, 2, 0X400, N) void testMessageType() { - testMessageTypeA(); - testMessageTypeB(); - testMessageTypeC(); - testMessageTypeD(); - testMessageTypeE(); - testMessageTypeF(); - testMessageTypeG(); - testMessageTypeH(); - testMessageTypeI(); - testMessageTypeAA(); - testMessageTypeBB(); - testMessageTypeAAA(); - testMessageTypeBBB(); - testMessageTypeCCC(); - testMessageTypeDDD(); - testMessageTypeDD(); - testMessageTypeEE(); - testMessageTypeFF(); - testMessageTypeGG(); - testMessageTypeHH(); - testMessageTypeII(); - testMessageTypeJJ(); - testMessageTypeKK(); - testMessageTypeLL(); - testMessageTypeMM(); - testMessageTypeNN(); - testMessageTypeK(); - testMessageTypeL(); - testMessageTypeM(); - testMessageTypeN(); + testMessageTypeA(); + testMessageTypeB(); + testMessageTypeC(); + testMessageTypeD(); + testMessageTypeE(); + testMessageTypeF(); + testMessageTypeG(); + testMessageTypeH(); + testMessageTypeI(); + testMessageTypeAA(); + testMessageTypeBB(); + testMessageTypeAAA(); + testMessageTypeBBB(); + testMessageTypeCCC(); + testMessageTypeDDD(); + testMessageTypeDD(); + testMessageTypeEE(); + testMessageTypeFF(); + testMessageTypeGG(); + testMessageTypeHH(); + testMessageTypeII(); + testMessageTypeJJ(); + testMessageTypeKK(); + testMessageTypeLL(); + testMessageTypeMM(); + testMessageTypeNN(); + testMessageTypeK(); + testMessageTypeL(); + testMessageTypeM(); + testMessageTypeN(); } void testBusNames() { - A_T A_input; - B_T B_input; - C_T C_input; - D_T D_input; - E_T E_input; - F_T F_input; - G_T G_input; - H_T H_input; - I_T I_input; - AA_T AA_input; - BB_T BB_input; - AAA_T AAA_input; - BBB_T BBB_input; - CCC_T CCC_input; - DDD_T DDD_input; - DD_T DD_input; - EE_T EE_input; - FF_T FF_input; - GG_T GG_input; - HH_T HH_input; - II_T II_input; - JJ_T JJ_input; - KK_T KK_input; - LL_T LL_input; - MM_T MM_input; - NN_T NN_input; - K_T K_input; - L_T L_input; - M_T M_input; - N_T N_input; - assert(A_input.name_ == Bus_Names_T::map1); - assert(B_input.name_ == Bus_Names_T::map1); - assert(C_input.name_ == Bus_Names_T::map1); - assert(D_input.name_ == Bus_Names_T::map1); - assert(E_input.name_ == Bus_Names_T::map1); - assert(F_input.name_ == Bus_Names_T::map2); - assert(G_input.name_ == Bus_Names_T::map2); - assert(H_input.name_ == Bus_Names_T::map2); - assert(I_input.name_ == Bus_Names_T::map2); - assert(AA_input.name_ == Bus_Names_T::map2); - assert(BB_input.name_ == Bus_Names_T::map2); - assert(AAA_input.name_ == Bus_Names_T::map2); - assert(BBB_input.name_ == Bus_Names_T::map2); - assert(CCC_input.name_ == Bus_Names_T::map2); - assert(DDD_input.name_ == Bus_Names_T::map2); - assert(DD_input.name_ == Bus_Names_T::map2); - assert(EE_input.name_ == Bus_Names_T::map2); - assert(FF_input.name_ == Bus_Names_T::map2); - assert(GG_input.name_ == Bus_Names_T::map2); - assert(HH_input.name_ == Bus_Names_T::map2); - assert(II_input.name_ == Bus_Names_T::map2); - assert(JJ_input.name_ == Bus_Names_T::map2); - assert(KK_input.name_ == Bus_Names_T::map2); - assert(LL_input.name_ == Bus_Names_T::map2); - assert(MM_input.name_ == Bus_Names_T::map2); - assert(NN_input.name_ == Bus_Names_T::map2); - assert(K_input.name_ == Bus_Names_T::map2); - assert(L_input.name_ == Bus_Names_T::map2); - assert(M_input.name_ == Bus_Names_T::map2); - assert(N_input.name_ == Bus_Names_T::map2); + map1::A_T A_input; + map1::B_T B_input; + map1::C_T C_input; + map1::D_T D_input; + map1::E_T E_input; + map2::F_T F_input; + map2::G_T G_input; + map2::H_T H_input; + map2::I_T I_input; + map2::J::AA_T AA_input; + map2::J::BB_T BB_input; + map2::J::CC::AAA_T AAA_input; + map2::J::CC::BBB_T BBB_input; + map2::J::CC::CCC_T CCC_input; + map2::J::CC::DDD_T DDD_input; + map2::J::DD_T DD_input; + map2::J::EE_T EE_input; + map2::J::FF_T FF_input; + map2::J::GG_T GG_input; + map2::J::HH_T HH_input; + map2::J::II_T II_input; + map2::J::JJ_T JJ_input; + map2::J::KK_T KK_input; + map2::J::LL_T LL_input; + map2::J::MM_T MM_input; + map2::J::NN_T NN_input; + map2::K_T K_input; + map2::L_T L_input; + map2::M_T M_input; + map2::N_T N_input; + assert(A_input.get_bus_name() == Bus_Names_T::map1); + assert(B_input.get_bus_name() == Bus_Names_T::map1); + assert(C_input.get_bus_name() == Bus_Names_T::map1); + assert(D_input.get_bus_name() == Bus_Names_T::map1); + assert(E_input.get_bus_name() == Bus_Names_T::map1); + assert(F_input.get_bus_name() == Bus_Names_T::map2); + assert(G_input.get_bus_name() == Bus_Names_T::map2); + assert(H_input.get_bus_name() == Bus_Names_T::map2); + assert(I_input.get_bus_name() == Bus_Names_T::map2); + assert(AA_input.get_bus_name() == Bus_Names_T::map2); + assert(BB_input.get_bus_name() == Bus_Names_T::map2); + assert(AAA_input.get_bus_name() == Bus_Names_T::map2); + assert(BBB_input.get_bus_name() == Bus_Names_T::map2); + assert(CCC_input.get_bus_name() == Bus_Names_T::map2); + assert(DDD_input.get_bus_name() == Bus_Names_T::map2); + assert(DD_input.get_bus_name() == Bus_Names_T::map2); + assert(EE_input.get_bus_name() == Bus_Names_T::map2); + assert(FF_input.get_bus_name() == Bus_Names_T::map2); + assert(GG_input.get_bus_name() == Bus_Names_T::map2); + assert(HH_input.get_bus_name() == Bus_Names_T::map2); + assert(II_input.get_bus_name() == Bus_Names_T::map2); + assert(JJ_input.get_bus_name() == Bus_Names_T::map2); + assert(KK_input.get_bus_name() == Bus_Names_T::map2); + assert(LL_input.get_bus_name() == Bus_Names_T::map2); + assert(MM_input.get_bus_name() == Bus_Names_T::map2); + assert(NN_input.get_bus_name() == Bus_Names_T::map2); + assert(K_input.get_bus_name() == Bus_Names_T::map2); + assert(L_input.get_bus_name() == Bus_Names_T::map2); + assert(M_input.get_bus_name() == Bus_Names_T::map2); + assert(N_input.get_bus_name() == Bus_Names_T::map2); } diff --git a/test/tests/src/identify.cpp b/test/tests/src/identify.cpp index 6dbdf69..b28cffb 100644 --- a/test/tests/src/identify.cpp +++ b/test/tests/src/identify.cpp @@ -1,8 +1,9 @@ -#include "test.hpp" #include +#include +#include "test.hpp" namespace CANlib { -extern Message_T** messages[2]; +extern Message_T **messages[2]; } using namespace CANlib; @@ -11,28 +12,30 @@ using namespace map2; using namespace J; using namespace CC; -#define CREATE_TEST0(ID, bus_idx, key) \ - static void test##ID() { \ - for (int cs = 0;cs < 100;++cs) { \ - Frame f; \ - f.dlc = distribution(generator); \ - for (int i = 0;i < 8;++i) { \ - f.data[i] = distribution(generator); \ - } \ - f.id = key; \ - Message_T* msg = messages[bus_idx][Identify(Bus_Names_T::map##bus_idx, f)]; \ - assert((dynamic_cast (msg)) != nullptr); \ - } \ - } +#define CREATE_TEST0(ID, bus_idx, key) \ + static void test##ID() { \ + for (int cs = 0; cs < 100; ++cs) { \ + Frame f; \ + f.dlc = distribution(generator); \ + for (int i = 0; i < 8; ++i) { \ + f.data[i] = distribution(generator); \ + } \ + f.id = key; \ + int idx = Identify(Bus_Names_T::map##bus_idx, f); \ + Message_T *msg = messages[bus_idx - 1][idx]; \ + assert((dynamic_cast(msg)) != nullptr); \ + } \ + } -#define CREATE_TEST1(ID, bus_idx, key) \ - static void test##ID() { \ - ID##_T ID##_input; \ - Frame f; \ - ID##_input.unpack(f); \ - Message_T* msg = messages[bus_idx][Identify(Bus_Names_T::map##bus_idx, f)]; \ - assert((dynamic_cast (msg)) != nullptr); \ - } +#define CREATE_TEST1(ID, bus_idx, key) \ + static void test##ID() { \ + ID##_T ID##_input; \ + Frame f; \ + ID##_input.unpack(f); \ + int idx = Identify(Bus_Names_T::map##bus_idx, f); \ + Message_T *msg = messages[bus_idx - 1][idx]; \ + assert((dynamic_cast(msg)) != nullptr); \ + } CREATE_TEST0(A, 1, 0X2FF) CREATE_TEST0(B, 1, 0X305) @@ -66,34 +69,34 @@ CREATE_TEST0(M, 2, 0X0F0) CREATE_TEST0(N, 2, 0X400) void testIdentify() { - testA(); - testB(); - testC(); - testD(); - testE(); - testF(); - testG(); - testH(); - testI(); - testAA(); - testBB(); - testAAA(); - testBBB(); - testCCC(); - testDDD(); - testDD(); - testEE(); - testFF(); - testGG(); - testHH(); - testII(); - testJJ(); - testKK(); - testLL(); - testMM(); - testNN(); - testK(); - testL(); - testM(); - testN(); + testA(); + testB(); + testC(); + testD(); + testE(); + testF(); + testG(); + testH(); + testI(); + testAA(); + testBB(); + testAAA(); + testBBB(); + testCCC(); + testDDD(); + testDD(); + testEE(); + testFF(); + testGG(); + testHH(); + testII(); + testJJ(); + testKK(); + testLL(); + testMM(); + testNN(); + testK(); + testL(); + testM(); + testN(); } diff --git a/test/tests/src/message.cpp b/test/tests/src/message.cpp index 48c1d38..8f2f56d 100644 --- a/test/tests/src/message.cpp +++ b/test/tests/src/message.cpp @@ -1,6 +1,7 @@ -#include "test.hpp" -#include "pack_unpack.hpp" #include +#include +#include "pack_unpack.hpp" +#include "test.hpp" using namespace CANlib; using namespace map1; @@ -8,86 +9,97 @@ using namespace map2; using namespace J; using namespace CC; -#define CREATE_TEST(ID, BITMASK) \ - void test##ID() { \ - ID##_T ID##_input;\ - Frame f0; \ - for (int i = 0;i < 8;++i) { \ - f0.data[i] = distribution(generator); \ - } \ - uint64_t bitstring0; \ - to_bitstring((uint8_t*)f0.data, &bitstring0); \ - bitstring0 &= BITMASK; \ - ID##_input.pack(f0); \ - Frame f1; \ - ID##_input.unpack(f1); \ - uint64_t bitstring1;\ - to_bitstring((uint8_t*)f1.data, &bitstring1); \ - assert(bitstring0 == bitstring1); \ - } - - -CREATE_TEST(A, get_bitmask(7,56)) -CREATE_TEST(B, get_bitmask(5,64)) -CREATE_TEST(C, get_bitmask(0,56)) -CREATE_TEST(D, get_bitmask(0,18)) -CREATE_TEST(E, get_bitmask(0,64)) -CREATE_TEST(F, get_bitmask(0,10) | get_bitmask(18, 28) | get_bitmask(36, 46) | get_bitmask(54, 64)) -CREATE_TEST(G, get_bitmask(0,60)) -CREATE_TEST(H, get_bitmask(0,64)) -CREATE_TEST(I, get_bitmask(0,64)) -CREATE_TEST(AA, get_bitmask(23, 24) | get_bitmask(39, 40)) -CREATE_TEST(BB, get_bitmask(23, 24) | get_bitmask(39, 40)) -CREATE_TEST(AAA, get_bitmask(23, 24) | get_bitmask(32, 48)) -CREATE_TEST(BBB, get_bitmask(23, 24) | get_bitmask(32, 48)) -CREATE_TEST(CCC, get_bitmask(23, 24) | get_bitmask(32, 48)) -CREATE_TEST(DDD, get_bitmask(23, 24) | get_bitmask(32, 48)) -CREATE_TEST(DD, get_bitmask(23, 24) | get_bitmask(32, 48)) -CREATE_TEST(EE, get_bitmask(23, 24) | get_bitmask(32, 48)) -CREATE_TEST(FF, get_bitmask(23, 24) | get_bitmask(32, 48)) -CREATE_TEST(GG, get_bitmask(23, 24) | get_bitmask(32, 48)) -CREATE_TEST(HH, get_bitmask(23, 24) | get_bitmask(32, 48)) -CREATE_TEST(II, get_bitmask(23, 24) | get_bitmask(32, 48)) -CREATE_TEST(JJ, get_bitmask(23, 24) | get_bitmask(32, 48)) -CREATE_TEST(KK, get_bitmask(23, 24) | get_bitmask(32, 48)) -CREATE_TEST(LL, get_bitmask(23, 24) | get_bitmask(32, 48)) -CREATE_TEST(MM, get_bitmask(23, 24) | get_bitmask(39, 40)) -CREATE_TEST(NN, get_bitmask(23, 24) | get_bitmask(39, 40)) -CREATE_TEST(K, get_bitmask(0, 32)) -CREATE_TEST(L, get_bitmask(0, 25)) -CREATE_TEST(M, get_bitmask(0, 16)) -CREATE_TEST(N, get_bitmask(3, 11)) +#define CREATE_TEST(ID, BITMASK) \ + void test##ID() { \ + for (int cs = 0; cs < 100000; ++cs) { \ + ID##_T ID##_input; \ + Frame f0; \ + for (int i = 0; i < 8; ++i) { \ + f0.data[i] = distribution(generator); \ + } \ + uint64_t bitstring0; \ + to_bitstring((uint8_t *)f0.data, &bitstring0); \ + bitstring0 &= BITMASK; \ + ID##_input.pack(f0); \ + Frame f1; \ + memset(f1.data, 0, sizeof(f1.data)); \ + ID##_input.unpack(f1); \ + uint64_t bitstring1; \ + to_bitstring((uint8_t *)f1.data, &bitstring1); \ + bitstring1 &= BITMASK; \ + assert(bitstring0 == bitstring1); \ + } \ + } +CREATE_TEST(A, (~ZEROES_MASK(7, 49))) +CREATE_TEST(B, (~ZEROES_MASK(5, 59))) +CREATE_TEST(C, (~ZEROES_MASK(0, 56))) +CREATE_TEST(D, + (~ZEROES_MASK(0, 1)) | (~ZEROES_MASK(2, 1)) | (~ZEROES_MASK(3, 1)) | + (~ZEROES_MASK(4, 1)) | (~ZEROES_MASK(5, 1)) | (~ZEROES_MASK(6, 1)) | + (~ZEROES_MASK(7, 1)) | (~ZEROES_MASK(9, 1)) | (~ZEROES_MASK(16, 1)) | + (~ZEROES_MASK(17, 1))) +CREATE_TEST(E, (~ZEROES_MASK(0, 64))) +CREATE_TEST(F, + (~ZEROES_MASK(0, 10)) | (~ZEROES_MASK(10, 8)) | (~ZEROES_MASK(18, 10)) | + (~ZEROES_MASK(28, 8)) | (~ZEROES_MASK(36, 10)) | (~ZEROES_MASK(46, 8)) | + (~ZEROES_MASK(54, 10))) +CREATE_TEST(G, (~ZEROES_MASK(0, 60))) +CREATE_TEST(H, (~ZEROES_MASK(0, 64))) +CREATE_TEST(I, (~ZEROES_MASK(0, 64))) +CREATE_TEST(AA, (~ZEROES_MASK(23, 1)) | (~ZEROES_MASK(39, 1))) +CREATE_TEST(BB, (~ZEROES_MASK(23, 1)) | (~ZEROES_MASK(39, 1))) +CREATE_TEST(AAA, (~ZEROES_MASK(23, 1) | (~ZEROES_MASK(32, 16)))) +CREATE_TEST(BBB, (~ZEROES_MASK(23, 1)) | (~ZEROES_MASK(32, 16))) +CREATE_TEST(CCC, (~ZEROES_MASK(23, 1)) | (~ZEROES_MASK(32, 16))) +CREATE_TEST(DDD, (~ZEROES_MASK(23, 1) | (~ZEROES_MASK(32, 16)))) +CREATE_TEST(DD, (~ZEROES_MASK(23, 1) | (~ZEROES_MASK(32, 16)))) +CREATE_TEST(EE, (~ZEROES_MASK(23, 1) | (~ZEROES_MASK(32, 16)))) +CREATE_TEST(FF, (~ZEROES_MASK(23, 1) | (~ZEROES_MASK(32, 16)))) +CREATE_TEST(GG, (~ZEROES_MASK(23, 1) | (~ZEROES_MASK(32, 16)))) +CREATE_TEST(HH, (~ZEROES_MASK(23, 1) | (~ZEROES_MASK(32, 16)))) +CREATE_TEST(II, (~ZEROES_MASK(23, 1) | (~ZEROES_MASK(32, 16)))) +CREATE_TEST(JJ, (~ZEROES_MASK(23, 1) | (~ZEROES_MASK(32, 16)))) +CREATE_TEST(KK, (~ZEROES_MASK(23, 1) | (~ZEROES_MASK(32, 16)))) +CREATE_TEST(LL, (~ZEROES_MASK(23, 1) | (~ZEROES_MASK(32, 16)))) +CREATE_TEST(MM, (~ZEROES_MASK(23, 1) | (~ZEROES_MASK(39, 1)))) +CREATE_TEST(NN, (~ZEROES_MASK(23, 1) | (~ZEROES_MASK(39, 1)))) +CREATE_TEST(K, (~ZEROES_MASK(0, 32))) +CREATE_TEST(L, (~ZEROES_MASK(0, 25))) +CREATE_TEST(M, (~ZEROES_MASK(0, 16))) +CREATE_TEST(N, + ((~ZEROES_MASK(3, 1)) | (~ZEROES_MASK(4, 3)) | (~ZEROES_MASK(8, 1)) | + (~ZEROES_MASK(9, 1)) | (~ZEROES_MASK(10, 1)))) void testPackUnpack() { - testA(); - testB(); - testC(); - testD(); - testE(); - testF(); - testG(); - testH(); - testI(); - testAA(); - testBB(); - testAAA(); - testBBB(); - testCCC(); - testDDD(); - testDD(); - testEE(); - testFF(); - testGG(); - testHH(); - testII(); - testJJ(); - testKK(); - testLL(); - testMM(); - testNN(); - testK(); - testL(); - testM(); - testN(); + testA(); + testB(); + testC(); + testD(); + testE(); + testF(); + testG(); + testH(); + testI(); + testAA(); + testBB(); + testAAA(); + testBBB(); + testCCC(); + testDDD(); + testDD(); + testEE(); + testFF(); + testGG(); + testHH(); + testII(); + testJJ(); + testKK(); + testLL(); + testMM(); + testNN(); + testK(); + testL(); + testM(); + testN(); } diff --git a/test/tests/src/send.cpp b/test/tests/src/send.cpp index c097876..40ae574 100644 --- a/test/tests/src/send.cpp +++ b/test/tests/src/send.cpp @@ -1,6 +1,7 @@ #include -#include #include +#include +#include #include "pack_unpack.hpp" #include "test.hpp" @@ -15,90 +16,109 @@ extern CAN can1; extern CAN can2; extern CAN can3; -#define CREATE_TEST(ID, can_idx, BITMASK) \ - static void testSend##ID() { \ - ID##_T ID##_input; \ - can##can_idx.clear(); \ - auto starting_time = Clock::now(); \ - Frame f0; \ - for (int i = 0;i < 8;++i) { \ - f0.data[i] = distribution(generator); \ - } \ - uint64_t bitstring0; \ - to_bitstring((uint8_t*)f0.data, &bitstring0); \ - bitstring0 &= BITMASK; \ - ID##_input.unpack(f0); \ - while (Clock::now() - starting_time <= ID##_input.period_ + 5ms) { \ - send(starting_time, &ID##_input); \ - } \ - uint64_t bitstring1; \ - assert(can##can_idx.framesReceived() == 1); \ - Frame f1 = can##can_idx.topFrame(); \ - to_bitstring((uint8_t*)f1.data, &bitstring1); \ - bitstring1 &= BITMASK;\ - assert(bitstring0 == bitstring1); \ - } \ +#define CREATE_TEST(ID, can, BITMASK) \ + static void testSend##ID() { \ + ID##_T ID##_input; \ + Frame f0; \ + for (int i = 0; i < 8; ++i) { \ + f0.data[i] = distribution(generator); \ + } \ + uint64_t bitstring0; \ + to_bitstring((uint8_t *)f0.data, &bitstring0); \ + bitstring0 &= BITMASK; \ + ID##_input.pack(f0); \ + can.clear(); \ + if (ID##_input.get_period() != 0ms) { \ + auto starting_time = Clock::now(); \ + auto tmp = starting_time; \ + while (Clock::now() - starting_time <= ID##_input.get_period() + 5ms) { \ + send(tmp, &ID##_input); \ + } \ + } else { \ + send(&ID##_input); \ + } \ + uint64_t bitstring1; \ + assert(can.framesReceived() == 1); \ + Frame f1 = can.topFrame(); \ + to_bitstring((uint8_t *)f1.data, &bitstring1); \ + bitstring1 &= BITMASK; \ + assert(bitstring0 == bitstring1); \ + } -CREATE_TEST(A, 2, get_bitmask(7,56)) -CREATE_TEST(B, 2, get_bitmask(5,64)) -CREATE_TEST(C, 2, get_bitmask(0,56)) -CREATE_TEST(D, 2, get_bitmask(0,18)) -CREATE_TEST(E, 2, get_bitmask(0,64)) -CREATE_TEST(F, 1, get_bitmask(0,10) | get_bitmask(18, 28) | get_bitmask(36, 46) | get_bitmask(54, 64)) -CREATE_TEST(G, 1, get_bitmask(0,60)) -CREATE_TEST(H, 1, get_bitmask(0,64)) -CREATE_TEST(I, 1, get_bitmask(0,64)) -CREATE_TEST(AA, 1, get_bitmask(23, 24) | get_bitmask(39, 40)) -CREATE_TEST(BB, 1, get_bitmask(23, 24) | get_bitmask(39, 40)) -CREATE_TEST(AAA, 1, get_bitmask(23, 24) | get_bitmask(32, 48)) -CREATE_TEST(BBB, 1, get_bitmask(23, 24) | get_bitmask(32, 48)) -CREATE_TEST(CCC, 1, get_bitmask(23, 24) | get_bitmask(32, 48)) -CREATE_TEST(DDD, 1, get_bitmask(23, 24) | get_bitmask(32, 48)) -CREATE_TEST(DD, 1, get_bitmask(23, 24) | get_bitmask(32, 48)) -CREATE_TEST(EE, 1, get_bitmask(23, 24) | get_bitmask(32, 48)) -CREATE_TEST(FF, 1, get_bitmask(23, 24) | get_bitmask(32, 48)) -CREATE_TEST(GG, 1, get_bitmask(23, 24) | get_bitmask(32, 48)) -CREATE_TEST(HH, 1, get_bitmask(23, 24) | get_bitmask(32, 48)) -CREATE_TEST(II, 1, get_bitmask(23, 24) | get_bitmask(32, 48)) -CREATE_TEST(JJ, 1, get_bitmask(23, 24) | get_bitmask(32, 48)) -CREATE_TEST(KK, 1, get_bitmask(23, 24) | get_bitmask(32, 48)) -CREATE_TEST(LL, 1, get_bitmask(23, 24) | get_bitmask(32, 48)) -CREATE_TEST(MM, 1, get_bitmask(23, 24) | get_bitmask(39, 40)) -CREATE_TEST(NN, 1, get_bitmask(23, 24) | get_bitmask(39, 40)) -CREATE_TEST(K, 1, get_bitmask(0, 32)) -CREATE_TEST(L, 1, get_bitmask(0, 25)) -CREATE_TEST(M, 1, get_bitmask(0, 16)) -CREATE_TEST(N, 1, get_bitmask(3, 11)) +CREATE_TEST(A, MAP1_CAN, (~ZEROES_MASK(7, 49))) +CREATE_TEST(B, MAP1_CAN, (~ZEROES_MASK(5, 59))) +CREATE_TEST(C, MAP1_CAN, (~ZEROES_MASK(0, 56))) +CREATE_TEST(D, + MAP1_CAN, + (~ZEROES_MASK(0, 1)) | (~ZEROES_MASK(2, 1)) | (~ZEROES_MASK(3, 1)) | + (~ZEROES_MASK(4, 1)) | (~ZEROES_MASK(5, 1)) | (~ZEROES_MASK(6, 1)) | + (~ZEROES_MASK(7, 1)) | (~ZEROES_MASK(9, 1)) | (~ZEROES_MASK(16, 1)) | + (~ZEROES_MASK(17, 1))) +CREATE_TEST(E, MAP1_CAN, (~ZEROES_MASK(0, 64))) +CREATE_TEST(F, + MAP2_CAN, + (~ZEROES_MASK(0, 10)) | (~ZEROES_MASK(10, 8)) | (~ZEROES_MASK(18, 10)) | + (~ZEROES_MASK(28, 8)) | (~ZEROES_MASK(36, 10)) | (~ZEROES_MASK(46, 8)) | + (~ZEROES_MASK(54, 10))) +CREATE_TEST(G, MAP2_CAN, (~ZEROES_MASK(0, 60))) +CREATE_TEST(H, MAP2_CAN, (~ZEROES_MASK(0, 64))) +CREATE_TEST(I, MAP2_CAN, (~ZEROES_MASK(0, 64))) +CREATE_TEST(AA, MAP2_CAN, (~ZEROES_MASK(23, 1)) | (~ZEROES_MASK(39, 1))) +CREATE_TEST(BB, MAP2_CAN, (~ZEROES_MASK(23, 1)) | (~ZEROES_MASK(39, 1))) +CREATE_TEST(AAA, MAP2_CAN, (~ZEROES_MASK(23, 1) | (~ZEROES_MASK(32, 16)))) +CREATE_TEST(BBB, MAP2_CAN, (~ZEROES_MASK(23, 1)) | (~ZEROES_MASK(32, 16))) +CREATE_TEST(CCC, MAP2_CAN, (~ZEROES_MASK(23, 1)) | (~ZEROES_MASK(32, 16))) +CREATE_TEST(DDD, MAP2_CAN, (~ZEROES_MASK(23, 1) | (~ZEROES_MASK(32, 16)))) +CREATE_TEST(DD, MAP2_CAN, (~ZEROES_MASK(23, 1) | (~ZEROES_MASK(32, 16)))) +CREATE_TEST(EE, MAP2_CAN, (~ZEROES_MASK(23, 1) | (~ZEROES_MASK(32, 16)))) +CREATE_TEST(FF, MAP2_CAN, (~ZEROES_MASK(23, 1) | (~ZEROES_MASK(32, 16)))) +CREATE_TEST(GG, MAP2_CAN, (~ZEROES_MASK(23, 1) | (~ZEROES_MASK(32, 16)))) +CREATE_TEST(HH, MAP2_CAN, (~ZEROES_MASK(23, 1) | (~ZEROES_MASK(32, 16)))) +CREATE_TEST(II, MAP2_CAN, (~ZEROES_MASK(23, 1) | (~ZEROES_MASK(32, 16)))) +CREATE_TEST(JJ, MAP2_CAN, (~ZEROES_MASK(23, 1) | (~ZEROES_MASK(32, 16)))) +CREATE_TEST(KK, MAP2_CAN, (~ZEROES_MASK(23, 1) | (~ZEROES_MASK(32, 16)))) +CREATE_TEST(LL, MAP2_CAN, (~ZEROES_MASK(23, 1) | (~ZEROES_MASK(32, 16)))) +CREATE_TEST(MM, MAP2_CAN, (~ZEROES_MASK(23, 1) | (~ZEROES_MASK(39, 1)))) +CREATE_TEST(NN, MAP2_CAN, (~ZEROES_MASK(23, 1) | (~ZEROES_MASK(39, 1)))) +CREATE_TEST(K, MAP2_CAN, (~ZEROES_MASK(0, 32))) +CREATE_TEST(L, MAP2_CAN, (~ZEROES_MASK(0, 25))) +CREATE_TEST(M, MAP2_CAN, (~ZEROES_MASK(0, 16))) +CREATE_TEST(N, + MAP2_CAN, + ((~ZEROES_MASK(3, 1)) | (~ZEROES_MASK(4, 3)) | (~ZEROES_MASK(8, 1)) | + (~ZEROES_MASK(9, 1)) | (~ZEROES_MASK(10, 1)))) void testSend() { - testSendA(); - testSendB(); - testSendC(); - testSendD(); - testSendE(); - testSendF(); - testSendG(); - testSendH(); - testSendI(); - testSendAA(); - testSendBB(); - testSendAAA(); - testSendBBB(); - testSendCCC(); - testSendDDD(); - testSendDD(); - testSendEE(); - testSendFF(); - testSendGG(); - testSendHH(); - testSendII(); - testSendJJ(); - testSendKK(); - testSendLL(); - testSendMM(); - testSendNN(); - testSendK(); - testSendL(); - testSendM(); - testSendN(); + for (int cs = 0; cs < 10; cs++) { + testSendA(); + testSendB(); + testSendC(); + testSendD(); + testSendE(); + testSendF(); + testSendG(); + testSendH(); + testSendI(); + testSendAA(); + testSendBB(); + testSendAAA(); + testSendBBB(); + testSendCCC(); + testSendDDD(); + testSendDD(); + testSendEE(); + testSendFF(); + testSendGG(); + testSendHH(); + testSendII(); + testSendJJ(); + testSendKK(); + testSendLL(); + testSendMM(); + testSendNN(); + testSendK(); + testSendL(); + testSendM(); + testSendN(); + } } From 6a3e73977f43b67d94061124954976a88e74e8c0 Mon Sep 17 00:00:00 2001 From: Gabriel Cojocaru Date: Sun, 25 Apr 2021 16:03:22 +0300 Subject: [PATCH 03/17] changed names --- generator/main.py | 68 +++++++------ generator/templates/bus.cpp.j2 | 24 ++--- generator/templates/bus.hpp.j2 | 8 +- generator/templates/computer.cpp.j2 | 39 +++----- generator/templates/computer.hpp.j2 | 12 ++- .../templates/drivers/inc/testfamily.hpp.j2 | 14 +-- generator/templates/structs.cpp.j2 | 22 ++--- generator/templates/structs.hpp.j2 | 6 +- src/driver.hpp | 24 ----- src/drivers/src/stm32f2xx.cpp | 99 ------------------- src/drivers/src/stm32f4xx.cpp | 88 ----------------- src/drivers/src/testfamily.cpp | 57 ----------- src/{ => inc}/clock.hpp | 2 +- src/inc/driver.hpp | 4 +- src/src/drivers/stm32f4xx.cpp | 8 +- src/src/drivers/testfamily.cpp | 20 ++-- src/static.hpp | 11 --- test/tests/src/arch0.cpp | 14 +-- test/tests/src/arch1.cpp | 14 +-- test/tests/src/arch2.cpp | 14 +-- test/tests/src/constants.cpp | 68 ++++++------- test/tests/src/identify.cpp | 4 +- 22 files changed, 171 insertions(+), 449 deletions(-) delete mode 100644 src/driver.hpp delete mode 100644 src/drivers/src/stm32f2xx.cpp delete mode 100644 src/drivers/src/stm32f4xx.cpp delete mode 100644 src/drivers/src/testfamily.cpp rename src/{ => inc}/clock.hpp (99%) delete mode 100644 src/static.hpp diff --git a/generator/main.py b/generator/main.py index 1646ce2..f8bf2d9 100644 --- a/generator/main.py +++ b/generator/main.py @@ -79,33 +79,41 @@ def render_template(env, relative_path): if __name__ == '__main__': - specpath = sys.argv[1] - specfile = open(specpath, 'r') - system = ParseCAN.spec.System.from_yaml(specfile) - can = system.protocol['name']['can'] - - script_dir = os.path.dirname(sys.argv[0]) - if script_dir == '': - script_dir = '.' - os.chdir(script_dir) - - template_loader = jinja2.FileSystemLoader(searchpath=".") - template_env = jinja2.Environment(loader=template_loader, keep_trailing_newline=True, extensions=[RaiseExtension]) - template_env.globals["can"] = can - template_env.globals["system"] = system - - for filename in ["pack_unpack.cpp", "pack_unpack.hpp", "structs.hpp", "bus.hpp", "bus.cpp", "structs.cpp"]: - render_template(template_env, filename) - - testing = '--testing' in sys.argv - computers_hpp.write(template_env, system.computer, computer_hpp_template_path, computer_hpp_dir_path, testing) - computers_cpp.write(template_env, system.computer, computer_cpp_template_path, computer_cpp_dir_path, testing) - drivers_inc.write(template_env, system, drivers_inc_template_dir_path, drivers_inc_dir_path, testing) - import os - try: - os.system('clang-format -i ../src/inc/drivers/* ../src/src/drivers/*') - os.system('clang-format -i ../src/inc/computers/* ../src/src/computers/*') - os.system('clang-format -i ../src/inc/*') - os.system('clang-format -i ../src/src/*') - except: - print('Error during clang-format, is it installed?') + if '--clean' in sys.argv: + os.system("rm src/inc/computers/*.hpp") + os.system("rm src/inc/drivers/*.hpp") + os.system("rm src/inc/bus.hpp src/inc/pack_unpack.hpp src/inc/structs.hpp") + os.system("rm src/src/computers/*.cpp") + os.system("rm src/src/bus.cpp src/src/pack_unpack.cpp src/src/structs.cpp") + else: + specpath = sys.argv[1] + specfile = open(specpath, 'r') + system = ParseCAN.spec.System.from_yaml(specfile) + can = system.protocol['name']['can'] + + script_dir = os.path.dirname(sys.argv[0]) + if script_dir == '': + script_dir = '.' + os.chdir(script_dir) + + template_loader = jinja2.FileSystemLoader(searchpath=".") + template_env = jinja2.Environment(loader=template_loader, keep_trailing_newline=True, extensions=[RaiseExtension]) + template_env.globals["can"] = can + template_env.globals["system"] = system + + for filename in ["pack_unpack.cpp", "pack_unpack.hpp", "structs.hpp", "bus.hpp", "bus.cpp", "structs.cpp"]: + render_template(template_env, filename) + + testing = '--testing' in sys.argv + computers_hpp.write(template_env, system.computer, computer_hpp_template_path, computer_hpp_dir_path, testing) + computers_cpp.write(template_env, system.computer, computer_cpp_template_path, computer_cpp_dir_path, testing) + drivers_inc.write(template_env, system, drivers_inc_template_dir_path, drivers_inc_dir_path, testing) + pth = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..') + try: + spth = str(pth) + os.system('clang-format -i ' + spth + '/src/inc/drivers/*.hpp ' + spth + '/src/src/drivers/*.cpp') + os.system('clang-format -i ' + spth + '/src/inc/computers/*.hpp ' + spth + '/src/src/computers/*.cpp') + os.system('clang-format -i ' + spth + '/src/inc/*.hpp') + os.system('clang-format -i ' + spth + '/src/src/*.cpp') + except: + print('Error during clang-format, is it installed?') diff --git a/generator/templates/bus.cpp.j2 b/generator/templates/bus.cpp.j2 index 40f8237..d3156e1 100644 --- a/generator/templates/bus.cpp.j2 +++ b/generator/templates/bus.cpp.j2 @@ -16,11 +16,11 @@ #include "pack_unpack.hpp" namespace CANlib { -extern const std::pair* frame_id_range[static_cast(Bus_Names_T::INVALID_NAME)]; -extern const uint32_t* frame_len[static_cast(Bus_Names_T::INVALID_NAME)]; -extern const uint32_t* keys[static_cast(Bus_Names_T::INVALID_NAME)]; -extern const size_t can_size[static_cast(Bus_Names_T::INVALID_NAME)]; -extern Message_T** messages[static_cast(Bus_Names_T::INVALID_NAME)]; +extern const std::pair* frame_id_range[static_cast(AbstractBus::INVALID_NAME)]; +extern const uint32_t* frame_len[static_cast(AbstractBus::INVALID_NAME)]; +extern const uint32_t* keys[static_cast(AbstractBus::INVALID_NAME)]; +extern const size_t can_size[static_cast(AbstractBus::INVALID_NAME)]; +extern Message_T** messages[static_cast(AbstractBus::INVALID_NAME)]; {%- for bus in can.bus -%} {{ last_sent_def(bus, bus, bus.name) }} {%- endfor -%} @@ -28,7 +28,7 @@ extern Message_T** messages[static_cast(Bus_Names_T::INVALID_NAME)]; using namespace CANlib; -static uint32_t Identify_internal(const uint32_t key, const Frame& frame, int l, int r, int bus_idx) { +static uint32_t identify_internal(const uint32_t key, const Frame& frame, int l, int r, int bus_idx) { for (int i = l;i <= r;++i) { if (keys[bus_idx][i] == key) { int left_bound = frame_id_range[bus_idx][i].first; @@ -36,7 +36,7 @@ static uint32_t Identify_internal(const uint32_t key, const Frame& frame, int l, if (left_bound <= right_bound) { uint64_t bitstring; to_bitstring((uint8_t*)frame.data, &bitstring); - return Identify_internal(EXTRACT(bitstring, left_bound, right_bound), frame, i + 1, i + 1 + frame_len[bus_idx][i], bus_idx); + return identify_internal(EXTRACT(bitstring, left_bound, right_bound), frame, i + 1, i + 1 + frame_len[bus_idx][i], bus_idx); } else { return i; } @@ -46,17 +46,17 @@ static uint32_t Identify_internal(const uint32_t key, const Frame& frame, int l, } -uint32_t CANlib::Identify(Bus_Names_T bus, const Frame& frame) { +uint32_t CANlib::identify(AbstractBus bus, const Frame& frame) { const int bus_idx = static_cast(bus); - return Identify_internal(frame.id, frame, 1, can_size[bus_idx] - 1, bus_idx); + return identify_internal(frame.id, frame, 1, can_size[bus_idx] - 1, bus_idx); } -void CANlib::HandleFrame(Bus_Names_T bus_name, const Frame& frame) { - if (bus_name == Bus_Names_T::INVALID_NAME) { +void CANlib::handle_frame(AbstractBus bus_name, const Frame& frame) { + if (bus_name == AbstractBus::INVALID_NAME) { return; } - uint32_t message_idx = Identify(bus_name, frame); + uint32_t message_idx = identify(bus_name, frame); uint32_t bus_idx = static_cast(bus_name); if (message_idx > 0) { messages[bus_idx][message_idx]->pack(frame); diff --git a/generator/templates/bus.hpp.j2 b/generator/templates/bus.hpp.j2 index 150e782..4d196db 100644 --- a/generator/templates/bus.hpp.j2 +++ b/generator/templates/bus.hpp.j2 @@ -15,20 +15,20 @@ namespace CANlib { -enum class Bus_Names_T { +enum class AbstractBus { {%- for bus in can.bus %} {{ bus.name }}, {%- endfor %} INVALID_NAME, }; -uint32_t Identify(Bus_Names_T, const Frame&); -void HandleFrame(Bus_Names_T, const Frame&); +uint32_t identify(AbstractBus, const Frame&); +void handle_frame(AbstractBus, const Frame&); {% for bus in can.bus %} namespace {{bus.name}} { {%- set ns.first_frame = true %} - enum class Message_Type_T { + enum class MessageType { UNKNOWN_MSG = 0, {%- for msg in bus.frame -%} {{- enum_name(msg) }} diff --git a/generator/templates/computer.cpp.j2 b/generator/templates/computer.cpp.j2 index 83d5ddf..4deb305 100644 --- a/generator/templates/computer.cpp.j2 +++ b/generator/templates/computer.cpp.j2 @@ -4,53 +4,42 @@ using namespace CANlib; -{% if testing %} -Raw_Bus_T CANlib::GetRawBus(Bus_Names_T bus) { -{% else %} -Raw_Bus_T CANlib::GetRawBus(Bus_Names_T bus) { -{% endif %} - switch (bus) { +RawBus CANlib::get_raw_bus(AbstractBus bus_name) { + switch (bus_name) { {%- for busnm, rawnm in computer.participation['name']['can'].mapping.items() %} - case Bus_Names_T::{{ busnm }}: - return Raw_Bus_T::{{ rawnm }}; + case AbstractBus::{{ busnm }}: + return RawBus::{{ rawnm }}; {%- endfor %} default: - return Raw_Bus_T::INVALID_BUS; + return RawBus::INVALID_BUS; } } -{% if testing %} -Bus_Names_T CANlib::GetBusName(Raw_Bus_T bus) { -{% else %} -Bus_Names_T CANlib::GetBusName(Raw_Bus_T bus) { -{% endif %} +AbstractBus CANlib::get_bus_name(RawBus bus) { switch (bus) { {%- for busnm, rawnm in computer.participation['name']['can'].mapping.items() %} - case Raw_Bus_T::{{ rawnm }}: - return Bus_Names_T::{{ busnm }}; + case RawBus::{{ rawnm }}: + return AbstractBus::{{ busnm }}; {%- endfor %} default: - return Bus_Names_T::INVALID_NAME; + return AbstractBus::INVALID_NAME; } } -namespace CANlib { {%- for busnm, rawnm in computer.participation['name']['can'].mapping.items() %} {% if testing %} -void {{busnm}}_update_can() { +void CANlib::{{busnm}}_update_can() { {% else %} -static void {{busnm}}_update_can() { +static void CANlib::{{busnm}}_update_can() { {% endif %} Frame frame; - ReadFrame(frame, Bus_Names_T::{{ busnm }}); - HandleFrame(Bus_Names_T::{{busnm}}, frame); + read_frame(frame, AbstractBus::{{ busnm }}); + handle_frame(AbstractBus::{{busnm}}, frame); } {%- endfor %} -void update_can(void) { +void CANlib::update_can(void) { {%- for busnm in computer.participation['name']['can'].subscribe.keys() %} {{ busnm }}_update_can(); {%- endfor %} } -} - diff --git a/generator/templates/computer.hpp.j2 b/generator/templates/computer.hpp.j2 index 62c96f3..8c7b6b6 100644 --- a/generator/templates/computer.hpp.j2 +++ b/generator/templates/computer.hpp.j2 @@ -11,10 +11,14 @@ namespace CANlib { {%- if testing -%} {%- for busnm, rawnm in computer.participation['name']['can'].mapping.items() %} - void {{busnm}}_update_can(); + void {{busnm}}_update_can(); + {%- endfor %} + {% else %} + {%- for busnm, rawnm in computer.participation['name']['can'].mapping.items() %} + static void {{busnm}}_update_can(); {%- endfor %} {% endif %} - void update_can(void); - Raw_Bus_T GetRawBus(Bus_Names_T bus); - Bus_Names_T GetBusName(Raw_Bus_T bus); + void update_can(); + RawBus get_raw_bus(AbstractBus bus_name); + AbstractBus get_bus_name(RawBus bus); } diff --git a/generator/templates/drivers/inc/testfamily.hpp.j2 b/generator/templates/drivers/inc/testfamily.hpp.j2 index af2941e..ff7cddc 100644 --- a/generator/templates/drivers/inc/testfamily.hpp.j2 +++ b/generator/templates/drivers/inc/testfamily.hpp.j2 @@ -28,21 +28,21 @@ protected: Frame frame_to_send; }; -enum class Raw_Bus_T { +enum class RawBus { {%- for bus in architecture.participation['name']['can'].buses -%} {%- if bus == 'INVALID_BUS' -%} {%- raise "INVALID_BUS is a reserved bus name" -%} {%- endif %} {{ bus }}, {%- endfor %} - INVALID_BUS + INVALID_BUS, }; -typedef bool Transmit_Error_T; +typedef bool TransmitError; -Transmit_Error_T TransmitFrame(const Frame& frame, Bus_Names_T bus); -void ReadFrame(Frame& frame, Bus_Names_T bus); -Raw_Bus_T GetRawBus(Bus_Names_T); -Bus_Names_T GetBusName(Raw_Bus_T); +TransmitError transmit_frame(const Frame& frame, AbstractBus bus_name); +void read_frame(Frame& frame, AbstractBus bus_name); +RawBus get_raw_bus(AbstractBus); +AbstractBus get_bus_name(RawBus); } // CANlib diff --git a/generator/templates/structs.cpp.j2 b/generator/templates/structs.cpp.j2 index 2355964..4de8010 100644 --- a/generator/templates/structs.cpp.j2 +++ b/generator/templates/structs.cpp.j2 @@ -13,12 +13,12 @@ {%- macro get_message_type(bus, msg, msg_names) -%} {%- if msg.frame is defined -%} - {{bus.name}}::Message_Type_T::UNKNOWN_MSG, + MessageType::UNKNOWN_MSG, {%- for sub_frame in msg.frame -%} {{ get_message_type(bus, sub_frame, msg_names + [sub_frame.name]) }} {%- endfor -%} {%- else -%} - Message_Type_T::{{'_'.join(msg_names)}}, + MessageType::{{'_'.join(msg_names)}}, {%- endif -%} {%- endmacro -%} @@ -80,14 +80,14 @@ void send(Clock::time_point &last_sent_, Message_T* msg) { last_sent_ = Clock::now(); Frame frame; msg->unpack(frame); - TransmitFrame(frame, msg->get_bus_name()); + transmit_frame(frame, msg->get_bus_name()); } } void send(Message_T* msg) { Frame frame; msg->unpack(frame); - TransmitFrame(frame, msg->get_bus_name()); + transmit_frame(frame, msg->get_bus_name()); } {%- for bus in can.bus %} @@ -96,8 +96,8 @@ namespace {{bus.name}} { {{ struct_declarations(bus, msg, msg.name) }} {%- endfor -%} -extern const Message_Type_T message_types[{{get_msg_len(bus)}}] = { - Message_Type_T::UNKNOWN_MSG, +extern const MessageType message_types[{{get_msg_len(bus)}}] = { + MessageType::UNKNOWN_MSG, {% for msg in bus.frame -%} {{ get_message_type(bus, msg, [msg.name]) }} {%- endfor -%} @@ -134,31 +134,31 @@ Message_T* {{bus.name}}_messages[] = { }; {%- endfor -%} -const uint32_t* keys[static_cast(Bus_Names_T::INVALID_NAME)] = { +const uint32_t* keys[static_cast(AbstractBus::INVALID_NAME)] = { {%- for bus in can.bus -%} {{bus.name}}_keys, {%- endfor -%} }; -const std::pair* frame_id_range[static_cast(Bus_Names_T::INVALID_NAME)] = { +const std::pair* frame_id_range[static_cast(AbstractBus::INVALID_NAME)] = { {%- for bus in can.bus -%} {{bus.name}}_frame_id_range, {%- endfor -%} }; -const uint32_t* frame_len[static_cast(Bus_Names_T::INVALID_NAME)] = { +const uint32_t* frame_len[static_cast(AbstractBus::INVALID_NAME)] = { {%- for bus in can.bus -%} {{bus.name}}_frame_len, {%- endfor -%} }; -extern const size_t can_size[static_cast(Bus_Names_T::INVALID_NAME)] = { +extern const size_t can_size[static_cast(AbstractBus::INVALID_NAME)] = { {%- for bus in can.bus -%} {{ get_msg_len(bus) }}, {%- endfor -%} }; -Message_T** messages[static_cast(Bus_Names_T::INVALID_NAME)] = { +Message_T** messages[static_cast(AbstractBus::INVALID_NAME)] = { {%- for bus in can.bus -%} {{bus.name}}_messages, {%- endfor -%} diff --git a/generator/templates/structs.hpp.j2 b/generator/templates/structs.hpp.j2 index fffd326..695aad7 100644 --- a/generator/templates/structs.hpp.j2 +++ b/generator/templates/structs.hpp.j2 @@ -17,8 +17,8 @@ void send() override { CANlib::send(this->last_sent_, this); } - Bus_Names_T get_bus_name() override { - return Bus_Names_T::{{ bus.name }}; + AbstractBus get_bus_name() override { + return AbstractBus::{{ bus.name }}; } Clock::duration get_period() override { {% if msg.period %} @@ -103,7 +103,7 @@ struct Message_T { virtual void pack(const Frame&) = 0; virtual uint32_t get_key() = 0; virtual void send() = 0; - virtual Bus_Names_T get_bus_name() = 0; + virtual AbstractBus get_bus_name() = 0; virtual Clock::duration get_period() = 0; }; diff --git a/src/driver.hpp b/src/driver.hpp deleted file mode 100644 index 61517da..0000000 --- a/src/driver.hpp +++ /dev/null @@ -1,24 +0,0 @@ -#pragma once - -// INCLUDE THIS AFTER YOUR DRIVER - -//#if !(CANLIB_ARCH_STM32F4XX || CANLIB_ARCH_STM32F2XX || CANLIB_ARCH_TESTFAMILY) -//#error "No architecture specified!" -//#endif - -#ifdef CANLIB_ARCH_STM32F4xx -#include "drivers/inc/stm32f4xx.hpp" -#elif defined(CANLIB_ARCH_STM32F2XX) -#include "drivers/inc/stm32f2xx.hpp" -#elif defined(CANLIB_ARCH_TESTFAMILY) -#include "drivers/inc/testfamily.hpp" -#else -#error "No architecture specified!" -#endif - -#include "bus.hpp" - -namespace CANlib { - Transmit_Error_T TransmitFrame(const Frame &frame, Bus_Names_T bus); - void ReadFrame(Frame &frame, Bus_Names_T bus); -} diff --git a/src/drivers/src/stm32f2xx.cpp b/src/drivers/src/stm32f2xx.cpp deleted file mode 100644 index 5831517..0000000 --- a/src/drivers/src/stm32f2xx.cpp +++ /dev/null @@ -1,99 +0,0 @@ -#ifdef CANLIB_ARCH_STM32F2XX -#include "static.hpp" - -#include -#include "stm32f2xx_hal_can.h" - -CAN_HandleTypeDef CanHandle; - -HAL_StatusTypeDef CANlib_Init(uint32_t baudrate) { - // TODO calculate baudrate and set stuff accordingly - // Right now the baudrate is hard-coded to 500kbaud - // Can change prescaler to change this - // 2 Mbaud / prescaler = baudrate (prescaler goes from 1 to 1024) - - CAN_FilterConfTypeDef sFilterConfig; - static CanTxMsgTypeDef TxMessage; - static CanRxMsgTypeDef RxMessage; - - CanHandle.Instance = CAN1; - CanHandle.pTxMsg = &TxMessage; - CanHandle.pRxMsg = &RxMessage; - - CanHandle.Init.TTCM = DISABLE; - CanHandle.Init.ABOM = DISABLE; - CanHandle.Init.AWUM = DISABLE; - CanHandle.Init.NART = DISABLE; - CanHandle.Init.RFLM = DISABLE; - CanHandle.Init.TXFP = DISABLE; - CanHandle.Init.Mode = CAN_MODE_NORMAL; - CanHandle.Init.SJW = CAN_SJW_1TQ; - CanHandle.Init.BS1 = CAN_BS1_6TQ; - CanHandle.Init.BS2 = CAN_BS2_8TQ; - CanHandle.Init.Prescaler = 4; - - HAL_StatusTypeDef status; - - if ((status = HAL_CAN_Init(&CanHandle)) != HAL_OK) { - /* Initialization Error */ - - printf("[CAN INIT] ERROR\r\n"); - return status; - } - - // TODO: Might want to comment this out - sFilterConfig.FilterNumber = 0; - sFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK; - sFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT; - sFilterConfig.FilterIdHigh = 0x0000; - sFilterConfig.FilterIdLow = 0x0000; - sFilterConfig.FilterMaskIdHigh = 0x0000; - sFilterConfig.FilterMaskIdLow = 0x0000; - sFilterConfig.FilterFIFOAssignment = 0; - sFilterConfig.FilterActivation = ENABLE; - sFilterConfig.BankNumber = 14; - - if ((status = HAL_CAN_ConfigFilter(&CanHandle, &sFilterConfig)) != HAL_OK) { - return status; - } - - if ((status = HAL_CAN_Receive_IT(&CanHandle, CAN_FIFO0)) != HAL_OK) { - return status; - } - - return HAL_OK; -} - -HAL_StatusTypeDef CANlib_TransmitFrame(Frame *frame) { - if (frame->extended) { - CanHandle.pTxMsg->ExtId = frame->id; - CanHandle.pTxMsg->IDE = CAN_ID_EXT; - } else { - CanHandle.pTxMsg->StdId = frame->id; - CanHandle.pTxMsg->IDE = CAN_ID_STD; - } - - CanHandle.pTxMsg->DLC = frame->len; - CanHandle.pTxMsg->RTR = CAN_RTR_DATA; - - memcpy(CanHandle.pTxMsg->Data, frame->data, sizeof(frame->data)); - - __disable_irq(); - HAL_StatusTypeDef CAN_TX_STATUS = HAL_CAN_Transmit_IT(&CanHandle); - __enable_irq(); - - if (CAN_TX_STATUS != HAL_OK) { - // TODO handle error - printf("[CAN TX] ERROR: HAL_StatusTypeDef is %d\r\n", (int)CAN_TX_STATUS); - printf("[CAN TX] ERROR: HAL_CAN_StateTypeDef is %d\r\n", CanHandle.State); - printf("[CAN TX] ERROR: ErrorCode is %d\r\n", CanHandle.ErrorCode); - - return CAN_TX_STATUS; - } - - // ~HACK~ - HAL_CAN_Receive_IT(&CanHandle, CAN_FIFO0); - - return HAL_OK; -} -#endif diff --git a/src/drivers/src/stm32f4xx.cpp b/src/drivers/src/stm32f4xx.cpp deleted file mode 100644 index ff0a189..0000000 --- a/src/drivers/src/stm32f4xx.cpp +++ /dev/null @@ -1,88 +0,0 @@ -#ifdef CANLIB_ARCH_STM32F4XX -#include "static.h" - -#include -#include -#include "bus.h" -#include "driver.h" -#include "drivers/inc/stm32f4xx.hpp" -#include "stm32f4xx_hal.h" -#ifdef USING_LOGGING_CALLBACK -#include "log.h" -#endif - -extern CAN_HandleTypeDef hcan1; -extern CAN_HandleTypeDef hcan2; -extern CAN_HandleTypeDef hcan3; - -using namespace CANlib; - -Transmit_Error_T CANlib::TransmitFrame(const Frame &frame, Bus_Names_T bus_name) { - Raw_Bus_T raw_bus = GetRawBus(bus); - int bus_num; - CAN_HandleTypeDef *hcan; - switch (raw_bus) { - case CAN_1: - hcan = &hcan1; - bus_num = 1; - break; - case CAN_2: - hcan = &hcan2; - bus_num = 2; - break; - case CAN_3: - hcan = &hcan3; - bus_num = 3; - break; - default: - return HAL_ERROR; - } - - CAN_TxHeaderTypeDef pHeader; - uint32_t pTxMailbox = 0; - - pHeader.DLC = frame.dlc; - pHeader.StdId = frame.id; - pHeader.IDE = frame.extended ? CAN_ID_EXT : CAN_ID_STD; - pHeader.RTR = CAN_RTR_DATA; // Data frame (as opposed to a remote frame) - pHeader.TransmitGlobalTime = DISABLE; // Don't replace last 2 bytes of data with TX time. -#ifdef USING_LOGGING_CALLBACK - log_frame(frame, bus_num); -#else - UNUSED(bus_num); -#endif - return HAL_CAN_AddTxMessage(hcan, &pHeader, frame.data, &pTxMailbox); -} - -void ReadFrame(Frame &frame, Bus_Names_T bus) { - Raw_Bus_T raw_bus = 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; - } - - 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; - } - } -} -#endif diff --git a/src/drivers/src/testfamily.cpp b/src/drivers/src/testfamily.cpp deleted file mode 100644 index 3abd49b..0000000 --- a/src/drivers/src/testfamily.cpp +++ /dev/null @@ -1,57 +0,0 @@ -#ifdef CANLIB_ARCH_TESTFAMILY -#include "static.h" - -#include -#include -#include "bus.hpp" -#include "driver.hpp" -#include "drivers/inc/testfamily.hpp" - -using namespace CANlib; - -CAN can1; -CAN can2; -CAN can3; - -Clock::time_point Clock::now() noexcept { - static const auto start_time = std::chrono::system_clock::now(); - const auto time_passed = std::choron::system_clock::now() - start_time; - return time_point(std::chrono::milliseconds(time_passed)); -} - -Transmit_Error_T CANlib::TransmitFrame(const Frame &frame, Bus_Names_T bus_name) { - Raw_Bus_T raw_bus = GetRawBus(bus); - switch (raw_bus) { - case CAN_1: - can1.receiveFrame(frame); - break; - case CAN_2: - can2.receiveFrame(frame); - break; - case CAN_3: - can3.receiveFrame(frame); - break; - default: - return true; - } - - return false; -} - -void CANLib::ReadFrame(Frame &frame, Bus_Names_T bus) { - Raw_Bus_T raw_bus = GetRawBus(bus); - switch (raw_bus) { - case CAN_1: - frame = can1.frameToSend(); - break; - case CAN_2: - frame = can2.frameToSend(); - break; - case CAN_3: - frame = can3.frameToSend(); - break; - default: - return; - } -} -#endif diff --git a/src/clock.hpp b/src/inc/clock.hpp similarity index 99% rename from src/clock.hpp rename to src/inc/clock.hpp index 1da4c7e..f36eda4 100644 --- a/src/clock.hpp +++ b/src/inc/clock.hpp @@ -18,5 +18,5 @@ struct Clock { static constexpr bool is_steady = true; }; - + } // namespace CANlib diff --git a/src/inc/driver.hpp b/src/inc/driver.hpp index b9426f0..ae1e97c 100644 --- a/src/inc/driver.hpp +++ b/src/inc/driver.hpp @@ -19,6 +19,6 @@ #include "bus.hpp" namespace CANlib { -Transmit_Error_T TransmitFrame(const Frame &frame, Bus_Names_T bus); -void ReadFrame(Frame &frame, Raw_Bus_T bus); +TransmitError transmit_frame(const Frame &frame, AbstractBus bus_name); +void read_frame(Frame &frame, RawBus bus); } // namespace CANlib diff --git a/src/src/drivers/stm32f4xx.cpp b/src/src/drivers/stm32f4xx.cpp index ff0a189..410e32f 100644 --- a/src/src/drivers/stm32f4xx.cpp +++ b/src/src/drivers/stm32f4xx.cpp @@ -17,8 +17,8 @@ extern CAN_HandleTypeDef hcan3; using namespace CANlib; -Transmit_Error_T CANlib::TransmitFrame(const Frame &frame, Bus_Names_T bus_name) { - Raw_Bus_T raw_bus = GetRawBus(bus); +TransmitError CANlib::TransmitFrame(const Frame &frame, AbstractBus bus_name) { + RawBus raw_bus = GetRawBus(bus); int bus_num; CAN_HandleTypeDef *hcan; switch (raw_bus) { @@ -54,8 +54,8 @@ Transmit_Error_T CANlib::TransmitFrame(const Frame &frame, Bus_Names_T bus_name) return HAL_CAN_AddTxMessage(hcan, &pHeader, frame.data, &pTxMailbox); } -void ReadFrame(Frame &frame, Bus_Names_T bus) { - Raw_Bus_T raw_bus = GetRawBus(bus); +void ReadFrame(Frame &frame, AbstractBus bus_name) { + RawBus raw_bus = GetRawBus(bus_name); CAN_HandleTypeDef *hcan; switch (raw_bus) { case CAN_1: diff --git a/src/src/drivers/testfamily.cpp b/src/src/drivers/testfamily.cpp index 8c063d8..76e1ba2 100644 --- a/src/src/drivers/testfamily.cpp +++ b/src/src/drivers/testfamily.cpp @@ -21,15 +21,15 @@ Clock::time_point Clock::now() noexcept { return time_point(std::chrono::milliseconds(us.count())); } -Transmit_Error_T CANlib::TransmitFrame(const Frame &frame, Bus_Names_T bus_name) { - switch (GetRawBus(bus_name)) { - case Raw_Bus_T::CAN_1: +TransmitError CANlib::transmit_frame(const Frame &frame, AbstractBus bus_name) { + switch (get_raw_bus(bus_name)) { + case RawBus::CAN_1: can1.receiveFrame(frame); break; - case Raw_Bus_T::CAN_2: + case RawBus::CAN_2: can2.receiveFrame(frame); break; - case Raw_Bus_T::CAN_3: + case RawBus::CAN_3: can3.receiveFrame(frame); break; default: @@ -39,15 +39,15 @@ Transmit_Error_T CANlib::TransmitFrame(const Frame &frame, Bus_Names_T bus_name) return false; } -void CANlib::ReadFrame(Frame &frame, Bus_Names_T bus_name) { - switch (GetRawBus(bus_name)) { - case Raw_Bus_T::CAN_1: +void CANlib::read_frame(Frame &frame, AbstractBus bus_name) { + switch (get_raw_bus(bus_name)) { + case RawBus::CAN_1: frame = can1.frameToSend(); break; - case Raw_Bus_T::CAN_2: + case RawBus::CAN_2: frame = can2.frameToSend(); break; - case Raw_Bus_T::CAN_3: + case RawBus::CAN_3: frame = can3.frameToSend(); break; default: diff --git a/src/static.hpp b/src/static.hpp deleted file mode 100644 index e4a2b46..0000000 --- a/src/static.hpp +++ /dev/null @@ -1,11 +0,0 @@ -#pragma once - -#include -#include - -struct Frame { - uint32_t id; - uint8_t data[8]; - uint8_t dlc; - bool extended; -}; diff --git a/test/tests/src/arch0.cpp b/test/tests/src/arch0.cpp index e199887..5aaab0d 100644 --- a/test/tests/src/arch0.cpp +++ b/test/tests/src/arch0.cpp @@ -21,13 +21,13 @@ extern CAN can2; extern CAN can3; void testArch() { - assert(GetRawBus(Bus_Names_T::map1) == Raw_Bus_T::CAN_2); - assert(GetRawBus(Bus_Names_T::map2) == Raw_Bus_T::CAN_1); - assert(GetRawBus(Bus_Names_T::INVALID_NAME) == Raw_Bus_T::INVALID_BUS); - assert(GetBusName(Raw_Bus_T::CAN_2) == Bus_Names_T::map1); - assert(GetBusName(Raw_Bus_T::CAN_1) == Bus_Names_T::map2); - assert(GetBusName(Raw_Bus_T::CAN_3) == Bus_Names_T::INVALID_NAME); - assert(GetBusName(Raw_Bus_T::INVALID_BUS) == Bus_Names_T::INVALID_NAME); + assert(get_raw_bus(AbstractBus::map1) == RawBus::CAN_2); + assert(get_raw_bus(AbstractBus::map2) == RawBus::CAN_1); + assert(get_raw_bus(AbstractBus::INVALID_NAME) == RawBus::INVALID_BUS); + assert(get_bus_name(RawBus::CAN_2) == AbstractBus::map1); + assert(get_bus_name(RawBus::CAN_1) == AbstractBus::map2); + assert(get_bus_name(RawBus::CAN_3) == AbstractBus::INVALID_NAME); + assert(get_bus_name(RawBus::INVALID_BUS) == AbstractBus::INVALID_NAME); can1.clear(); can2.clear(); can3.clear(); diff --git a/test/tests/src/arch1.cpp b/test/tests/src/arch1.cpp index 6afebe9..f642bd1 100644 --- a/test/tests/src/arch1.cpp +++ b/test/tests/src/arch1.cpp @@ -20,13 +20,13 @@ extern CAN can2; extern CAN can3; void testArch() { - assert(GetRawBus(Bus_Names_T::map1) == Raw_Bus_T::CAN_2); - assert(GetRawBus(Bus_Names_T::map2) == Raw_Bus_T::CAN_3); - assert(GetRawBus(Bus_Names_T::INVALID_NAME) == Raw_Bus_T::INVALID_BUS); - assert(GetBusName(Raw_Bus_T::CAN_2) == Bus_Names_T::map1); - assert(GetBusName(Raw_Bus_T::CAN_3) == Bus_Names_T::map2); - assert(GetBusName(Raw_Bus_T::CAN_1) == Bus_Names_T::INVALID_NAME); - assert(GetBusName(Raw_Bus_T::INVALID_BUS) == Bus_Names_T::INVALID_NAME); + assert(get_raw_bus(AbstractBus::map1) == RawBus::CAN_2); + assert(get_raw_bus(AbstractBus::map2) == RawBus::CAN_3); + assert(get_raw_bus(AbstractBus::INVALID_NAME) == RawBus::INVALID_BUS); + assert(get_bus_name(RawBus::CAN_2) == AbstractBus::map1); + assert(get_bus_name(RawBus::CAN_3) == AbstractBus::map2); + assert(get_bus_name(RawBus::CAN_1) == AbstractBus::INVALID_NAME); + assert(get_bus_name(RawBus::INVALID_BUS) == AbstractBus::INVALID_NAME); can1.clear(); can2.clear(); can3.clear(); diff --git a/test/tests/src/arch2.cpp b/test/tests/src/arch2.cpp index bfa8f8e..c8d4b77 100644 --- a/test/tests/src/arch2.cpp +++ b/test/tests/src/arch2.cpp @@ -20,13 +20,13 @@ extern CAN can2; extern CAN can3; void testArch() { - assert(GetRawBus(Bus_Names_T::map1) == Raw_Bus_T::CAN_3); - assert(GetRawBus(Bus_Names_T::map2) == Raw_Bus_T::CAN_1); - assert(GetRawBus(Bus_Names_T::INVALID_NAME) == Raw_Bus_T::INVALID_BUS); - assert(GetBusName(Raw_Bus_T::CAN_3) == Bus_Names_T::map1); - assert(GetBusName(Raw_Bus_T::CAN_1) == Bus_Names_T::map2); - assert(GetBusName(Raw_Bus_T::CAN_2) == Bus_Names_T::INVALID_NAME); - assert(GetBusName(Raw_Bus_T::INVALID_BUS) == Bus_Names_T::INVALID_NAME); + assert(get_raw_bus(AbstractBus::map1) == RawBus::CAN_3); + assert(get_raw_bus(AbstractBus::map2) == RawBus::CAN_1); + assert(get_raw_bus(AbstractBus::INVALID_NAME) == RawBus::INVALID_BUS); + assert(get_bus_name(RawBus::CAN_3) == AbstractBus::map1); + assert(get_bus_name(RawBus::CAN_1) == AbstractBus::map2); + assert(get_bus_name(RawBus::CAN_2) == AbstractBus::INVALID_NAME); + assert(get_bus_name(RawBus::INVALID_BUS) == AbstractBus::INVALID_NAME); can1.clear(); can2.clear(); can3.clear(); diff --git a/test/tests/src/constants.cpp b/test/tests/src/constants.cpp index 95bac94..be7d9fe 100644 --- a/test/tests/src/constants.cpp +++ b/test/tests/src/constants.cpp @@ -4,10 +4,10 @@ namespace CANlib { namespace map1 { -extern Message_Type_T message_types[6]; +extern MessageType message_types[6]; } namespace map2 { -extern Message_Type_T message_types[28]; +extern MessageType message_types[28]; } } // namespace CANlib @@ -207,8 +207,8 @@ void testPeriod() { ID##_T ID##_input; \ Frame f; \ ID##_input.unpack(f); \ - int idx = Identify(Bus_Names_T::map##bus_idx, f); \ - assert(map##bus_idx::message_types[idx] == map##bus_idx::Message_Type_T::msg); \ + int idx = identify(AbstractBus::map##bus_idx, f); \ + assert(map##bus_idx::message_types[idx] == map##bus_idx::MessageType::msg); \ } CREATE_TEST(A, 1, 0X2FF, A) CREATE_TEST(B, 1, 0X305, B) @@ -305,34 +305,34 @@ void testBusNames() { map2::L_T L_input; map2::M_T M_input; map2::N_T N_input; - assert(A_input.get_bus_name() == Bus_Names_T::map1); - assert(B_input.get_bus_name() == Bus_Names_T::map1); - assert(C_input.get_bus_name() == Bus_Names_T::map1); - assert(D_input.get_bus_name() == Bus_Names_T::map1); - assert(E_input.get_bus_name() == Bus_Names_T::map1); - assert(F_input.get_bus_name() == Bus_Names_T::map2); - assert(G_input.get_bus_name() == Bus_Names_T::map2); - assert(H_input.get_bus_name() == Bus_Names_T::map2); - assert(I_input.get_bus_name() == Bus_Names_T::map2); - assert(AA_input.get_bus_name() == Bus_Names_T::map2); - assert(BB_input.get_bus_name() == Bus_Names_T::map2); - assert(AAA_input.get_bus_name() == Bus_Names_T::map2); - assert(BBB_input.get_bus_name() == Bus_Names_T::map2); - assert(CCC_input.get_bus_name() == Bus_Names_T::map2); - assert(DDD_input.get_bus_name() == Bus_Names_T::map2); - assert(DD_input.get_bus_name() == Bus_Names_T::map2); - assert(EE_input.get_bus_name() == Bus_Names_T::map2); - assert(FF_input.get_bus_name() == Bus_Names_T::map2); - assert(GG_input.get_bus_name() == Bus_Names_T::map2); - assert(HH_input.get_bus_name() == Bus_Names_T::map2); - assert(II_input.get_bus_name() == Bus_Names_T::map2); - assert(JJ_input.get_bus_name() == Bus_Names_T::map2); - assert(KK_input.get_bus_name() == Bus_Names_T::map2); - assert(LL_input.get_bus_name() == Bus_Names_T::map2); - assert(MM_input.get_bus_name() == Bus_Names_T::map2); - assert(NN_input.get_bus_name() == Bus_Names_T::map2); - assert(K_input.get_bus_name() == Bus_Names_T::map2); - assert(L_input.get_bus_name() == Bus_Names_T::map2); - assert(M_input.get_bus_name() == Bus_Names_T::map2); - assert(N_input.get_bus_name() == Bus_Names_T::map2); + assert(A_input.get_bus_name() == AbstractBus::map1); + assert(B_input.get_bus_name() == AbstractBus::map1); + assert(C_input.get_bus_name() == AbstractBus::map1); + assert(D_input.get_bus_name() == AbstractBus::map1); + assert(E_input.get_bus_name() == AbstractBus::map1); + assert(F_input.get_bus_name() == AbstractBus::map2); + assert(G_input.get_bus_name() == AbstractBus::map2); + assert(H_input.get_bus_name() == AbstractBus::map2); + assert(I_input.get_bus_name() == AbstractBus::map2); + assert(AA_input.get_bus_name() == AbstractBus::map2); + assert(BB_input.get_bus_name() == AbstractBus::map2); + assert(AAA_input.get_bus_name() == AbstractBus::map2); + assert(BBB_input.get_bus_name() == AbstractBus::map2); + assert(CCC_input.get_bus_name() == AbstractBus::map2); + assert(DDD_input.get_bus_name() == AbstractBus::map2); + assert(DD_input.get_bus_name() == AbstractBus::map2); + assert(EE_input.get_bus_name() == AbstractBus::map2); + assert(FF_input.get_bus_name() == AbstractBus::map2); + assert(GG_input.get_bus_name() == AbstractBus::map2); + assert(HH_input.get_bus_name() == AbstractBus::map2); + assert(II_input.get_bus_name() == AbstractBus::map2); + assert(JJ_input.get_bus_name() == AbstractBus::map2); + assert(KK_input.get_bus_name() == AbstractBus::map2); + assert(LL_input.get_bus_name() == AbstractBus::map2); + assert(MM_input.get_bus_name() == AbstractBus::map2); + assert(NN_input.get_bus_name() == AbstractBus::map2); + assert(K_input.get_bus_name() == AbstractBus::map2); + assert(L_input.get_bus_name() == AbstractBus::map2); + assert(M_input.get_bus_name() == AbstractBus::map2); + assert(N_input.get_bus_name() == AbstractBus::map2); } diff --git a/test/tests/src/identify.cpp b/test/tests/src/identify.cpp index b28cffb..a76a93f 100644 --- a/test/tests/src/identify.cpp +++ b/test/tests/src/identify.cpp @@ -21,7 +21,7 @@ using namespace CC; f.data[i] = distribution(generator); \ } \ f.id = key; \ - int idx = Identify(Bus_Names_T::map##bus_idx, f); \ + int idx = identify(AbstractBus::map##bus_idx, f); \ Message_T *msg = messages[bus_idx - 1][idx]; \ assert((dynamic_cast(msg)) != nullptr); \ } \ @@ -32,7 +32,7 @@ using namespace CC; ID##_T ID##_input; \ Frame f; \ ID##_input.unpack(f); \ - int idx = Identify(Bus_Names_T::map##bus_idx, f); \ + int idx = identify(AbstractBus::map##bus_idx, f); \ Message_T *msg = messages[bus_idx - 1][idx]; \ assert((dynamic_cast(msg)) != nullptr); \ } From 7a521167568134da61b525deb271014ec114f333 Mon Sep 17 00:00:00 2001 From: Gabriel Cojocaru Date: Sun, 25 Apr 2021 16:27:16 +0300 Subject: [PATCH 04/17] replaced array size from INVALID_NAME to number --- generator/main.py | 21 ++++++++++++--------- generator/templates/bus.cpp.j2 | 10 +++++----- generator/templates/structs.cpp.j2 | 10 +++++----- test/Makefile | 1 + 4 files changed, 23 insertions(+), 19 deletions(-) diff --git a/generator/main.py b/generator/main.py index f8bf2d9..a0143b6 100644 --- a/generator/main.py +++ b/generator/main.py @@ -39,6 +39,9 @@ def get_msg_len(msg): return 1 + sum([get_msg_len(sub_frame) for sub_frame in msg.frame]) return 1 +def get_len(can): + return len(can.bus) + # FROM: https://github.com/duelafn/python-jinja2-apci/blob/master/jinja2_apci/error.py class RaiseExtension(Extension): # This is our keyword(s): @@ -67,9 +70,9 @@ def render_template_from_to(env, input_path, output_path): template = env.get_template(str(input_path)) with open(output_path, 'w') as f: if output_path in [inc_dir.joinpath("structs.hpp"), src_dir.joinpath("structs.cpp")]: - f.write(template.render(get_ms = get_ms, get_msg_len = get_msg_len)) + f.write(template.render(get_len = get_len, get_ms = get_ms, get_msg_len = get_msg_len)) else: - f.write(template.render()) + f.write(template.render(get_len = get_len)) def render_template(env, relative_path): if relative_path.endswith('hpp') or relative_path.endswith('h'): @@ -79,12 +82,14 @@ def render_template(env, relative_path): if __name__ == '__main__': + pth = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..') + spth = str(pth) if '--clean' in sys.argv: - os.system("rm src/inc/computers/*.hpp") - os.system("rm src/inc/drivers/*.hpp") - os.system("rm src/inc/bus.hpp src/inc/pack_unpack.hpp src/inc/structs.hpp") - os.system("rm src/src/computers/*.cpp") - os.system("rm src/src/bus.cpp src/src/pack_unpack.cpp src/src/structs.cpp") + os.system("rm " + spth + "/src/inc/computers/*.hpp") + os.system("rm " + spth + "/src/inc/drivers/*.hpp") + os.system("rm " + spth + "/src/inc/bus.hpp " + spth + "/src/inc/pack_unpack.hpp " + spth + "/src/inc/structs.hpp") + os.system("rm " + spth + "/src/src/computers/*.cpp") + os.system("rm " + spth + "/src/src/bus.cpp " + spth + "/src/src/pack_unpack.cpp " + spth + "/src/src/structs.cpp") else: specpath = sys.argv[1] specfile = open(specpath, 'r') @@ -108,9 +113,7 @@ def render_template(env, relative_path): computers_hpp.write(template_env, system.computer, computer_hpp_template_path, computer_hpp_dir_path, testing) computers_cpp.write(template_env, system.computer, computer_cpp_template_path, computer_cpp_dir_path, testing) drivers_inc.write(template_env, system, drivers_inc_template_dir_path, drivers_inc_dir_path, testing) - pth = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..') try: - spth = str(pth) os.system('clang-format -i ' + spth + '/src/inc/drivers/*.hpp ' + spth + '/src/src/drivers/*.cpp') os.system('clang-format -i ' + spth + '/src/inc/computers/*.hpp ' + spth + '/src/src/computers/*.cpp') os.system('clang-format -i ' + spth + '/src/inc/*.hpp') diff --git a/generator/templates/bus.cpp.j2 b/generator/templates/bus.cpp.j2 index d3156e1..6c97bcb 100644 --- a/generator/templates/bus.cpp.j2 +++ b/generator/templates/bus.cpp.j2 @@ -16,11 +16,11 @@ #include "pack_unpack.hpp" namespace CANlib { -extern const std::pair* frame_id_range[static_cast(AbstractBus::INVALID_NAME)]; -extern const uint32_t* frame_len[static_cast(AbstractBus::INVALID_NAME)]; -extern const uint32_t* keys[static_cast(AbstractBus::INVALID_NAME)]; -extern const size_t can_size[static_cast(AbstractBus::INVALID_NAME)]; -extern Message_T** messages[static_cast(AbstractBus::INVALID_NAME)]; +extern const std::pair* frame_id_range[{{ get_len(can) }}]; +extern const uint32_t* frame_len[{{ get_len(can) }}]; +extern const uint32_t* keys[{{ get_len(can) }}]; +extern const size_t can_size[{{ get_len(can) }}]; +extern Message_T** messages[{{ get_len(can) }}]; {%- for bus in can.bus -%} {{ last_sent_def(bus, bus, bus.name) }} {%- endfor -%} diff --git a/generator/templates/structs.cpp.j2 b/generator/templates/structs.cpp.j2 index 4de8010..0961141 100644 --- a/generator/templates/structs.cpp.j2 +++ b/generator/templates/structs.cpp.j2 @@ -134,31 +134,31 @@ Message_T* {{bus.name}}_messages[] = { }; {%- endfor -%} -const uint32_t* keys[static_cast(AbstractBus::INVALID_NAME)] = { +const uint32_t* keys[{{ get_len(can) }}] = { {%- for bus in can.bus -%} {{bus.name}}_keys, {%- endfor -%} }; -const std::pair* frame_id_range[static_cast(AbstractBus::INVALID_NAME)] = { +const std::pair* frame_id_range[{{ get_len(can) }}] = { {%- for bus in can.bus -%} {{bus.name}}_frame_id_range, {%- endfor -%} }; -const uint32_t* frame_len[static_cast(AbstractBus::INVALID_NAME)] = { +const uint32_t* frame_len[{{ get_len(can) }}] = { {%- for bus in can.bus -%} {{bus.name}}_frame_len, {%- endfor -%} }; -extern const size_t can_size[static_cast(AbstractBus::INVALID_NAME)] = { +extern const size_t can_size[{{ get_len(can) }}] = { {%- for bus in can.bus -%} {{ get_msg_len(bus) }}, {%- endfor -%} }; -Message_T** messages[static_cast(AbstractBus::INVALID_NAME)] = { +Message_T** messages[{{ get_len(can) }}] = { {%- for bus in can.bus -%} {{bus.name}}_messages, {%- endfor -%} diff --git a/test/Makefile b/test/Makefile index 800fd06..c45fdbc 100644 --- a/test/Makefile +++ b/test/Makefile @@ -89,6 +89,7 @@ $(BUILD_DIR)/src/src/computers/canlib_testcomp2.cpp.o: $(BUILD_DIR) .PHONY: clean build clean: + python3 ../generator/main.py --clean rm main0 main1 main2 build: main0 main1 main2 run: From 37e4314cb810c7a7d8fa3aea3c5a261124b04859 Mon Sep 17 00:00:00 2001 From: Gabriel Cojocaru Date: Sun, 25 Apr 2021 17:16:18 +0300 Subject: [PATCH 05/17] deleted _T --- generator/templates/bus.cpp.j2 | 4 +- .../templates/drivers/inc/stm32f4xx.hpp.j2 | 18 +- generator/templates/pack_unpack.cpp.j2 | 4 +- generator/templates/pack_unpack.hpp.j2 | 11 - generator/templates/structs.cpp.j2 | 18 +- generator/templates/structs.hpp.j2 | 11 +- src/src/drivers/stm32f4xx.cpp | 6 + test/tests/src/arch0.cpp | 10 +- test/tests/src/arch1.cpp | 10 +- test/tests/src/arch2.cpp | 10 +- test/tests/src/constants.cpp | 492 +++++++++--------- test/tests/src/identify.cpp | 44 +- test/tests/src/message.cpp | 6 +- test/tests/src/send.cpp | 54 +- 14 files changed, 344 insertions(+), 354 deletions(-) diff --git a/generator/templates/bus.cpp.j2 b/generator/templates/bus.cpp.j2 index 6c97bcb..8a8afc8 100644 --- a/generator/templates/bus.cpp.j2 +++ b/generator/templates/bus.cpp.j2 @@ -6,7 +6,7 @@ {{ last_sent_def(bus, sub_frame, msg_name + '::' + sub_frame.name) }} {% endfor %} {% else %} - Clock::time_point {{msg_name}}_T::last_sent_; + Clock::time_point {{msg_name}}::last_sent_; {% endif %} {%- endmacro -%} @@ -20,7 +20,7 @@ extern const std::pair* frame_id_range[{{ get_len(can) }}]; extern const uint32_t* frame_len[{{ get_len(can) }}]; extern const uint32_t* keys[{{ get_len(can) }}]; extern const size_t can_size[{{ get_len(can) }}]; -extern Message_T** messages[{{ get_len(can) }}]; +extern Message** messages[{{ get_len(can) }}]; {%- for bus in can.bus -%} {{ last_sent_def(bus, bus, bus.name) }} {%- endfor -%} diff --git a/generator/templates/drivers/inc/stm32f4xx.hpp.j2 b/generator/templates/drivers/inc/stm32f4xx.hpp.j2 index e76d2cc..d372cdc 100644 --- a/generator/templates/drivers/inc/stm32f4xx.hpp.j2 +++ b/generator/templates/drivers/inc/stm32f4xx.hpp.j2 @@ -7,28 +7,22 @@ #include -Clock::time_point Clock::now() noexcept { - static const auto start_time = HAL_GetTick(); - const auto time_passed = HAL_GetTick() - start_time; - return time_point(std::chrono::milliseconds(time_passed)); -} - namespace CANlib { -enum class Raw_Bus_T { +enum class RawBus { {%- for bus in architecture.participation['name']['can'].buses -%} {%- if bus == 'INVALID_BUS' -%} {%- raise "INVALID_BUS is a reserved bus name" -%} {%- endif %} {{ bus }}, {%- endfor %} - INVALID_BUS + INVALID_BUS, }; -typedef HAL_StatusTypeDef Transmit_Error_T; -typedef HAL_StatusTypeDef Init_Error_T; +typedef HAL_StatusTypeDef TransmitError; +typedef HAL_StatusTypeDef InitError; -Transmit_Error_T TransmitFrame(const Frame& frame, Bus_Names_T bus); -void ReadFrame(Frame& frame, Bus_Names_T bus); +TransmitError transmit_frame(const Frame& frame, AbstractBus bus_name); +void read_frame(Frame& frame, AbstractBus bus_name); } // CANlib diff --git a/generator/templates/pack_unpack.cpp.j2 b/generator/templates/pack_unpack.cpp.j2 index f8ad375..a734670 100644 --- a/generator/templates/pack_unpack.cpp.j2 +++ b/generator/templates/pack_unpack.cpp.j2 @@ -4,7 +4,7 @@ {{ can_pack_handler(sub_frame, name_prepends + [frame.name], bus_ext, parent_slices + [frame.slice]) }} {% endfor -%} {%- else -%} - {%- set name_prepends = name_prepends + [frame.name + '_T'] -%} + {%- set name_prepends = name_prepends + [frame.name] -%} {%- set tot_name = '::'.join(name_prepends) -%} void {{tot_name}}::unpack(Frame& can_out) { uint64_t bitstring = 0; @@ -32,7 +32,7 @@ {% endfor -%} {%- else -%} {%- set tot_name = "::".join(name_prepends) -%} - void {{ tot_name }}_T::pack(const Frame& can_in) { + void {{ tot_name }}::pack(const Frame& can_in) { uint64_t bitstring = 0; to_bitstring((uint8_t*)can_in.data, &bitstring); {%- for atom in frame.atom %} diff --git a/generator/templates/pack_unpack.hpp.j2 b/generator/templates/pack_unpack.hpp.j2 index dea7e0a..0619d37 100644 --- a/generator/templates/pack_unpack.hpp.j2 +++ b/generator/templates/pack_unpack.hpp.j2 @@ -42,24 +42,13 @@ struct DATA_T { // utility functions void data_transfer(DATA_T *in, DATA_T *out); - void to_bitstring(uint8_t in[], uint64_t *out); - void from_bitstring(uint64_t *in, uint8_t out[]); - uint8_t swap_uint8(uint8_t val); - int8_t swap_int8(int8_t val); - uint16_t swap_uint16(uint16_t val); - int16_t swap_int16(int16_t val); - uint32_t swap_uint32(uint32_t val); - int32_t swap_int32(int32_t val); - int64_t swap_int64(int64_t val); - uint64_t swap_uint64(uint64_t val); - diff --git a/generator/templates/structs.cpp.j2 b/generator/templates/structs.cpp.j2 index 0961141..c9a2432 100644 --- a/generator/templates/structs.cpp.j2 +++ b/generator/templates/structs.cpp.j2 @@ -7,7 +7,7 @@ } {% else %} - {{msg.name}}_T {{msg.name}}_input; + {{msg.name}} {{msg.name}}_input; {% endif %} {%- endmacro -%} @@ -40,7 +40,7 @@ {{ get_keys(sub_frame, msg_names + [sub_frame.name]) }} {%- endfor -%} {%- else -%} - {{"::".join(msg_names)}}_T::key, + {{"::".join(msg_names)}}::key, {%- endif -%} {%- endmacro -%} @@ -75,7 +75,7 @@ namespace CANlib { -void send(Clock::time_point &last_sent_, Message_T* msg) { +void send(Clock::time_point &last_sent_, Message* msg) { if (Clock::now() - last_sent_ > msg->get_period()) { last_sent_ = Clock::now(); Frame frame; @@ -84,7 +84,7 @@ void send(Clock::time_point &last_sent_, Message_T* msg) { } } -void send(Message_T* msg) { +void send(Message* msg) { Frame frame; msg->unpack(frame); transmit_frame(frame, msg->get_bus_name()); @@ -105,28 +105,28 @@ extern const MessageType message_types[{{get_msg_len(bus)}}] = { } -const uint32_t {{bus.name}}_keys[] = { +static const uint32_t {{bus.name}}_keys[] = { 0, {% for msg in bus.frame -%} {{ get_keys(msg, [bus.name, msg.name]) }} {%- endfor -%} }; -const std::pair {{bus.name}}_frame_id_range[] = { +static const std::pair {{bus.name}}_frame_id_range[] = { std::make_pair(1,0), {% for msg in bus.frame -%} {{ get_message_ranges(msg, [bus.name, msg.name]) }} {%- endfor -%} }; -const uint32_t {{bus.name}}_frame_len[] = { +static const uint32_t {{bus.name}}_frame_len[] = { 0, {% for msg in bus.frame -%} {{ get_frame_ranges(msg, [bus.name, msg.name]) }} {%- endfor -%} }; -Message_T* {{bus.name}}_messages[] = { +static Message* {{bus.name}}_messages[] = { nullptr, {%- for msg in bus.frame -%} {{ get_messages(msg, ['CANlib', bus.name, msg.name]) }} @@ -158,7 +158,7 @@ extern const size_t can_size[{{ get_len(can) }}] = { {%- endfor -%} }; -Message_T** messages[{{ get_len(can) }}] = { +Message** messages[{{ get_len(can) }}] = { {%- for bus in can.bus -%} {{bus.name}}_messages, {%- endfor -%} diff --git a/generator/templates/structs.hpp.j2 b/generator/templates/structs.hpp.j2 index 695aad7..2a52b6b 100644 --- a/generator/templates/structs.hpp.j2 +++ b/generator/templates/structs.hpp.j2 @@ -8,7 +8,7 @@ } // {{msg_name}} {% else %} - struct {{msg_name}}_T : public Message_T { + struct {{msg_name}} : public Message { void unpack(Frame&) override; void pack(const Frame&) override; uint32_t get_key() override { @@ -61,7 +61,7 @@ {{ get_keys(sub_frame, msg_names + [sub_frame.name]) }} {%- endfor -%} {%- else -%} - {{"::".join(msg_names)}}_T::key, + {{"::".join(msg_names)}}::key, {%- endif -%} {%- endmacro -%} @@ -95,10 +95,11 @@ #include "driver.hpp" #include "static.hpp" #include "clock.hpp" +#include "bus.hpp" namespace CANlib { -struct Message_T { +struct Message { virtual void unpack(Frame&) = 0; virtual void pack(const Frame&) = 0; virtual uint32_t get_key() = 0; @@ -107,8 +108,8 @@ struct Message_T { virtual Clock::duration get_period() = 0; }; -void send(Clock::time_point &last_sent_, Message_T* msg); -void send(Message_T* msg); +void send(Clock::time_point &last_sent_, Message* msg); +void send(Message* msg); {%- for bus in can.bus %} diff --git a/src/src/drivers/stm32f4xx.cpp b/src/src/drivers/stm32f4xx.cpp index 410e32f..c4884a6 100644 --- a/src/src/drivers/stm32f4xx.cpp +++ b/src/src/drivers/stm32f4xx.cpp @@ -17,6 +17,12 @@ extern CAN_HandleTypeDef hcan3; using namespace CANlib; +Clock::time_point Clock::now() noexcept { + static const auto start_time = HAL_GetTick(); + const auto time_passed = HAL_GetTick() - start_time; + return time_point(std::chrono::milliseconds(time_passed)); +} + TransmitError CANlib::TransmitFrame(const Frame &frame, AbstractBus bus_name) { RawBus raw_bus = GetRawBus(bus); int bus_num; diff --git a/test/tests/src/arch0.cpp b/test/tests/src/arch0.cpp index 5aaab0d..e632c80 100644 --- a/test/tests/src/arch0.cpp +++ b/test/tests/src/arch0.cpp @@ -5,10 +5,10 @@ namespace CANlib { namespace map1 { -extern A_T A_input; +extern A A_input; } // namespace map1 namespace map2 { -extern F_T F_input; +extern F F_input; } // namespace map2 } // namespace CANlib @@ -40,17 +40,17 @@ void testArch() { can2.clear(); can3.clear(); Frame f; - map1::A_T A_copy; + map1::A A_copy; A_copy.ARG0 = true; A_copy.ARG1 = 69; A_copy.ARG2 = 69; A_copy.ARG3 = 69; A_copy.unpack(f); can2.setFrameToSend(f); - map1::A_T A_copy2; + map1::A A_copy2; map1_update_can(); assert(A_input.ARG0 && A_input.ARG1 == 69 && A_input.ARG2 == 69 && A_input.ARG3 == 69); - map2::F_T F_copy; + map2::F F_copy; F_copy.ARG0 = 69; F_copy.ARG1 = 69; F_copy.ARG2 = 69; diff --git a/test/tests/src/arch1.cpp b/test/tests/src/arch1.cpp index f642bd1..c0c96f0 100644 --- a/test/tests/src/arch1.cpp +++ b/test/tests/src/arch1.cpp @@ -4,10 +4,10 @@ namespace CANlib { namespace map1 { -extern A_T A_input; +extern A A_input; } // namespace map1 namespace map2 { -extern F_T F_input; +extern F F_input; } // namespace map2 } // namespace CANlib @@ -39,17 +39,17 @@ void testArch() { can2.clear(); can3.clear(); Frame f; - map1::A_T A_copy; + map1::A A_copy; A_copy.ARG0 = true; A_copy.ARG1 = 69; A_copy.ARG2 = 69; A_copy.ARG3 = 69; A_copy.unpack(f); can2.setFrameToSend(f); - map1::A_T A_copy2; + map1::A A_copy2; map1_update_can(); assert(A_input.ARG0 && A_input.ARG1 == 69 && A_input.ARG2 == 69 && A_input.ARG3 == 69); - map2::F_T F_copy; + map2::F F_copy; F_copy.ARG0 = 69; F_copy.ARG1 = 69; F_copy.ARG2 = 69; diff --git a/test/tests/src/arch2.cpp b/test/tests/src/arch2.cpp index c8d4b77..77fe656 100644 --- a/test/tests/src/arch2.cpp +++ b/test/tests/src/arch2.cpp @@ -4,10 +4,10 @@ namespace CANlib { namespace map1 { -extern A_T A_input; +extern A A_input; } // namespace map1 namespace map2 { -extern F_T F_input; +extern F F_input; } // namespace map2 } // namespace CANlib @@ -39,17 +39,17 @@ void testArch() { can2.clear(); can3.clear(); Frame f; - map1::A_T A_copy; + map1::A A_copy; A_copy.ARG0 = true; A_copy.ARG1 = 69; A_copy.ARG2 = 69; A_copy.ARG3 = 69; A_copy.unpack(f); can3.setFrameToSend(f); - map1::A_T A_copy2; + map1::A A_copy2; map1_update_can(); assert(A_input.ARG0 && A_input.ARG1 == 69 && A_input.ARG2 == 69 && A_input.ARG3 == 69); - map2::F_T F_copy; + map2::F F_copy; F_copy.ARG0 = 69; F_copy.ARG1 = 69; F_copy.ARG2 = 69; diff --git a/test/tests/src/constants.cpp b/test/tests/src/constants.cpp index be7d9fe..615d5f6 100644 --- a/test/tests/src/constants.cpp +++ b/test/tests/src/constants.cpp @@ -13,201 +13,201 @@ extern MessageType message_types[28]; using namespace CANlib; using namespace std::chrono_literals; -using map1::A_T; -using map1::B_T; -using map1::C_T; -using map1::D_T; -using map1::E_T; -using map2::F_T; -using map2::G_T; -using map2::H_T; -using map2::I_T; -using map2::K_T; -using map2::L_T; -using map2::M_T; -using map2::N_T; -using map2::J::AA_T; -using map2::J::BB_T; -using map2::J::DD_T; -using map2::J::EE_T; -using map2::J::FF_T; -using map2::J::GG_T; -using map2::J::HH_T; -using map2::J::II_T; -using map2::J::JJ_T; -using map2::J::KK_T; -using map2::J::LL_T; -using map2::J::MM_T; -using map2::J::NN_T; -using map2::J::CC::AAA_T; -using map2::J::CC::BBB_T; -using map2::J::CC::CCC_T; -using map2::J::CC::DDD_T; +using map1::A; +using map1::B; +using map1::C; +using map1::D; +using map1::E; +using map2::F; +using map2::G; +using map2::H; +using map2::I; +using map2::K; +using map2::L; +using map2::M; +using map2::N; +using map2::J::AA; +using map2::J::BB; +using map2::J::DD; +using map2::J::EE; +using map2::J::FF; +using map2::J::GG; +using map2::J::HH; +using map2::J::II; +using map2::J::JJ; +using map2::J::KK; +using map2::J::LL; +using map2::J::MM; +using map2::J::NN; +using map2::J::CC::AAA; +using map2::J::CC::BBB; +using map2::J::CC::CCC; +using map2::J::CC::DDD; void testKeys() { - map1::A_T A_input; - map1::B_T B_input; - map1::C_T C_input; - map1::D_T D_input; - map1::E_T E_input; - map2::F_T F_input; - map2::G_T G_input; - map2::H_T H_input; - map2::I_T I_input; - map2::J::AA_T AA_input; - map2::J::BB_T BB_input; - map2::J::CC::AAA_T AAA_input; - map2::J::CC::BBB_T BBB_input; - map2::J::CC::CCC_T CCC_input; - map2::J::CC::DDD_T DDD_input; - map2::J::DD_T DD_input; - map2::J::EE_T EE_input; - map2::J::FF_T FF_input; - map2::J::GG_T GG_input; - map2::J::HH_T HH_input; - map2::J::II_T II_input; - map2::J::JJ_T JJ_input; - map2::J::KK_T KK_input; - map2::J::LL_T LL_input; - map2::J::MM_T MM_input; - map2::J::NN_T NN_input; - map2::K_T K_input; - map2::L_T L_input; - map2::M_T M_input; - map2::N_T N_input; - assert(A_input.get_key() == 0x2FF); - assert(map1::A_T::key == 0x2FF); - assert(B_input.get_key() == 0x305); - assert(map1::B_T::key == 0x305); - assert(C_input.get_key() == 0x306); - assert(map1::C_T::key == 0x306); - assert(D_input.get_key() == 0x307); - assert(map1::D_T::key == 0x307); - assert(E_input.get_key() == 0x308); - assert(map1::E_T::key == 0x308); - assert(F_input.get_key() == 0x16); - assert(map2::F_T::key == 0x16); - assert(G_input.get_key() == 0x17); - assert(map2::G_T::key == 0x17); - assert(H_input.get_key() == 0xA0); - assert(map2::H_T::key == 0xA0); - assert(I_input.get_key() == 0xA2); - assert(map2::I_T::key == 0xA2); + A A_copy; + B B_copy; + C C_copy; + D D_copy; + E E_copy; + F F_copy; + G G_copy; + H H_copy; + I I_copy; + AA AA_copy; + BB BB_copy; + AAA AAA_copy; + BBB BBB_copy; + CCC CCC_copy; + DDD DDD_copy; + DD DD_copy; + EE EE_copy; + FF FF_copy; + GG GG_copy; + HH HH_copy; + II II_copy; + JJ JJ_copy; + KK KK_copy; + LL LL_copy; + MM MM_copy; + NN NN_copy; + K K_copy; + L L_copy; + M M_copy; + N N_copy; + assert(A_copy.get_key() == 0x2FF); + assert(map1::A::key == 0x2FF); + assert(B_copy.get_key() == 0x305); + assert(map1::B::key == 0x305); + assert(C_copy.get_key() == 0x306); + assert(map1::C::key == 0x306); + assert(D_copy.get_key() == 0x307); + assert(map1::D::key == 0x307); + assert(E_copy.get_key() == 0x308); + assert(map1::E::key == 0x308); + assert(F_copy.get_key() == 0x16); + assert(map2::F::key == 0x16); + assert(G_copy.get_key() == 0x17); + assert(map2::G::key == 0x17); + assert(H_copy.get_key() == 0xA0); + assert(map2::H::key == 0xA0); + assert(I_copy.get_key() == 0xA2); + assert(map2::I::key == 0xA2); assert(map2::J::key == 0xC2); - assert(AA_input.get_key() == 0x0); - assert(map2::J::AA_T::key == 0x0); - assert(BB_input.get_key() == 0x14); - assert(map2::J::BB_T::key == 0x14); + assert(AA_copy.get_key() == 0x0); + assert(map2::J::AA::key == 0x0); + assert(BB_copy.get_key() == 0x14); + assert(map2::J::BB::key == 0x14); assert(map2::J::CC::key == 0x64); - assert(AAA_input.get_key() == 0x69); - assert(map2::J::CC::AAA_T::key == 0x69); - assert(BBB_input.get_key() == 0x70); - assert(map2::J::CC::BBB_T::key == 0x70); - assert(CCC_input.get_key() == 0x71); - assert(map2::J::CC::CCC_T::key == 0x71); - assert(DDD_input.get_key() == 0x72); - assert(map2::J::CC::DDD_T::key == 0x72); - assert(DD_input.get_key() == 0x65); - assert(map2::J::DD_T::key == 0x65); - assert(EE_input.get_key() == 0x66); - assert(map2::J::EE_T::key == 0x66); - assert(FF_input.get_key() == 0x67); - assert(map2::J::FF_T::key == 0x67); - assert(GG_input.get_key() == 0x68); - assert(map2::J::GG_T::key == 0x68); - assert(HH_input.get_key() == 0x6A); - assert(map2::J::HH_T::key == 0x6A); - assert(II_input.get_key() == 0x6B); - assert(map2::J::II_T::key == 0x6B); - assert(JJ_input.get_key() == 0x6C); - assert(map2::J::JJ_T::key == 0x6C); - assert(KK_input.get_key() == 0x6D); - assert(map2::J::KK_T::key == 0x6D); - assert(LL_input.get_key() == 0x6F); - assert(map2::J::LL_T::key == 0x6F); - assert(MM_input.get_key() == 0xAB); - assert(map2::J::MM_T::key == 0xAB); - assert(NN_input.get_key() == 0x91); - assert(map2::J::NN_T::key == 0x91); - assert(K_input.get_key() == 0xBB); - assert(map2::K_T::key == 0xBB); - assert(L_input.get_key() == 0xDF); - assert(map2::L_T::key == 0xDF); - assert(M_input.get_key() == 0xF0); - assert(map2::M_T::key == 0xF0); - assert(N_input.get_key() == 0x400); - assert(map2::N_T::key == 0x400); + assert(AAA_copy.get_key() == 0x69); + assert(map2::J::CC::AAA::key == 0x69); + assert(BBB_copy.get_key() == 0x70); + assert(map2::J::CC::BBB::key == 0x70); + assert(CCC_copy.get_key() == 0x71); + assert(map2::J::CC::CCC::key == 0x71); + assert(DDD_copy.get_key() == 0x72); + assert(map2::J::CC::DDD::key == 0x72); + assert(DD_copy.get_key() == 0x65); + assert(map2::J::DD::key == 0x65); + assert(EE_copy.get_key() == 0x66); + assert(map2::J::EE::key == 0x66); + assert(FF_copy.get_key() == 0x67); + assert(map2::J::FF::key == 0x67); + assert(GG_copy.get_key() == 0x68); + assert(map2::J::GG::key == 0x68); + assert(HH_copy.get_key() == 0x6A); + assert(map2::J::HH::key == 0x6A); + assert(II_copy.get_key() == 0x6B); + assert(map2::J::II::key == 0x6B); + assert(JJ_copy.get_key() == 0x6C); + assert(map2::J::JJ::key == 0x6C); + assert(KK_copy.get_key() == 0x6D); + assert(map2::J::KK::key == 0x6D); + assert(LL_copy.get_key() == 0x6F); + assert(map2::J::LL::key == 0x6F); + assert(MM_copy.get_key() == 0xAB); + assert(map2::J::MM::key == 0xAB); + assert(NN_copy.get_key() == 0x91); + assert(map2::J::NN::key == 0x91); + assert(K_copy.get_key() == 0xBB); + assert(map2::K::key == 0xBB); + assert(L_copy.get_key() == 0xDF); + assert(map2::L::key == 0xDF); + assert(M_copy.get_key() == 0xF0); + assert(map2::M::key == 0xF0); + assert(N_copy.get_key() == 0x400); + assert(map2::N::key == 0x400); } void testPeriod() { - map1::A_T A_input; - map1::B_T B_input; - map1::C_T C_input; - map1::D_T D_input; - map1::E_T E_input; - map2::F_T F_input; - map2::G_T G_input; - map2::H_T H_input; - map2::I_T I_input; - map2::J::AA_T AA_input; - map2::J::BB_T BB_input; - map2::J::CC::AAA_T AAA_input; - map2::J::CC::BBB_T BBB_input; - map2::J::CC::CCC_T CCC_input; - map2::J::CC::DDD_T DDD_input; - map2::J::DD_T DD_input; - map2::J::EE_T EE_input; - map2::J::FF_T FF_input; - map2::J::GG_T GG_input; - map2::J::HH_T HH_input; - map2::J::II_T II_input; - map2::J::JJ_T JJ_input; - map2::J::KK_T KK_input; - map2::J::LL_T LL_input; - map2::J::MM_T MM_input; - map2::J::NN_T NN_input; - map2::K_T K_input; - map2::L_T L_input; - map2::M_T M_input; - map2::N_T N_input; - assert(A_input.get_period() == 50ms); - assert(B_input.get_period() == 200ms); - assert(C_input.get_period() == 200ms); - assert(D_input.get_period() == 200ms); - assert(E_input.get_period() == 1000ms); - assert(F_input.get_period() == 101ms); - assert(G_input.get_period() == 31ms); - assert(H_input.get_period() == 0ms); - assert(I_input.get_period() == 0ms); - assert(AA_input.get_period() == 0ms); - assert(BB_input.get_period() == 0ms); - assert(AAA_input.get_period() == 0ms); - assert(BBB_input.get_period() == 0ms); - assert(CCC_input.get_period() == 0ms); - assert(DDD_input.get_period() == 0ms); - assert(DD_input.get_period() == 0ms); - assert(EE_input.get_period() == 0ms); - assert(FF_input.get_period() == 0ms); - assert(GG_input.get_period() == 0ms); - assert(HH_input.get_period() == 0ms); - assert(II_input.get_period() == 0ms); - assert(JJ_input.get_period() == 0ms); - assert(KK_input.get_period() == 0ms); - assert(LL_input.get_period() == 0ms); - assert(MM_input.get_period() == 0ms); - assert(NN_input.get_period() == 0ms); - assert(K_input.get_period() == 0ms); - assert(L_input.get_period() == 103ms); - assert(M_input.get_period() == 103ms); - assert(N_input.get_period() == 0ms); + map1::A A_copy; + map1::B B_copy; + map1::C C_copy; + map1::D D_copy; + map1::E E_copy; + map2::F F_copy; + map2::G G_copy; + map2::H H_copy; + map2::I I_copy; + map2::J::AA AA_copy; + map2::J::BB BB_copy; + map2::J::CC::AAA AAA_copy; + map2::J::CC::BBB BBB_copy; + map2::J::CC::CCC CCC_copy; + map2::J::CC::DDD DDD_copy; + map2::J::DD DD_copy; + map2::J::EE EE_copy; + map2::J::FF FF_copy; + map2::J::GG GG_copy; + map2::J::HH HH_copy; + map2::J::II II_copy; + map2::J::JJ JJ_copy; + map2::J::KK KK_copy; + map2::J::LL LL_copy; + map2::J::MM MM_copy; + map2::J::NN NN_copy; + map2::K K_copy; + map2::L L_copy; + map2::M M_copy; + map2::N N_copy; + assert(A_copy.get_period() == 50ms); + assert(B_copy.get_period() == 200ms); + assert(C_copy.get_period() == 200ms); + assert(D_copy.get_period() == 200ms); + assert(E_copy.get_period() == 1000ms); + assert(F_copy.get_period() == 101ms); + assert(G_copy.get_period() == 31ms); + assert(H_copy.get_period() == 0ms); + assert(I_copy.get_period() == 0ms); + assert(AA_copy.get_period() == 0ms); + assert(BB_copy.get_period() == 0ms); + assert(AAA_copy.get_period() == 0ms); + assert(BBB_copy.get_period() == 0ms); + assert(CCC_copy.get_period() == 0ms); + assert(DDD_copy.get_period() == 0ms); + assert(DD_copy.get_period() == 0ms); + assert(EE_copy.get_period() == 0ms); + assert(FF_copy.get_period() == 0ms); + assert(GG_copy.get_period() == 0ms); + assert(HH_copy.get_period() == 0ms); + assert(II_copy.get_period() == 0ms); + assert(JJ_copy.get_period() == 0ms); + assert(KK_copy.get_period() == 0ms); + assert(LL_copy.get_period() == 0ms); + assert(MM_copy.get_period() == 0ms); + assert(NN_copy.get_period() == 0ms); + assert(K_copy.get_period() == 0ms); + assert(L_copy.get_period() == 103ms); + assert(M_copy.get_period() == 103ms); + assert(N_copy.get_period() == 0ms); } -#define CREATE_TEST(ID, bus_idx, key, msg) \ - static void testMessageType##ID() { \ - ID##_T ID##_input; \ - Frame f; \ - ID##_input.unpack(f); \ - int idx = identify(AbstractBus::map##bus_idx, f); \ +#define CREATE_TEST(ID, bus_idx, key, msg) \ + static void testMessageType##ID() { \ + ID ID##_copy; \ + Frame f; \ + ID##_copy.unpack(f); \ + int idx = identify(AbstractBus::map##bus_idx, f); \ assert(map##bus_idx::message_types[idx] == map##bus_idx::MessageType::msg); \ } CREATE_TEST(A, 1, 0X2FF, A) @@ -275,64 +275,64 @@ void testMessageType() { } void testBusNames() { - map1::A_T A_input; - map1::B_T B_input; - map1::C_T C_input; - map1::D_T D_input; - map1::E_T E_input; - map2::F_T F_input; - map2::G_T G_input; - map2::H_T H_input; - map2::I_T I_input; - map2::J::AA_T AA_input; - map2::J::BB_T BB_input; - map2::J::CC::AAA_T AAA_input; - map2::J::CC::BBB_T BBB_input; - map2::J::CC::CCC_T CCC_input; - map2::J::CC::DDD_T DDD_input; - map2::J::DD_T DD_input; - map2::J::EE_T EE_input; - map2::J::FF_T FF_input; - map2::J::GG_T GG_input; - map2::J::HH_T HH_input; - map2::J::II_T II_input; - map2::J::JJ_T JJ_input; - map2::J::KK_T KK_input; - map2::J::LL_T LL_input; - map2::J::MM_T MM_input; - map2::J::NN_T NN_input; - map2::K_T K_input; - map2::L_T L_input; - map2::M_T M_input; - map2::N_T N_input; - assert(A_input.get_bus_name() == AbstractBus::map1); - assert(B_input.get_bus_name() == AbstractBus::map1); - assert(C_input.get_bus_name() == AbstractBus::map1); - assert(D_input.get_bus_name() == AbstractBus::map1); - assert(E_input.get_bus_name() == AbstractBus::map1); - assert(F_input.get_bus_name() == AbstractBus::map2); - assert(G_input.get_bus_name() == AbstractBus::map2); - assert(H_input.get_bus_name() == AbstractBus::map2); - assert(I_input.get_bus_name() == AbstractBus::map2); - assert(AA_input.get_bus_name() == AbstractBus::map2); - assert(BB_input.get_bus_name() == AbstractBus::map2); - assert(AAA_input.get_bus_name() == AbstractBus::map2); - assert(BBB_input.get_bus_name() == AbstractBus::map2); - assert(CCC_input.get_bus_name() == AbstractBus::map2); - assert(DDD_input.get_bus_name() == AbstractBus::map2); - assert(DD_input.get_bus_name() == AbstractBus::map2); - assert(EE_input.get_bus_name() == AbstractBus::map2); - assert(FF_input.get_bus_name() == AbstractBus::map2); - assert(GG_input.get_bus_name() == AbstractBus::map2); - assert(HH_input.get_bus_name() == AbstractBus::map2); - assert(II_input.get_bus_name() == AbstractBus::map2); - assert(JJ_input.get_bus_name() == AbstractBus::map2); - assert(KK_input.get_bus_name() == AbstractBus::map2); - assert(LL_input.get_bus_name() == AbstractBus::map2); - assert(MM_input.get_bus_name() == AbstractBus::map2); - assert(NN_input.get_bus_name() == AbstractBus::map2); - assert(K_input.get_bus_name() == AbstractBus::map2); - assert(L_input.get_bus_name() == AbstractBus::map2); - assert(M_input.get_bus_name() == AbstractBus::map2); - assert(N_input.get_bus_name() == AbstractBus::map2); + map1::A A_copy; + map1::B B_copy; + map1::C C_copy; + map1::D D_copy; + map1::E E_copy; + map2::F F_copy; + map2::G G_copy; + map2::H H_copy; + map2::I I_copy; + map2::J::AA AA_copy; + map2::J::BB BB_copy; + map2::J::CC::AAA AAA_copy; + map2::J::CC::BBB BBB_copy; + map2::J::CC::CCC CCC_copy; + map2::J::CC::DDD DDD_copy; + map2::J::DD DD_copy; + map2::J::EE EE_copy; + map2::J::FF FF_copy; + map2::J::GG GG_copy; + map2::J::HH HH_copy; + map2::J::II II_copy; + map2::J::JJ JJ_copy; + map2::J::KK KK_copy; + map2::J::LL LL_copy; + map2::J::MM MM_copy; + map2::J::NN NN_copy; + map2::K K_copy; + map2::L L_copy; + map2::M M_copy; + map2::N N_copy; + assert(A_copy.get_bus_name() == AbstractBus::map1); + assert(B_copy.get_bus_name() == AbstractBus::map1); + assert(C_copy.get_bus_name() == AbstractBus::map1); + assert(D_copy.get_bus_name() == AbstractBus::map1); + assert(E_copy.get_bus_name() == AbstractBus::map1); + assert(F_copy.get_bus_name() == AbstractBus::map2); + assert(G_copy.get_bus_name() == AbstractBus::map2); + assert(H_copy.get_bus_name() == AbstractBus::map2); + assert(I_copy.get_bus_name() == AbstractBus::map2); + assert(AA_copy.get_bus_name() == AbstractBus::map2); + assert(BB_copy.get_bus_name() == AbstractBus::map2); + assert(AAA_copy.get_bus_name() == AbstractBus::map2); + assert(BBB_copy.get_bus_name() == AbstractBus::map2); + assert(CCC_copy.get_bus_name() == AbstractBus::map2); + assert(DDD_copy.get_bus_name() == AbstractBus::map2); + assert(DD_copy.get_bus_name() == AbstractBus::map2); + assert(EE_copy.get_bus_name() == AbstractBus::map2); + assert(FF_copy.get_bus_name() == AbstractBus::map2); + assert(GG_copy.get_bus_name() == AbstractBus::map2); + assert(HH_copy.get_bus_name() == AbstractBus::map2); + assert(II_copy.get_bus_name() == AbstractBus::map2); + assert(JJ_copy.get_bus_name() == AbstractBus::map2); + assert(KK_copy.get_bus_name() == AbstractBus::map2); + assert(LL_copy.get_bus_name() == AbstractBus::map2); + assert(MM_copy.get_bus_name() == AbstractBus::map2); + assert(NN_copy.get_bus_name() == AbstractBus::map2); + assert(K_copy.get_bus_name() == AbstractBus::map2); + assert(L_copy.get_bus_name() == AbstractBus::map2); + assert(M_copy.get_bus_name() == AbstractBus::map2); + assert(N_copy.get_bus_name() == AbstractBus::map2); } diff --git a/test/tests/src/identify.cpp b/test/tests/src/identify.cpp index a76a93f..4ae884a 100644 --- a/test/tests/src/identify.cpp +++ b/test/tests/src/identify.cpp @@ -3,7 +3,7 @@ #include "test.hpp" namespace CANlib { -extern Message_T **messages[2]; +extern Message **messages[2]; } using namespace CANlib; @@ -12,29 +12,29 @@ using namespace map2; using namespace J; using namespace CC; -#define CREATE_TEST0(ID, bus_idx, key) \ - static void test##ID() { \ - for (int cs = 0; cs < 100; ++cs) { \ - Frame f; \ - f.dlc = distribution(generator); \ - for (int i = 0; i < 8; ++i) { \ - f.data[i] = distribution(generator); \ - } \ - f.id = key; \ - int idx = identify(AbstractBus::map##bus_idx, f); \ - Message_T *msg = messages[bus_idx - 1][idx]; \ - assert((dynamic_cast(msg)) != nullptr); \ - } \ +#define CREATE_TEST0(ID, bus_idx, key) \ + static void test##ID() { \ + for (int cs = 0; cs < 100; ++cs) { \ + Frame f; \ + f.dlc = distribution(generator); \ + for (int i = 0; i < 8; ++i) { \ + f.data[i] = distribution(generator); \ + } \ + f.id = key; \ + int idx = identify(AbstractBus::map##bus_idx, f); \ + Message *msg = messages[bus_idx - 1][idx]; \ + assert((dynamic_cast(msg)) != nullptr); \ + } \ } -#define CREATE_TEST1(ID, bus_idx, key) \ - static void test##ID() { \ - ID##_T ID##_input; \ - Frame f; \ - ID##_input.unpack(f); \ - int idx = identify(AbstractBus::map##bus_idx, f); \ - Message_T *msg = messages[bus_idx - 1][idx]; \ - assert((dynamic_cast(msg)) != nullptr); \ +#define CREATE_TEST1(ID, bus_idx, key) \ + static void test##ID() { \ + ID ID##_copy; \ + Frame f; \ + ID##_copy.unpack(f); \ + int idx = identify(AbstractBus::map##bus_idx, f); \ + Message *msg = messages[bus_idx - 1][idx]; \ + assert((dynamic_cast(msg)) != nullptr); \ } CREATE_TEST0(A, 1, 0X2FF) diff --git a/test/tests/src/message.cpp b/test/tests/src/message.cpp index 8f2f56d..2eb045b 100644 --- a/test/tests/src/message.cpp +++ b/test/tests/src/message.cpp @@ -12,7 +12,7 @@ using namespace CC; #define CREATE_TEST(ID, BITMASK) \ void test##ID() { \ for (int cs = 0; cs < 100000; ++cs) { \ - ID##_T ID##_input; \ + ID ID##_copy; \ Frame f0; \ for (int i = 0; i < 8; ++i) { \ f0.data[i] = distribution(generator); \ @@ -20,10 +20,10 @@ using namespace CC; uint64_t bitstring0; \ to_bitstring((uint8_t *)f0.data, &bitstring0); \ bitstring0 &= BITMASK; \ - ID##_input.pack(f0); \ + ID##_copy.pack(f0); \ Frame f1; \ memset(f1.data, 0, sizeof(f1.data)); \ - ID##_input.unpack(f1); \ + ID##_copy.unpack(f1); \ uint64_t bitstring1; \ to_bitstring((uint8_t *)f1.data, &bitstring1); \ bitstring1 &= BITMASK; \ diff --git a/test/tests/src/send.cpp b/test/tests/src/send.cpp index 40ae574..932dd1e 100644 --- a/test/tests/src/send.cpp +++ b/test/tests/src/send.cpp @@ -16,33 +16,33 @@ extern CAN can1; extern CAN can2; extern CAN can3; -#define CREATE_TEST(ID, can, BITMASK) \ - static void testSend##ID() { \ - ID##_T ID##_input; \ - Frame f0; \ - for (int i = 0; i < 8; ++i) { \ - f0.data[i] = distribution(generator); \ - } \ - uint64_t bitstring0; \ - to_bitstring((uint8_t *)f0.data, &bitstring0); \ - bitstring0 &= BITMASK; \ - ID##_input.pack(f0); \ - can.clear(); \ - if (ID##_input.get_period() != 0ms) { \ - auto starting_time = Clock::now(); \ - auto tmp = starting_time; \ - while (Clock::now() - starting_time <= ID##_input.get_period() + 5ms) { \ - send(tmp, &ID##_input); \ - } \ - } else { \ - send(&ID##_input); \ - } \ - uint64_t bitstring1; \ - assert(can.framesReceived() == 1); \ - Frame f1 = can.topFrame(); \ - to_bitstring((uint8_t *)f1.data, &bitstring1); \ - bitstring1 &= BITMASK; \ - assert(bitstring0 == bitstring1); \ +#define CREATE_TEST(ID, can, BITMASK) \ + static void testSend##ID() { \ + ID ID##_copy; \ + Frame f0; \ + for (int i = 0; i < 8; ++i) { \ + f0.data[i] = distribution(generator); \ + } \ + uint64_t bitstring0; \ + to_bitstring((uint8_t *)f0.data, &bitstring0); \ + bitstring0 &= BITMASK; \ + ID##_copy.pack(f0); \ + can.clear(); \ + if (ID##_copy.get_period() != 0ms) { \ + auto starting_time = Clock::now(); \ + auto tmp = starting_time; \ + while (Clock::now() - starting_time <= ID##_copy.get_period() + 5ms) { \ + send(tmp, &ID##_copy); \ + } \ + } else { \ + send(&ID##_copy); \ + } \ + uint64_t bitstring1; \ + assert(can.framesReceived() == 1); \ + Frame f1 = can.topFrame(); \ + to_bitstring((uint8_t *)f1.data, &bitstring1); \ + bitstring1 &= BITMASK; \ + assert(bitstring0 == bitstring1); \ } CREATE_TEST(A, MAP1_CAN, (~ZEROES_MASK(7, 49))) From 35a5d3fa0565bbc38807f8333ae6e61713edadac Mon Sep 17 00:00:00 2001 From: Gabriel Cojocaru Date: Sun, 25 Apr 2021 17:41:38 +0300 Subject: [PATCH 06/17] added get_message_type --- generator/templates/structs.hpp.j2 | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/generator/templates/structs.hpp.j2 b/generator/templates/structs.hpp.j2 index 2a52b6b..094ab5c 100644 --- a/generator/templates/structs.hpp.j2 +++ b/generator/templates/structs.hpp.j2 @@ -1,14 +1,17 @@ -{%- macro struct_declarations(bus, msg, msg_name=msg.name) -%} +{%- macro struct_declarations(bus, msg, msg_names = [msg.name]) -%} {%- if msg.frame is defined %} - namespace {{msg_name}} { + namespace {{msg.name}} { const uint32_t key = 0x{{ '%0X' % msg.key }}; {% for sub_frame in msg.frame %} - {{ struct_declarations(bus, sub_frame) }} + {{ struct_declarations(bus, sub_frame, msg_names + [sub_frame.name]) }} {% endfor %} } // {{msg_name}} {% else %} - struct {{msg_name}} : public Message { + struct {{msg.name}} : public Message_{{ bus.name }} { + MessageType get_message_type() override { + return MessageType::{{ '_'.join(msg_names) }}; + } void unpack(Frame&) override; void pack(const Frame&) override; uint32_t get_key() override { @@ -114,6 +117,9 @@ void send(Message* msg); {%- for bus in can.bus %} namespace {{ bus.name }} { + struct Message_{{bus.name}} : public Message { + virtual MessageType get_message_type() = 0; + }; {% for msg in bus.frame -%} {{ struct_declarations(bus, msg) }} From 07a16eb14bb20cc1886c84181c692459ccf02c07 Mon Sep 17 00:00:00 2001 From: Gabriel Cojocaru Date: Sun, 25 Apr 2021 17:42:09 +0300 Subject: [PATCH 07/17] removed uints and old template names --- src/src/drivers/testfamily.cpp | 2 - test/CMakeLists.txt | 36 ------------------ test/can_spec.yml | 68 ++++++++++++++++------------------ 3 files changed, 31 insertions(+), 75 deletions(-) delete mode 100644 test/CMakeLists.txt diff --git a/src/src/drivers/testfamily.cpp b/src/src/drivers/testfamily.cpp index 76e1ba2..fb86638 100644 --- a/src/src/drivers/testfamily.cpp +++ b/src/src/drivers/testfamily.cpp @@ -1,4 +1,3 @@ -//#ifdef CANLIB_ARCH_TESTFAMILY #include "static.hpp" #include @@ -54,4 +53,3 @@ void CANlib::read_frame(Frame &frame, AbstractBus bus_name) { return; } } -//#endif diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt deleted file mode 100644 index 74f07b1..0000000 --- a/test/CMakeLists.txt +++ /dev/null @@ -1,36 +0,0 @@ -cmake_minimum_required(VERSION 3.1.3) - -set(CMAKE_CXX_STANDARD 17) - -project(canlib C CXX) - - -set(GCC_COVERAGE_COMPILE_FLAGS "-fprofile-arcs -ftest-coverage --coverage") -set(GCC_COVERAGE_LINK_FLAGS "-lgcov --coverage") -set(GCC_DEBUG_FLAGS "-g -ggdb -Og") -set(GCC_WARNING_FLAGS "-Wall -Wextra -fdiagnostics-color=always -Werror") - -set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${GCC_COVERAGE_COMPILE_FLAGS} ${GCC_WARNING_FLAGS}") -set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${GCC_COVERAGE_LINK_FLAGS}") - -include_directories(../src) -include_directories(./tests/inc) -include_directories(../src/drivers/inc) -include_directories(../src/computers/inc) - -file(GLOB CANLIB_SOURCES "../src/*.cpp" "../src/*.c" "../src/drivers/src/*.cpp" "../src/drivers/src/*.c" "../src/computers/src/canlib_testcomp0.cpp") -add_library(canlib_src SHARED ${CANLIB_SOURCES}) -target_compile_features(canlib_src INTERFACE cxx_strong_enums) -target_compile_definitions(canlib_src PUBLIC CANLIB_ARCH_TESTFAMILY) - -file(GLOB_RECURSE TEST_SOURCES "./tests/src/*.cpp") -add_library(canlib_tests SHARED ${TEST_SOURCES}) -target_link_libraries(canlib_tests PUBLIC canlib_src) - -add_executable(${PROJECT_NAME} "./tests/main.cpp") - -target_link_libraries(${PROJECT_NAME} PUBLIC canlib_src) -target_link_libraries(${PROJECT_NAME} PUBLIC canlib_tests) - -enable_testing() -add_test(Tests ${PROJECT_NAME}) diff --git a/test/can_spec.yml b/test/can_spec.yml index 7663441..72f4bc0 100644 --- a/test/can_spec.yml +++ b/test/can_spec.yml @@ -1,11 +1,5 @@ name: MY20 units: - - newtonmeter = N * m = J = Nm - - tick = 3 ms - - RPM = 360 deg / min - - pct = 0.01 - - halfpct = 0.5 pct - - tenthpct = 0.1 pct architecture: testarch: family: testfamily @@ -248,7 +242,7 @@ protocol: H: key: 0x0A0 atom: - <<: &rms_temps + <<: &temps a_temp: slice: 0 + 16 unit: decidegC @@ -286,7 +280,7 @@ protocol: frame: AA: key: 0 - <<: &rms_bool_data + <<: &bool_data atom: write_success: slice: 23 + 1 @@ -296,7 +290,7 @@ protocol: type: bool little BB: key: 0x14 - <<: *rms_bool_data + <<: *bool_data #Required to correctly parse the data with the script, as this parameter is constantly #being transmitted over the CAN bus. CC: @@ -306,99 +300,99 @@ protocol: AAA: key: 0x69 atom: - <<: &rms_c_write_success + <<: &write_success write_success: # whether EEPROM has been re-written slice: 23 + 1 type: bool little data: - <<: &rms_c_signed_int_data + <<: &signed_int_data slice: 32 + 16 type: int16 little BBB: key: 0x70 atom: - <<: *rms_c_write_success + <<: *write_success data: - <<: *rms_c_signed_int_data + <<: *signed_int_data CCC: key: 0x71 atom: - <<: *rms_c_write_success + <<: *write_success data: - <<: *rms_c_signed_int_data + <<: *signed_int_data DDD: key: 0x72 atom: - <<: *rms_c_write_success + <<: *write_success data: - <<: *rms_c_signed_int_data + <<: *signed_int_data DD: key: 0x65 atom: - <<: &rms_write_success + <<: &write_success_2 write_success: # whether EEPROM has been re-written slice: 23 + 1 type: bool little data: - <<: &rms_signed_int_data + <<: &signed_int_data_2 slice: 32 + 16 type: int16 little EE: key: 0x66 atom: - <<: *rms_write_success + <<: *write_success_2 data: - <<: *rms_signed_int_data + <<: *signed_int_data_2 FF: key: 0x67 atom: - <<: *rms_write_success + <<: *write_success_2 data: - <<: *rms_signed_int_data + <<: *signed_int_data_2 GG: key: 0x68 atom: - <<: *rms_write_success + <<: *write_success_2 data: - <<: *rms_signed_int_data + <<: *signed_int_data_2 HH: key: 0x6a atom: - <<: *rms_write_success + <<: *write_success_2 data: - <<: *rms_signed_int_data + <<: *signed_int_data_2 II: key: 0x6b atom: - <<: *rms_write_success + <<: *write_success_2 data: - <<: &rms_unsigned_int_data + <<: &unsigned_int_data slice: 32 + 16 type: uint16 little JJ: key: 0x6c atom: - <<: *rms_write_success + <<: *write_success_2 data: - <<: *rms_unsigned_int_data + <<: *unsigned_int_data KK: key: 0x6d atom: - <<: *rms_write_success + <<: *write_success_2 data: - <<: *rms_unsigned_int_data + <<: *unsigned_int_data LL: key: 0x6f atom: - <<: *rms_write_success + <<: *write_success_2 data: - <<: *rms_signed_int_data + <<: *signed_int_data MM: key: 0xab - <<: *rms_bool_data + <<: *bool_data NN: key: 0x91 - <<: *rms_bool_data + <<: *bool_data K: key: 0x0BB atom: From 277f84bce8eb8ea106498b386f85839ea2c1ed46 Mon Sep 17 00:00:00 2001 From: Gabriel Cojocaru Date: Sun, 25 Apr 2021 18:04:42 +0300 Subject: [PATCH 08/17] separed send with period --- generator/templates/structs.cpp.j2 | 6 ++---- generator/templates/structs.hpp.j2 | 4 ++-- test/Makefile | 2 -- test/tests/src/send.cpp | 2 +- 4 files changed, 5 insertions(+), 9 deletions(-) diff --git a/generator/templates/structs.cpp.j2 b/generator/templates/structs.cpp.j2 index c9a2432..a295287 100644 --- a/generator/templates/structs.cpp.j2 +++ b/generator/templates/structs.cpp.j2 @@ -75,12 +75,10 @@ namespace CANlib { -void send(Clock::time_point &last_sent_, Message* msg) { +void send_period(Clock::time_point &last_sent_, Message* msg) { if (Clock::now() - last_sent_ > msg->get_period()) { last_sent_ = Clock::now(); - Frame frame; - msg->unpack(frame); - transmit_frame(frame, msg->get_bus_name()); + send(msg); } } diff --git a/generator/templates/structs.hpp.j2 b/generator/templates/structs.hpp.j2 index 094ab5c..01e6a07 100644 --- a/generator/templates/structs.hpp.j2 +++ b/generator/templates/structs.hpp.j2 @@ -18,7 +18,7 @@ return key; } void send() override { - CANlib::send(this->last_sent_, this); + CANlib::send_period(this->last_sent_, this); } AbstractBus get_bus_name() override { return AbstractBus::{{ bus.name }}; @@ -111,7 +111,7 @@ struct Message { virtual Clock::duration get_period() = 0; }; -void send(Clock::time_point &last_sent_, Message* msg); +void send_period(Clock::time_point &last_sent_, Message* msg); void send(Message* msg); {%- for bus in can.bus %} diff --git a/test/Makefile b/test/Makefile index c45fdbc..0f520f0 100644 --- a/test/Makefile +++ b/test/Makefile @@ -14,8 +14,6 @@ COMP_SRC := ../src/src/computers/*.cpp # As an example, ./build/hello.cpp.o turns into ./build/hello.cpp.d #DEPS := $(OBJS:.o=.d) -# Every folder in ./src will need to be passed to GCC so that it can find header files -INC_DIRS := $(shell find ../src/inc tests/inc -type d) # Add a prefix to INC_DIRS. So moduleA would become -ImoduleA. GCC understands this -I flag INC_FLAGS := -I../src/inc -Itests/inc COMPUTER_FLAGS := -I../src/inc/drivers -I../src/inc/computers diff --git a/test/tests/src/send.cpp b/test/tests/src/send.cpp index 932dd1e..95df0e4 100644 --- a/test/tests/src/send.cpp +++ b/test/tests/src/send.cpp @@ -32,7 +32,7 @@ extern CAN can3; auto starting_time = Clock::now(); \ auto tmp = starting_time; \ while (Clock::now() - starting_time <= ID##_copy.get_period() + 5ms) { \ - send(tmp, &ID##_copy); \ + send_period(tmp, &ID##_copy); \ } \ } else { \ send(&ID##_copy); \ From 1197aa30b9949dfe2dcaeae8ee2fce4f047d16d9 Mon Sep 17 00:00:00 2001 From: Gabriel Cojocaru Date: Sun, 25 Apr 2021 18:38:30 +0300 Subject: [PATCH 09/17] fixed empty lines --- generator/templates/bus.cpp.j2 | 17 ++++++++++------- generator/templates/computer.cpp.j2 | 11 ++++++----- generator/templates/pack_unpack.cpp.j2 | 13 ++++++++----- generator/templates/structs.cpp.j2 | 16 +++++++++------- 4 files changed, 33 insertions(+), 24 deletions(-) diff --git a/generator/templates/bus.cpp.j2 b/generator/templates/bus.cpp.j2 index 8a8afc8..5a4a1eb 100644 --- a/generator/templates/bus.cpp.j2 +++ b/generator/templates/bus.cpp.j2 @@ -1,13 +1,13 @@ {%- macro key_type(num_bits) -%} uint{{ (((num_bits / 8) | round(method='ceil')) * 8) | int }}_t {%- endmacro -%} {%- macro last_sent_def(bus, msg, msg_name) -%} -{%- if msg.frame is defined %} - {% for sub_frame in msg.frame %} +{%- if msg.frame is defined -%} + {% for sub_frame in msg.frame -%} {{ last_sent_def(bus, sub_frame, msg_name + '::' + sub_frame.name) }} - {% endfor %} -{% else %} + {%- endfor %} +{%- else -%} Clock::time_point {{msg_name}}::last_sent_; -{% endif %} +{%- endif %} {%- endmacro -%} #include "static.hpp" @@ -16,14 +16,17 @@ #include "pack_unpack.hpp" namespace CANlib { + extern const std::pair* frame_id_range[{{ get_len(can) }}]; extern const uint32_t* frame_len[{{ get_len(can) }}]; extern const uint32_t* keys[{{ get_len(can) }}]; extern const size_t can_size[{{ get_len(can) }}]; extern Message** messages[{{ get_len(can) }}]; -{%- for bus in can.bus -%} + +{% for bus in can.bus %} {{ last_sent_def(bus, bus, bus.name) }} -{%- endfor -%} +{% endfor %} + } using namespace CANlib; diff --git a/generator/templates/computer.cpp.j2 b/generator/templates/computer.cpp.j2 index 4deb305..30f2445 100644 --- a/generator/templates/computer.cpp.j2 +++ b/generator/templates/computer.cpp.j2 @@ -27,17 +27,18 @@ AbstractBus CANlib::get_bus_name(RawBus bus) { } -{%- for busnm, rawnm in computer.participation['name']['can'].mapping.items() %} -{% if testing %} +{% for busnm, rawnm in computer.participation['name']['can'].mapping.items() %} +{% if testing -%} void CANlib::{{busnm}}_update_can() { -{% else %} +{%- else -%} static void CANlib::{{busnm}}_update_can() { -{% endif %} +{%- endif %} Frame frame; read_frame(frame, AbstractBus::{{ busnm }}); handle_frame(AbstractBus::{{busnm}}, frame); } -{%- endfor %} +{% endfor %} + void CANlib::update_can(void) { {%- for busnm in computer.participation['name']['can'].subscribe.keys() %} {{ busnm }}_update_can(); diff --git a/generator/templates/pack_unpack.cpp.j2 b/generator/templates/pack_unpack.cpp.j2 index a734670..e02245e 100644 --- a/generator/templates/pack_unpack.cpp.j2 +++ b/generator/templates/pack_unpack.cpp.j2 @@ -1,9 +1,10 @@ {%- macro can_pack_handler(frame, name_prepends, bus_ext, parent_slices = []) -%} {%- if frame.frame is defined -%} - {% for sub_frame in frame.frame -%} + {% for sub_frame in frame.frame %} {{ can_pack_handler(sub_frame, name_prepends + [frame.name], bus_ext, parent_slices + [frame.slice]) }} {% endfor -%} -{%- else -%} + +{% else -%} {%- set name_prepends = name_prepends + [frame.name] -%} {%- set tot_name = '::'.join(name_prepends) -%} void {{tot_name}}::unpack(Frame& can_out) { @@ -22,7 +23,7 @@ can_out.dlc = {{ (ns.length / 8) | round(method='ceil') | int }}; can_out.extended = {{ bus_ext | lower }}; } -{%- endif %} +{% endif %} {%- endmacro -%} {%- macro can_unpack_handler(frame, name_prepends) -%} @@ -30,7 +31,8 @@ {% for sub_frame in frame.frame -%} {{ can_unpack_handler(sub_frame, name_prepends + [sub_frame.name]) }} {% endfor -%} -{%- else -%} + +{% else -%} {%- set tot_name = "::".join(name_prepends) -%} void {{ tot_name }}::pack(const Frame& can_in) { uint64_t bitstring = 0; @@ -56,7 +58,7 @@ ; {%- endfor %} } -{%- endif %} +{% endif %} {%- endmacro -%} #include "structs.hpp" #include "pack_unpack.hpp" @@ -127,6 +129,7 @@ uint64_t swap_uint64(uint64_t val) { {% for bus in can.bus %} {%- for msg in bus.frame -%} {{ can_pack_handler(msg, [bus.name], bus.extended) }} + {{ can_unpack_handler(msg, [bus.name, msg.name]) }} {% endfor %} diff --git a/generator/templates/structs.cpp.j2 b/generator/templates/structs.cpp.j2 index a295287..2e2ad28 100644 --- a/generator/templates/structs.cpp.j2 +++ b/generator/templates/structs.cpp.j2 @@ -1,14 +1,15 @@ {%- macro struct_declarations(bus, msg, msg_name) -%} {%- if msg.frame is defined %} + namespace {{msg.name}} { - {% for sub_frame in msg.frame %} + {% for sub_frame in msg.frame -%} {{ struct_declarations(bus, sub_frame, msg_name + '::' + sub_frame.name) }} - {% endfor %} - } + {%- endfor %} + } {% else %} {{msg.name}} {{msg.name}}_input; -{% endif %} +{%- endif -%} {%- endmacro -%} {%- macro get_message_type(bus, msg, msg_names) -%} @@ -88,11 +89,11 @@ void send(Message* msg) { transmit_frame(frame, msg->get_bus_name()); } -{%- for bus in can.bus %} +{% for bus in can.bus %} namespace {{bus.name}} { {% for msg in bus.frame -%} {{ struct_declarations(bus, msg, msg.name) }} -{%- endfor -%} +{%- endfor %} extern const MessageType message_types[{{get_msg_len(bus)}}] = { MessageType::UNKNOWN_MSG, @@ -130,7 +131,7 @@ static Message* {{bus.name}}_messages[] = { {{ get_messages(msg, ['CANlib', bus.name, msg.name]) }} {%- endfor -%} }; -{%- endfor -%} +{% endfor %} const uint32_t* keys[{{ get_len(can) }}] = { {%- for bus in can.bus -%} @@ -162,4 +163,5 @@ Message** messages[{{ get_len(can) }}] = { {%- endfor -%} }; + } From b7c6042bb14f40e8d138ab0257c88356cd8a96c5 Mon Sep 17 00:00:00 2001 From: Gabriel Cojocaru Date: Sun, 25 Apr 2021 18:49:27 +0300 Subject: [PATCH 10/17] change get_msg_len to get_num_msg_types --- generator/main.py | 6 +++--- generator/templates/structs.cpp.j2 | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/generator/main.py b/generator/main.py index a0143b6..6f75183 100644 --- a/generator/main.py +++ b/generator/main.py @@ -34,9 +34,9 @@ def get_ms(period_str): ur = UnitRegistry() return (int)(ur[period_str].to('ms').magnitude) -def get_msg_len(msg): +def get_num_msg_types(msg): if hasattr(msg, "frame"): - return 1 + sum([get_msg_len(sub_frame) for sub_frame in msg.frame]) + return 1 + sum([get_num_msg_types(sub_frame) for sub_frame in msg.frame]) return 1 def get_len(can): @@ -70,7 +70,7 @@ def render_template_from_to(env, input_path, output_path): template = env.get_template(str(input_path)) with open(output_path, 'w') as f: if output_path in [inc_dir.joinpath("structs.hpp"), src_dir.joinpath("structs.cpp")]: - f.write(template.render(get_len = get_len, get_ms = get_ms, get_msg_len = get_msg_len)) + f.write(template.render(get_len = get_len, get_ms = get_ms, get_num_msg_types = get_num_msg_types)) else: f.write(template.render(get_len = get_len)) diff --git a/generator/templates/structs.cpp.j2 b/generator/templates/structs.cpp.j2 index 2e2ad28..48bedb2 100644 --- a/generator/templates/structs.cpp.j2 +++ b/generator/templates/structs.cpp.j2 @@ -58,7 +58,7 @@ {%- macro get_frame_ranges(msg, msg_names, cnt = 0) -%} {%- if msg.frame is defined -%} - {{ get_msg_len(msg) }}, + {{ get_num_msg_types(msg) }}, {%- for sub_frame in msg.frame -%} {{ get_frame_ranges(sub_frame, msg_names + [sub_frame.name], cnt + 1) }} {%- endfor -%} @@ -95,7 +95,7 @@ namespace {{bus.name}} { {{ struct_declarations(bus, msg, msg.name) }} {%- endfor %} -extern const MessageType message_types[{{get_msg_len(bus)}}] = { +extern const MessageType message_types[{{get_num_msg_types(bus)}}] = { MessageType::UNKNOWN_MSG, {% for msg in bus.frame -%} {{ get_message_type(bus, msg, [msg.name]) }} @@ -153,7 +153,7 @@ const uint32_t* frame_len[{{ get_len(can) }}] = { extern const size_t can_size[{{ get_len(can) }}] = { {%- for bus in can.bus -%} -{{ get_msg_len(bus) }}, +{{ get_num_msg_types(bus) }}, {%- endfor -%} }; From 542a86806b39e18efeec1d42a000ab3c549d2871 Mon Sep 17 00:00:00 2001 From: Gabriel Cojocaru Date: Sun, 25 Apr 2021 18:55:55 +0300 Subject: [PATCH 11/17] replace ID with Name --- test/tests/src/constants.cpp | 8 +++--- test/tests/src/identify.cpp | 16 +++++------ test/tests/src/message.cpp | 10 +++---- test/tests/src/send.cpp | 54 ++++++++++++++++++------------------ 4 files changed, 44 insertions(+), 44 deletions(-) diff --git a/test/tests/src/constants.cpp b/test/tests/src/constants.cpp index 615d5f6..a931f76 100644 --- a/test/tests/src/constants.cpp +++ b/test/tests/src/constants.cpp @@ -202,11 +202,11 @@ void testPeriod() { assert(N_copy.get_period() == 0ms); } -#define CREATE_TEST(ID, bus_idx, key, msg) \ - static void testMessageType##ID() { \ - ID ID##_copy; \ +#define CREATE_TEST(Name, bus_idx, key, msg) \ + static void testMessageType##Name() { \ + Name Name##_copy; \ Frame f; \ - ID##_copy.unpack(f); \ + Name##_copy.unpack(f); \ int idx = identify(AbstractBus::map##bus_idx, f); \ assert(map##bus_idx::message_types[idx] == map##bus_idx::MessageType::msg); \ } diff --git a/test/tests/src/identify.cpp b/test/tests/src/identify.cpp index 4ae884a..1330735 100644 --- a/test/tests/src/identify.cpp +++ b/test/tests/src/identify.cpp @@ -12,8 +12,8 @@ using namespace map2; using namespace J; using namespace CC; -#define CREATE_TEST0(ID, bus_idx, key) \ - static void test##ID() { \ +#define CREATE_TEST0(Name, bus_idx, key) \ + static void test##Name() { \ for (int cs = 0; cs < 100; ++cs) { \ Frame f; \ f.dlc = distribution(generator); \ @@ -23,18 +23,18 @@ using namespace CC; f.id = key; \ int idx = identify(AbstractBus::map##bus_idx, f); \ Message *msg = messages[bus_idx - 1][idx]; \ - assert((dynamic_cast(msg)) != nullptr); \ + assert((dynamic_cast(msg)) != nullptr); \ } \ } -#define CREATE_TEST1(ID, bus_idx, key) \ - static void test##ID() { \ - ID ID##_copy; \ +#define CREATE_TEST1(Name, bus_idx, key) \ + static void test##Name() { \ + Name Name##_copy; \ Frame f; \ - ID##_copy.unpack(f); \ + Name##_copy.unpack(f); \ int idx = identify(AbstractBus::map##bus_idx, f); \ Message *msg = messages[bus_idx - 1][idx]; \ - assert((dynamic_cast(msg)) != nullptr); \ + assert((dynamic_cast(msg)) != nullptr); \ } CREATE_TEST0(A, 1, 0X2FF) diff --git a/test/tests/src/message.cpp b/test/tests/src/message.cpp index 2eb045b..975fba7 100644 --- a/test/tests/src/message.cpp +++ b/test/tests/src/message.cpp @@ -9,10 +9,10 @@ using namespace map2; using namespace J; using namespace CC; -#define CREATE_TEST(ID, BITMASK) \ - void test##ID() { \ +#define CREATE_TEST(Name, BITMASK) \ + void test##Name() { \ for (int cs = 0; cs < 100000; ++cs) { \ - ID ID##_copy; \ + Name Name##_copy; \ Frame f0; \ for (int i = 0; i < 8; ++i) { \ f0.data[i] = distribution(generator); \ @@ -20,10 +20,10 @@ using namespace CC; uint64_t bitstring0; \ to_bitstring((uint8_t *)f0.data, &bitstring0); \ bitstring0 &= BITMASK; \ - ID##_copy.pack(f0); \ + Name##_copy.pack(f0); \ Frame f1; \ memset(f1.data, 0, sizeof(f1.data)); \ - ID##_copy.unpack(f1); \ + Name##_copy.unpack(f1); \ uint64_t bitstring1; \ to_bitstring((uint8_t *)f1.data, &bitstring1); \ bitstring1 &= BITMASK; \ diff --git a/test/tests/src/send.cpp b/test/tests/src/send.cpp index 95df0e4..d394fe2 100644 --- a/test/tests/src/send.cpp +++ b/test/tests/src/send.cpp @@ -16,33 +16,33 @@ extern CAN can1; extern CAN can2; extern CAN can3; -#define CREATE_TEST(ID, can, BITMASK) \ - static void testSend##ID() { \ - ID ID##_copy; \ - Frame f0; \ - for (int i = 0; i < 8; ++i) { \ - f0.data[i] = distribution(generator); \ - } \ - uint64_t bitstring0; \ - to_bitstring((uint8_t *)f0.data, &bitstring0); \ - bitstring0 &= BITMASK; \ - ID##_copy.pack(f0); \ - can.clear(); \ - if (ID##_copy.get_period() != 0ms) { \ - auto starting_time = Clock::now(); \ - auto tmp = starting_time; \ - while (Clock::now() - starting_time <= ID##_copy.get_period() + 5ms) { \ - send_period(tmp, &ID##_copy); \ - } \ - } else { \ - send(&ID##_copy); \ - } \ - uint64_t bitstring1; \ - assert(can.framesReceived() == 1); \ - Frame f1 = can.topFrame(); \ - to_bitstring((uint8_t *)f1.data, &bitstring1); \ - bitstring1 &= BITMASK; \ - assert(bitstring0 == bitstring1); \ +#define CREATE_TEST(Name, can, BITMASK) \ + static void testSend##Name() { \ + Name Name##_copy; \ + Frame f0; \ + for (int i = 0; i < 8; ++i) { \ + f0.data[i] = distribution(generator); \ + } \ + uint64_t bitstring0; \ + to_bitstring((uint8_t *)f0.data, &bitstring0); \ + bitstring0 &= BITMASK; \ + Name##_copy.pack(f0); \ + can.clear(); \ + if (Name##_copy.get_period() != 0ms) { \ + auto starting_time = Clock::now(); \ + auto tmp = starting_time; \ + while (Clock::now() - starting_time <= Name##_copy.get_period() + 5ms) { \ + send_period(tmp, &Name##_copy); \ + } \ + } else { \ + send(&Name##_copy); \ + } \ + uint64_t bitstring1; \ + assert(can.framesReceived() == 1); \ + Frame f1 = can.topFrame(); \ + to_bitstring((uint8_t *)f1.data, &bitstring1); \ + bitstring1 &= BITMASK; \ + assert(bitstring0 == bitstring1); \ } CREATE_TEST(A, MAP1_CAN, (~ZEROES_MASK(7, 49))) From 661c705fd6b676e1f8fbadab1ec72e27f035e2b4 Mon Sep 17 00:00:00 2001 From: Gabriel Cojocaru Date: Sun, 25 Apr 2021 18:56:28 +0300 Subject: [PATCH 12/17] added deletion of objects --- test/Makefile | 1 + test/tests/main.cpp | 2 ++ 2 files changed, 3 insertions(+) diff --git a/test/Makefile b/test/Makefile index 0f520f0..1ee3a16 100644 --- a/test/Makefile +++ b/test/Makefile @@ -88,6 +88,7 @@ $(BUILD_DIR)/src/src/computers/canlib_testcomp2.cpp.o: $(BUILD_DIR) .PHONY: clean build clean: python3 ../generator/main.py --clean + rm -r build/ rm main0 main1 main2 build: main0 main1 main2 run: diff --git a/test/tests/main.cpp b/test/tests/main.cpp index ca95fcd..2a83f05 100644 --- a/test/tests/main.cpp +++ b/test/tests/main.cpp @@ -1,3 +1,4 @@ +#include #include "test.hpp" std::default_random_engine generator; @@ -11,5 +12,6 @@ int main() { testMessageType(); testPackUnpack(); testSend(); + printf("Success ..."); return 0; } From 749390f3b1a408ccb8b1749b647b7967d40e62c1 Mon Sep 17 00:00:00 2001 From: Gabriel Cojocaru Date: Sun, 25 Apr 2021 19:02:24 +0300 Subject: [PATCH 13/17] replaced CAN with TestCAN --- generator/templates/drivers/inc/testfamily.hpp.j2 | 2 +- src/src/drivers/testfamily.cpp | 6 +++--- test/tests/src/arch0.cpp | 6 +++--- test/tests/src/arch1.cpp | 6 +++--- test/tests/src/arch2.cpp | 6 +++--- test/tests/src/send.cpp | 6 +++--- 6 files changed, 16 insertions(+), 16 deletions(-) diff --git a/generator/templates/drivers/inc/testfamily.hpp.j2 b/generator/templates/drivers/inc/testfamily.hpp.j2 index ff7cddc..0339e6c 100644 --- a/generator/templates/drivers/inc/testfamily.hpp.j2 +++ b/generator/templates/drivers/inc/testfamily.hpp.j2 @@ -14,7 +14,7 @@ namespace CANlib { -class CAN { +class TestCAN { public: void setFrameToSend(const Frame& f) {frame_to_send = f;} void receiveFrame(const Frame& f) {frames_received.push_back(f);} diff --git a/src/src/drivers/testfamily.cpp b/src/src/drivers/testfamily.cpp index fb86638..19173f6 100644 --- a/src/src/drivers/testfamily.cpp +++ b/src/src/drivers/testfamily.cpp @@ -9,9 +9,9 @@ using namespace CANlib; -CAN can1; -CAN can2; -CAN can3; +TestCAN can1; +TestCAN can2; +TestCAN can3; Clock::time_point Clock::now() noexcept { static const auto start_time = std::chrono::system_clock::now(); diff --git a/test/tests/src/arch0.cpp b/test/tests/src/arch0.cpp index e632c80..03de020 100644 --- a/test/tests/src/arch0.cpp +++ b/test/tests/src/arch0.cpp @@ -16,9 +16,9 @@ using namespace CANlib; using namespace map1; using namespace map2; -extern CAN can1; -extern CAN can2; -extern CAN can3; +extern TestCAN can1; +extern TestCAN can2; +extern TestCAN can3; void testArch() { assert(get_raw_bus(AbstractBus::map1) == RawBus::CAN_2); diff --git a/test/tests/src/arch1.cpp b/test/tests/src/arch1.cpp index c0c96f0..950b094 100644 --- a/test/tests/src/arch1.cpp +++ b/test/tests/src/arch1.cpp @@ -15,9 +15,9 @@ using namespace CANlib; using namespace map1; using namespace map2; -extern CAN can1; -extern CAN can2; -extern CAN can3; +extern TestCAN can1; +extern TestCAN can2; +extern TestCAN can3; void testArch() { assert(get_raw_bus(AbstractBus::map1) == RawBus::CAN_2); diff --git a/test/tests/src/arch2.cpp b/test/tests/src/arch2.cpp index 77fe656..172b324 100644 --- a/test/tests/src/arch2.cpp +++ b/test/tests/src/arch2.cpp @@ -15,9 +15,9 @@ using namespace CANlib; using namespace map1; using namespace map2; -extern CAN can1; -extern CAN can2; -extern CAN can3; +extern TestCAN can1; +extern TestCAN can2; +extern TestCAN can3; void testArch() { assert(get_raw_bus(AbstractBus::map1) == RawBus::CAN_3); diff --git a/test/tests/src/send.cpp b/test/tests/src/send.cpp index d394fe2..a4336f2 100644 --- a/test/tests/src/send.cpp +++ b/test/tests/src/send.cpp @@ -12,9 +12,9 @@ using namespace J; using namespace CC; using namespace std::chrono_literals; -extern CAN can1; -extern CAN can2; -extern CAN can3; +extern TestCAN can1; +extern TestCAN can2; +extern TestCAN can3; #define CREATE_TEST(Name, can, BITMASK) \ static void testSend##Name() { \ From fea048317310c93efb5f91b74a73be3776b76091 Mon Sep 17 00:00:00 2001 From: Gabriel Cojocaru Date: Sun, 25 Apr 2021 20:44:59 +0300 Subject: [PATCH 14/17] added get_input method --- generator/templates/structs.cpp.j2 | 19 ++++++++++++------- generator/templates/structs.hpp.j2 | 2 ++ test/tests/src/arch0.cpp | 21 +++++++-------------- test/tests/src/arch1.cpp | 21 +++++++-------------- test/tests/src/arch2.cpp | 12 +++++++----- 5 files changed, 35 insertions(+), 40 deletions(-) diff --git a/generator/templates/structs.cpp.j2 b/generator/templates/structs.cpp.j2 index 48bedb2..58ffba6 100644 --- a/generator/templates/structs.cpp.j2 +++ b/generator/templates/structs.cpp.j2 @@ -1,15 +1,20 @@ -{%- macro struct_declarations(bus, msg, msg_name) -%} +{%- macro struct_declarations(bus, msg, msg_names = [msg.name]) -%} {%- if msg.frame is defined %} namespace {{msg.name}} { {% for sub_frame in msg.frame -%} - {{ struct_declarations(bus, sub_frame, msg_name + '::' + sub_frame.name) }} + {{ struct_declarations(bus, sub_frame, msg_names + [sub_frame.name]) }} {%- endfor %} } {% else %} {{msg.name}} {{msg.name}}_input; -{%- endif -%} + + {{ msg.name }}* CANlib::{{bus.name}}::{{'::'.join(msg_names)}}::get_input() { + return &{{msg.name}}_input; + } + +{% endif -%} {%- endmacro -%} {%- macro get_message_type(bus, msg, msg_names) -%} @@ -76,9 +81,9 @@ namespace CANlib { -void send_period(Clock::time_point &last_sent_, Message* msg) { - if (Clock::now() - last_sent_ > msg->get_period()) { - last_sent_ = Clock::now(); +void send_period(Clock::time_point &last_sent, Message* msg) { + if (Clock::now() - last_sent > msg->get_period()) { + last_sent = Clock::now(); send(msg); } } @@ -92,7 +97,7 @@ void send(Message* msg) { {% for bus in can.bus %} namespace {{bus.name}} { {% for msg in bus.frame -%} -{{ struct_declarations(bus, msg, msg.name) }} +{{ struct_declarations(bus, msg) }} {%- endfor %} extern const MessageType message_types[{{get_num_msg_types(bus)}}] = { diff --git a/generator/templates/structs.hpp.j2 b/generator/templates/structs.hpp.j2 index 01e6a07..f3e4597 100644 --- a/generator/templates/structs.hpp.j2 +++ b/generator/templates/structs.hpp.j2 @@ -1,6 +1,7 @@ {%- macro struct_declarations(bus, msg, msg_names = [msg.name]) -%} {%- if msg.frame is defined %} namespace {{msg.name}} { + const uint32_t key = 0x{{ '%0X' % msg.key }}; {% for sub_frame in msg.frame %} {{ struct_declarations(bus, sub_frame, msg_names + [sub_frame.name]) }} @@ -9,6 +10,7 @@ {% else %} struct {{msg.name}} : public Message_{{ bus.name }} { + static {{msg.name}} * get_input(); MessageType get_message_type() override { return MessageType::{{ '_'.join(msg_names) }}; } diff --git a/test/tests/src/arch0.cpp b/test/tests/src/arch0.cpp index 03de020..df60e6e 100644 --- a/test/tests/src/arch0.cpp +++ b/test/tests/src/arch0.cpp @@ -3,15 +3,6 @@ #include "canlib_testcomp0.hpp" #include "test.hpp" -namespace CANlib { -namespace map1 { -extern A A_input; -} // namespace map1 -namespace map2 { -extern F F_input; -} // namespace map2 -} // namespace CANlib - using namespace CANlib; using namespace map1; using namespace map2; @@ -31,8 +22,8 @@ void testArch() { can1.clear(); can2.clear(); can3.clear(); - send(&A_input); - send(&F_input); + send(map1::A::get_input()); + send(map2::F::get_input()); assert(1 == can1.framesReceived()); assert(1 == can2.framesReceived()); assert(0 == can3.framesReceived()); @@ -49,7 +40,8 @@ void testArch() { can2.setFrameToSend(f); map1::A A_copy2; map1_update_can(); - assert(A_input.ARG0 && A_input.ARG1 == 69 && A_input.ARG2 == 69 && A_input.ARG3 == 69); + map1::A* A_input = map1::A::get_input(); + assert(A_input->ARG0 && A_input->ARG1 == 69 && A_input->ARG2 == 69 && A_input->ARG3 == 69); map2::F F_copy; F_copy.ARG0 = 69; F_copy.ARG1 = 69; @@ -60,6 +52,7 @@ void testArch() { F_copy.unpack(f); can1.setFrameToSend(f); map2_update_can(); - assert(F_input.ARG0 == 69 && F_input.ARG1 == 69 && F_input.ARG2 == 69 && F_input.ARG3 == 69 && - F_input.ARG4 == 69 && F_input.ARG5 == 69); + map2::F* F_input = map2::F::get_input(); + assert(F_input->ARG0 == 69 && F_input->ARG1 == 69 && F_input->ARG2 == 69 && F_input->ARG3 == 69 && + F_input->ARG4 == 69 && F_input->ARG5 == 69); } diff --git a/test/tests/src/arch1.cpp b/test/tests/src/arch1.cpp index 950b094..cb9b59f 100644 --- a/test/tests/src/arch1.cpp +++ b/test/tests/src/arch1.cpp @@ -2,15 +2,6 @@ #include "canlib_testcomp1.hpp" #include "test.hpp" -namespace CANlib { -namespace map1 { -extern A A_input; -} // namespace map1 -namespace map2 { -extern F F_input; -} // namespace map2 -} // namespace CANlib - using namespace CANlib; using namespace map1; using namespace map2; @@ -30,8 +21,8 @@ void testArch() { can1.clear(); can2.clear(); can3.clear(); - send(&A_input); - send(&F_input); + send(map1::A::get_input()); + send(map2::F::get_input()); assert(0 == can1.framesReceived()); assert(1 == can2.framesReceived()); assert(1 == can3.framesReceived()); @@ -48,7 +39,8 @@ void testArch() { can2.setFrameToSend(f); map1::A A_copy2; map1_update_can(); - assert(A_input.ARG0 && A_input.ARG1 == 69 && A_input.ARG2 == 69 && A_input.ARG3 == 69); + map1::A* A_input = map1::A::get_input(); + assert(A_input->ARG0 && A_input->ARG1 == 69 && A_input->ARG2 == 69 && A_input->ARG3 == 69); map2::F F_copy; F_copy.ARG0 = 69; F_copy.ARG1 = 69; @@ -59,6 +51,7 @@ void testArch() { F_copy.unpack(f); can3.setFrameToSend(f); map2_update_can(); - assert(F_input.ARG0 == 69 && F_input.ARG1 == 69 && F_input.ARG2 == 69 && F_input.ARG3 == 69 && - F_input.ARG4 == 69 && F_input.ARG5 == 69); + map2::F* F_input = map2::F::get_input(); + assert(F_input->ARG0 == 69 && F_input->ARG1 == 69 && F_input->ARG2 == 69 && F_input->ARG3 == 69 && + F_input->ARG4 == 69 && F_input->ARG5 == 69); } diff --git a/test/tests/src/arch2.cpp b/test/tests/src/arch2.cpp index 172b324..ef1fe2f 100644 --- a/test/tests/src/arch2.cpp +++ b/test/tests/src/arch2.cpp @@ -30,8 +30,8 @@ void testArch() { can1.clear(); can2.clear(); can3.clear(); - send(&A_input); - send(&F_input); + send(map1::A::get_input()); + send(map2::F::get_input()); assert(1 == can1.framesReceived()); assert(0 == can2.framesReceived()); assert(1 == can3.framesReceived()); @@ -48,7 +48,8 @@ void testArch() { can3.setFrameToSend(f); map1::A A_copy2; map1_update_can(); - assert(A_input.ARG0 && A_input.ARG1 == 69 && A_input.ARG2 == 69 && A_input.ARG3 == 69); + map1::A* A_input = map1::A::get_input(); + assert(A_input->ARG0 && A_input->ARG1 == 69 && A_input->ARG2 == 69 && A_input->ARG3 == 69); map2::F F_copy; F_copy.ARG0 = 69; F_copy.ARG1 = 69; @@ -59,6 +60,7 @@ void testArch() { F_copy.unpack(f); can1.setFrameToSend(f); map2_update_can(); - assert(F_input.ARG0 == 69 && F_input.ARG1 == 69 && F_input.ARG2 == 69 && F_input.ARG3 == 69 && - F_input.ARG4 == 69 && F_input.ARG5 == 69); + map2::F* F_input = map2::F::get_input(); + assert(F_input->ARG0 == 69 && F_input->ARG1 == 69 && F_input->ARG2 == 69 && F_input->ARG3 == 69 && + F_input->ARG4 == 69 && F_input->ARG5 == 69); } From 6be3c841db465671390200c1fcb01d1bd23a527a Mon Sep 17 00:00:00 2001 From: Gabriel Cojocaru Date: Sun, 9 May 2021 18:45:58 +0300 Subject: [PATCH 15/17] added some comments --- generator/main.py | 12 ++- generator/templates/bus.cpp.j2 | 1 + generator/templates/computer.cpp.j2 | 28 +++--- generator/templates/computer.hpp.j2 | 6 -- .../templates/drivers/inc/stm32f2xx.hpp.j2 | 14 --- .../templates/drivers/inc/stm32f4xx.hpp.j2 | 2 +- generator/templates/structs.cpp.j2 | 6 ++ src/inc/driver.hpp | 10 +- src/src/drivers/stm32f2xx.cpp | 99 ------------------- src/src/drivers/stm32f4xx.cpp | 31 +++--- test/Makefile | 2 - test/tests/src/arch0.cpp | 10 +- test/tests/src/arch1.cpp | 10 +- test/tests/src/arch2.cpp | 10 +- test/tests/src/message.cpp | 6 +- test/tests/src/send.cpp | 1 + 16 files changed, 78 insertions(+), 170 deletions(-) delete mode 100644 generator/templates/drivers/inc/stm32f2xx.hpp.j2 delete mode 100644 src/src/drivers/stm32f2xx.cpp diff --git a/generator/main.py b/generator/main.py index 6f75183..c8b267f 100644 --- a/generator/main.py +++ b/generator/main.py @@ -113,10 +113,14 @@ def render_template(env, relative_path): computers_hpp.write(template_env, system.computer, computer_hpp_template_path, computer_hpp_dir_path, testing) computers_cpp.write(template_env, system.computer, computer_cpp_template_path, computer_cpp_dir_path, testing) drivers_inc.write(template_env, system, drivers_inc_template_dir_path, drivers_inc_dir_path, testing) + clang_style = "" + styles = [arg for arg in sys.argv if arg.startswith('style=')] + if len(styles) > 0: + clang_style = styles[0] try: - os.system('clang-format -i ' + spth + '/src/inc/drivers/*.hpp ' + spth + '/src/src/drivers/*.cpp') - os.system('clang-format -i ' + spth + '/src/inc/computers/*.hpp ' + spth + '/src/src/computers/*.cpp') - os.system('clang-format -i ' + spth + '/src/inc/*.hpp') - os.system('clang-format -i ' + spth + '/src/src/*.cpp') + os.system('clang-format -i ' + clang_style + ' ' + spth + '/src/inc/drivers/*.hpp ' + spth + '/src/src/drivers/*.cpp') + os.system('clang-format -i ' + clang_style + ' ' + spth + '/src/inc/computers/*.hpp ' + spth + '/src/src/computers/*.cpp') + os.system('clang-format -i ' + clang_style + ' ' + spth + '/src/inc/*.hpp') + os.system('clang-format -i ' + clang_style + ' ' + spth + '/src/src/*.cpp') except: print('Error during clang-format, is it installed?') diff --git a/generator/templates/bus.cpp.j2 b/generator/templates/bus.cpp.j2 index 5a4a1eb..f81acf9 100644 --- a/generator/templates/bus.cpp.j2 +++ b/generator/templates/bus.cpp.j2 @@ -36,6 +36,7 @@ static uint32_t identify_internal(const uint32_t key, const Frame& frame, int l, if (keys[bus_idx][i] == key) { int left_bound = frame_id_range[bus_idx][i].first; int right_bound = frame_id_range[bus_idx][i].second; + // If this is a frame search inside the frame, otherwise return the index of the message if (left_bound <= right_bound) { uint64_t bitstring; to_bitstring((uint8_t*)frame.data, &bitstring); diff --git a/generator/templates/computer.cpp.j2 b/generator/templates/computer.cpp.j2 index 30f2445..58cf452 100644 --- a/generator/templates/computer.cpp.j2 +++ b/generator/templates/computer.cpp.j2 @@ -1,10 +1,11 @@ #include "canlib_{{ computer.name }}.hpp" #include "bus.hpp" -#include "drivers/{{ system.architecture['name'][computer.architecture].family }}.hpp" +#include "driver.hpp" +#include "{{ system.architecture['name'][computer.architecture].family }}.hpp" -using namespace CANlib; +namespace CANlib { -RawBus CANlib::get_raw_bus(AbstractBus bus_name) { +RawBus get_raw_bus(AbstractBus bus_name) { switch (bus_name) { {%- for busnm, rawnm in computer.participation['name']['can'].mapping.items() %} case AbstractBus::{{ busnm }}: @@ -15,8 +16,8 @@ RawBus CANlib::get_raw_bus(AbstractBus bus_name) { } } -AbstractBus CANlib::get_bus_name(RawBus bus) { - switch (bus) { +AbstractBus get_bus_name(RawBus bus) { + switch (bus) { {%- for busnm, rawnm in computer.participation['name']['can'].mapping.items() %} case RawBus::{{ rawnm }}: return AbstractBus::{{ busnm }}; @@ -26,21 +27,24 @@ AbstractBus CANlib::get_bus_name(RawBus bus) { } } - {% for busnm, rawnm in computer.participation['name']['can'].mapping.items() %} {% if testing -%} -void CANlib::{{busnm}}_update_can() { + void {{busnm}}_update_can() { {%- else -%} -static void CANlib::{{busnm}}_update_can() { + static void {{busnm}}_update_can() { {%- endif %} - Frame frame; - read_frame(frame, AbstractBus::{{ busnm }}); - handle_frame(AbstractBus::{{busnm}}, frame); + Frame frame; + read_frame(frame, AbstractBus::{{ busnm }}); + handle_frame(AbstractBus::{{busnm}}, frame); } {% endfor %} -void CANlib::update_can(void) { +void update_can(void) { {%- for busnm in computer.participation['name']['can'].subscribe.keys() %} {{ busnm }}_update_can(); {%- endfor %} } + +} + + diff --git a/generator/templates/computer.hpp.j2 b/generator/templates/computer.hpp.j2 index 8c7b6b6..917e79b 100644 --- a/generator/templates/computer.hpp.j2 +++ b/generator/templates/computer.hpp.j2 @@ -13,12 +13,6 @@ namespace CANlib { {%- for busnm, rawnm in computer.participation['name']['can'].mapping.items() %} void {{busnm}}_update_can(); {%- endfor %} - {% else %} - {%- for busnm, rawnm in computer.participation['name']['can'].mapping.items() %} - static void {{busnm}}_update_can(); - {%- endfor %} {% endif %} void update_can(); - RawBus get_raw_bus(AbstractBus bus_name); - AbstractBus get_bus_name(RawBus bus); } diff --git a/generator/templates/drivers/inc/stm32f2xx.hpp.j2 b/generator/templates/drivers/inc/stm32f2xx.hpp.j2 deleted file mode 100644 index 78b3b39..0000000 --- a/generator/templates/drivers/inc/stm32f2xx.hpp.j2 +++ /dev/null @@ -1,14 +0,0 @@ -#pragma once - -#include "static.hpp" - -#include "stm32f2xx_hal_can.h" -#include - -namespace CANlib { - - typedef HAL_StatusTypeDef CANlib_Transmit_Error_T; - - HAL_StatusTypeDef Init(uint32_t baudrate); - HAL_StatusTypeDef TransmitFrame(Frame& frame); -} diff --git a/generator/templates/drivers/inc/stm32f4xx.hpp.j2 b/generator/templates/drivers/inc/stm32f4xx.hpp.j2 index d372cdc..8ab940d 100644 --- a/generator/templates/drivers/inc/stm32f4xx.hpp.j2 +++ b/generator/templates/drivers/inc/stm32f4xx.hpp.j2 @@ -3,7 +3,7 @@ #include "static.hpp" #include "stm32f4xx_hal.h" #include "bus.hpp" -#include "clock.h" +#include "clock.hpp" #include diff --git a/generator/templates/structs.cpp.j2 b/generator/templates/structs.cpp.j2 index 58ffba6..976d256 100644 --- a/generator/templates/structs.cpp.j2 +++ b/generator/templates/structs.cpp.j2 @@ -116,6 +116,11 @@ static const uint32_t {{bus.name}}_keys[] = { {%- endfor -%} }; +/** + * In case the some index represents a frame, the first element represents the lower bound + * of the frame inside the array and the second element represents the upper bound of the + * frame inside the array. + **/ static const std::pair {{bus.name}}_frame_id_range[] = { std::make_pair(1,0), {% for msg in bus.frame -%} @@ -123,6 +128,7 @@ static const std::pair {{bus.name}}_frame_id_range[] = { {%- endfor -%} }; +// In case some index represents a frame, it will contain number of messages inside the frame static const uint32_t {{bus.name}}_frame_len[] = { 0, {% for msg in bus.frame -%} diff --git a/src/inc/driver.hpp b/src/inc/driver.hpp index ae1e97c..83818c9 100644 --- a/src/inc/driver.hpp +++ b/src/inc/driver.hpp @@ -1,11 +1,5 @@ #pragma once -// INCLUDE THIS AFTER YOUR DRIVER - -#if !(CANLIB_ARCH_STM32F4XX || CANLIB_ARCH_STM32F2XX || CANLIB_ARCH_TESTFAMILY) -#error "No architecture specified!" -#endif - #ifdef CANLIB_ARCH_STM32F4xx #include "drivers/stm32f4xx.hpp" #elif defined(CANLIB_ARCH_STM32F2XX) @@ -19,6 +13,6 @@ #include "bus.hpp" namespace CANlib { -TransmitError transmit_frame(const Frame &frame, AbstractBus bus_name); -void read_frame(Frame &frame, RawBus bus); +RawBus get_raw_bus(AbstractBus bus_name); +AbstractBus get_bus_name(RawBus bus); } // namespace CANlib diff --git a/src/src/drivers/stm32f2xx.cpp b/src/src/drivers/stm32f2xx.cpp deleted file mode 100644 index 5831517..0000000 --- a/src/src/drivers/stm32f2xx.cpp +++ /dev/null @@ -1,99 +0,0 @@ -#ifdef CANLIB_ARCH_STM32F2XX -#include "static.hpp" - -#include -#include "stm32f2xx_hal_can.h" - -CAN_HandleTypeDef CanHandle; - -HAL_StatusTypeDef CANlib_Init(uint32_t baudrate) { - // TODO calculate baudrate and set stuff accordingly - // Right now the baudrate is hard-coded to 500kbaud - // Can change prescaler to change this - // 2 Mbaud / prescaler = baudrate (prescaler goes from 1 to 1024) - - CAN_FilterConfTypeDef sFilterConfig; - static CanTxMsgTypeDef TxMessage; - static CanRxMsgTypeDef RxMessage; - - CanHandle.Instance = CAN1; - CanHandle.pTxMsg = &TxMessage; - CanHandle.pRxMsg = &RxMessage; - - CanHandle.Init.TTCM = DISABLE; - CanHandle.Init.ABOM = DISABLE; - CanHandle.Init.AWUM = DISABLE; - CanHandle.Init.NART = DISABLE; - CanHandle.Init.RFLM = DISABLE; - CanHandle.Init.TXFP = DISABLE; - CanHandle.Init.Mode = CAN_MODE_NORMAL; - CanHandle.Init.SJW = CAN_SJW_1TQ; - CanHandle.Init.BS1 = CAN_BS1_6TQ; - CanHandle.Init.BS2 = CAN_BS2_8TQ; - CanHandle.Init.Prescaler = 4; - - HAL_StatusTypeDef status; - - if ((status = HAL_CAN_Init(&CanHandle)) != HAL_OK) { - /* Initialization Error */ - - printf("[CAN INIT] ERROR\r\n"); - return status; - } - - // TODO: Might want to comment this out - sFilterConfig.FilterNumber = 0; - sFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK; - sFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT; - sFilterConfig.FilterIdHigh = 0x0000; - sFilterConfig.FilterIdLow = 0x0000; - sFilterConfig.FilterMaskIdHigh = 0x0000; - sFilterConfig.FilterMaskIdLow = 0x0000; - sFilterConfig.FilterFIFOAssignment = 0; - sFilterConfig.FilterActivation = ENABLE; - sFilterConfig.BankNumber = 14; - - if ((status = HAL_CAN_ConfigFilter(&CanHandle, &sFilterConfig)) != HAL_OK) { - return status; - } - - if ((status = HAL_CAN_Receive_IT(&CanHandle, CAN_FIFO0)) != HAL_OK) { - return status; - } - - return HAL_OK; -} - -HAL_StatusTypeDef CANlib_TransmitFrame(Frame *frame) { - if (frame->extended) { - CanHandle.pTxMsg->ExtId = frame->id; - CanHandle.pTxMsg->IDE = CAN_ID_EXT; - } else { - CanHandle.pTxMsg->StdId = frame->id; - CanHandle.pTxMsg->IDE = CAN_ID_STD; - } - - CanHandle.pTxMsg->DLC = frame->len; - CanHandle.pTxMsg->RTR = CAN_RTR_DATA; - - memcpy(CanHandle.pTxMsg->Data, frame->data, sizeof(frame->data)); - - __disable_irq(); - HAL_StatusTypeDef CAN_TX_STATUS = HAL_CAN_Transmit_IT(&CanHandle); - __enable_irq(); - - if (CAN_TX_STATUS != HAL_OK) { - // TODO handle error - printf("[CAN TX] ERROR: HAL_StatusTypeDef is %d\r\n", (int)CAN_TX_STATUS); - printf("[CAN TX] ERROR: HAL_CAN_StateTypeDef is %d\r\n", CanHandle.State); - printf("[CAN TX] ERROR: ErrorCode is %d\r\n", CanHandle.ErrorCode); - - return CAN_TX_STATUS; - } - - // ~HACK~ - HAL_CAN_Receive_IT(&CanHandle, CAN_FIFO0); - - return HAL_OK; -} -#endif diff --git a/src/src/drivers/stm32f4xx.cpp b/src/src/drivers/stm32f4xx.cpp index c4884a6..8b83614 100644 --- a/src/src/drivers/stm32f4xx.cpp +++ b/src/src/drivers/stm32f4xx.cpp @@ -1,11 +1,9 @@ -#ifdef CANLIB_ARCH_STM32F4XX -#include "static.h" +#include "static.hpp" #include #include -#include "bus.h" -#include "driver.h" -#include "drivers/inc/stm32f4xx.hpp" +#include "bus.hpp" +#include "driver.hpp" #include "stm32f4xx_hal.h" #ifdef USING_LOGGING_CALLBACK #include "log.h" @@ -23,20 +21,20 @@ Clock::time_point Clock::now() noexcept { return time_point(std::chrono::milliseconds(time_passed)); } -TransmitError CANlib::TransmitFrame(const Frame &frame, AbstractBus bus_name) { - RawBus raw_bus = GetRawBus(bus); +TransmitError CANlib::transmit_frame(const Frame &frame, AbstractBus bus_name) { + RawBus raw_bus = get_raw_bus(bus_name); int bus_num; CAN_HandleTypeDef *hcan; switch (raw_bus) { - case CAN_1: + case RawBus::CAN_1: hcan = &hcan1; bus_num = 1; break; - case CAN_2: + case RawBus::CAN_2: hcan = &hcan2; bus_num = 2; break; - case CAN_3: + case RawBus::CAN_3: hcan = &hcan3; bus_num = 3; break; @@ -57,20 +55,20 @@ TransmitError CANlib::TransmitFrame(const Frame &frame, AbstractBus bus_name) { #else UNUSED(bus_num); #endif - return HAL_CAN_AddTxMessage(hcan, &pHeader, frame.data, &pTxMailbox); + return HAL_CAN_AddTxMessage(hcan, &pHeader, (uint8_t *)frame.data, &pTxMailbox); } -void ReadFrame(Frame &frame, AbstractBus bus_name) { - RawBus raw_bus = GetRawBus(bus_name); +void read_frame(Frame &frame, AbstractBus bus_name) { + RawBus raw_bus = get_raw_bus(bus_name); CAN_HandleTypeDef *hcan; switch (raw_bus) { - case CAN_1: + case RawBus::CAN_1: hcan = &hcan1; break; - case CAN_2: + case RawBus::CAN_2: hcan = &hcan2; break; - case CAN_3: + case RawBus::CAN_3: hcan = &hcan3; break; default: @@ -91,4 +89,3 @@ void ReadFrame(Frame &frame, AbstractBus bus_name) { } } } -#endif diff --git a/test/Makefile b/test/Makefile index 1ee3a16..b0719f2 100644 --- a/test/Makefile +++ b/test/Makefile @@ -3,8 +3,6 @@ TARGET_EXEC := canlib-tests BUILD_DIR := ./build SRCS_DIR := ../src/src tests/src -SRCS := $(shell find $(SRC_DIRS) -name *.cpp -or -name *.c) - COMP_SRC := ../src/src/computers/*.cpp # String substitution for every C/C++ file. diff --git a/test/tests/src/arch0.cpp b/test/tests/src/arch0.cpp index df60e6e..bf514d2 100644 --- a/test/tests/src/arch0.cpp +++ b/test/tests/src/arch0.cpp @@ -12,6 +12,7 @@ extern TestCAN can2; extern TestCAN can3; void testArch() { + // AbstractBus/RawBus mapping is correct assert(get_raw_bus(AbstractBus::map1) == RawBus::CAN_2); assert(get_raw_bus(AbstractBus::map2) == RawBus::CAN_1); assert(get_raw_bus(AbstractBus::INVALID_NAME) == RawBus::INVALID_BUS); @@ -22,6 +23,7 @@ void testArch() { can1.clear(); can2.clear(); can3.clear(); + // Correct cans receive the messages send(map1::A::get_input()); send(map2::F::get_input()); assert(1 == can1.framesReceived()); @@ -37,10 +39,12 @@ void testArch() { A_copy.ARG2 = 69; A_copy.ARG3 = 69; A_copy.unpack(f); + // can2 will send A_copy can2.setFrameToSend(f); map1::A A_copy2; map1_update_can(); - map1::A* A_input = map1::A::get_input(); + map1::A *A_input = map1::A::get_input(); + // The received message is the same as A_copy assert(A_input->ARG0 && A_input->ARG1 == 69 && A_input->ARG2 == 69 && A_input->ARG3 == 69); map2::F F_copy; F_copy.ARG0 = 69; @@ -50,9 +54,11 @@ void testArch() { F_copy.ARG4 = 69; F_copy.ARG5 = 69; F_copy.unpack(f); + // can1 will send F_copy can1.setFrameToSend(f); map2_update_can(); - map2::F* F_input = map2::F::get_input(); + map2::F *F_input = map2::F::get_input(); + // The received message is the same as F_copy assert(F_input->ARG0 == 69 && F_input->ARG1 == 69 && F_input->ARG2 == 69 && F_input->ARG3 == 69 && F_input->ARG4 == 69 && F_input->ARG5 == 69); } diff --git a/test/tests/src/arch1.cpp b/test/tests/src/arch1.cpp index cb9b59f..25878de 100644 --- a/test/tests/src/arch1.cpp +++ b/test/tests/src/arch1.cpp @@ -11,6 +11,7 @@ extern TestCAN can2; extern TestCAN can3; void testArch() { + // AbstractBus/RawBus mapping is correct assert(get_raw_bus(AbstractBus::map1) == RawBus::CAN_2); assert(get_raw_bus(AbstractBus::map2) == RawBus::CAN_3); assert(get_raw_bus(AbstractBus::INVALID_NAME) == RawBus::INVALID_BUS); @@ -21,6 +22,7 @@ void testArch() { can1.clear(); can2.clear(); can3.clear(); + // Correct cans receive the messages send(map1::A::get_input()); send(map2::F::get_input()); assert(0 == can1.framesReceived()); @@ -36,10 +38,12 @@ void testArch() { A_copy.ARG2 = 69; A_copy.ARG3 = 69; A_copy.unpack(f); + // can2 will send A_copy can2.setFrameToSend(f); map1::A A_copy2; map1_update_can(); - map1::A* A_input = map1::A::get_input(); + map1::A *A_input = map1::A::get_input(); + // The received message is the same as A_copy assert(A_input->ARG0 && A_input->ARG1 == 69 && A_input->ARG2 == 69 && A_input->ARG3 == 69); map2::F F_copy; F_copy.ARG0 = 69; @@ -49,9 +53,11 @@ void testArch() { F_copy.ARG4 = 69; F_copy.ARG5 = 69; F_copy.unpack(f); + // can3 will send F_copy can3.setFrameToSend(f); map2_update_can(); - map2::F* F_input = map2::F::get_input(); + map2::F *F_input = map2::F::get_input(); + // The received message is the same as F_copy assert(F_input->ARG0 == 69 && F_input->ARG1 == 69 && F_input->ARG2 == 69 && F_input->ARG3 == 69 && F_input->ARG4 == 69 && F_input->ARG5 == 69); } diff --git a/test/tests/src/arch2.cpp b/test/tests/src/arch2.cpp index ef1fe2f..ec075eb 100644 --- a/test/tests/src/arch2.cpp +++ b/test/tests/src/arch2.cpp @@ -20,6 +20,7 @@ extern TestCAN can2; extern TestCAN can3; void testArch() { + // AbstractBus/RawBus mapping is correct assert(get_raw_bus(AbstractBus::map1) == RawBus::CAN_3); assert(get_raw_bus(AbstractBus::map2) == RawBus::CAN_1); assert(get_raw_bus(AbstractBus::INVALID_NAME) == RawBus::INVALID_BUS); @@ -30,6 +31,7 @@ void testArch() { can1.clear(); can2.clear(); can3.clear(); + // Correct cans receive the messages send(map1::A::get_input()); send(map2::F::get_input()); assert(1 == can1.framesReceived()); @@ -45,10 +47,12 @@ void testArch() { A_copy.ARG2 = 69; A_copy.ARG3 = 69; A_copy.unpack(f); + // can3 will send A_copy can3.setFrameToSend(f); map1::A A_copy2; map1_update_can(); - map1::A* A_input = map1::A::get_input(); + map1::A *A_input = map1::A::get_input(); + // The received message is the same as A_copy assert(A_input->ARG0 && A_input->ARG1 == 69 && A_input->ARG2 == 69 && A_input->ARG3 == 69); map2::F F_copy; F_copy.ARG0 = 69; @@ -58,9 +62,11 @@ void testArch() { F_copy.ARG4 = 69; F_copy.ARG5 = 69; F_copy.unpack(f); + // can1 will send F_copy can1.setFrameToSend(f); map2_update_can(); - map2::F* F_input = map2::F::get_input(); + map2::F *F_input = map2::F::get_input(); + // The received message is the same as F_copy assert(F_input->ARG0 == 69 && F_input->ARG1 == 69 && F_input->ARG2 == 69 && F_input->ARG3 == 69 && F_input->ARG4 == 69 && F_input->ARG5 == 69); } diff --git a/test/tests/src/message.cpp b/test/tests/src/message.cpp index 975fba7..5e6a532 100644 --- a/test/tests/src/message.cpp +++ b/test/tests/src/message.cpp @@ -11,7 +11,7 @@ using namespace CC; #define CREATE_TEST(Name, BITMASK) \ void test##Name() { \ - for (int cs = 0; cs < 100000; ++cs) { \ + for (int cs = 0; cs < 10000; ++cs) { \ Name Name##_copy; \ Frame f0; \ for (int i = 0; i < 8; ++i) { \ @@ -27,6 +27,10 @@ using namespace CC; uint64_t bitstring1; \ to_bitstring((uint8_t *)f1.data, &bitstring1); \ bitstring1 &= BITMASK; \ + /** \ + * The frame should be the same before \ + * and after we pack and unpack it \ + **/ \ assert(bitstring0 == bitstring1); \ } \ } diff --git a/test/tests/src/send.cpp b/test/tests/src/send.cpp index a4336f2..9af941e 100644 --- a/test/tests/src/send.cpp +++ b/test/tests/src/send.cpp @@ -38,6 +38,7 @@ extern TestCAN can3; send(&Name##_copy); \ } \ uint64_t bitstring1; \ + /* Expecting to receive the message exactly once */ \ assert(can.framesReceived() == 1); \ Frame f1 = can.topFrame(); \ to_bitstring((uint8_t *)f1.data, &bitstring1); \ From fd3ba31a974a030d805598d6aeba01349e40162c Mon Sep 17 00:00:00 2001 From: Gabriel Cojocaru Date: Sat, 11 Sep 2021 12:04:40 -0400 Subject: [PATCH 16/17] added gitignore to ignore the source files --- .gitignore | 12 ++---------- 1 file changed, 2 insertions(+), 10 deletions(-) diff --git a/.gitignore b/.gitignore index ed21527..a336324 100644 --- a/.gitignore +++ b/.gitignore @@ -3,16 +3,8 @@ compile_commands.json *.pyc # Files that should be written from CAN spec -src/constants.h -src/pack_unpack.c -src/pack_unpack.h -src/enum_atom.h -src/structs.h -src/computers/ -src/send_receive.c -src/bus.h -src/drivers/inc/ -src/test/ +src/* +src/** **/*.o **/*.out From 978ba65fc8afb325ed14c981e42f21ea3f343de6 Mon Sep 17 00:00:00 2001 From: Gabriel Cojocaru Date: Sat, 11 Sep 2021 12:32:34 -0400 Subject: [PATCH 17/17] fixed the linking issue related to read_frame --- src/src/drivers/stm32f4xx.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/src/drivers/stm32f4xx.cpp b/src/src/drivers/stm32f4xx.cpp index 8b83614..429ee75 100644 --- a/src/src/drivers/stm32f4xx.cpp +++ b/src/src/drivers/stm32f4xx.cpp @@ -58,7 +58,7 @@ TransmitError CANlib::transmit_frame(const Frame &frame, AbstractBus bus_name) { return HAL_CAN_AddTxMessage(hcan, &pHeader, (uint8_t *)frame.data, &pTxMailbox); } -void read_frame(Frame &frame, AbstractBus bus_name) { +void CANlib::read_frame(Frame &frame, AbstractBus bus_name) { RawBus raw_bus = get_raw_bus(bus_name); CAN_HandleTypeDef *hcan; switch (raw_bus) {