xsscanner.h

Go to the documentation of this file.

 
//  Copyright (c) 2003-2021 Xsens Technologies B.V. or subsidiaries worldwide.
//  All rights reserved.
//  
//  Redistribution and use in source and binary forms, with or without modification,
//  are permitted provided that the following conditions are met:
//  
//  1.  Redistributions of source code must retain the above copyright notice,
//      this list of conditions, and the following disclaimer.
//  
//  2.  Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions, and the following disclaimer in the documentation
//      and/or other materials provided with the distribution.
//  
//  3.  Neither the names of the copyright holders nor the names of their contributors
//      may be used to endorse or promote products derived from this software without
//      specific prior written permission.
//  
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
//  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
//  THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
//  SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
//  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
//  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR
//  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.THE LAWS OF THE NETHERLANDS 
//  SHALL BE EXCLUSIVELY APPLICABLE AND ANY DISPUTES SHALL BE FINALLY SETTLED UNDER THE RULES 
//  OF ARBITRATION OF THE INTERNATIONAL CHAMBER OF COMMERCE IN THE HAGUE BY ONE OR MORE 
//  ARBITRATORS APPOINTED IN ACCORDANCE WITH SAID RULES.
//  
 
 
//  Copyright (c) 2003-2021 Xsens Technologies B.V. or subsidiaries worldwide.
//  All rights reserved.
//  
//  Redistribution and use in source and binary forms, with or without modification,
//  are permitted provided that the following conditions are met:
//  
//  1.  Redistributions of source code must retain the above copyright notice,
//      this list of conditions, and the following disclaimer.
//  
//  2.  Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions, and the following disclaimer in the documentation
//      and/or other materials provided with the distribution.
//  
//  3.  Neither the names of the copyright holders nor the names of their contributors
//      may be used to endorse or promote products derived from this software without
//      specific prior written permission.
//  
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
//  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
//  THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
//  SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
//  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
//  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR
//  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.THE LAWS OF THE NETHERLANDS 
//  SHALL BE EXCLUSIVELY APPLICABLE AND ANY DISPUTES SHALL BE FINALLY SETTLED UNDER THE RULES 
//  OF ARBITRATION OF THE INTERNATIONAL CHAMBER OF COMMERCE IN THE HAGUE BY ONE OR MORE 
//  ARBITRATORS APPOINTED IN ACCORDANCE WITH SAID RULES.
//  
 
#ifndef XSSCANNER_H
#define XSSCANNER_H
 
#include "xscontrollerconfig.h"
#include <xstypes/xsbaud.h>
 
//AUTO namespace xstypes {
struct XsPortInfoArray;
//AUTO }
 
//AUTO namespace xscontroller {
struct XsUsbHubInfo;
//AUTO }
 
#ifdef __cplusplus
#include <xstypes/xsportinfoarray.h>
#include <xstypes/xsintarray.h>
#include <xstypes/xsstringarray.h>
#include "xsusbhubinfo.h"
#include <xstypes/xsstring.h>
#include <sstream>
extern "C" {
#endif
struct XsPortInfo;
 
typedef void (*XsScanLogCallbackFunc)(struct XsString const*);
 
XDA_DLL_API void XsScanner_scanPorts(struct XsPortInfoArray* ports, XsBaudRate baudrate, int singleScanTimeout, int ignoreNonXsensDevices, int detectRs485);
XDA_DLL_API int XsScanner_scanPort(struct XsPortInfo* port, XsBaudRate baudrate, int singleScanTimeout, int detectRs485);
XDA_DLL_API void XsScanner_enumerateSerialPorts(struct XsPortInfoArray* ports, int ignoreNonXsensDevices);
XDA_DLL_API void XsScanner_filterResponsiveDevices(struct XsPortInfoArray* ports, XsBaudRate baudrate, int singleScanTimeout, int detectRs485);
XDA_DLL_API void XsScanner_enumerateUsbDevices(struct XsPortInfoArray* ports);
XDA_DLL_API void XsScanner_scanUsbHub(struct XsUsbHubInfo* hub, const struct XsPortInfo* port);
XDA_DLL_API void XsScanner_enumerateNetworkDevices(struct XsPortInfoArray* ports);
XDA_DLL_API void XsScanner_enumerateBluetoothDevices(struct XsPortInfoArray* ports);
XDA_DLL_API void XsScanner_abortScan(void);
XDA_DLL_API void XsScanner_setScanLogCallback(XsScanLogCallbackFunc cb);
 
#ifdef __cplusplus
} // extern "C"
 
class XsScanner
{
public:
        static inline XsPortInfoArray scanPorts(XsBaudRate baudrate = XBR_Invalid, int singleScanTimeout = 100, bool ignoreNonXsensDevices = true, bool detectRs485 = false)
        {
                XsPortInfoArray ports;
                XsScanner_scanPorts(&ports, baudrate, singleScanTimeout, ignoreNonXsensDevices ? 1 : 0, detectRs485 ? 1 : 0);
                return ports;
        }
 
        static inline bool XSNOCOMEXPORT scanPort(XsPortInfo& port, XsBaudRate baudrate = XBR_Invalid, int singleScanTimeout = 100, bool detectRs485 = false)
        {
                return 0 != XsScanner_scanPort(&port, baudrate, singleScanTimeout, detectRs485 ? 1 : 0);
        }
 
        static inline XsPortInfo scanPort(const XsString& portName, XsBaudRate baudrate = XBR_Invalid, int singleScanTimeout = 100, bool detectRs485 = false)
        {
                XsPortInfo pi(portName, baudrate);
                if (scanPort(pi, baudrate, singleScanTimeout, detectRs485))
                        return pi;
 
                return XsPortInfo();
        }
 
        static inline XsPortInfoArray scanComPortList(const XsStringArray& portList, const XsIntArray& portLinesOptionsList = XsIntArray(), XsBaudRate baudrate = XBR_Invalid, int singleScanTimeout = 100)
        {
                XsPortInfoArray pInfoArray;
 
                if (!portLinesOptionsList.empty() && (portLinesOptionsList.size() != portList.size()))
                        return pInfoArray;
 
                for (XsIntArray::size_type idxPort = 0; idxPort < portList.size(); ++idxPort)
                {
                        const XsPortLinesOptions portLinesOptions = portLinesOptionsList.empty() ? XPLO_All_Ignore : static_cast<XsPortLinesOptions>(portLinesOptionsList[idxPort]);
 
                        XsPortInfo portInfo(portList[idxPort], baudrate, portLinesOptions);
 
                        if (scanPort(portInfo, baudrate, singleScanTimeout, (portLinesOptions == XPLO_All_Clear))) // XPLO_All_Clear == both RTS/DTR to 0 (RS485).
                                pInfoArray.push_back(portInfo);
                }
                return pInfoArray;
        }
 
        static inline XsPortInfoArray enumerateSerialPorts(bool ignoreNonXsensDevices = true)
        {
                XsPortInfoArray ports;
                XsScanner_enumerateSerialPorts(&ports, ignoreNonXsensDevices ? 1 : 0);
                return ports;
        }
 
        static inline XsPortInfoArray filterResponsiveDevices(const XsPortInfoArray& ports, XsBaudRate baudrate = XBR_Invalid, int singleScanTimeout = 100, bool detectRs485 = false)
        {
                XsPortInfoArray filtered(ports);
                XsScanner_filterResponsiveDevices(&filtered, baudrate, singleScanTimeout, detectRs485 ? 1 : 0);
                return filtered;
        }
 
        static inline XsPortInfoArray enumerateUsbDevices(void)
        {
                XsPortInfoArray ports;
                XsScanner_enumerateUsbDevices(&ports);
                return ports;
        }
 
        static inline XsUsbHubInfo scanUsbHub(const XsPortInfo& port)
        {
                XsUsbHubInfo hub;
                XsScanner_scanUsbHub(&hub, &port);
                return hub;
        }
 
        static inline XsPortInfoArray enumerateNetworkDevices(void)
        {
                XsPortInfoArray ports;
                XsScanner_enumerateNetworkDevices(&ports);
                return ports;
        }
 
        static inline XsPortInfoArray enumerateBluetoothDevices(void)
        {
                XsPortInfoArray ports;
                XsScanner_enumerateBluetoothDevices(&ports);
                return ports;
        }
 
        static inline void abortScan(void)
        {
                XsScanner_abortScan();
        }
 
        static inline void XSNOCOMEXPORT setScanLogCallback(XsScanLogCallbackFunc cb)
        {
                XsScanner_setScanLogCallback(cb);
        }
};
 
#endif
 
#endif