feat: make pgn request protocol use the new message handler

Author: GwnDaan

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<std::uint32_t>(isobus::CANLibParameterGroupNumber::ProprietaryA), example_proprietary_a_pgn_request_handler, nullptr);
+	TestInternalECU->get_pgn_request_protocol()->register_pgn_request_callback(static_cast<std::uint32_t>(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<std::uint32_t>(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<std::uint32_t>(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<std::uint32_t>(isobus::CANLibParameterGroupNumber::ProprietaryA), TestInternalECU, nullptr);
+	TestInternalECU->get_pgn_request_protocol()->request_parameter_group_number(static_cast<std::uint32_t>(isobus::CANLibParameterGroupNumber::ProprietaryA), nullptr);
 
 	while (running)
 	{

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"

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<ParameterGroupNumberRequestProtocol> get_pgn_request_protocol() const;
+		std::shared_ptr<ParameterGroupNumberRequestProtocol> 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<ParameterGroupNumberRequestProtocol> 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<ParameterGroupNumberRequestProtocol> 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<std::uint8_t> addressClaimedDispatcher; ///< The event dispatcher for when an address is claimed
+		std::shared_ptr<ParameterGroupNumberRequestProtocol> pgnRequestProtocol = nullptr; ///< The PGN request protocol for this ICF
 	};
 
 } // namespace isobus

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

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 <memory>
 
 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> internalControlFunction);
 
-		/// @brief The destructor for this protocol
-		~ParameterGroupNumberRequestProtocol();
-
 		/// @brief Remove the copy constructor
 		ParameterGroupNumberRequestProtocol(const ParameterGroupNumberRequestProtocol &) = delete;
 
@@ -45,19 +38,17 @@ namespace isobus
 
 		/// @brief Sends a PGN request to the specified control function
 		/// @param[in] pgn The PGN to request
-		/// @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<InternalControlFunction> source, std::shared_ptr<ControlFunction> destination);
+		bool request_parameter_group_number(std::uint32_t pgn, std::shared_ptr<ControlFunction> 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
 		/// @param[in] pgn The PGN to request
 		/// @param[in] repetitionRate_ms The repetition rate to request in milliseconds
-		/// @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<InternalControlFunction> source, std::shared_ptr<ControlFunction> destination);
+		bool request_repetition_rate(std::uint32_t pgn, std::uint16_t repetitionRate_ms, std::shared_ptr<ControlFunction> 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 +133,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)

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
 	{

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<ParameterGroupNumberRequestProtocol> InternalControlFunction::get_pgn_request_protocol() const
+	std::shared_ptr<ParameterGroupNumberRequestProtocol> InternalControlFunction::get_pgn_request_protocol() const
 	{
 		return pgnRequestProtocol;
 	}
 
+	void InternalControlFunction::set_pgn_request_protocol(std::shared_ptr<ParameterGroupNumberRequestProtocol> protocol)
+	{
+		pgnRequestProtocol = protocol;
+	}
+
 	bool InternalControlFunction::send_request_to_claim() const
 	{
 		const auto parameterGroupNumber = static_cast<std::uint32_t>(CANLibParameterGroupNumber::AddressClaim);

isobus/src/can_network_manager.cpp

@@ -52,7 +52,8 @@ namespace isobus
 	std::shared_ptr<InternalControlFunction> CANNetworkManager::create_internal_control_function(NAME desiredName, std::uint8_t CANPort, std::uint8_t preferredAddress)
 	{
 		auto controlFunction = std::make_shared<InternalControlFunction>(desiredName, preferredAddress, CANPort);
-		controlFunction->pgnRequestProtocol.reset(new ParameterGroupNumberRequestProtocol(controlFunction));
+		controlFunction->set_pgn_request_protocol(std::make_shared<ParameterGroupNumberRequestProtocol>(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<InternalControlFunction> 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>(controlFunction));

isobus/src/can_parameter_group_number_request_protocol.cpp

@@ -23,32 +23,24 @@ namespace isobus
 	  myControlFunction(internalControlFunction)
 	{
 		assert(nullptr != myControlFunction && "ParameterGroupNumberRequestProtocol::ParameterGroupNumberRequestProtocol() called with nullptr internalControlFunction");
-		CANNetworkManager::CANNetwork.add_protocol_parameter_group_number_callback(static_cast<std::uint32_t>(CANLibParameterGroupNumber::ParameterGroupNumberRequest), process_message, this);
-		CANNetworkManager::CANNetwork.add_protocol_parameter_group_number_callback(static_cast<std::uint32_t>(CANLibParameterGroupNumber::RequestForRepetitionRate), process_message, this);
 	}
 
-	ParameterGroupNumberRequestProtocol::~ParameterGroupNumberRequestProtocol()
-	{
-		CANNetworkManager::CANNetwork.remove_protocol_parameter_group_number_callback(static_cast<std::uint32_t>(CANLibParameterGroupNumber::ParameterGroupNumberRequest), process_message, this);
-		CANNetworkManager::CANNetwork.remove_protocol_parameter_group_number_callback(static_cast<std::uint32_t>(CANLibParameterGroupNumber::RequestForRepetitionRate), process_message, this);
-	}
-
-	bool ParameterGroupNumberRequestProtocol::request_parameter_group_number(std::uint32_t pgn, std::shared_ptr<InternalControlFunction> source, std::shared_ptr<ControlFunction> destination)
+	bool ParameterGroupNumberRequestProtocol::request_parameter_group_number(std::uint32_t pgn, std::shared_ptr<ControlFunction> destination)
 	{
 		std::array<std::uint8_t, PGN_REQUEST_LENGTH> buffer;
 
 		buffer[0] = static_cast<std::uint8_t>(pgn & 0xFF);
 		buffer[1] = static_cast<std::uint8_t>((pgn >> 8) & 0xFF);
 		buffer[2] = static_cast<std::uint8_t>((pgn >> 16) & 0xFF);
 
-		return CANNetworkManager::CANNetwork.send_can_message(static_cast<std::uint32_t>(CANLibParameterGroupNumber::ParameterGroupNumberRequest),
-		                                                      buffer.data(),
-		                                                      PGN_REQUEST_LENGTH,
-		                                                      source,
-		                                                      destination);
+		return send_can_message(static_cast<std::uint32_t>(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<InternalControlFunction> source, std::shared_ptr<ControlFunction> destination)
+	bool ParameterGroupNumberRequestProtocol::request_repetition_rate(std::uint32_t pgn, std::uint16_t repetitionRate_ms, std::shared_ptr<ControlFunction> destination)
 	{
 		std::array<std::uint8_t, CAN_DATA_LENGTH> buffer;
 
@@ -61,11 +53,11 @@ namespace isobus
 		buffer[6] = 0xFF;
 		buffer[7] = 0xFF;
 
-		return CANNetworkManager::CANNetwork.send_can_message(static_cast<std::uint32_t>(CANLibParameterGroupNumber::RequestForRepetitionRate),
-		                                                      buffer.data(),
-		                                                      CAN_DATA_LENGTH,
-		                                                      source,
-		                                                      destination);
+		return send_can_message(static_cast<std::uint32_t>(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<std::uint32_t>(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<ParameterGroupNumberRequestProtocol *>(parent)->process_message(message);
-		}
-	}
-
 	bool ParameterGroupNumberRequestProtocol::send_acknowledgement(AcknowledgementType type, std::uint32_t parameterGroupNumber, std::shared_ptr<ControlFunction> destination) const
 	{
 		bool retVal = false;
@@ -283,11 +265,11 @@ namespace isobus
 			buffer[6] = static_cast<std::uint8_t>((parameterGroupNumber >> 8) & 0xFF);
 			buffer[7] = static_cast<std::uint8_t>((parameterGroupNumber >> 16) & 0xFF);
 
-			retVal = CANNetworkManager::CANNetwork.send_can_message(static_cast<std::uint32_t>(CANLibParameterGroupNumber::Acknowledge),
-			                                                        buffer.data(),
-			                                                        CAN_DATA_LENGTH,
-			                                                        myControlFunction,
-			                                                        nullptr);
+			retVal = send_can_message(static_cast<std::uint32_t>(CANLibParameterGroupNumber::Acknowledge),
+			                          buffer.data(),
+			                          CAN_DATA_LENGTH,
+			                          myControlFunction,
+			                          nullptr);
 		}
 		return retVal;
 	}