whb04b: Error handling

Author: hdiethelm

src/hal/user_comps/xhc-whb04b-6/usb.cc

@@ -135,11 +135,6 @@ bool Usb::isWaitForPendantBeforeHalEnabled() const
     return isWaitWithTimeout;
 }
 // ----------------------------------------------------------------------
-bool Usb::getDoReconnect() const
-{
-    return mDoReconnect;
-}
-// ----------------------------------------------------------------------
 void Usb::setUsbProductId(uint16_t usbProductId)
 {
     this->usbProductId = usbProductId;
@@ -436,6 +431,7 @@ bool Usb::setupAsyncTransfer()
     int r = libusb_submit_transfer(inTransfer);
     if(r != 0){
         std::cerr << "libusb_submit_transfer failed with " << r << endl;
+        mDoReconnect = true;
         return false;
     }
     else
@@ -518,7 +514,7 @@ void Usb::onUsbDataReceived(struct libusb_transfer* transfer)
             {
                 if(!setupAsyncTransfer())
                 {
-                    requestTermination();
+                    transferFailed = true;
                 }
             }
 
@@ -530,7 +526,7 @@ void Usb::onUsbDataReceived(struct libusb_transfer* transfer)
             {
                 if(!setupAsyncTransfer())
                 {
-                    requestTermination();
+                    transferFailed = true;
                 }
             }
             break;
@@ -543,12 +539,12 @@ void Usb::onUsbDataReceived(struct libusb_transfer* transfer)
         case (LIBUSB_TRANSFER_OVERFLOW):
         case (LIBUSB_TRANSFER_ERROR):
             std::cerr << "transfer error: " << transfer->status << endl;
-            requestTermination();
+            transferFailed = true;
             break;
 
         default:
             std::cerr << "unknown transfer status: " << transfer->status << endl;
-            requestTermination();
+            transferFailed = true;
             break;
     }
     //libusb_free_transfer(transfer);
@@ -604,7 +600,7 @@ Usb::InitStatus Usb::init()
     {
         std::cerr << endl << "Bug: Not cleaned up deviceHandle properly before calling init again!" << endl;
     }
-    if (getDoReconnect())
+    if (mDoReconnect)
     {
         int pauseSecs = 3;
         *verboseInitOut << "init  pausing " << pauseSecs << "s, waiting for device to be gone ...";
@@ -681,11 +677,11 @@ Usb::InitStatus Usb::init()
             sleep(1);
         }
     } while (deviceHandle == nullptr && mIsRunning);
-    *verboseInitOut << " ok" << endl
-                    << "init  " << mName << " device found" << endl;
 
     if (deviceHandle != nullptr)
     {
+        *verboseInitOut << " ok" << endl
+                        << "init  " << mName << " device found" << endl;
         *verboseInitOut << "init  detaching active kernel driver ...";
         r = libusb_kernel_driver_active(deviceHandle, 0);
         if (r == 1)
@@ -727,7 +723,7 @@ Usb::InitStatus Usb::init()
     return InitStatus::OK;
 }
 // ----------------------------------------------------------------------
-void Usb::handleTimeouts()
+void Usb::process()
 {
     struct timeval timeout;
     timeout.tv_sec  = 0;
@@ -736,7 +732,14 @@ void Usb::handleTimeouts()
     int r = libusb_handle_events_timeout_completed(context, &timeout, nullptr);
     if(r != 0)
     {
-        std::cerr << endl << "Error: handleTimeouts() libusb_handle_events_timeout_completed returned " << r << endl;
+        std::cerr << endl << "Error: process() libusb_handle_events_timeout_completed returned " << r << endl;
+    }
+
+    if(transferFailed)
+    {
+        close();
+        transferFailed = false;
+        mDoReconnect = true;
     }
 }
 // ----------------------------------------------------------------------

src/hal/user_comps/xhc-whb04b-6/usb.h

@@ -287,7 +287,6 @@ class Usb : public UsbRawInputListener
     void setUsbProductId(uint16_t usbProductId);
     bool isDeviceOpen() const;
     bool isWaitForPendantBeforeHalEnabled() const;
-    bool getDoReconnect() const;
     void onUsbDataReceived(struct libusb_transfer* transfer) override;
     void setSimulationMode(bool isSimulationMode);
     void setIsRunning(bool enableRunning);
@@ -300,7 +299,7 @@ class Usb : public UsbRawInputListener
     void enableVerboseRx(bool enable);
     void enableVerboseInit(bool enable);
     InitStatus init();
-    void handleTimeouts();
+    void process();
     void close();
     void teardown();
     void setWaitWithTimeout(uint8_t waitSecs);
@@ -318,6 +317,7 @@ class Usb : public UsbRawInputListener
     bool                mIsSimulationMode{false};
     SleepDetect         sleepState;
     bool                mIsRunning{false};
+    bool                transferFailed{false};
     UsbInPackageBuffer  inputPackageBuffer;
     UsbOutPackageBuffer outputPackageBuffer;
     UsbOutPackageData   outputPackageData;

src/hal/user_comps/xhc-whb04b-6/xhc-whb04b6.cc

@@ -450,15 +450,18 @@ int XhcWhb04b6Component::run()
             if (mUsb.isDeviceOpen())
             {
                 *mInitCout << "init  enabling reception ...";
-                if (!mUsb.setupAsyncTransfer())
+                if (mUsb.setupAsyncTransfer())
                 {
-                    std::cerr << endl << "failed to enable reception" << endl;
-                    return EXIT_FAILURE;
+                    *mInitCout << " ok" << endl;
+                    process(); //process loops until disconnect/stopped
+                    mUsb.teardown();
+                }
+                else
+                {
+                    mUsb.close();
+                    mUsb.teardown();
                 }
-                *mInitCout << " ok" << endl;
             }
-            process();
-            mUsb.teardown();
         }
         else if(status == Usb::InitStatus::RETRY)
         {
@@ -487,23 +490,22 @@ void XhcWhb04b6Component::setSimulationMode(bool enableSimulationMode)
 // ----------------------------------------------------------------------
 void XhcWhb04b6Component::process()
 {
-    if (mUsb.isDeviceOpen())
+    while (isRunning() && mUsb.isDeviceOpen())
     {
-        while (isRunning() && !mUsb.getDoReconnect())
+        if (mHal.isSimulationModeEnabled())
         {
-            mUsb.handleTimeouts();
-            if (mHal.isSimulationModeEnabled())
-            {
-                linuxcncSimulate();
-            }
-            updateDisplay();
+            linuxcncSimulate();
         }
         updateDisplay();
-
-        mHal.setIsPendantConnected(false);
-        *mInitCout << "connection lost, cleaning up" << endl;
+        mUsb.process();
+    }
+    if(mUsb.isDeviceOpen())
+    {
         mUsb.close();
     }
+
+    mHal.setIsPendantConnected(false);
+    *mInitCout << "connection lost, cleaning up" << endl;
 }
 // ----------------------------------------------------------------------
 void XhcWhb04b6Component::enableVerbosePendant(bool enable)