xsscanner.cpp

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.
//  
 
#include "xsscanner.h"
#include "scanner.h"
#include "enumerateusbdevices.h"
 
void XsScanner_scanPorts_int(XsPortInfoArray* ports, XsBaudRate baudrate, int singleScanTimeout, int ignoreNonXsensDevices, int detectRs485)
{
        LOGXSSCAN(__FUNCTION__ << " baudrate " << baudrate << " singleScanTimeout " << singleScanTimeout << " ignoreNonXsensDevices " << ignoreNonXsensDevices << " detectRs485 " << detectRs485);
 
        assert(ports != nullptr);
        if (!ports)
                return;
 
        XsPortInfoArray tmp;
        Scanner::Accessor accessor;
        accessor.scanner().xsScanPorts(tmp, baudrate, (uint32_t) singleScanTimeout, ignoreNonXsensDevices != 0, detectRs485 != 0);
        if (tmp.size())
                ports->assign(tmp.size(), &tmp[0]);
        else
                ports->clear();
}
 
int XsScanner_scanPort_int(XsPortInfo* port, XsBaudRate baudrate, int singleScanTimeout, int detectRs485)
{
        assert(port != nullptr);
        if (!port)
                return 0;
 
        Scanner::Accessor accessor;
        return accessor.scanner().xsScanPort(*port, baudrate, (uint32_t)singleScanTimeout, detectRs485 != 0) ? 1 : 0;
}
 
void XsScanner_enumerateSerialPorts_int(XsPortInfoArray* ports, int ignoreNonXsensDevices)
{
        LOGXSSCAN(__FUNCTION__ << " ignoreNonXsensDevices " << ignoreNonXsensDevices);
 
        assert(ports != nullptr);
        if (!ports)
                return;
 
        XsPortInfoArray tmp;
        Scanner::Accessor accessor;
        accessor.scanner().xsEnumerateSerialPorts(tmp, ignoreNonXsensDevices != 0);
        if (tmp.size())
                ports->assign(tmp.size(), &tmp[0]);
        else
                ports->clear();
}
 
extern "C" {
 
        void XsScanner_setScanLogCallback(XsScanLogCallbackFunc cb)
        {
                Scanner::setScanLogCallback(cb);
        }
 
        void XsScanner_scanPorts(XsPortInfoArray* ports, XsBaudRate baudrate, int singleScanTimeout, int ignoreNonXsensDevices, int detectRs485)
        {
                LOGXSSCAN(__FUNCTION__ << " baudrate " << baudrate << " singleScanTimeout " << singleScanTimeout << " ignoreNonXsensDevices " << ignoreNonXsensDevices << " detectRs485 " << detectRs485);
                XsScanner_scanPorts_int(ports, baudrate, singleScanTimeout, ignoreNonXsensDevices, detectRs485);
        }
 
        int XsScanner_scanPort(XsPortInfo* port, XsBaudRate baudrate, int singleScanTimeout, int detectRs485)
        {
                LOGXSSCAN(__FUNCTION__ << " baudrate " << baudrate << " singleScanTimeout " << singleScanTimeout << " detectRs485 " << detectRs485);
                return XsScanner_scanPort_int(port, baudrate, singleScanTimeout, detectRs485);
        }
 
        void XsScanner_enumerateSerialPorts(XsPortInfoArray* ports, int ignoreNonXsensDevices)
        {
                LOGXSSCAN(__FUNCTION__ << " ignoreNonXsensDevices " << ignoreNonXsensDevices);
                XsScanner_enumerateSerialPorts_int(ports, ignoreNonXsensDevices);
        }
 
        void XsScanner_filterResponsiveDevices(XsPortInfoArray* ports, XsBaudRate baudrate, int singleScanTimeout, int detectRs485)
        {
                LOGXSSCAN(__FUNCTION__ << " baudrate " << baudrate << " singleScanTimeout " << singleScanTimeout << " detectRs485 " << detectRs485);
                assert(ports != nullptr);
                if (!ports)
                        return;
 
                XsPortInfoArray tmp;
                for (XsSize i = 0; i < ports->size(); ++i)
                        tmp.push_back(ports->at(i));
                Scanner::Accessor accessor;
                if (accessor.scanner().xsFilterResponsiveDevices(tmp, baudrate, (uint32_t) singleScanTimeout, detectRs485 != 0))
                {
                        if (tmp.size())
                        {
                                ports->assign(tmp.size(), &tmp[0]);
                                return;
                        }
                }
                ports->clear();
        }
 
        void XsScanner_enumerateUsbDevices(XsPortInfoArray* ports)
        {
                LOGXSSCAN(__FUNCTION__);
 
                assert(ports != nullptr);
                if (!ports)
                        return;
 
                XsPortInfoArray tmp;
                xsEnumerateUsbDevices(tmp);
                if (tmp.size())
                        ports->assign(tmp.size(), &tmp[0]);
                else
                        ports->clear();
        }
 
        void XsScanner_scanUsbHub(XsUsbHubInfo* hub, const XsPortInfo* port)
        {
                LOGXSSCAN(__FUNCTION__);
 
                assert(hub != nullptr && port != nullptr);
                if (!hub || !port)
                        return;
 
                Scanner::Accessor accessor;
                *hub = accessor.scanner().xsScanUsbHub(*port);
        }
 
        void XsScanner_enumerateNetworkDevices(XsPortInfoArray* ports)
        {
                LOGXSSCAN(__FUNCTION__);
                assert(ports != nullptr);
                if (!ports)
                        return;
 
                XsPortInfoArray tmp;
 
                Scanner::Accessor accessor;
                accessor.scanner().xsEnumerateNetworkDevices(tmp);
                ports->swap(tmp);
        }
 
        void XsScanner_enumerateBluetoothDevices(XsPortInfoArray* ports)
        {
                LOGXSSCAN(__FUNCTION__);
                assert(ports != nullptr);
                if (!ports)
                        return;
 
                XsPortInfoArray tmp;
 
                Scanner::Accessor accessor;
                accessor.scanner().xsEnumerateBluetoothDevices(tmp);
                ports->swap(tmp);
        }
 
        void XsScanner_abortScan(void)
        {
                LOGXSSCAN(__FUNCTION__);
                XsScannerNamespace::abortPortScan = true;
        }
 
}       // extern "C"