xscontrol_def.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 "xscontrol_def.h"
#include "xdacommunicatorfactory.h"
#include <xstypes/xsportinfo.h>
#include <xstypes/xsportinfoarray.h>
#include "xsdeviceconfiguration.h"
#include <xstypes/xsfilterprofile.h>
#include <xstypes/xsdatapacket.h>
 
#include "proxycommunicator.h"
#include "restorecommunication.h"
 
#include <xstypes/xsversion.h>
 
#include "mtix0device.h"
#include "mtix00device.h"
#include "mtigdevice.h"
#include <xstypes/xsdid.h>                      // xddid and xsens_private for imar device id checks
#include "xsdeviceptrarray.h"
#include <xstypes/xssyncsetting.h>
#include <xstypes/xsmath.h>
#include <xstypes/xsdeviceidarray.h>
#include <set>
#include <memory>
#include <xstypes/xssyncsettingarray.h>
#include "broadcastdevice.h"
#include "idfetchhelpers.h"
 
using namespace xsens;
using namespace XsMath;
 
XsControl::XsControl()
        : m_useFakeMessages(true)
        , m_lastHwError(XRV_OK)
        , m_lastHwErrorDeviceId(0)
        , m_recording(false)
        , m_broadcaster(0)
        , m_optionsEnable(XSO_Calibrate | XSO_Orientation)
        , m_optionsDisable(XSO_None)
        , m_latLonAlt(XsVector())
        , m_deviceFactory(new DeviceFactory)
        , m_communicatorFactory(new XdaCommunicatorFactory)
        , m_restoreCommunication(nullptr)
{
        m_communicatorFactory->registerCommunicatorTypes();
        m_deviceFactory->registerDevices();
 
        m_broadcaster = new BroadcastDevice(this);
        m_restoreCommunication = new RestoreCommunication(this);
}
 
 
XsControl::~XsControl()
{
        try
        {
                close();
                delete m_broadcaster;
                delete m_restoreCommunication;
        }
        catch (...)
        {}
 
        delete m_deviceFactory;
        delete m_communicatorFactory;
        m_broadcaster = nullptr;
        m_restoreCommunication = nullptr;
}
 
XsString XsControl::resultText(XsResultValue resultCode)
{
        return XsResultValue_toString(resultCode);
}
 
void XsControl::close()
{
        JLDEBUGG("");
        XSEXITLOGD(gJournal);
 
        if (!m_broadcaster->isReadingFromFile())
                m_broadcaster->gotoConfig();
 
        std::vector<XsDevice*> localList = m_deviceList;
        for (std::vector<XsDevice*>::iterator it = localList.begin(); it != localList.end(); ++it)
        {
                removeChainedManager(*it);
 
                // prepareForTermination is called automatically when the reference is removed
                (*it)->prepareForTermination();
                (*it)->removeRef();
        }
        m_deviceList.clear();
 
        m_lastHwError = XRV_OK;
        m_lastHwErrorDeviceId = 0;
 
        m_lastResult = XRV_OK;
}
 
#ifndef XSENS_NO_PORT_NUMBERS
 
void XsControl::closePort(int portNr)
{
        JLDEBUGG(portNr);
        XSEXITLOGD(gJournal);
 
        closePort(XsPortInfo(portNr).portName());
}
#endif
 
void XsControl::closePort(XsDevice* device)
{
        JLDEBUGG(device);
        XSEXITLOGD(gJournal);
 
        for (uint16_t i = 0; i < m_deviceList.size(); ++i)
        {
                if (device == m_deviceList[i])
                {
                        m_deviceList.erase(m_deviceList.begin() + i);
                        removeChainedManager(device);
                        device->prepareForTermination();
                        device->removeRef();
                }
        }
}
 
void XsControl::closePort(const XsString& portname)
{
        JLDEBUGG(portname.toStdString());
        XSEXITLOGD(gJournal);
 
        // find appropriate port
        LockReadWrite portLock(&m_portMutex);
        portLock.lock(true);
 
        for (uint16_t i = 0; i < m_deviceList.size(); ++i)
        {
                if (portname == m_deviceList[i]->portName())
                        closePort(m_deviceList[i]);
        }
}
 
void XsControl::closePort(const XsDeviceId& deviceId)
{
        XsDevice* inf = findDevice(deviceId);
        if (inf)
                closePort(inf);
}
 
void XsControl::closePort(const XsPortInfo& portinfo)
{
        closePort(portinfo.portName());
}
 
void XsControl::flushInputBuffers()
{
        JLDEBUGG("");
        XSEXITLOGD(gJournal);
 
        for (uint32_t i = 0; i < m_deviceList.size(); i++) // loop over all devices,
        {
                XsDevice* dev = m_deviceList[i];
                dev->flushInputBuffers(); // flush data buffer of each device.
        }
}
 
int XsControl::deviceCount() const
{
        int count = 0;
        for (uint32_t i = 0; i < m_deviceList.size(); i++)
        {
                XsDevice* dev = m_deviceList[i];
                count += 1 + (int) dev->childCount();
        }
        m_lastResult = XRV_OK;
        return count;
}
 
std::vector<XsDeviceId> XsControl::deviceIds() const
{
        LockReadWrite portLock(&m_portMutex, LS_Read);
 
        std::vector<XsDeviceId> result;
        for (uint32_t index = 0; index < m_deviceList.size(); ++index)
        {
                XsDevice const* dev = m_deviceList[index];
                result.push_back(dev->deviceId());
                auto childrn = dev->children();
                for (auto child : childrn)
                        if (child)
                                result.push_back(child->deviceId());
        }
        return result;
}
 
XsDevice* XsControl::getDeviceFromLocationId(uint16_t locationId) const
{
        JLDEBUGG((int) locationId);
        XSEXITLOGD(gJournal);
        for (uint16_t i = 0; i < m_deviceList.size(); ++i)
        {
                XsDevice* d = m_deviceList[i]->getDeviceFromLocationId(locationId);
                if (!d)
                        continue;
                m_lastResult = XRV_OK;
                return d;
        }
        m_lastResult = XRV_NOTFOUND;
        return nullptr;
}
 
void XsControl::clearHardwareError()
{
        m_lastHwErrorDeviceId = 0;
        m_lastHwError = XRV_OK;
}
 
XsResultValue XsControl::lastHardwareError() const
{
        return m_lastHwError;
}
 
XsDeviceId XsControl::lastHardwareErrorDeviceId() const
{
        return m_lastHwErrorDeviceId;
}
 
XsResultValue XsControl::lastResult() const
{
        return m_lastResult.lastResult();
}
 
XsString XsControl::lastResultText() const
{
        return m_lastResult.lastResultText();
}
 
int XsControl::mainDeviceCount() const
{
        //      m_lastResult = XRV_OK;
        return (int) m_deviceList.size();
}
 
/* We assume motion trackers cannot have children and if a device is a child device, it is a motion tracker */
int XsControl::mtCount() const
{
        int count = 0;
        for (uint32_t i = 0; i < m_deviceList.size(); i++)
        {
                XsDevice* dev = m_deviceList[i];
                if (dev->isMotionTracker())
                        count++;
        }
        m_lastResult = XRV_OK;
        return count;
}
 
std::vector<XsDeviceId> XsControl::mainDeviceIds() const
{
        LockReadWrite portLock(&m_portMutex);
        portLock.lock(false);
 
        m_lastResult = XRV_OK;
        std::vector<XsDeviceId> ids;
        ids.reserve(m_deviceList.size());
        for (uint32_t index = 0; index < m_deviceList.size(); ++index)
                ids.push_back(m_deviceList[index]->deviceId());
        return ids;
}
 
std::vector<XsDeviceId> XsControl::mtDeviceIds() const
{
        m_lastResult = XRV_OK;
 
        LockReadWrite portLock(&m_portMutex);
        portLock.lock(false);
 
        std::vector<XsDeviceId> result;
        for (uint32_t i = 0; i < m_deviceList.size(); ++i)
        {
                XsDevice const* main = m_deviceList.at(i);
                if (main->isMotionTracker())
                        result.push_back(main->deviceId());
        }
        return result;
}
 
void XsControl::gotoConfig(void)
{
        JLDEBUGG("");
        XSEXITLOGD(gJournal);
 
        m_broadcaster->gotoConfig();
}
 
void XsControl::gotoMeasurement()
{
        JLDEBUGG("");
        XSEXITLOGD(gJournal);
 
        m_broadcaster->gotoMeasurement();
}
 
XsResultValue XsControl::startRestoreCommunication(const XsString& portName)
{
        return m_restoreCommunication->start(portName);
}
 
void XsControl::stopRestoreCommunication()
{
        m_restoreCommunication->stop();
}
 
bool XsControl::isDeviceDocked(const XsDeviceId& deviceId) const
{
        (void)deviceId;
        return false;
}
 
bool XsControl::isDeviceWireless(const XsDeviceId& deviceId) const
{
        (void)deviceId;
        return false;
}
 
XsDevice* XsControl::addMasterDevice(Communicator* communicator)
{
        XsDevice* result = nullptr;
        XsDevice* dev = m_deviceFactory->createMasterDevice(communicator);
        if (dev != nullptr)
        {
                setPersistentSettings(dev);
                addChainedManager(dev);
                m_deviceList.push_back(dev);
                result = dev;
        }
        return result;
}
bool XsControl::openLogFile(const XsString& filename)
{
        JLDEBUGG(filename.toStdString());
        XSEXITLOGD(gJournal);
 
        LockReadWrite portLock(&m_portMutex);
        portLock.lock(true);
 
        // try opening the file as a regular mtb file
        auto object = Communicator::createUniquePtr(m_communicatorFactory->create(filename));
 
        copyCallbackHandlersTo(object.get());
        //object->addCallbackHandler(d);
        if (!object->openLogFile(filename))
        {
                m_lastResult = object->lastResult();
                return false;
        }
 
        // note that addMasterDevice ALWAYS takes ownership of communicator
        XsDevice* dev = addMasterDevice(object.release());
        if (!dev)
        {
                m_lastResult = XRV_DEVICEERROR;
                return false;
        }
 
        dev->resetLogFileReadPosition();        // this will and should call reinitializeProcessors();
 
        m_lastResult = XRV_OK;
        return true;
 
}
 
#ifndef XSENS_NO_PORT_NUMBERS
 
bool XsControl::openPort(int portNr, XsBaudRate baudrate, uint32_t timeout, bool detectRs485)
{
        JLDEBUGG("port " << (int32_t) portNr << " baudrate " << baudrate << " timeout " << timeout << " detectRs485 " << (int32_t)detectRs485);
        XSEXITLOGD(gJournal);
 
        XsPortInfo pinfo(portNr, baudrate);
        return openPort(pinfo, timeout, detectRs485);
}
#endif
 
bool XsControl::openPort(const XsString& portname, XsBaudRate baudrate, uint32_t timeout, bool detectRs485)
{
        XsPortInfo localPortInfo = XsPortInfo(portname, baudrate);
        uint16_t vid = vidFromString(portname.toStdString());
        uint16_t pid = pidFromString(portname.toStdString());
        localPortInfo.setVidPid(vid, pid);
        return openPort(localPortInfo, timeout, detectRs485);
}
 
bool XsControl::finalizeOpenPort(Communicator* communicator, XsPortInfo& portinfo, uint32_t timeout, bool detectRs485)
{
        XSEXITLOGD(gJournal);
        if (!communicator)
        {
                m_lastResult = XRV_INVALIDPARAM;
                return false;
        }
 
        auto serialPort = Communicator::createUniquePtr(communicator);
 
        copyCallbackHandlersTo(serialPort.get());
 
        if (timeout)
                serialPort->setGotoConfigTimeout(timeout);
 
        bool retval = serialPort->openPort(portinfo, OPS_Full, detectRs485);
        if (serialPort->masterDeviceId().isValid())
                portinfo.setDeviceId(serialPort->masterDeviceId());
 
        if (!retval)
        {
                m_lastResult.set(serialPort->lastResult(), serialPort->lastResultText());
                return false;
        }
 
        // note that addMasterDevice ALWAYS takes ownership of communicator
        if (!addMasterDevice(serialPort.release()))
                return false;
 
        return true;
}
bool XsControl::openPort(XsPortInfo& portinfo, uint32_t timeout, bool detectRs485)
{
        JLDEBUGG("port " << portinfo << " timeout " << timeout << " detectRs485 " << (int32_t)detectRs485);
        XSEXITLOGD(gJournal);
 
        Communicator* xs3info = findXbusInterface(portinfo);
        if (xs3info)
        {
                if (xs3info->masterDeviceId().isValid() && !portinfo.deviceId().isValid())
                        portinfo.setDeviceId(xs3info->masterDeviceId());
                m_lastResult = XRV_ALREADYOPEN;
                return true;
        }
 
        return finalizeOpenPort(m_communicatorFactory->create(portinfo), portinfo, timeout, detectRs485);
}
 
bool XsControl::openPortWithCredentials(XsPortInfo& portinfo, XsString const& id, XsString const& key, uint32_t timeout)
{
        JLDEBUGG("port " << portinfo << " id " << id << " key " << key << " timeout " << timeout);
        XSEXITLOGD(gJournal);
 
        Communicator* xs3info = findXbusInterface(portinfo);
        if (xs3info)
        {
                if (xs3info->masterDeviceId().isValid())
                        portinfo.setDeviceId(xs3info->masterDeviceId());
                m_lastResult = XRV_ALREADYOPEN;
                return true;
        }
 
        xs3info = m_communicatorFactory->create(portinfo);
        xs3info->setCredentials(id, key);
        return finalizeOpenPort(xs3info, portinfo, timeout, false);
}
 
bool XsControl::openCustomPort(int channelId, uint32_t channelLatency, bool detectRs485)
{
        if (m_proxyChannels.find(channelId) != m_proxyChannels.end())
        {
                // We are assuming that the device is there in this case
                m_lastResult = XRV_ALREADYOPEN;
                return true;
        }
 
        ProxyCommunicator* proxy = new ProxyCommunicator(channelId, channelLatency);
        m_proxyChannels[channelId] = proxy;
 
        XsPortInfo portInfo = ProxyCommunicator::createPortInfo(channelId);
        if (!finalizeOpenPort(proxy, portInfo, 0, detectRs485))
        {
                //Please note that finalizeOpenPort takes ownership of the Communicator pointer and will clean it up on error
                m_proxyChannels.erase(channelId);
                return false;
        }
 
        return true;
}
 
XsPortInfo XsControl::customPortInfo(int channelId) const
{
        if (m_proxyChannels.find(channelId) == m_proxyChannels.end())
                return XsPortInfo();
 
        return m_proxyChannels.at(channelId)->portInfo();
}
 
void XsControl::closeCustomPort(int channelId)
{
        auto it = m_proxyChannels.find(channelId);
        if (it == m_proxyChannels.end())
                return;
 
        ProxyCommunicator* p = it->second;
        if (p)
        {
                XsDevice* dev = findDevice(p->masterDeviceId());
                if (dev)
                        dev->setGotoConfigOnClose(false);
                m_proxyChannels.erase(it);
                closePort(p->masterDeviceId());
        }
        else
                m_proxyChannels.erase(it);
}
 
void XsControl::transmissionReceived(int channelId, const XsByteArray& data)
{
        if (m_proxyChannels.find(channelId) == m_proxyChannels.end())
                return;
        m_proxyChannels[channelId]->handleReceivedData(data);
}
 
bool XsControl::openImarPort_internal(const XsString&, XsBaudRate, int, uint32_t)
{
        return false;
}
 
XsDeviceId XsControl::dockDeviceId(const XsDeviceId& deviceId) const
{
        JLDEBUGG(deviceId.toString().toStdString());
 
        LockReadWrite portLock(&m_portMutex);
        portLock.lock(false);
 
        m_lastResult = XRV_OK;
        if (!deviceId.isMtw())
                return XsDeviceId();
 
        XsDevice* dev = findDevice(deviceId);
        if (!dev)
        {
                m_lastResult = XRV_INVALIDID;
                return XsDeviceId();
        }
 
        for (uint32_t index = 0; index < m_deviceList.size(); ++index)
        {
                if (m_deviceList[index]->deviceIsDocked(dev))
                        return m_deviceList[index]->deviceId();
        }
 
        return XsDeviceId();
}
 
bool XsControl::setInitialPositionLLA(const XsVector& lla)
{
        m_latLonAlt = lla;
        m_broadcaster->setInitialPositionLLA(lla);
        return true;
}
 
XsDevice* XsControl::device(const XsDeviceId& deviceId) const
{
        return findDevice(deviceId);
}
 
XsDevicePtrArray XsControl::mainDevices() const
{
        XsDevicePtrArray rv;
        for (std::vector<XsDevice*>::const_iterator it = m_deviceList.begin(); it != m_deviceList.end(); ++it)
                rv.push_back(*it);
        return rv;
}
 
XsDevice* XsControl::broadcast() const
{
        return m_broadcaster;
}
 
void XsControl::updateRecordingState()
{
        for (size_t i = 0 ; i < m_deviceList.size(); ++i)
                if (m_deviceList[i]->isRecording())
                        m_recording = true;
 
        m_recording = false;
}
 
XsDevice* XsControl::findDevice(const XsDeviceId& deviceId) const
{
        if (m_deviceList.empty())
        {
                m_lastResult = XRV_NOFILEORPORTOPEN;
                return NULL;
        }
 
        m_lastResult = XRV_OK;
 
        if (deviceId.toInt() == 0)
                return m_deviceList[0]; // simply return the first item in the list
 
        for (size_t i = 0; i < m_deviceList.size(); i++)
        {
                XsDevice* dev = m_deviceList[i];
 
                if (!dev)
                        break;
 
                if (dev->deviceId() == deviceId)
                        return dev;
 
                dev = dev->findDevice(deviceId);
                if (dev)
                        return dev;
        }
 
        m_lastResult = XRV_INVALIDID;
        return NULL;
}
 
void XsControl::removeExistingDevice(XsDeviceId const& deviceId)
{
        XsDevice* dev  = findDevice(deviceId);
        if (!dev)
                return;
 
        if (dev->isMasterDevice())
                closePort(deviceId);
}
 
Communicator* XsControl::findXbusInterface(const XsDeviceId& deviceId) const
{
        XsDevice* dev = findDevice(deviceId);
        if (!dev)
                return NULL;
 
        return dev->communicator();
}
 
Communicator* XsControl::findXbusInterface(const XsPortInfo& portInfo) const
{
        return findXbusInterface(portInfo.portName());
}
 
Communicator* XsControl::findXbusInterface(const XsString& portName) const
{
        for (size_t i = 0; i < m_deviceList.size(); ++i)
        {
                assert(m_deviceList[i]->communicator());
                if (portName == m_deviceList[i]->communicator()->portInfo().portName())
                        return m_deviceList[i]->communicator();
        }
        return NULL;
}
bool XsControl::loadFilterProfiles(const XsString&)
{
        return false;
}
 
void XsControl::closePortByIndex(uint32_t i)
{
        JLDEBUGG(i);
        //      XSEXITLOGD(gJournal);
 
        XsDevice* dev = m_deviceList[i];
        closePort(dev);
}
XsOption XsControl::enabledOptions() const
{
        return m_optionsEnable;
}
 
XsOption XsControl::disabledOptions() const
{
        return m_optionsDisable;
}
 
void XsControl::setOptions(XsOption enable, XsOption disable)
{
        m_optionsEnable = XsOption_purify(enable);
        m_optionsDisable = disable;
        m_broadcaster->setOptions(m_optionsEnable, m_optionsDisable);
}
 
void XsControl::setOptionsForce(XsOption enabled)
{
        m_optionsEnable = XsOption_purify(enabled);
        m_optionsDisable = (XsOption)((~m_optionsEnable) & XSO_All);
        m_broadcaster->setOptions(m_optionsEnable, m_optionsDisable);
}
 
void XsControl::setPersistentSettings(XsDevice* dev)
{
        dev->setOptions(m_optionsEnable, m_optionsDisable);
 
        if (!m_latLonAlt.empty())
                dev->setInitialPositionLLA(m_latLonAlt);
}
#ifndef XDA_PRIVATE_BUILD
        #include "xscontrol_public.h"
#else
        #include "xscontrolex.h"
#endif
XsControl* XsControl::construct()
{
        return new XsControlEx;
}