Location>code7788 >text

SICK Ranger3 source code analysis——disconnection and reconnection

Popularity：102 ℃/2025-03-11 02:58:22

Preface

This article can be found in/SICK-Ranger3-source-code-analysis-01/Read more

A brief analysis of the implementation of SICK Ranger3 source code interrupt line reconnection is relatively easy. Let’s select it first to analyze it.

Code examples only post key parts for analysis

Version using SDK is 3.4.2.6

Official routine of disconnection and reconnection: Demo_R3_callback_with_heartbeat.cpp

Disconnection detection

Disconnection and reconnection can be divided into two steps. First, detect the camera's disconnection and notify, and then the user performs the reconnection operation after receiving the notification. Let’s first look at how SICK implements disconnection detection.

The disconnection detection mechanism is built into the SICK SDK and is managed by the SICK SDK:

// file:
 EXPORT_TO_DLL CAM_STATUS
 Ranger3::connectCamera(CallbackEvent_HeartBeats pCallback, const uint32_t& microSecond, void * any)
 {
	 try{
		 auto e = connectCamera();
		 if(e == CAM_STATUS::All_OK)
		 {
             m_heartbeat_is_on = 1;
             ...
             // Turn on the heartbeat detection thread
			 auto _thread = std::make_shared<std::thread>(&Ranger3::_check_HeartBeats_run, this);
			 _thread->detach();
		 }
		 return e;
	 }
     ...
 }

 void
 Ranger3::_check_HeartBeats_run()
 {
     While (m_heartbeat_is_on==1)
     {
         __sleep1MS(m_heartbeat_interval);
         ...
         try {
             Str value("");
             // The device is online and does not throw exceptions, otherwise, throw exceptions
             m_Param.getParameter(m_deviceNodeMap, "DeviceTemperature", value);
             ...
         }
         catch (...) {
             ...
         }
     }
 }

It can be seen that the disconnection detection mechanism is very simple, which is to separate a thread and circulate the camera register (the implementation of SICK is to access the camera register by obtaining the device temperature regularly). If it cannot be accessed (failed), it means that the camera is offline.

{% notel purple Paw5zxNote: %}

{% endnotel %}

Disconnection notification

The disconnect notification mechanism is also built into the SICK SDK: after detecting that the device is offline, the registered callback function is called (the registration process will be introduced below)

// file:
 void
 Ranger3::_check_HeartBeats_run()
 {
     While (m_heartbeat_is_on==1)
     {
         __sleep1MS(m_heartbeat_interval);
         ...
         try {
             Str value("");
             // The device is online and does not throw exceptions, otherwise, throw exceptions
             m_Param.getParameter(m_deviceNodeMap, "DeviceTemperature", value);
             ...
         }
         catch (...) {
             // Some resource release operations
             ...
             // m_on_lost_function is a registered callback function object
             // The device is offline, the register access failed, the exception is caught, and the m_on_lost_function is called
             auto _thread = std::make_shared<std::thread>(m_on_lost_function, &m_DeviceName, &m_DeviceIP, &m_on_lost_mac, &msg, m_on_lost_inputs);
			 _thread->join();
             return;
         }
     }
 }

Reconnection implementation

The specific implementation of the reconnection mechanism is carried out by the user. In routineDemo_R3_callback_with_heartbeat.cppIn this article, a callback function is customized by the user (it will be called when the camera is offline), and the callback loops to reconnect the camera. User registers this callback when connecting to the camera

User layer code:

// file: Demo_R3_callback_with_heartbeat.cpp

 // User defined callback function, called when the camera is disconnected
 void SICK_CALLBACK
 on_lost_device_Demo_R3_callback_with_heartbeat(std::string* name, std::string* ip, std::string* mac, std::string* msg, void * pR3)
 {
     auto pCam = (SickCam::Ranger3*)pR3;
     While (true)
     {
         // Reconnect the physical camera based on the device information stored in the camera object, and the explanation will not be expanded
         auto ec = pCam->reconnectCamera();
         ...
         __sleep1MS(1000);
     }
 }
 // Register callback when connecting to the camera
 auto err = pCam1->connectCamera(on_lost_device_Demo_R3_callback_with_heartbeat, 1000, ());

In the SICK SDK, the registration process will:

  • Registered useron_lost_device_Demo_R3_callback_with_heartbeatAssign tom_on_lost_function
  • Pass context information to the useranyAssign tom_on_lost_inputs 
// file:
 typedef std::function<void(std::string* name, std::string* ip, std::string* mac, std::string* msg, void* any)> CallbackEvent_HeartBeats;

 // file:
 /*
 [in] – pCallback When the heartbeat is lost, the user-defined callback function will be called.  The corresponding processing can be performed in this function.
 [in] – microSecond The time interval for reading the heartbeat, in milliseconds, with a recommended value of 10 000;
 [in] – any In the response function that loses heartbeat (CallbackEvent_HeartBeats), this pointer will be used as an input parameter, defined by the user.
 */
 EXPORT_TO_DLL CAM_STATUS
 Ranger3::connectCamera(CallbackEvent_HeartBeats pCallback, const uint32_t& microSecond, void * any)
 {
	 try{
		 auto e = connectCamera();
		 if(e == CAM_STATUS::All_OK)
		 {
			 ...
             m_on_lost_function = pCallback;
			 m_on_lost_inputs = any;
			 auto _thread = std::make_shared<std::thread>(&Ranger3::_check_HeartBeats_run, this);
			 _thread->detach();
		 }
		 return e;
	 }
     ...
 }

After registration, when the camera is offline, it is likeAs mentioned above, the SDK will call the registered callback function to reconnect.

<Previous Next>