From 9fbb934f3886ff00d802ffef94351d2bce9aad51 Mon Sep 17 00:00:00 2001 From: Daan Steenbergen Date: Mon, 1 Jul 2024 09:48:53 +0200 Subject: [PATCH] feat: make pgn request protocol use the new message handler --- examples/pgn_requests/main.cpp | 6 +- examples/seeder_example/seeder.cpp | 1 + .../isobus/can_internal_control_function.hpp | 12 ++-- .../isobus/isobus/can_message_handling.hpp | 2 - ...arameter_group_number_request_protocol.hpp | 22 ++----- .../isobus/isobus/isobus_functionalities.hpp | 2 - isobus/src/can_internal_control_function.cpp | 8 ++- isobus/src/can_network_manager.cpp | 5 +- ...arameter_group_number_request_protocol.cpp | 60 +++++++------------ isobus/src/isobus_diagnostic_protocol.cpp | 40 +++++++------ isobus/src/isobus_functionalities.cpp | 5 +- isobus/src/isobus_heartbeat.cpp | 12 ++-- .../src/isobus_language_command_interface.cpp | 13 ++-- isobus/src/isobus_time_date_interface.cpp | 12 ++-- test/diagnostic_protocol_tests.cpp | 3 +- test/language_command_interface_tests.cpp | 1 + 16 files changed, 94 insertions(+), 110 deletions(-) diff --git a/examples/pgn_requests/main.cpp b/examples/pgn_requests/main.cpp index 3dc236b7..76c893ef 100644 --- a/examples/pgn_requests/main.cpp +++ b/examples/pgn_requests/main.cpp @@ -143,13 +143,13 @@ int main() } // Register a callback to handle PROPA PGN Requests - TestInternalECU->get_pgn_request_protocol().lock()->register_pgn_request_callback(static_cast(isobus::CANLibParameterGroupNumber::ProprietaryA), example_proprietary_a_pgn_request_handler, nullptr); + TestInternalECU->get_pgn_request_protocol()->register_pgn_request_callback(static_cast(isobus::CANLibParameterGroupNumber::ProprietaryA), example_proprietary_a_pgn_request_handler, nullptr); // Now, if you send a PGN request for EF00 to our internal control function, the stack will acknowledge it. Other requests will be NACK'ed (negative acknowledged) // NOTE the device you send from MUST have address claimed. // Now we'll set up a callback to handle requests for repetition rate for the PROPA PGN - TestInternalECU->get_pgn_request_protocol().lock()->register_request_for_repetition_rate_callback(static_cast(isobus::CANLibParameterGroupNumber::ProprietaryA), example_proprietary_a_request_for_repetition_rate_handler, nullptr); + TestInternalECU->get_pgn_request_protocol()->register_request_for_repetition_rate_callback(static_cast(isobus::CANLibParameterGroupNumber::ProprietaryA), example_proprietary_a_request_for_repetition_rate_handler, nullptr); // Now we'll get a callback when someone requests a repetition rate for PROPA. // The application (not the stack) must handle these requests, as the CAN stack does not know what data to send when responding. @@ -159,7 +159,7 @@ int main() // This is how you would request a PGN from someone else. In this example, we request it from the broadcast address. // Generally you'd want to replace nullptr with your partner control function as its a little nicer than just asking everyone on the bus for a PGN - isobus::ParameterGroupNumberRequestProtocol::request_parameter_group_number(static_cast(isobus::CANLibParameterGroupNumber::ProprietaryA), TestInternalECU, nullptr); + TestInternalECU->get_pgn_request_protocol()->request_parameter_group_number(static_cast(isobus::CANLibParameterGroupNumber::ProprietaryA), nullptr); while (running) { diff --git a/examples/seeder_example/seeder.cpp b/examples/seeder_example/seeder.cpp index 6f3b8049..126ebdb5 100644 --- a/examples/seeder_example/seeder.cpp +++ b/examples/seeder_example/seeder.cpp @@ -10,6 +10,7 @@ #include "isobus/hardware_integration/available_can_drivers.hpp" #include "isobus/hardware_integration/can_hardware_interface.hpp" +#include "isobus/isobus/can_network_manager.hpp" #include "isobus/isobus/isobus_diagnostic_protocol.hpp" #include "isobus/isobus/isobus_standard_data_description_indices.hpp" #include "isobus/isobus/isobus_task_controller_client.hpp" diff --git a/isobus/include/isobus/isobus/can_internal_control_function.hpp b/isobus/include/isobus/isobus/can_internal_control_function.hpp index 4a042df1..a09a20fa 100644 --- a/isobus/include/isobus/isobus/can_internal_control_function.hpp +++ b/isobus/include/isobus/isobus/can_internal_control_function.hpp @@ -76,7 +76,12 @@ namespace isobus /// @brief Gets the PGN request protocol for this ICF /// @returns The PGN request protocol for this ICF - std::weak_ptr get_pgn_request_protocol() const; + std::shared_ptr get_pgn_request_protocol() const; + + /// @brief Sets the PGN request protocol for this ICF, only use this if you have advanced needs. + /// Normally, when you create the internal control function via the network manager, it will set this for you. + /// @param[in] protocol The PGN request protocol for this ICF + void set_pgn_request_protocol(std::shared_ptr protocol); /// @brief Validates that a CAN message has not caused an address violation for this ICF. /// If a violation is found, a re-claim will be executed for as is required by ISO 11783-5, @@ -88,10 +93,6 @@ namespace isobus /// @returns true if the message caused an address violation, otherwise false bool process_rx_message_for_address_violation(const CANMessage &message); - protected: - friend class CANNetworkManager; ///< Allow the network manager to access the pgn request protocol - std::shared_ptr pgnRequestProtocol; ///< The PGN request protocol for this ICF - private: /// @brief Sends the PGN request for the address claim PGN /// @returns true if the message was sent, otherwise false @@ -119,6 +120,7 @@ namespace isobus std::uint8_t preferredAddress; ///< The address we'd prefer to claim as (we may not get it) std::uint8_t randomClaimDelay_ms; ///< The random delay before claiming an address as required by the ISO11783 standard EventDispatcher addressClaimedDispatcher; ///< The event dispatcher for when an address is claimed + std::shared_ptr pgnRequestProtocol = nullptr; ///< The PGN request protocol for this ICF }; } // namespace isobus diff --git a/isobus/include/isobus/isobus/can_message_handling.hpp b/isobus/include/isobus/isobus/can_message_handling.hpp index 3430057d..5d707f87 100644 --- a/isobus/include/isobus/isobus/can_message_handling.hpp +++ b/isobus/include/isobus/isobus/can_message_handling.hpp @@ -68,14 +68,12 @@ namespace isobus virtual ~CANMessagingConsumer() = default; /// @brief Processes incoming CAN messages - /// @param message The incoming CAN message to process virtual void process_rx_message(const CANMessage &) { // Override this function in the derived class, if you want to process incoming messages } /// @brief Processes outgoing CAN messages - /// @param message The outgoing CAN message to process virtual void process_tx_message(const CANMessage &) { // Override this function in the derived class, if you want to process outgoing messages diff --git a/isobus/include/isobus/isobus/can_parameter_group_number_request_protocol.hpp b/isobus/include/isobus/isobus/can_parameter_group_number_request_protocol.hpp index 2d135c25..e5ad3bd6 100644 --- a/isobus/include/isobus/isobus/can_parameter_group_number_request_protocol.hpp +++ b/isobus/include/isobus/isobus/can_parameter_group_number_request_protocol.hpp @@ -13,30 +13,23 @@ #include "isobus/isobus/can_badge.hpp" #include "isobus/isobus/can_control_function.hpp" -#include "isobus/isobus/can_network_manager.hpp" +#include "isobus/isobus/can_message_handling.hpp" #include namespace isobus { - //================================================================================================ - /// @class ParameterGroupNumberRequestProtocol - /// /// @brief A protocol that handles PGN requests /// @details The purpose of this protocol is to simplify and standardize how PGN requests /// are made and responded to. It provides a way to easily send a PGN request or a request for /// repetition rate, as well as methods to receive PGN requests. - //================================================================================================ - class ParameterGroupNumberRequestProtocol + class ParameterGroupNumberRequestProtocol : public CANMessagingConsumer { public: /// @brief The constructor for this protocol /// @param[in] internalControlFunction The internal control function that owns this protocol and will be used to send messages explicit ParameterGroupNumberRequestProtocol(std::shared_ptr internalControlFunction); - /// @brief The destructor for this protocol - ~ParameterGroupNumberRequestProtocol(); - /// @brief Remove the copy constructor ParameterGroupNumberRequestProtocol(const ParameterGroupNumberRequestProtocol &) = delete; @@ -48,7 +41,7 @@ namespace isobus /// @param[in] source The internal control function to send from /// @param[in] destination The control function to request `pgn` from /// @returns `true` if the request was successfully sent - static bool request_parameter_group_number(std::uint32_t pgn, std::shared_ptr source, std::shared_ptr destination); + bool request_parameter_group_number(std::uint32_t pgn, std::shared_ptr destination); /// @brief Sends a PGN request for repetition rate /// @details Use this if you want the destination CF to send you the specified PGN at some fixed interval @@ -57,7 +50,7 @@ namespace isobus /// @param[in] source The internal control function to send from /// @param[in] destination The control function to send the request to /// @returns `true` if the request was sent - static bool request_repetition_rate(std::uint32_t pgn, std::uint16_t repetitionRate_ms, std::shared_ptr source, std::shared_ptr destination); + bool request_repetition_rate(std::uint32_t pgn, std::uint16_t repetitionRate_ms, std::shared_ptr destination); /// @brief Registers for a callback on receipt of a PGN request /// @param[in] pgn The PGN you want to handle in the callback @@ -142,12 +135,7 @@ namespace isobus /// @brief A generic way for a protocol to process a received message /// @param[in] message A received CAN message - void process_message(const CANMessage &message); - - /// @brief A generic way for a protocol to process a received message - /// @param[in] message A received CAN message - /// @param[in] parent Provides the context to the actual TP manager object - static void process_message(const CANMessage &message, void *parent); + void process_rx_message(const CANMessage &message) override; /// @brief Sends a message using the acknowledgement PGN /// @param[in] type The type of acknowledgement to send (Ack, vs Nack, etc) diff --git a/isobus/include/isobus/isobus/isobus_functionalities.hpp b/isobus/include/isobus/isobus/isobus_functionalities.hpp index b1da36a5..c90d24f7 100644 --- a/isobus/include/isobus/isobus/isobus_functionalities.hpp +++ b/isobus/include/isobus/isobus/isobus_functionalities.hpp @@ -23,8 +23,6 @@ namespace isobus { - class DiagnosticProtocol; // Forward declaration - /// @brief Manages the control function functionalities message class ControlFunctionFunctionalities { diff --git a/isobus/src/can_internal_control_function.cpp b/isobus/src/can_internal_control_function.cpp index be299c39..9151a0b7 100644 --- a/isobus/src/can_internal_control_function.cpp +++ b/isobus/src/can_internal_control_function.cpp @@ -11,6 +11,7 @@ #include "isobus/isobus/can_internal_control_function.hpp" #include "isobus/isobus/can_constants.hpp" +#include "isobus/isobus/can_network_manager.hpp" #include "isobus/isobus/can_parameter_group_number_request_protocol.hpp" #include "isobus/isobus/can_stack_logger.hpp" #include "isobus/utility/system_timing.hpp" @@ -300,11 +301,16 @@ namespace isobus return addressClaimedDispatcher; } - std::weak_ptr InternalControlFunction::get_pgn_request_protocol() const + std::shared_ptr InternalControlFunction::get_pgn_request_protocol() const { return pgnRequestProtocol; } + void InternalControlFunction::set_pgn_request_protocol(std::shared_ptr protocol) + { + pgnRequestProtocol = protocol; + } + bool InternalControlFunction::send_request_to_claim() const { const auto parameterGroupNumber = static_cast(CANLibParameterGroupNumber::AddressClaim); diff --git a/isobus/src/can_network_manager.cpp b/isobus/src/can_network_manager.cpp index cb60802c..d0fa89a0 100644 --- a/isobus/src/can_network_manager.cpp +++ b/isobus/src/can_network_manager.cpp @@ -52,7 +52,8 @@ namespace isobus std::shared_ptr CANNetworkManager::create_internal_control_function(NAME desiredName, std::uint8_t CANPort, std::uint8_t preferredAddress) { auto controlFunction = std::make_shared(desiredName, preferredAddress, CANPort); - controlFunction->pgnRequestProtocol.reset(new ParameterGroupNumberRequestProtocol(controlFunction)); + controlFunction->set_pgn_request_protocol(std::make_shared(controlFunction)); + messageHandler.add_consumer(controlFunction->get_pgn_request_protocol()); internalControlFunctions.push_back(controlFunction); heartBeatInterfaces.at(CANPort)->on_new_internal_control_function(controlFunction); return controlFunction; @@ -68,7 +69,7 @@ namespace isobus void CANNetworkManager::deactivate_control_function(std::shared_ptr controlFunction) { // We need to unregister the control function from the interfaces managed by the network manager first. - controlFunction->pgnRequestProtocol.reset(); + controlFunction->set_pgn_request_protocol(nullptr); heartBeatInterfaces.at(controlFunction->get_can_port())->on_destroyed_internal_control_function(controlFunction); internalControlFunctions.erase(std::remove(internalControlFunctions.begin(), internalControlFunctions.end(), controlFunction), internalControlFunctions.end()); deactivate_control_function(std::static_pointer_cast(controlFunction)); diff --git a/isobus/src/can_parameter_group_number_request_protocol.cpp b/isobus/src/can_parameter_group_number_request_protocol.cpp index 14e6d26f..184a2c70 100644 --- a/isobus/src/can_parameter_group_number_request_protocol.cpp +++ b/isobus/src/can_parameter_group_number_request_protocol.cpp @@ -23,17 +23,9 @@ namespace isobus myControlFunction(internalControlFunction) { assert(nullptr != myControlFunction && "ParameterGroupNumberRequestProtocol::ParameterGroupNumberRequestProtocol() called with nullptr internalControlFunction"); - CANNetworkManager::CANNetwork.add_protocol_parameter_group_number_callback(static_cast(CANLibParameterGroupNumber::ParameterGroupNumberRequest), process_message, this); - CANNetworkManager::CANNetwork.add_protocol_parameter_group_number_callback(static_cast(CANLibParameterGroupNumber::RequestForRepetitionRate), process_message, this); } - ParameterGroupNumberRequestProtocol::~ParameterGroupNumberRequestProtocol() - { - CANNetworkManager::CANNetwork.remove_protocol_parameter_group_number_callback(static_cast(CANLibParameterGroupNumber::ParameterGroupNumberRequest), process_message, this); - CANNetworkManager::CANNetwork.remove_protocol_parameter_group_number_callback(static_cast(CANLibParameterGroupNumber::RequestForRepetitionRate), process_message, this); - } - - bool ParameterGroupNumberRequestProtocol::request_parameter_group_number(std::uint32_t pgn, std::shared_ptr source, std::shared_ptr destination) + bool ParameterGroupNumberRequestProtocol::request_parameter_group_number(std::uint32_t pgn, std::shared_ptr destination) { std::array buffer; @@ -41,14 +33,14 @@ namespace isobus buffer[1] = static_cast((pgn >> 8) & 0xFF); buffer[2] = static_cast((pgn >> 16) & 0xFF); - return CANNetworkManager::CANNetwork.send_can_message(static_cast(CANLibParameterGroupNumber::ParameterGroupNumberRequest), - buffer.data(), - PGN_REQUEST_LENGTH, - source, - destination); + return send_can_message(static_cast(CANLibParameterGroupNumber::ParameterGroupNumberRequest), + buffer.data(), + PGN_REQUEST_LENGTH, + myControlFunction, + destination); } - bool ParameterGroupNumberRequestProtocol::request_repetition_rate(std::uint32_t pgn, std::uint16_t repetitionRate_ms, std::shared_ptr source, std::shared_ptr destination) + bool ParameterGroupNumberRequestProtocol::request_repetition_rate(std::uint32_t pgn, std::uint16_t repetitionRate_ms, std::shared_ptr destination) { std::array buffer; @@ -61,11 +53,11 @@ namespace isobus buffer[6] = 0xFF; buffer[7] = 0xFF; - return CANNetworkManager::CANNetwork.send_can_message(static_cast(CANLibParameterGroupNumber::RequestForRepetitionRate), - buffer.data(), - CAN_DATA_LENGTH, - source, - destination); + return send_can_message(static_cast(CANLibParameterGroupNumber::RequestForRepetitionRate), + buffer.data(), + CAN_DATA_LENGTH, + myControlFunction, + destination); } bool ParameterGroupNumberRequestProtocol::register_pgn_request_callback(std::uint32_t pgn, PGNRequestCallback callback, void *parentPointer) @@ -162,18 +154,16 @@ namespace isobus return ((obj.callbackFunction == this->callbackFunction) && (obj.pgn == this->pgn) && (obj.parent == this->parent)); } - void ParameterGroupNumberRequestProtocol::process_message(const CANMessage &message) + void ParameterGroupNumberRequestProtocol::process_rx_message(const CANMessage &message) { - if (((nullptr == message.get_destination_control_function()) && - (BROADCAST_CAN_ADDRESS == message.get_identifier().get_destination_address())) || - (message.get_destination_control_function() == myControlFunction)) + if (message.is_broadcast() || message.is_destination(myControlFunction)) { switch (message.get_identifier().get_parameter_group_number()) { case static_cast(CANLibParameterGroupNumber::RequestForRepetitionRate): { // Can't send this request to global, and must be 8 bytes. Ignore illegal message formats - if ((CAN_DATA_LENGTH == message.get_data_length()) && (nullptr != message.get_destination_control_function())) + if ((CAN_DATA_LENGTH == message.get_data_length()) && message.is_destination(myControlFunction)) { std::uint32_t requestedPGN = message.get_uint24_at(0); std::uint16_t requestedRate = message.get_uint16_at(3); @@ -235,7 +225,7 @@ namespace isobus } } - if ((!anyCallbackProcessed) && (nullptr != message.get_destination_control_function())) + if ((!anyCallbackProcessed) && message.is_destination(myControlFunction)) { send_acknowledgement(AcknowledgementType::Negative, requestedPGN, @@ -258,14 +248,6 @@ namespace isobus } } - void ParameterGroupNumberRequestProtocol::process_message(const CANMessage &message, void *parent) - { - if (nullptr != parent) - { - reinterpret_cast(parent)->process_message(message); - } - } - bool ParameterGroupNumberRequestProtocol::send_acknowledgement(AcknowledgementType type, std::uint32_t parameterGroupNumber, std::shared_ptr destination) const { bool retVal = false; @@ -283,11 +265,11 @@ namespace isobus buffer[6] = static_cast((parameterGroupNumber >> 8) & 0xFF); buffer[7] = static_cast((parameterGroupNumber >> 16) & 0xFF); - retVal = CANNetworkManager::CANNetwork.send_can_message(static_cast(CANLibParameterGroupNumber::Acknowledge), - buffer.data(), - CAN_DATA_LENGTH, - myControlFunction, - nullptr); + retVal = send_can_message(static_cast(CANLibParameterGroupNumber::Acknowledge), + buffer.data(), + CAN_DATA_LENGTH, + myControlFunction, + nullptr); } return retVal; } diff --git a/isobus/src/isobus_diagnostic_protocol.cpp b/isobus/src/isobus_diagnostic_protocol.cpp index 00c311ca..29e9b3f0 100644 --- a/isobus/src/isobus_diagnostic_protocol.cpp +++ b/isobus/src/isobus_diagnostic_protocol.cpp @@ -104,16 +104,17 @@ namespace isobus CANNetworkManager::CANNetwork.add_global_parameter_group_number_callback(static_cast(CANLibParameterGroupNumber::DiagnosticMessage13), process_message, this); addressViolationEventHandle = CANNetworkManager::CANNetwork.get_address_violation_event_dispatcher().add_listener([this](std::shared_ptr affectedCF) { this->on_address_violation(affectedCF); }); - if (auto requestProtocol = myControlFunction->get_pgn_request_protocol().lock()) + auto pgnRequestProtocol = myControlFunction->get_pgn_request_protocol(); + if (nullptr != pgnRequestProtocol) { - requestProtocol->register_pgn_request_callback(static_cast(CANLibParameterGroupNumber::DiagnosticMessage1), process_parameter_group_number_request, this); - requestProtocol->register_pgn_request_callback(static_cast(CANLibParameterGroupNumber::DiagnosticMessage2), process_parameter_group_number_request, this); - requestProtocol->register_pgn_request_callback(static_cast(CANLibParameterGroupNumber::DiagnosticMessage3), process_parameter_group_number_request, this); - requestProtocol->register_pgn_request_callback(static_cast(CANLibParameterGroupNumber::DiagnosticMessage11), process_parameter_group_number_request, this); - requestProtocol->register_pgn_request_callback(static_cast(CANLibParameterGroupNumber::ProductIdentification), process_parameter_group_number_request, this); - requestProtocol->register_pgn_request_callback(static_cast(CANLibParameterGroupNumber::DiagnosticProtocolIdentification), process_parameter_group_number_request, this); - requestProtocol->register_pgn_request_callback(static_cast(CANLibParameterGroupNumber::SoftwareIdentification), process_parameter_group_number_request, this); - requestProtocol->register_pgn_request_callback(static_cast(CANLibParameterGroupNumber::ECUIdentificationInformation), process_parameter_group_number_request, this); + pgnRequestProtocol->register_pgn_request_callback(static_cast(CANLibParameterGroupNumber::DiagnosticMessage1), process_parameter_group_number_request, this); + pgnRequestProtocol->register_pgn_request_callback(static_cast(CANLibParameterGroupNumber::DiagnosticMessage2), process_parameter_group_number_request, this); + pgnRequestProtocol->register_pgn_request_callback(static_cast(CANLibParameterGroupNumber::DiagnosticMessage3), process_parameter_group_number_request, this); + pgnRequestProtocol->register_pgn_request_callback(static_cast(CANLibParameterGroupNumber::DiagnosticMessage11), process_parameter_group_number_request, this); + pgnRequestProtocol->register_pgn_request_callback(static_cast(CANLibParameterGroupNumber::ProductIdentification), process_parameter_group_number_request, this); + pgnRequestProtocol->register_pgn_request_callback(static_cast(CANLibParameterGroupNumber::DiagnosticProtocolIdentification), process_parameter_group_number_request, this); + pgnRequestProtocol->register_pgn_request_callback(static_cast(CANLibParameterGroupNumber::SoftwareIdentification), process_parameter_group_number_request, this); + pgnRequestProtocol->register_pgn_request_callback(static_cast(CANLibParameterGroupNumber::ECUIdentificationInformation), process_parameter_group_number_request, this); } retVal = true; } @@ -135,16 +136,17 @@ namespace isobus { initialized = false; - if (auto requestProtocol = myControlFunction->get_pgn_request_protocol().lock()) + auto pgnRequestProtocol = myControlFunction->get_pgn_request_protocol(); + if (nullptr != pgnRequestProtocol) { - requestProtocol->remove_pgn_request_callback(static_cast(CANLibParameterGroupNumber::DiagnosticMessage1), process_parameter_group_number_request, this); - requestProtocol->remove_pgn_request_callback(static_cast(CANLibParameterGroupNumber::DiagnosticMessage2), process_parameter_group_number_request, this); - requestProtocol->remove_pgn_request_callback(static_cast(CANLibParameterGroupNumber::DiagnosticMessage3), process_parameter_group_number_request, this); - requestProtocol->remove_pgn_request_callback(static_cast(CANLibParameterGroupNumber::DiagnosticMessage11), process_parameter_group_number_request, this); - requestProtocol->remove_pgn_request_callback(static_cast(CANLibParameterGroupNumber::ProductIdentification), process_parameter_group_number_request, this); - requestProtocol->remove_pgn_request_callback(static_cast(CANLibParameterGroupNumber::DiagnosticProtocolIdentification), process_parameter_group_number_request, this); - requestProtocol->remove_pgn_request_callback(static_cast(CANLibParameterGroupNumber::SoftwareIdentification), process_parameter_group_number_request, this); - requestProtocol->remove_pgn_request_callback(static_cast(CANLibParameterGroupNumber::ECUIdentificationInformation), process_parameter_group_number_request, this); + pgnRequestProtocol->remove_pgn_request_callback(static_cast(CANLibParameterGroupNumber::DiagnosticMessage1), process_parameter_group_number_request, this); + pgnRequestProtocol->remove_pgn_request_callback(static_cast(CANLibParameterGroupNumber::DiagnosticMessage2), process_parameter_group_number_request, this); + pgnRequestProtocol->remove_pgn_request_callback(static_cast(CANLibParameterGroupNumber::DiagnosticMessage3), process_parameter_group_number_request, this); + pgnRequestProtocol->remove_pgn_request_callback(static_cast(CANLibParameterGroupNumber::DiagnosticMessage11), process_parameter_group_number_request, this); + pgnRequestProtocol->remove_pgn_request_callback(static_cast(CANLibParameterGroupNumber::ProductIdentification), process_parameter_group_number_request, this); + pgnRequestProtocol->remove_pgn_request_callback(static_cast(CANLibParameterGroupNumber::DiagnosticProtocolIdentification), process_parameter_group_number_request, this); + pgnRequestProtocol->remove_pgn_request_callback(static_cast(CANLibParameterGroupNumber::SoftwareIdentification), process_parameter_group_number_request, this); + pgnRequestProtocol->remove_pgn_request_callback(static_cast(CANLibParameterGroupNumber::ECUIdentificationInformation), process_parameter_group_number_request, this); } CANNetworkManager::CANNetwork.remove_protocol_parameter_group_number_callback(static_cast(CANLibParameterGroupNumber::DiagnosticMessage22), process_message, this); CANNetworkManager::CANNetwork.remove_protocol_parameter_group_number_callback(static_cast(CANLibParameterGroupNumber::DiagnosticMessage13), process_message, this); @@ -180,7 +182,7 @@ namespace isobus } else { - if ((0 != activeDTCList.size()) && + if ((!activeDTCList.empty()) && (SystemTiming::time_expired_ms(lastDM1SentTimestamp, DM_MAX_FREQUENCY_MS))) { txFlags.set_flag(static_cast(TransmitFlags::DM1)); diff --git a/isobus/src/isobus_functionalities.cpp b/isobus/src/isobus_functionalities.cpp index 8c62041c..c593ee53 100644 --- a/isobus/src/isobus_functionalities.cpp +++ b/isobus/src/isobus_functionalities.cpp @@ -8,6 +8,7 @@ //================================================================================================ #include "isobus/isobus/isobus_functionalities.hpp" #include "isobus/isobus/can_general_parameter_group_numbers.hpp" +#include "isobus/isobus/can_network_manager.hpp" #include "isobus/isobus/can_stack_logger.hpp" #include @@ -22,7 +23,7 @@ namespace isobus { set_functionality_is_supported(Functionalities::MinimumControlFunction, 1, true); // Support the absolute minimum by default - if (auto pgnRequestProtocol = sourceControlFunction->get_pgn_request_protocol().lock()) + if (auto pgnRequestProtocol = sourceControlFunction->get_pgn_request_protocol()) { pgnRequestProtocol->register_pgn_request_callback(static_cast(CANLibParameterGroupNumber::ControlFunctionFunctionalities), pgn_request_handler, this); } @@ -34,7 +35,7 @@ namespace isobus ControlFunctionFunctionalities::~ControlFunctionFunctionalities() { - if (auto pgnRequestProtocol = myControlFunction->get_pgn_request_protocol().lock()) + if (auto pgnRequestProtocol = myControlFunction->get_pgn_request_protocol()) { pgnRequestProtocol->remove_pgn_request_callback(static_cast(CANLibParameterGroupNumber::ControlFunctionFunctionalities), pgn_request_handler, this); } diff --git a/isobus/src/isobus_heartbeat.cpp b/isobus/src/isobus_heartbeat.cpp index 2777db01..d00b596b 100644 --- a/isobus/src/isobus_heartbeat.cpp +++ b/isobus/src/isobus_heartbeat.cpp @@ -44,19 +44,19 @@ namespace isobus if ((nullptr != sourceControlFunction) && (nullptr != destinationControlFunction) && + (nullptr != sourceControlFunction->get_pgn_request_protocol()) && enabled) { - retVal = ParameterGroupNumberRequestProtocol::request_repetition_rate(static_cast(CANLibParameterGroupNumber::HeartbeatMessage), - SEQUENCE_REPETITION_RATE_MS, - sourceControlFunction, - destinationControlFunction); + retVal = sourceControlFunction->get_pgn_request_protocol()->request_repetition_rate(static_cast(CANLibParameterGroupNumber::HeartbeatMessage), + SEQUENCE_REPETITION_RATE_MS, + destinationControlFunction); } return retVal; } void HeartbeatInterface::on_new_internal_control_function(std::shared_ptr newControlFunction) { - auto pgnRequestProtocol = newControlFunction->get_pgn_request_protocol().lock(); + auto pgnRequestProtocol = newControlFunction->get_pgn_request_protocol(); if (nullptr != pgnRequestProtocol) { @@ -66,7 +66,7 @@ namespace isobus void HeartbeatInterface::on_destroyed_internal_control_function(std::shared_ptr destroyedControlFunction) { - auto pgnRequestProtocol = destroyedControlFunction->get_pgn_request_protocol().lock(); + auto pgnRequestProtocol = destroyedControlFunction->get_pgn_request_protocol(); if (nullptr != pgnRequestProtocol) { diff --git a/isobus/src/isobus_language_command_interface.cpp b/isobus/src/isobus_language_command_interface.cpp index 2617c6b3..7e44245e 100644 --- a/isobus/src/isobus_language_command_interface.cpp +++ b/isobus/src/isobus_language_command_interface.cpp @@ -11,6 +11,7 @@ #include "isobus/isobus/can_constants.hpp" #include "isobus/isobus/can_general_parameter_group_numbers.hpp" +#include "isobus/isobus/can_network_manager.hpp" #include "isobus/isobus/can_parameter_group_number_request_protocol.hpp" #include "isobus/isobus/can_partnered_control_function.hpp" #include "isobus/isobus/can_stack_logger.hpp" @@ -40,9 +41,10 @@ namespace isobus { CANNetworkManager::CANNetwork.remove_global_parameter_group_number_callback(static_cast(CANLibParameterGroupNumber::LanguageCommand), process_rx_message, this); - if (respondToRequests && (!myControlFunction->get_pgn_request_protocol().expired())) + auto pgnRequestProtocol = myControlFunction->get_pgn_request_protocol(); + if (respondToRequests && (nullptr != pgnRequestProtocol)) { - myControlFunction->get_pgn_request_protocol().lock()->remove_pgn_request_callback(static_cast(CANLibParameterGroupNumber::LanguageCommand), on_language_request, this); + pgnRequestProtocol->remove_pgn_request_callback(static_cast(CANLibParameterGroupNumber::LanguageCommand), on_language_request, this); } } } @@ -55,9 +57,10 @@ namespace isobus { CANNetworkManager::CANNetwork.add_global_parameter_group_number_callback(static_cast(CANLibParameterGroupNumber::LanguageCommand), process_rx_message, this); - if (respondToRequests && (!myControlFunction->get_pgn_request_protocol().expired())) + auto pgnRequestProtocol = myControlFunction->get_pgn_request_protocol(); + if (respondToRequests && (nullptr != pgnRequestProtocol)) { - myControlFunction->get_pgn_request_protocol().lock()->register_pgn_request_callback(static_cast(CANLibParameterGroupNumber::LanguageCommand), on_language_request, this); + pgnRequestProtocol->register_pgn_request_callback(static_cast(CANLibParameterGroupNumber::LanguageCommand), on_language_request, this); } initialized = true; } @@ -93,7 +96,7 @@ namespace isobus if (initialized) { - retVal = ParameterGroupNumberRequestProtocol::request_parameter_group_number(static_cast(CANLibParameterGroupNumber::LanguageCommand), myControlFunction, myPartner); + retVal = myControlFunction->get_pgn_request_protocol()->request_parameter_group_number(static_cast(CANLibParameterGroupNumber::LanguageCommand), myPartner); } else { diff --git a/isobus/src/isobus_time_date_interface.cpp b/isobus/src/isobus_time_date_interface.cpp index 392e4583..bd4511a0 100644 --- a/isobus/src/isobus_time_date_interface.cpp +++ b/isobus/src/isobus_time_date_interface.cpp @@ -11,6 +11,7 @@ #include "isobus/isobus/isobus_time_date_interface.hpp" #include "isobus/isobus/can_general_parameter_group_numbers.hpp" +#include "isobus/isobus/can_network_manager.hpp" #include "isobus/isobus/can_parameter_group_number_request_protocol.hpp" #include "isobus/isobus/can_stack_logger.hpp" #include "isobus/utility/to_string.hpp" @@ -38,7 +39,7 @@ namespace isobus { if (initialized && (nullptr != myControlFunction)) { - auto pgnRequestProtocol = myControlFunction->get_pgn_request_protocol().lock(); + auto pgnRequestProtocol = myControlFunction->get_pgn_request_protocol(); if (nullptr != pgnRequestProtocol) { @@ -57,7 +58,7 @@ namespace isobus if (nullptr != myControlFunction) { - auto pgnRequestProtocol = myControlFunction->get_pgn_request_protocol().lock(); + auto pgnRequestProtocol = myControlFunction->get_pgn_request_protocol(); if (nullptr != pgnRequestProtocol) { @@ -118,11 +119,10 @@ namespace isobus { bool retVal = false; - if (nullptr != requestingControlFunction) + if ((nullptr != requestingControlFunction) && (nullptr != requestingControlFunction->get_pgn_request_protocol())) { - retVal = ParameterGroupNumberRequestProtocol::request_parameter_group_number(static_cast(CANLibParameterGroupNumber::TimeDate), - requestingControlFunction, - optionalDestination); + retVal = requestingControlFunction->get_pgn_request_protocol()->request_parameter_group_number(static_cast(CANLibParameterGroupNumber::TimeDate), + optionalDestination); } return retVal; } diff --git a/test/diagnostic_protocol_tests.cpp b/test/diagnostic_protocol_tests.cpp index 19ea00d8..646a08c5 100644 --- a/test/diagnostic_protocol_tests.cpp +++ b/test/diagnostic_protocol_tests.cpp @@ -2,6 +2,7 @@ #include "isobus/hardware_integration/can_hardware_interface.hpp" #include "isobus/hardware_integration/virtual_can_plugin.hpp" +#include "isobus/isobus/can_network_manager.hpp" #include "isobus/isobus/isobus_diagnostic_protocol.hpp" #include "isobus/utility/system_timing.hpp" @@ -20,7 +21,7 @@ TEST(DIAGNOSTIC_PROTOCOL_TESTS, CreateAndDestroyProtocolObjects) EXPECT_TRUE(diagnosticProtocol->initialize()); EXPECT_FALSE(diagnosticProtocol->initialize()); // Should not be able to initialize twice - auto pgnRequestProtocol = TestInternalECU->get_pgn_request_protocol().lock(); + auto pgnRequestProtocol = TestInternalECU->get_pgn_request_protocol(); ASSERT_TRUE(pgnRequestProtocol); EXPECT_NO_THROW(diagnosticProtocol->terminate()); diff --git a/test/language_command_interface_tests.cpp b/test/language_command_interface_tests.cpp index 584acf06..6c22224a 100644 --- a/test/language_command_interface_tests.cpp +++ b/test/language_command_interface_tests.cpp @@ -12,6 +12,7 @@ #include "isobus/hardware_integration/virtual_can_plugin.hpp" #include "isobus/isobus/can_NAME_filter.hpp" #include "isobus/isobus/can_internal_control_function.hpp" +#include "isobus/isobus/can_network_manager.hpp" #include "isobus/isobus/can_parameter_group_number_request_protocol.hpp" #include "isobus/isobus/can_partnered_control_function.hpp" #include "isobus/isobus/can_stack_logger.hpp"